← Back to branch summary

~ubuntu-branches/debian/sid/eclipse-cdt/sid

« back to all changes in this revision

Viewing changes to build/org.eclipse.cdt.managedbuilder.core/src/org/eclipse/cdt/managedbuilder/internal/tcmodification/ToolChainModificationManager.java

  • Committer: Package Import Robot
  • Author(s): Jakub Adam
  • Date: 2011-10-06 21:15:04 UTC
  • mfrom: (1.1.4)
  • Revision ID: package-import@ubuntu.com-20111006211504-8dutmljjih0zikfv
Tags: 8.0.1-1
* New upstream release.
* Split the JNI packages into a separate architecture dependent
  package and made eclipse-cdt architecture independent.
* Install JNI libraries into multiarch aware location
* Bumped Standards-Version to 3.9.2.

Show diffs side-by-side

added added

removed removed

Lines of Context:
build/org.eclipse.cdt.managedbuilder.core/src/org/eclipse/cdt/managedbuilder/internal/tcmodification/ToolChainModificationManager.java
 
1
/*******************************************************************************
 
2
 * Copyright (c) 2007, 2008 Intel Corporation and others.
 
3
 * All rights reserved. This program and the accompanying materials
 
4
 * are made available under the terms of the Eclipse Public License v1.0
 
5
 * which accompanies this distribution, and is available at
 
6
 * http://www.eclipse.org/legal/epl-v10.html
 
7
 *
 
8
 * Contributors:
 
9
 * Intel Corporation - Initial API and implementation
 
10
 *******************************************************************************/
 
11
package org.eclipse.cdt.managedbuilder.internal.tcmodification;
 
12
 
 
13
import java.util.ArrayList;
 
14
import java.util.Arrays;
 
15
import java.util.Collections;
 
16
import java.util.HashMap;
 
17
import java.util.HashSet;
 
18
import java.util.List;
 
19
import java.util.Map;
 
20
import java.util.Set;
 
21
 
 
22
import org.eclipse.cdt.managedbuilder.core.IConfiguration;
 
23
import org.eclipse.cdt.managedbuilder.core.IFileInfo;
 
24
import org.eclipse.cdt.managedbuilder.core.IFolderInfo;
 
25
import org.eclipse.cdt.managedbuilder.core.IResourceInfo;
 
26
import org.eclipse.cdt.managedbuilder.internal.core.FolderInfo;
 
27
import org.eclipse.cdt.managedbuilder.internal.core.IRealBuildObjectAssociation;
 
28
import org.eclipse.cdt.managedbuilder.internal.core.ResourceConfiguration;
 
29
import org.eclipse.cdt.managedbuilder.internal.tcmodification.extension.ObjectSetListBasedDefinition;
 
30
import org.eclipse.cdt.managedbuilder.internal.tcmodification.extension.RulesManager;
 
31
import org.eclipse.cdt.managedbuilder.tcmodification.IFileInfoModification;
 
32
import org.eclipse.cdt.managedbuilder.tcmodification.IFolderInfoModification;
 
33
import org.eclipse.cdt.managedbuilder.tcmodification.IToolChainModificationManager;
 
34
import org.eclipse.core.runtime.IPath;
 
35
 
 
36
public class ToolChainModificationManager implements
 
37
                IToolChainModificationManager {
 
38
        private static ToolChainModificationManager fInstance;
 
39
        
 
40
        private ToolChainModificationManager(){
 
41
        }
 
42
        
 
43
        public static ToolChainModificationManager getInstance(){
 
44
                if(fInstance == null)
 
45
                        fInstance = getInstanceSynch();
 
46
                return fInstance;
 
47
        }
 
48
        
 
49
        private static synchronized ToolChainModificationManager getInstanceSynch() {
 
50
                if(fInstance == null)
 
51
                        fInstance = new ToolChainModificationManager();
 
52
                return fInstance;
 
53
        }
 
54
        
 
55
        public void start(){
 
56
                RulesManager.getInstance().start();
 
57
        }
 
58
        
 
59
        public IFileInfoModification createModification(IFileInfo rcInfo) {
 
60
                return new FileInfoModification((ResourceConfiguration)rcInfo);
 
61
        }
 
62
 
 
63
        public IFolderInfoModification createModification(IFolderInfo rcInfo) {
 
64
                FolderInfo foInfo = (FolderInfo)rcInfo;
 
65
                if(foInfo.isRoot())
 
66
                        return new ConfigurationModification(foInfo);
 
67
                return new FolderInfoModification(foInfo);
 
68
        }
 
69
 
 
70
        public IFolderInfoModification createModification(IConfiguration cfg,
 
71
                        IFolderInfoModification base) throws IllegalArgumentException {
 
72
                IResourceInfo baseRcInfo = base.getResourceInfo();
 
73
                IPath path = baseRcInfo.getPath();
 
74
                IResourceInfo rcInfo = cfg.getResourceInfo(path, true);
 
75
                FolderInfo folderInfo;
 
76
                if(rcInfo != null){
 
77
                        if(rcInfo instanceof FolderInfo){
 
78
                                folderInfo = (FolderInfo)rcInfo;
 
79
                        } else {
 
80
                                throw new IllegalArgumentException();
 
81
                        }
 
82
                } else {
 
83
                        folderInfo = (FolderInfo)cfg.createFolderInfo(path);
 
84
                }
 
85
                
 
86
                return folderInfo.isRoot() ?
 
87
                                new ConfigurationModification(folderInfo, (ConfigurationModification)base)
 
88
                                : new FolderInfoModification(folderInfo, (FolderInfoModification)base);
 
89
        }
 
90
 
 
91
        public IFileInfoModification createModification(IConfiguration cfg,
 
92
                        IFileInfoModification base) throws IllegalArgumentException {
 
93
                IResourceInfo baseRcInfo = base.getResourceInfo();
 
94
                IPath path = baseRcInfo.getPath();
 
95
                IResourceInfo rcInfo = cfg.getResourceInfo(path, true);
 
96
                ResourceConfiguration fileInfo;
 
97
                if(rcInfo != null){
 
98
                        if(rcInfo instanceof ResourceConfiguration){
 
99
                                fileInfo = (ResourceConfiguration)rcInfo;
 
100
                        } else {
 
101
                                throw new IllegalArgumentException();
 
102
                        }
 
103
                } else {
 
104
                        fileInfo = (ResourceConfiguration)cfg.createFileInfo(path);
 
105
                }
 
106
                
 
107
                return new FileInfoModification(fileInfo, (FileInfoModification)base);
 
108
        }
 
109
 
 
110
        public static boolean checkFlags(int flags, int value){
 
111
                return (flags & value) == value;
 
112
        }
 
113
 
 
114
        public static int addFlags(int flags, int value){
 
115
                return flags |= value;
 
116
        }
 
117
 
 
118
        public static int clearFlags(int flags, int value){
 
119
                return flags &= (~value);
 
120
        }
 
121
        
 
122
        private boolean getMatchingObjects(int type, IObjectSet[] oSets, Set<IRealBuildObjectAssociation> skipSet, IRealBuildObjectAssociation additionalSkip, Set<IRealBuildObjectAssociation> result){
 
123
                Set<IRealBuildObjectAssociation> tmp = null;
 
124
                boolean added = false;
 
125
                for (IObjectSet os : oSets) {
 
126
                        int setType = os.getObjectType();
 
127
                        if(setType != type)
 
128
                                continue;
 
129
 
 
130
                        if(tmp == null)
 
131
                                tmp = new HashSet<IRealBuildObjectAssociation>();
 
132
                        else
 
133
                                tmp.clear();
 
134
                        
 
135
                        os.getRealBuildObjects(tmp);
 
136
                        
 
137
                        if(skipSet != null)
 
138
                                tmp.removeAll(skipSet);
 
139
                        
 
140
                        if(additionalSkip != null)
 
141
                                tmp.remove(additionalSkip);
 
142
                        
 
143
                        if(result.addAll(tmp)){
 
144
                                added = true;
 
145
                        }
 
146
                }
 
147
                return added;
 
148
        }
 
149
 
 
150
        public ConflictMatchSet getConflictInfo(int objType, PerTypeMapStorage<IRealBuildObjectAssociation, Set<IPath>> parent){
 
151
                //parent should be passed - it is constant no need to recalculate every time
 
152
                //PerTypeMapStorage parent = TcModificationUtil.createParentObjectsRealToolToPathSet(foInfo);
 
153
                
 
154
                ConflictMatchSet conflicts = getConflictMatches(objType, parent, null);
 
155
                
 
156
                return conflicts;
 
157
        }
 
158
 
 
159
        public static class ConflictMatch {
 
160
                final int fMatchType;
 
161
                final Map<IRealBuildObjectAssociation, Set<IPath>> fRObjToPathMap;
 
162
                final int fConflictType;
 
163
                final Set<IRealBuildObjectAssociation> fConflicts;
 
164
                
 
165
                ConflictMatch(int matchType, Map<IRealBuildObjectAssociation, Set<IPath>> rtToPathMap, int conflictType, Set<IRealBuildObjectAssociation> conflicts){
 
166
                        fMatchType = matchType;
 
167
                        fRObjToPathMap = Collections.unmodifiableMap(rtToPathMap);
 
168
                        fConflictType = conflictType;
 
169
                        fConflicts = Collections.unmodifiableSet(conflicts);
 
170
                }
 
171
        }
 
172
        
 
173
        public static class ConflictMatchSet {
 
174
                ConflictMatch[] fConflicts;
 
175
                Map<? extends IRealBuildObjectAssociation, List<ConflictMatch>> fObjToConflictListMap;
 
176
                
 
177
                ConflictMatchSet(ConflictMatch[] coflicts, Map<? extends IRealBuildObjectAssociation, List<ConflictMatch>> objToConflictMap){
 
178
                        fConflicts = coflicts;
 
179
                        fObjToConflictListMap = objToConflictMap;
 
180
                }
 
181
                
 
182
                
 
183
        }
 
184
        
 
185
        private ConflictMatchSet getConflictMatches(int type, PerTypeMapStorage<IRealBuildObjectAssociation, Set<IPath>> rtToPath, PerTypeSetStorage<IRealBuildObjectAssociation> skip){
 
186
                
 
187
                //conversion:
 
188
                //1.first filter applicable to not-this
 
189
                //2. get variants for applicable ones
 
190
                
 
191
                //1.first filter applicable to not-this
 
192
                List<ConflictMatch> conflictList = new ArrayList<ConflictMatch>();
 
193
                Map<IRealBuildObjectAssociation, List<ConflictMatch>> objToConflictMatchMap = new HashMap<IRealBuildObjectAssociation, List<ConflictMatch>>();
 
194
                
 
195
                ObjectSetListBasedDefinition[] defs = RulesManager.getInstance().getRules(ObjectSetListBasedDefinition.CONFLICT);
 
196
                for(int i = 0; i < defs.length; i++){
 
197
                        ObjectSetListBasedDefinition def= defs[i];
 
198
                        ObjectSetList sl = def.getObjectSetList();
 
199
                        IObjectSet oss[] = sl.getObjectSets();
 
200
                        for(int k = 0; k < oss.length; k++){
 
201
                                IObjectSet os = oss[k];
 
202
                                int objType = os.getObjectType();
 
203
                                Map<IRealBuildObjectAssociation, Set<IPath>> rtToPathMap = rtToPath.getMap(objType, false);
 
204
                                if(rtToPathMap == null)
 
205
                                        continue;
 
206
                                
 
207
                                @SuppressWarnings("unchecked")
 
208
                                Map<IRealBuildObjectAssociation, Set<IPath>> clone = (Map<IRealBuildObjectAssociation, Set<IPath>>)((HashMap<IRealBuildObjectAssociation, Set<IPath>>)rtToPathMap).clone();
 
209
                                rtToPathMap = clone;
 
210
                                Set<IRealBuildObjectAssociation> skipSet = skip != null ? (Set<IRealBuildObjectAssociation>)skip.getSet(objType, false) : null;
 
211
                                Set<IRealBuildObjectAssociation> objSet = rtToPathMap.keySet();
 
212
 
 
213
                                if(skipSet != null)
 
214
                                        objSet.removeAll(skipSet);
 
215
 
 
216
                                os.retainMatches(objSet);
 
217
                                
 
218
                                if(objSet.size() != 0){
 
219
                                        List<IObjectSet> remainingList = new ArrayList<IObjectSet>(Arrays.asList(oss));
 
220
                                        remainingList.remove(os);
 
221
 
 
222
                                        IObjectSet[] remaining = remainingList.toArray(new IObjectSet[remainingList.size()]);
 
223
                                        //get objects matching remaining
 
224
                                        Set<IRealBuildObjectAssociation> skipSet2 = skip != null ? (Set<IRealBuildObjectAssociation>)skip.getSet(type, false) : null;
 
225
                                        Set<IRealBuildObjectAssociation> matchingObjects = new HashSet<IRealBuildObjectAssociation>();
 
226
                                        getMatchingObjects(type, remaining, skipSet2, null, matchingObjects);
 
227
                                        if(matchingObjects.size() != 0){
 
228
                                                ConflictMatch conflict = new ConflictMatch(objType, rtToPathMap, type, matchingObjects);
 
229
                                                
 
230
                                                for (IRealBuildObjectAssociation bo : matchingObjects) {
 
231
                                                        List<ConflictMatch> list = TcModificationUtil.getArrayList(objToConflictMatchMap, bo);
 
232
                                                        list.add(conflict);
 
233
                                                }
 
234
                                                
 
235
                                                conflictList.add(conflict);
 
236
                                        }
 
237
//                                      break;
 
238
                                }
 
239
                        }
 
240
                }
 
241
                
 
242
                return new ConflictMatchSet(conflictList.toArray(new ConflictMatch[conflictList.size()]), objToConflictMatchMap);
 
243
        }
 
244
}