Java > Open Source Codes > net > sf > invicta > type > TypeDefinition


1 package net.sf.invicta.type;
2
3 import java.util.ArrayList ;
4 import java.util.HashMap ;
5 import java.util.Iterator ;
6 import java.util.List ;
7 import java.util.Map ;
8 import java.util.StringTokenizer ;
9
10 import net.sf.invicta.InvictaConstants;
11 import net.sf.invicta.api.Target;
12
13 import org.apache.commons.collections.SequencedHashMap;
14  
15 /**
16  *
17  */
18 public class TypeDefinition {
19     private boolean isResolved;
20     private String name;
21     private String initTarget;
22     private String buildTarget;
23     private String cleanTarget;
24     private String distTarget;
25     private String template;
26     private Map targetTemplates = new SequencedHashMap();
27     private List extendsList = new ArrayList ();
28     private List removeTargets = new ArrayList ();
29     private Map definedProperties = new SequencedHashMap();
30     private String actualGeneralTemplate;
31     private Map actualTargetTemplates = new SequencedHashMap();
32     private Map actualDefinedProperties = new SequencedHashMap();
33                     
34     /**
35      * Returns the cleanTarget.
36      * @return String
37      */
38     public String getCleanTarget() {
39         return cleanTarget;
40     }
41
42     /**
43      * Returns the buildTarget.
44      * @return String
45      */
46     public String getBuildTarget() {
47         return buildTarget;
48     }
49
50     /**
51      * Returns the name of this type ('JAR' for example).
52      *
53      * @return String. The type name.
54      */
55     public String getName() {
56         return name;
57     }
58
59     /**
60      * Sets the cleanTarget.
61      * @param cleanTarget The cleanTarget to set
62      */
63     public void setCleanTarget(String cleanTarget) {
64         this.cleanTarget = cleanTarget;
65     }
66
67     /**
68      * Sets the buildTarget.
69      * @param buildTarget The buildTarget to set
70      */
71     public void setBuildTarget(String buildTarget) {
72         this.buildTarget = buildTarget;
73     }
74
75     /**
76      * Sets the name.
77      * @param name The name to set
78      */
79     public void setName(String name) {
80         this.name = name;
81     }
82
83     /**
84      * Returns the template.
85      * @return String
86      */
87     public String getGeneralTemplate() {
88         return this.actualGeneralTemplate;
89     }
90     
91
92     /**
93      * Note: For digester. Nobody should call this function.
94      * @return String
95      */
96     public String getTemplate() {
97         return this.actualGeneralTemplate;
98     }
99
100     /**
101      * Sets the template.
102      * @param template The template to set
103      */
104     public void setTemplate(String template) {
105         this.template = template;
106     }
107
108     /**
109      *
110      */
111     public void addDefineProperty(BasicDefinedProperty property) throws Exception {
112         if (this.definedProperties.containsKey(property.getName()))
113             throw InvictaTypeException.conflictingDefinedProperties(this.name, property.getName());
114         property.checkRequiredAttributes();
115         this.definedProperties.put(property.getName(), property);
116     }
117     
118     /**
119      *
120      */
121     public void addTargetTemplate(TargetTemplate targetTemplate) throws InvictaTypeException {
122         if (this.targetTemplates.containsKey(targetTemplate.getName()))
123             throw InvictaTypeException.duplicateTargetTemplate(this.name, targetTemplate.getName());
124         this.targetTemplates.put(targetTemplate.getName(), targetTemplate);
125     }
126
127     /**
128      *
129      */
130     public Map getTargetTemplates() {
131         return this.actualTargetTemplates;
132     }
133     
134     /**
135      *
136      */
137     public Map getDefinedProperties() {
138         return this.actualDefinedProperties;
139     }
140         
141     /**
142      * Returns the distTarget.
143      * @return String
144      */
145     public String getDistTarget() {
146         return distTarget;
147     }
148
149     /**
150      * Sets the distTarget.
151      * @param distTarget The distTarget to set
152      */
153     public void setDistTarget(String distTarget) {
154         this.distTarget = distTarget;
155     }
156
157     /**
158      *
159      */
160     public BasicDefinedProperty getDefinedProperty(String propertyName) {
161         return (BasicDefinedProperty)this.actualDefinedProperties.get(propertyName);
162     }
163     
164     /**
165      * Returns null.
166      * @return List
167      */
168     public String getExtends() {
169         return null;
170     }
171
172     /**
173      * Returns null
174      * @return List
175      */
176     public String getRemoveTargets() {
177         return null;
178     }
179
180     /**
181      * Sets the extendsList.
182      * @param extendsList The extendsList to set
183      */
184     public void setExtends(String extendsListStr) {
185         StringTokenizer st = new StringTokenizer (extendsListStr, InvictaConstants.LIST_DELIMITER);
186         while (st.hasMoreTokens())
187             this.extendsList.add(st.nextToken().trim());
188     }
189
190     /**
191      * Sets the removeTargets.
192      * @param removeTargets The removeTargets to set
193      */
194     public void setRemoveTargets(String removeTargetsStr) {
195         
196         StringTokenizer st = new StringTokenizer (removeTargetsStr, InvictaConstants.LIST_DELIMITER);
197         while (st.hasMoreTokens())
198             this.removeTargets.add(st.nextToken().trim());
199         
200     }
201     
202     /**
203      * Resolve this type definition.
204      */
205     public void resolve(TypeManager typeManager, int level) throws InvictaTypeException {
206         if (isResolved)
207             return;
208         
209         resolveWithExtendsTypes(typeManager, level);
210                             
211         this.isResolved = true;
212     }
213
214     /**
215      * Returns the full ANT template code of this type.
216      *
217      * @return String. ANT template code.
218      */
219     public String getAntTemplateString() {
220         String fullTemplateString = "";
221         for (Iterator targetIter = this.actualTargetTemplates.values().iterator(); targetIter.hasNext();) {
222             TargetTemplate targetTemplate = (TargetTemplate) targetIter.next();
223             fullTemplateString += targetTemplate.getAntTemplateString() + "\n";
224         }
225         if (this.actualGeneralTemplate != null)
226             fullTemplateString += this.actualGeneralTemplate + "\n";
227             
228         return fullTemplateString;
229     }
230     
231     /**
232      * Returns whether this type has a target with the given name.
233      **/
234     public boolean containsTarget(String targetName) {
235         return this.actualTargetTemplates.containsKey(targetName);
236     }
237     
238     /**
239      *
240      * @return Map of Target objects
241      */
242     public Map getTargetMap() {
243         return new HashMap (this.actualTargetTemplates);
244     }
245
246     /**
247      *
248      * @return List of Target objects
249      */
250     public List getTargetList() {
251         return (List )new ArrayList (this.actualTargetTemplates.values());
252     }
253     
254     /**
255      *
256      * @param targetName
257      * @return Target
258      */
259     public Target getTarget(String targetName) {
260         return (Target)this.actualTargetTemplates.get(targetName);
261     }
262     
263     /**
264      * @return String
265      */
266     public String getInitTarget() {
267         return initTarget;
268     }
269
270     /**
271      * @param string
272      */
273     public void setInitTarget(String string) {
274         initTarget = string;
275     }
276     
277     /**
278      * Resolve this type definition while resolving the types
279      * it extends and performing the inheritance resolving.
280      */
281     protected void resolveWithExtendsTypes(TypeManager typeManager, int level) throws InvictaTypeException {
282                 
283         // Resolve all types we extend
284 List parentTypes = new ArrayList ();
285         List parentDefinedProperties = new ArrayList ();
286         List parentTargetTemplates = new ArrayList ();
287         for (Iterator extendsIter = this.extendsList.iterator(); extendsIter.hasNext();) {
288             
289             String oneTypeName = (String ) extendsIter.next();
290             TypeDefinition oneType = typeManager.getTypeDefinition(oneTypeName, level + 1);
291             parentTypes.add(oneType);
292             parentDefinedProperties.add(new SequencedHashMap(oneType.getDefinedProperties()));
293             parentTargetTemplates.add(new SequencedHashMap(oneType.getTargetTemplates()));
294         }
295             
296         // Remove the targets that were specified to be removed.
297 removeTargetsFromParents(parentTargetTemplates);
298         
299         // Resolve the actual defined properties of this type.
300 resolveActualDefinedProperties(parentDefinedProperties);
301         
302         // Resolve the actual target templates of this type.
303 resolveActualTargetTemplates(parentTargetTemplates);
304         
305         // Resolve the list of dependencies all of actual target templates.
306 resolveTargetsDependList();
307                         
308         mergeTemplateStrings(parentTypes);
309     }
310
311
312     /**
313      * Merge all template strings of parents and this type into a
314      * single template.
315      *
316      * @param extendTypes
317      */
318     protected void mergeTemplateStrings(List extendTypes) {
319         this.actualGeneralTemplate = "";
320         for (Iterator parentIter = extendTypes.iterator(); parentIter.hasNext();) {
321             
322             TypeDefinition parentType = (TypeDefinition) parentIter.next();
323             if (parentType.getGeneralTemplate() != null)
324                 this.actualGeneralTemplate += parentType.getGeneralTemplate() + "\n";
325         }
326         if (this.template != null)
327             this.actualGeneralTemplate += this.template;
328     }
329     
330     /**
331      * Resolve the defined properties of this type by merging the
332      * defined properties of all parent types.
333      */
334     protected void resolveActualDefinedProperties(List extendsDefinedProperties) throws InvictaTypeException {
335                         
336         // Go over all local properties, remove then from the extends copies.
337 for (Iterator propIter = this.definedProperties.values().iterator(); propIter.hasNext();) {
338                         
339             BasicDefinedProperty oneProp = (BasicDefinedProperty)propIter.next();
340                         
341             // Remove this property from all extending types (only the copies, not the original maps)
342 for (Iterator extendsIter = extendsDefinedProperties.iterator();
343                 extendsIter.hasNext();) {
344                 Map propsMap = (Map ) extendsIter.next();
345                                 
346                 propsMap.remove(oneProp.getName());
347             }
348         }
349                         
350         // Copy all extends properties to the actual map.
351 // Note; putAll cannot be used because we need to look for
352 // duplicate properties.
353 for (Iterator extendsIter = extendsDefinedProperties.iterator();
354             extendsIter.hasNext();) {
355             Map propsMap = (Map ) extendsIter.next();
356             
357             for (Iterator propIter = propsMap.entrySet().iterator();
358                 propIter.hasNext();) {
359                 Map.Entry entry = (Map.Entry ) propIter.next();
360                 BasicDefinedProperty oneProp = (BasicDefinedProperty)entry.getValue();
361                 
362                 // Check if this property is already defined and is different (a conflict).
363 if (this.actualDefinedProperties.containsKey(oneProp.getName()) &&
364                     !((BasicDefinedProperty)this.actualDefinedProperties.get(oneProp.getName())).equals(oneProp))
365                     throw InvictaTypeException.conflictingDefinedProperties(this.name, oneProp.getName());
366                 
367                 // Add this property to the map of actual properties
368 if (!this.actualDefinedProperties.containsKey(oneProp.getName()))
369                     this.actualDefinedProperties.put(oneProp.getName(), oneProp);
370             }
371         }
372             
373         // Go over all local properties, add them to the actual map.
374 for (Iterator propIter = this.definedProperties.values().iterator(); propIter.hasNext();) {
375                          
376             BasicDefinedProperty oneProp = (BasicDefinedProperty)propIter.next();
377             this.actualDefinedProperties.put(oneProp.getName(),oneProp);
378         }
379     }
380     
381     /**
382      * Copy the local targets into the actual list.
383      * Remove parent targets that we replace.
384      * Rename parent targets that we rename.
385      * Add the template string of extends targets that we add to.
386      * Add all other targets of extends types while checking for conflicts.
387      *
388      * @param extendsTargetTemplates
389      *
390      */
391     protected void resolveActualTargetTemplates(List parentTargetTemplates) throws InvictaTypeException {
392          
393         // replace|rename|addBefore|addAfter|addBeforeAll|addAfterAll
394
395         // Go over all local templates, add them and if needed
396 // remove or rename the names of the targets of the extends with
397 // the same target name.
398 for (Iterator templateIter = this.targetTemplates.values().iterator();
399             templateIter.hasNext();) {
400                 
401             TargetTemplate targetTemplate = (TargetTemplate) templateIter.next();
402             this.actualTargetTemplates.put(targetTemplate.getName(), targetTemplate);
403             
404             // If mode is Replace, Remove this target from all extends types
405 if (targetTemplate.getMode().equals(TargetTemplate.MODE_REPLACE)) {
406                 // Remove this target from all extends types
407 for (Iterator extendsIter = parentTargetTemplates.iterator();
408                      extendsIter.hasNext();)
409                      ((Map ) extendsIter.next()).remove(targetTemplate.getName());
410             
411             // If mode is Rename, rename this target of all extends types
412 } else if (targetTemplate.getMode().equals(TargetTemplate.MODE_RENAME)) {
413             
414                 renameTargetTemplates(parentTargetTemplates, targetTemplate);
415                 
416             // If mode is addBefore or addAfter.
417 } else {
418                 addToTargetTemplate(parentTargetTemplates, targetTemplate);
419             }
420         }
421                 
422         
423         // Copy all extends targets to the actual map.
424 // Note; putAll cannot be used because we need to look for duplicate
425 // targets.
426 for (Iterator extendsIter = parentTargetTemplates.iterator();
427              extendsIter.hasNext();) {
428             Map templatesMap = (Map ) extendsIter.next();
429             
430             copyActualTargetTemplates(templatesMap);
431         }
432     }
433
434     /**
435      *
436      * @param templatesMap
437      * @throws InvictaTypeException
438      */
439     protected void copyActualTargetTemplates(Map templatesMap)
440         throws InvictaTypeException {
441         for (Iterator propIter = templatesMap.values().iterator();
442              propIter.hasNext();) {
443              TargetTemplate targetTemplate = (TargetTemplate)propIter.next();
444             
445              // Check if this target is already defined (a conflict).
446 if (this.actualTargetTemplates.containsKey(targetTemplate.getName()) &&
447                 !((TargetTemplate)this.actualTargetTemplates.get(targetTemplate.getName())).equals(targetTemplate, true))
448                 throw InvictaTypeException.conflictingTargetTemplates(this.name, targetTemplate.getName());
449             
450              // Add this property to the map of actual properties
451 if (!this.actualTargetTemplates.containsKey(targetTemplate.getName()))
452                 this.actualTargetTemplates.put(targetTemplate.getName(), targetTemplate);
453          }
454     }
455
456     /**
457      *
458      * @param parentTargetTemplates
459      * @param targetTemplate
460      * @throws InvictaTypeException
461      */
462     protected void addToTargetTemplate(
463         List parentTargetTemplates,
464         TargetTemplate targetTemplate)
465         throws InvictaTypeException {
466             
467         TargetTemplate extendTargetTemplate = null;
468         for (Iterator extendsIter = parentTargetTemplates.iterator();
469              extendsIter.hasNext();) {
470              Map templatesMap = (Map )extendsIter.next();
471              if (templatesMap.containsKey(targetTemplate.getName())) {
472                 
473                 TargetTemplate oneExtendsTarget = (TargetTemplate)templatesMap.get(targetTemplate.getName());
474                 
475                 // If this target is defined in 2 extends types, then it's a conflict
476 if ((targetTemplate.getMode().equals(TargetTemplate.MODE_ADD_AFTER) ||
477                     targetTemplate.getMode().equals(TargetTemplate.MODE_ADD_BEFORE)) &&
478                     (extendTargetTemplate != null) &&
479                     !((TargetTemplate)extendTargetTemplate).equals(oneExtendsTarget, false))
480                     throw InvictaTypeException.conflictingTargetTemplates(this.name, targetTemplate.getName());
481                     
482                 extendTargetTemplate = oneExtendsTarget;
483             
484                 // Add the template of parents before or after this template.
485 if (targetTemplate.getMode().equals(TargetTemplate.MODE_ADD_AFTER) ||
486                     targetTemplate.getMode().equals(TargetTemplate.MODE_ADD_AFTER_ALL))
487                     targetTemplate.setTemplateString
488                          (extendTargetTemplate.getTemplateString() + "\n" + targetTemplate.getTemplateString());
489                 else
490                     targetTemplate.setTemplateString
491                          (targetTemplate.getTemplateString() + "\n" + extendTargetTemplate.getTemplateString());
492                          
493                 templatesMap.remove(extendTargetTemplate.getName());
494              }
495         }
496         
497         // If no such target exists in a parent.
498 if (extendTargetTemplate == null)
499             throw InvictaTypeException.parentTargetUndefined(this.name, targetTemplate.getName());
500     }
501
502     /**
503      *
504      * @param parentTargetTemplates
505      * @param targetTemplate
506      */
507     protected void renameTargetTemplates(
508         List parentTargetTemplates,
509         TargetTemplate targetTemplate) {
510             
511         Iterator typeIter = this.extendsList.iterator();
512         // Rename the targets of all parent types
513 for (Iterator parentTemplateIter = parentTargetTemplates.iterator();
514               parentTemplateIter.hasNext();) {
515               
516              String typeName = (String )typeIter.next();
517              Map templatesMap = (Map )parentTemplateIter.next();
518              
519              TargetTemplate oneTemplate =
520                 (TargetTemplate)templatesMap.remove(targetTemplate.getName());
521                 
522              // If this template exists, rename it, for example:
523 // rename 'compile' to 'JAR.compile'
524 if (oneTemplate != null) {
525                 String newName = typeName + InvictaConstants.TARGET_DELIMITER + targetTemplate.getName();
526                 oneTemplate = new TargetTemplate(oneTemplate);
527                 oneTemplate.setName(newName);
528                 templatesMap.put(oneTemplate.getName(), oneTemplate);
529              }
530         }
531     }
532     
533     /**
534      *
535      * Note: This methods is being run after all targets were processes
536      * and we have the final actual targets list.
537      *
538      * @param extendsTargetTemplates
539      */
540     protected void resolveTargetsDependList() throws InvictaTypeException {
541                 
542         // Go over all target templates.
543 for (Iterator templateIter = this.targetTemplates.values().iterator();
544             templateIter.hasNext();) {
545             TargetTemplate targetTemplate = (TargetTemplate) templateIter.next();
546                         
547             // Go over all depend targets and check that they are valid.
548 for (Iterator dependIter = targetTemplate.getDependsList().iterator();
549                  dependIter.hasNext();) {
550                 String oneDepend = (String ) dependIter.next();
551                 
552                 // If it's not an absolute depend, check that the target exists
553 // in this type.
554 if (!targetTemplate.isAbsoluteDepend(oneDepend))
555                     if (!this.actualTargetTemplates.containsKey(oneDepend))
556                         throw InvictaTypeException.targetUndefined(this.name, oneDepend);
557             }
558         }
559     }
560     
561     /**
562      *
563      * @param extendsTargetTemplates
564      */
565     private void removeTargetsFromParents(List extendsTargetTemplates) throws InvictaTypeException {
566                 
567         // Go over all targets to remove
568 for (Iterator removeIter = this.removeTargets.iterator();
569             removeIter.hasNext();) {
570             String removeTargetStr = (String ) removeIter.next();
571             int dotIndex = removeTargetStr.indexOf(InvictaConstants.TARGET_DELIMITER);
572             if (dotIndex == -1)
573                 throw InvictaTypeException.parentTargetUndefined(this.name, removeTargetStr);
574             String removeTypeName = removeTargetStr.substring(0, dotIndex);
575             String removeTargetName = removeTargetStr.substring(dotIndex + 1);
576                                                         
577             boolean isFound = false;
578             // Go over all parents and look for a matching target.
579 Iterator typeIter = this.extendsList.iterator();
580             for (Iterator extendsIter = extendsTargetTemplates.iterator();
581                   extendsIter.hasNext();) {
582                 String typeName = (String )typeIter.next();
583                 Map templatesMap = (Map )extendsIter.next();
584                 if (typeName.equalsIgnoreCase(removeTypeName)) {
585                     if (!templatesMap.containsKey(removeTargetName))
586                     throw InvictaTypeException.parentTargetUndefined(this.name, removeTargetStr);
587                     templatesMap.remove(removeTargetName);
588                     isFound = true;
589                     break;
590                 }
591             }
592             
593             // Check if the target to be removed was not found.
594 if (!isFound)
595                 throw InvictaTypeException.parentTargetUndefined(this.name, removeTargetStr);
596         }
597                         
598     }
599     
600
601 }
602

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags