Complex Template How To

1. Create your template file
   • Template files singularities:
     • In every case:
       • Declaration for one import:
         • Use tag : <aw:import>aValue</aw:import>
           
         • aValue represents the import value
         • Caution: One import and only one by tag, no ;
         • Example :

           <aw:import>java.io.Serializable</aw:import>
           

         
         
       • Declaration for one interface implemented by the objet:
         • Use the tag : <aw:interface>aValue</aw:interface>
           
         • aValue represents an interface value
         • Caution: One interface and only one per tag, no ;. Use long name.
         • Example :

           <aw:interface>java.io.Serializable</aw:interface>
           

         
         
       • Declaration of the super class of the object:
         • Use the tag : <aw:parentClass>aValue</aw:parentClass>
           
         • Caution: No extends or ;. Use long name.
         • Example :

           <aw:parentClass>java.lang.Exception</aw:parentClass>
           

         
         
       • Specific Tokens:
         • <aw:className/> : will be replaced by the class name of the created object
         • <aw:packageName/> : will be replaced by the package class name of the created object
         
         
       • Attribut declaration:
         • start with: <aw:field> end by </aw:field>
           
         • Example :

           <aw:field>
             /** This is its int array. */
             protected int[] anIntTab;
           	
           </aw:field>
           

         
         
       • Declaration of a constructor:
         • Starts with <aw:constructor name="aName"> and ends with </aw:constructor>
           
         • aName represents a key name, it must be unique
         • Caution : If user uncheck "Create constructors" from the wizard panel, then no constructor will be generate.
         • Example :

           <aw:constructor name="C1">
             /**
              * Constructor of the object.
              */
             public <aw:className/>() {
               super();
             }
           </aw:constructor>
           

         
         
       • Declaration of one method:
         • Starts with <aw:method name="aName"> and ends with </aw:method>
           
         • aName represents a key name, it must be unique
         • The value main for aName is reserved and allow filtrage in the wizard panel.
         • In the same way, some other values are used with template Applet, Servlet and Factory.
         • Example :

           <aw:method name="toString">
             /**
              * Returns a string representation of the object. In general, the 
              * toString method returns a string that 
              * " textually represents " this object.
              *
              * @return  a string representation of the object.
              */
             public String toString() {
               StringBuffer sb = new StringBuffer();
               sb.append('[');
               sb.append(getClass());
               sb.append(']');
               return sb.toString();
             }
           
           </aw:method>
           
           

         
         
       • Static code:
         • There is no tag for doing static codes, but you can do it with the method, or constructor or attribut tag.
         • Example with constructor tag:

           <aw:constructor name="C1"> 
             /**
              * Constructor of the object.
              */
             public <aw:className/>() {
               super();
             }
           
             static {
               System.out.println("Yes");
             }
           </aw:constructor>
           

         • Example with the attribute tag:

           
           <aw:field>
             /** This is the array of object. */
             protected <aw:containedTypeEntered/>[] itsArray;
           
             static {
               System.out.println("Yes");
             }	
           </aw:field>
           

       
       
     • For list/array/set/map:
       • Specific Token:
         • <aw:listType/>: represents the name of the class that implements the interface java.util.List.
         • <aw:mapType/>: represents the name of the class that implements the interface java.util.Map.
         • <aw:setType/>: represents the name of the class that implements the interface java.util.Set.
         • <aw:containedTypeEntered/>: Will be replace by the value entered by the user throught the wizard panel, this value represents what will be inside the list/array/set/map
         • <aw:containedTypeClassName/>: Will be replaced by the name of the class representing what is inside the list/array/set/map.
           If <aw:containedTypeEntered/> is int then <aw:containedTypeClassName/> will be Integer.
           If <aw:containedTypeEntered/> is java.lang.String then <aw:containedTypeClassName/> will be java.lang.String.
         • <aw:containedTypeAsNull/>: sWill be replace by the null value of the class that is inside the list/array/set/map.
           If <aw:containedTypeEntered/> is int then <aw:containedTypeClassName/> will be Integer.MIN_VALUE.
           If <aw:containedTypeEntered/> is java.lang.String then <aw:containedTypeClassName/> will be null.
         • <aw:containedKeyEntered/>: Like <aw:containedTypeEntered/> but for the key of map.
         • <aw:containedKeyClassName/>: Like <aw:containedTypeClassName/> but for the key of map.
         • <aw:containedKeyAsNull/>: Like <aw:containedTypeAsNull/> but for the key of map.
         
         
       • Transformators:
         • <aw:containedTypeAsValue>value</aw:containedTypeAsValue> : Use this with structures that contains wrapped object that you want a basic type.
           Example : If the ArrayList contains some int, they will be wrapped with Integer. Writting <aw:containedTypeAsValue>anElement</aw:containedTypeAsValue> will generate the code anElement.intValue().
           Does nothing if the ArrayList contains Object.
         • <aw:containedKeyAsValue>value</aw:containedKeyAsValue> : same, but for the key of map.
         • <aw:containedTypeAsObject>value</aw:containedTypeAsObject> : Transforms a basic type in its wrapper.
           Example : If the ArrayList contains some int, they must be wrapped into Integer. Writting <aw:containedTypeAsObject>anElement</aw:containedTypeAsObject> will generate the code new Integer(anElement).
           Does nothing if the ArrayList contains Object.
         • <aw:containedKeyAsObject>value</aw:containedKeyAsObject> : same, but for the key of map.
         • Caution: Do NOT put a transformator inside a transformator.
     
     
   • You do not need to re-start Eclipse when you change a templa file.
   
   
2. Change/Edit the templates.properties file that is located in the directory [InstallEclipse]/plugins/com.aston.plugins
   • Add an entry for your template
     • JSP Template:
       jsp.template.3=fileName
       jsp.template.3.label=Label for Eclipse
       
     • HTML Template:
       html.template.3=fileName
       html.template.3.label=Label for Eclipse
       
     • HTML for applet:
       applethtml.template.2=fileName
       applethtml.template.2.label=Label for Eclipse
       
     • WARNING : in all case numbers should be in order
     • 'fileName' is the complete name (with its extension) of your template file
     • 'Label for Eclipse' is what Eclipse will show you
   • Adding an implemented structure.
     • If you want to add an implementation for the interface List, Set, Map you must do it throught the file templates.properties.
     • For example, with a Map, you just have to add the ligne:
       struct.map.6=java.util.IdentityHashMap
   
   
3. If you have change the templates.properties file, while Eclipse was running you will need to stop and re-start it.