Trail:

Changeset 8

Show
Ignore:
Timestamp:
07/26/08 23:24:56 (4 years ago)
Author:
harald
Message:
  • Improve c# support
  • Add generics support
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/out/templates/cs/class.vm

    r6 r8  
    66        public class $typeDescriptor.typeName#if($typeDescriptor.superClass) : $typeDescriptor.superClass#foreach($interface in $typeDescriptor.interfaces), $interface#end#else#foreach($interface in $typeDescriptor.interfaces)#if($velocityCount == 1) : #{else}, #end$interface#end#end { 
    77#foreach($fieldDescriptor in $typeDescriptor.fieldDescriptors) 
    8                 $fieldDescriptor.modifier $fieldDescriptor.qualifiedTypeName $fieldDescriptor.fieldName; 
     8                $fieldDescriptor.modifier $fieldDescriptor.qualifiedTypeName#if($fieldDescriptor.typeArguments)<#foreach($arg in $fieldDescriptor.typeArguments)#if($velocityCount>1), #end$arg#end>#end $fieldDescriptor.fieldName; 
    99#end 
    1010 
    …… 
    1414                 */ 
    1515#end 
    16                 $methodDescriptor.modifier $methodDescriptor.qualifiedTypeName ${methodDescriptor.methodName}(#foreach($parameterDescriptor in $methodDescriptor.parameterDescriptors)#if($velocityCount>1), #end$parameterDescriptor.qualifiedTypeName $parameterDescriptor.parameterName#end); 
     16                $methodDescriptor.modifier $methodDescriptor.qualifiedTypeName#if($methodDescriptor.typeArguments)<#foreach($arg in $methodDescriptor.typeArguments)#if($velocityCount>1), #end$arg#end>#end ${methodDescriptor.methodName}(#foreach($parameterDescriptor in $methodDescriptor.parameterDescriptors)#if($velocityCount>1), #end$parameterDescriptor.qualifiedTypeName#if($parameterDescriptor.typeArguments)<#foreach($arg in $parameterDescriptor.typeArguments)#if($velocityCount>1), #end$arg#end>#end $parameterDescriptor.parameterName#end); 
    1717#end 
    1818        } 

  • trunk/out/templates/cs/interface.vm

    r6 r8  
    1010                 */ 
    1111#end 
    12                 $methodDescriptor.modifier $methodDescriptor.qualifiedTypeName ${methodDescriptor.methodName}(#foreach($parameterDescriptor in $methodDescriptor.parameterDescriptors)#if($velocityCount>1), #end$parameterDescriptor.qualifiedTypeName $parameterDescriptor.parameterName#end); 
     12                $methodDescriptor.modifier $methodDescriptor.qualifiedTypeName#if($methodDescriptor.typeArguments)<#foreach($arg in $methodDescriptor.typeArguments)#if($velocityCount>1), #end$arg#end>#end ${methodDescriptor.methodName}(#foreach($parameterDescriptor in $methodDescriptor.parameterDescriptors)#if($velocityCount>1), #end$parameterDescriptor.qualifiedTypeName#if($parameterDescriptor.typeArguments)<#foreach($arg in $parameterDescriptor.typeArguments)#if($velocityCount>1), #end$arg#end>#end $parameterDescriptor.parameterName#end); 
    1313#end 
    1414        } 

  • trunk/src/org/fluffnstuff/asdoclet/AsDoclet.java

    r6 r8  
    33import com.sun.javadoc.ClassDoc; 
    44import com.sun.javadoc.DocErrorReporter; 
     5import com.sun.javadoc.LanguageVersion; 
    56import com.sun.javadoc.RootDoc; 
    67import org.fluffnstuff.asdoclet.generator.AsGenerator; 
    …… 
    1011import org.fluffnstuff.asdoclet.map.ClassTypeMap; 
    1112import org.fluffnstuff.asdoclet.map.TypeMap; 
    12 import org.fluffnstuff.asdoclet.util.EnumUtil; 
    1313 
    1414public class AsDoclet { 
    …… 
    1717    private static final String PARAM_GENERATOR = "-generator"; 
    1818    private static final String PARAM_MAP = "-map"; 
     19    private static final String PARAM_GENERIC_MAP = "-genericmap"; 
    1920    private static final String PARAM_ANNOTATION_MAP = "-annotationmap"; 
    2021 
    …… 
    5051                if (strings.length == 2) typeMap.addTypeMapping(strings[0], strings[1]); 
    5152            } 
     53            if (opt[0].equals(PARAM_GENERIC_MAP)) { 
     54                String[] strings = opt[1].split(":"); 
     55                if (strings.length == 2) typeMap.addGenericTypeMapping(strings[0], strings[1]); 
     56            } 
    5257            if (opt[0].equals(PARAM_ANNOTATION_MAP)) { 
    5358                String[] strings = opt[1].split(":"); 
    …… 
    6974        if (classDoc.isInterface()) { 
    7075            handler = new InterfaceHandler(generator); 
    71         } else if (EnumUtil.isEnum(classDoc.qualifiedTypeName())) { 
     76        } else if (classDoc.isEnum()) { 
    7277            handler = new EnumHandler(generator); 
    7378        } else { 
    …… 
    8590        if (PARAM_GENERATOR.equals(option)) length = 2; 
    8691        if (PARAM_MAP.equals(option)) length = 2; 
     92        if (PARAM_GENERIC_MAP.equals(option)) length = 2; 
    8793        if (PARAM_ANNOTATION_MAP.equals(option)) length = 2; 
    8894 
    …… 
    96102    } 
    97103 
     104    public static LanguageVersion languageVersion() { 
     105        return LanguageVersion.JAVA_1_5; 
     106    } 
     107 
    98108    private AsDoclet() { 
    99109    } 

  • trunk/src/org/fluffnstuff/asdoclet/generator/AsGenerator.java

    r7 r8  
    8181    } 
    8282 
    83     public void addField(int modifier, String fieldType, String propertyName) { 
     83    public void addField(int modifier, String fieldType, Collection<String> typeArguments, String propertyName) { 
    8484        field = ((ASClassType) type).newField(propertyName, getVisibility(modifier), fieldType); 
    8585    } 
    …… 
    9595    } 
    9696 
    97     public void addParameter(String type, String name) { 
     97    public void addParameter(String type, Collection<String> typeArguments, String name) { 
    9898        method.addParam(name, type); 
    9999        if (proxyUnit != null) proxyMethod.addParam(name, type); 
    …… 
    104104    } 
    105105 
    106     public void beginClass(String name) { 
     106    public void beginClass(String name, Collection<String> typeArguments) { 
    107107        newClass(name, false); 
    108108    } 
    …… 
    112112    } 
    113113 
    114     public void beginInterface(String name) { 
     114    public void beginInterface(String name, Collection<String> typeArguments) { 
    115115        unit = project.newInterface(name); 
    116116        type = unit.getType(); 
    117117    } 
    118118 
    119     public void beginMethod(int modifier, String returnType, String methodName) { 
     119    public void beginMethod(int modifier, String returnType, Collection<String> typeArguments, String methodName) { 
    120120        method = type.newMethod(methodName, getVisibility(modifier), returnType); 
    121121 
    …… 
    128128    } 
    129129 
    130     public void beginProxy(String proxyName, String returnType, String baseType, Collection<String> proxyImports, String interfaceType) { 
     130    public void beginProxy(String proxyName, Collection<String> typeArguments, String returnType, String baseType, Collection<String> proxyImports, String interfaceType) { 
    131131        ASCompilationUnit eventUnit = project.newClass(proxyName + "Events"); 
    132132        proxyUnit = project.newClass(proxyName); 
    …… 
    201201 
    202202    public String getAnnotation(String name, Collection<String> imports) { 
    203         return annotationMap.getType(name, false, imports); 
     203        return annotationMap.getType(name, false, false, false, imports); 
    204204    } 
    205205 
    …… 
    208208    } 
    209209 
    210     public String getType(String name, int dimensions, boolean primitive, Collection<String> imports) { 
     210    public String getType(String name, int dimensions, boolean primitive, boolean generic, boolean enumeration, Collection<String> imports) { 
    211211        if (dimensions > 0) return "Array"; 
    212         return typeMap.getType(name, primitive, imports); 
     212        return typeMap.getType(name, primitive, generic, enumeration, imports); 
    213213    } 
    214214 

  • trunk/src/org/fluffnstuff/asdoclet/generator/Generator.java

    r7 r8  
    88    void addEnumField(String name); 
    99 
    10     void addField(int modifier, String fieldType, String propertyName); 
     10    void addField(int modifier, String fieldType, Collection<String> typeArguments, String propertyName); 
    1111 
    1212    void addInterface(String name); 
    1313 
    14     void addParameter(String type, String name); 
     14    void addParameter(String type, Collection<String> typeArguments, String name); 
    1515 
    1616    void addTypeAnnotation(String tag); 
    1717 
    18     void beginClass(String name); 
     18    void beginClass(String name, Collection<String> typeArguments); 
    1919 
    2020    void beginEnum(String name); 
    2121 
    22     void beginInterface(String name); 
     22    void beginInterface(String name, Collection<String> typeArguments); 
    2323 
    24     void beginMethod(int modifier, String returnType, String methodName); 
     24    void beginMethod(int modifier, String returnType, Collection<String> typeArguments, String methodName); 
    2525 
    26     void beginProxy(String proxyName, String returnType, String baseType, Collection<String> proxyImports, String interfaceType); 
     26    void beginProxy(String proxyName, Collection<String> typeArguments, String returnType, String baseType, Collection<String> proxyImports, String interfaceType); 
    2727 
    2828    void endClass(Collection<String> imports); 
    …… 
    4242    String getName(); 
    4343 
    44     String getType(String name, int dimensions, boolean primitive, Collection<String> imports); 
     44    String getType(String name, int dimensions, boolean primitive, boolean generic, boolean enumeration, Collection<String> imports); 
    4545 
    4646    void setFieldDescription(String description); 

  • trunk/src/org/fluffnstuff/asdoclet/generator/VelocityGenerator.java

    r7 r8  
    5252 
    5353    private void initCsTypeMap() { 
     54        typeMap.addTypeMapping("?", "object"); 
     55         
    5456        typeMap.addTypeMapping("boolean", "bool"); 
    5557 
    …… 
    6365        typeMap.addTypeMapping("java.lang.Short", "short?"); 
    6466        typeMap.addTypeMapping("java.lang.Object", "object"); 
    65         typeMap.addTypeMapping("java.lang.String", "System.String"); 
     67        typeMap.addTypeMapping("java.lang.String", "string"); 
    6668        typeMap.addTypeMapping("java.lang.Exception", "System.Exception"); 
    6769 
    …… 
    7173        typeMap.addTypeMapping("java.util.Map", "System.Collections.IDictionary"); 
    7274        typeMap.addTypeMapping("java.util.Set", "System.Collections.ICollection"); 
     75 
     76        typeMap.addGenericTypeMapping("java.util.Collection", "System.Collections.Generic.ICollection"); 
     77        typeMap.addGenericTypeMapping("java.util.List", "System.Collections.Generic.IList"); 
     78        typeMap.addGenericTypeMapping("java.util.Map", "System.Collections.Generic.IDictionary"); 
     79        typeMap.addGenericTypeMapping("java.util.Set", "System.Collections.Generic.ICollection"); 
    7380    } 
    7481 
    …… 
    8087 
    8188    public void addEnumField(String name) { 
    82         addField(0, null, name); 
    83     } 
    84  
    85     public void addField(int modifier, String fieldType, String propertyName) { 
    86         fieldDescriptor = new FieldDescriptor(modifier, fieldType, propertyName); 
     89        addField(0, null, null, name); 
     90    } 
     91 
     92    public void addField(int modifier, String fieldType, Collection<String> typeArguments, String propertyName) { 
     93        fieldDescriptor = new FieldDescriptor(modifier, fieldType, typeArguments, propertyName); 
    8794        typeDescriptor.addFieldDescriptor(fieldDescriptor); 
    8895    } 
    …… 
    9299    } 
    93100 
    94     public void addParameter(String type, String name) { 
    95         parameterDescriptor = new ParameterDescriptor(type, name); 
     101    public void addParameter(String type, Collection<String> typeArguments, String name) { 
     102        parameterDescriptor = new ParameterDescriptor(type, typeArguments, name); 
    96103        methodDescriptor.addParameterDescriptor(parameterDescriptor); 
    97104    } 
    …… 
    101108    } 
    102109 
    103     public void beginClass(String name) { 
    104         beginType(new ClassDescriptor(name)); 
     110    public void beginClass(String name, Collection<String> typeArguments) { 
     111        beginType(new ClassDescriptor(name, typeArguments)); 
    105112    } 
    106113 
    …… 
    109116    } 
    110117 
    111     public void beginInterface(String name) { 
    112         beginType(new InterfaceDescriptor(name)); 
    113     } 
    114  
    115     public void beginMethod(int modifier, String returnType, String methodName) { 
    116         methodDescriptor = new MethodDescriptor(modifier, returnType, methodName); 
     118    public void beginInterface(String name, Collection<String> typeArguments) { 
     119        beginType(new InterfaceDescriptor(name, typeArguments)); 
     120    } 
     121 
     122    public void beginMethod(int modifier, String returnType, Collection<String> typeArguments, String methodName) { 
     123        methodDescriptor = new MethodDescriptor(modifier, returnType, typeArguments, methodName); 
    117124        typeDescriptor.addMethodDescriptor(methodDescriptor); 
    118     } 
    119  
    120     public void beginProxy(String proxyName, String returnType, String baseType, Collection<String> proxyImports, String interfaceType) { 
    121 //        ASCompilationUnit eventUnit = project.newClass(proxyName + "Events"); 
    122 //        eventType = (ASClassType) eventUnit.getType(); 
    123  
    124         proxyTypeDescriptor = new ClassDescriptor(proxyName); 
     125        if (proxyTypeDescriptor != null) proxyTypeDescriptor.addMethodDescriptor(methodDescriptor); 
     126    } 
     127 
     128    public void beginProxy(String proxyName, Collection<String> typeArguments, String returnType, String baseType, Collection<String> proxyImports, String interfaceType) { 
     129        proxyTypeDescriptor = new ProxyDescriptor(proxyName, typeArguments); 
    125130        proxyTypeDescriptor.addInterface(interfaceType); 
    126131 
    …… 
    133138 
    134139        if (!Constants.TYPE_VOID.equals(returnType)) proxyImports.add(returnType); 
    135  
    136 //        ASMethod callMethod = proxyType.newMethod(Constants.METHOD_CALL, Visibility.PROTECTED, returnType); 
    137 //        callMethod.addParam("name", "String"); 
    138 //        callMethod.addParam("...args", null); 
    139 //        callMethod.addStmt("throw new Error(\"Not Implemented\");"); 
    140  
    141 //        ASMethod resultMethod = proxyType.newMethod(Constants.METHOD_ON_RESULT, Visibility.PROTECTED, Constants.TYPE_VOID); 
    142 //        resultMethod.addParam("result", "Object"); 
    143  
    144 //        ASMethod statusMethod = proxyType.newMethod(Constants.METHOD_ON_STATUS, Visibility.PROTECTED, Constants.TYPE_VOID); 
    145 //        statusMethod.addParam("status", "Object"); 
    146140    } 
    147141 
    148142    public void endClass(Collection<String> imports) { 
     143        typeDescriptor = null; 
    149144    } 
    150145 
    151146    public void endEnum() { 
     147        typeDescriptor = null; 
    152148    } 
    153149 
    154150    public void endInterface(Collection<String> imports) { 
     151        typeDescriptor = null; 
    155152    } 
    156153 
    157154    public void endMethod() { 
     155        methodDescriptor = null; 
    158156    } 
    159157 
    160158    public void endProxy(Collection<String> proxyImports) { 
     159        proxyTypeDescriptor = null; 
    161160    } 
    162161 
    …… 
    188187 
    189188    public String getAnnotation(String name, Collection<String> imports) { 
    190         return annotationMap.getType(name, false, imports); 
     189        return annotationMap.getType(name, false, false, false, imports); 
    191190    } 
    192191 
    …… 
    195194    } 
    196195 
    197     public String getType(String name, int dimensions, boolean primitive, Collection<String> imports) { 
    198         return typeMap.getType(name, primitive, imports); 
     196    public String getType(String name, int dimensions, boolean primitive, boolean generic, boolean enumeration, Collection<String> imports) { 
     197        return typeMap.getType(name, primitive, generic, enumeration, imports); 
    199198    } 
    200199 

  • trunk/src/org/fluffnstuff/asdoclet/generator/velocity/ClassDescriptor.java

    r5 r8  
    11package org.fluffnstuff.asdoclet.generator.velocity; 
     2 
     3import java.util.Collection; 
    24 
    35public class ClassDescriptor extends TypeDescriptor { 
    46    private String superClass; 
    57 
    6     public ClassDescriptor(String className) { 
    7         super(className); 
     8    public ClassDescriptor(String className, Collection<String> typeArguments) { 
     9        super(className, typeArguments); 
    810    } 
    911 

  • trunk/src/org/fluffnstuff/asdoclet/generator/velocity/Descriptor.java

    r5 r8  
    99    private String typeName; 
    1010    private String description; 
     11    private Collection<String> typeArguments; 
    1112    private Collection<String> annotations = new ArrayList<String>(); 
    1213 
    13     public Descriptor(String typeName) { 
     14    public Descriptor(String typeName, Collection<String> typeArguments) { 
    1415        this.typeName = typeName; 
     16        this.typeArguments = typeArguments; 
    1517    } 
    1618 
    …… 
    2527    public void setDescription(String description) { 
    2628        this.description = description; 
     29    } 
     30 
     31    public Collection<String> getTypeArguments() { 
     32        return typeArguments; 
    2733    } 
    2834 

  • trunk/src/org/fluffnstuff/asdoclet/generator/velocity/EnumDescriptor.java

    r5 r8  
    33public class EnumDescriptor extends TypeDescriptor { 
    44    public EnumDescriptor(String typeName) { 
    5         super(typeName); 
     5        super(typeName, null); 
    66    } 
    77 

  • trunk/src/org/fluffnstuff/asdoclet/generator/velocity/FieldDescriptor.java

    r4 r8  
    22 
    33import java.lang.reflect.Modifier; 
     4import java.util.Collection; 
    45 
    56public class FieldDescriptor extends Descriptor { 
    …… 
    78    private int modifier; 
    89 
    9     public FieldDescriptor(int modifier, String type, String fieldName) { 
    10         super(type); 
     10    public FieldDescriptor(int modifier, String type, Collection<String> typeArguments, String fieldName) { 
     11        super(type, typeArguments); 
    1112 
    1213        this.fieldName = fieldName; 

  • trunk/src/org/fluffnstuff/asdoclet/generator/velocity/InterfaceDescriptor.java

    r5 r8  
    11package org.fluffnstuff.asdoclet.generator.velocity; 
    22 
     3import java.util.Collection; 
     4 
    35public class InterfaceDescriptor extends TypeDescriptor { 
    4     public InterfaceDescriptor(String typeName) { 
    5         super(typeName); 
     6    public InterfaceDescriptor(String typeName, Collection<String> typeArguments) { 
     7        super(typeName, typeArguments); 
    68    } 
    79 

  • trunk/src/org/fluffnstuff/asdoclet/generator/velocity/MethodDescriptor.java

    r4 r8  
    77    private Collection<ParameterDescriptor> parameterDescriptors = new ArrayList<ParameterDescriptor>(); 
    88 
    9     public MethodDescriptor(int modifier, String returnType, String methodName) { 
    10         super(modifier, returnType, methodName); 
     9    public MethodDescriptor(int modifier, String returnType, Collection<String> typeArguments, String methodName) { 
     10        super(modifier, returnType, typeArguments, methodName); 
    1111    } 
    1212 

  • trunk/src/org/fluffnstuff/asdoclet/generator/velocity/ParameterDescriptor.java

    r4 r8  
    11package org.fluffnstuff.asdoclet.generator.velocity; 
     2 
     3import java.util.Collection; 
    24 
    35public class ParameterDescriptor extends Descriptor { 
    46    private String parameterName; 
    57 
    6     public ParameterDescriptor(String parameterType, String parameterName) { 
    7         super(parameterType); 
     8    public ParameterDescriptor(String parameterType, Collection<String> typeArguments, String parameterName) { 
     9        super(parameterType, typeArguments); 
    810        this.parameterName = parameterName; 
    911    } 

  • trunk/src/org/fluffnstuff/asdoclet/generator/velocity/TypeDescriptor.java

    r5 r8  
    99    private Collection<String> interfaces = new ArrayList<String>(); 
    1010 
    11     public TypeDescriptor(String typeName) { 
    12         super(typeName); 
     11    public TypeDescriptor(String typeName, Collection<String> typeArguments) { 
     12        super(typeName, typeArguments); 
    1313    } 
    1414 

  • trunk/src/org/fluffnstuff/asdoclet/handler/AbstractHandler.java

    r7 r8  
    22 
    33import com.sun.javadoc.ClassDoc; 
     4import com.sun.javadoc.ParameterizedType; 
    45import com.sun.javadoc.Type; 
    56import org.fluffnstuff.asdoclet.generator.Generator; 
     7 
     8import java.util.ArrayList; 
     9import java.util.Collection; 
    610 
    711public abstract class AbstractHandler implements Handler { 
    …… 
    1620    protected Generator getGenerator() { 
    1721        return generator; 
     22    } 
     23 
     24    protected Collection<String> getTypeArguments(Type returnType) { 
     25        ParameterizedType type = returnType.asParameterizedType(); 
     26        Collection<String> args = null; 
     27        if (type != null) { 
     28            args = new ArrayList<String>(); 
     29            for (Type arg : type.typeArguments()) { 
     30                args.add(getGenerator().getType(arg.qualifiedTypeName(), getDimensions(arg), arg.isPrimitive(), false, isEnum(arg), null)); 
     31            } 
     32        } 
     33        return args; 
     34    } 
     35 
     36    protected int getDimensions(Type returnType) { 
     37        return returnType.dimension().length() / 2; 
     38    } 
     39 
     40    protected boolean isEnum(Type type) { 
     41        return type.asClassDoc() != null && type.asClassDoc().isEnum(); 
    1842    } 
    1943 
    …… 
    3458        if (description.length() > 0) getGenerator().setTypeDescription(description.toString()); 
    3559    } 
    36  
    37     protected int getDimensions(Type returnType) { 
    38         return returnType.dimension().length() / 2; 
    39     } 
    4060} 

  • trunk/src/org/fluffnstuff/asdoclet/handler/ClassHandler.java

    r7 r8  
    2525        String ignore = TagParser.getStringCommand(Constants.COMMAND_IGNORE, "", commands); 
    2626 
    27         getGenerator().beginClass(classDoc.qualifiedTypeName()); 
     27        Collection<String> arguments = getTypeArguments(classDoc); 
     28        getGenerator().beginClass(classDoc.qualifiedTypeName(), arguments); 
    2829 
     30        // todo move that to generator 
    2931        if (bindable) getGenerator().addTypeAnnotation("Bindable"); 
    3032        getGenerator().addTypeAnnotation("RemoteClass(alias=\"" + classDoc.qualifiedTypeName() + "\")"); 
    …… 
    4749                String propertyName = getBeanPropertyName(methodDoc); 
    4850                if (propertyName != null) { 
     51                    Type returnType = methodDoc.returnType(); 
    4952                    String fieldType = getFieldType(methodDoc, findField(classDoc, propertyName), imports, methodCommands); 
    50                     getGenerator().addField(Modifier.PUBLIC, fieldType, propertyName); 
     53                    Collection<String> arguments = null; 
     54 
     55                    if (fieldType == null) { 
     56                        arguments = getTypeArguments(returnType); 
     57                        fieldType = getGenerator().getType(returnType.qualifiedTypeName(), getDimensions(returnType), returnType.isPrimitive(), arguments != null, isEnum(returnType), imports); 
     58                    } 
     59 
     60                    getGenerator().addField(Modifier.PUBLIC, fieldType, arguments, propertyName); 
    5161 
    5262                    processFieldComment(methodDoc); 
    …… 
    7080    private String getFieldType(MethodDoc methodDoc, FieldDoc fieldDoc, Collection<String> imports, Map<String, String> methodCommands) { 
    7181        String overriddenType = TagParser.getStringCommand(Constants.COMMAND_TYPE, methodCommands); 
    72         Type returnType = methodDoc.returnType(); 
    7382        String fieldType; 
    7483 
    …… 
    7887            if (fieldType == null && fieldDoc != null) { 
    7988                fieldType = checkAnnotations(imports, fieldDoc.annotations()); 
    80             } 
    81  
    82             if (fieldType == null) { 
    83                 fieldType = getGenerator().getType(returnType.qualifiedTypeName(), getDimensions(returnType), returnType.isPrimitive(), imports); 
    8489            } 
    8590        } else { 
    …… 
    122127 
    123128    private void processSuperClass(ClassDoc classDoc, String ignore) { 
    124         ClassDoc superClassDoc = classDoc.superclass(); 
    125         if (superClassDoc != null) { 
    126             String superClassName = superClassDoc.qualifiedTypeName(); 
     129        Type type = classDoc.superclassType(); 
     130        if (type != null) { 
     131            String superClassName = type.qualifiedTypeName(); 
    127132            if (!superClassName.equals(Object.class.getName())) { 
    128                 superClassName = getGenerator().getType(superClassName, 0, false, null); 
     133                superClassName = getGenerator().getType(superClassName, 0, false, false, false, null); 
    129134                if (!Object.class.getName().equals(superClassName) && !ignore.contains(superClassName)) getGenerator().setSuperclass(superClassName); 
    130135            } 

  • trunk/src/org/fluffnstuff/asdoclet/handler/EnumHandler.java

    r6 r8  
    1616        processClassComment(classDoc); 
    1717 
    18         for (FieldDoc fieldDoc : classDoc.fields()) getGenerator().addEnumField(fieldDoc.name()); 
     18        for (FieldDoc fieldDoc : classDoc.enumConstants()) getGenerator().addEnumField(fieldDoc.name()); 
    1919 
    2020        getGenerator().endEnum(); 

  • trunk/src/org/fluffnstuff/asdoclet/handler/InterfaceHandler.java

    r7 r8  
    77import org.fluffnstuff.asdoclet.generator.Generator; 
    88 
    9 import java.util.Collection; 
    10 import java.util.HashMap; 
    11 import java.util.Map; 
    12 import java.util.TreeSet; 
     9import java.util.*; 
    1310 
    1411public class InterfaceHandler extends AbstractHandler { 
    …… 
    3633 
    3734        String interfaceName = classDoc.qualifiedTypeName(); 
    38  
    39         getGenerator().beginInterface(interfaceName); 
     35        Collection<String> arguments = getTypeArguments(classDoc); 
     36        getGenerator().beginInterface(interfaceName, arguments); 
    4037 
    4138        processClassComment(classDoc); 
    …… 
    4542            String baseType = TagParser.getStringCommand(Constants.COMMAND_PROXY_BASE_CLASS, commands); 
    4643 
    47             String interfaceType = getGenerator().getType(interfaceName, 0, false, proxyImports); 
    48             getGenerator().beginProxy(proxyName, asyncReturnType, baseType, proxyImports, interfaceType); 
     44            String interfaceType = getGenerator().getType(interfaceName, 0, false, false, isEnum(classDoc), proxyImports); 
     45            getGenerator().beginProxy(proxyName, arguments, asyncReturnType, baseType, proxyImports, interfaceType); 
    4946        } 
    5047 
    …… 
    7067 
    7168    private void processInterfaces(ClassDoc classDoc, Map<String, String> commands, String asyncReturnType, Collection<String> proxyImports, Collection<String> imports) { 
    72         for (ClassDoc interfaceDoc : classDoc.interfaces()) { 
    73             if (!commands.containsKey(Constants.COMMAND_IGNORE) || !commands.get(Constants.COMMAND_IGNORE).contains(interfaceDoc.qualifiedTypeName())) { 
    74                 String interfaceClass = getGenerator().getType(interfaceDoc.qualifiedTypeName(), 0, false, null); 
     69        for (Type type : classDoc.interfaceTypes()) { 
     70            if (!commands.containsKey(Constants.COMMAND_IGNORE) || !commands.get(Constants.COMMAND_IGNORE).contains(type.qualifiedTypeName())) { 
     71                String interfaceClass = getGenerator().getType(type.qualifiedTypeName(), 0, false, false, false, null); 
    7572                getGenerator().addInterface(interfaceClass); 
    7673 
    77                 processInterfaceInternal(interfaceDoc, asyncReturnType, commands, proxyImports, imports); 
     74                processInterfaceInternal(type.asClassDoc(), asyncReturnType, commands, proxyImports, imports); 
    7875            } 
    7976        } 
    …… 
    8380        for (MethodDoc methodDoc : classDoc.methods()) { 
    8481            Type returnType = methodDoc.returnType(); 
    85             String type = getGenerator().getType(returnType.qualifiedTypeName(), getDimensions(returnType), returnType.isPrimitive(), null); 
    86             processMethod(methodDoc, commands, imports, type, asyncReturnType); 
     82            Collection<String> args = getTypeArguments(returnType); 
     83            String type = getGenerator().getType(returnType.qualifiedTypeName(), getDimensions(returnType), returnType.isPrimitive(), args != null, isEnum(returnType), null); 
     84            processMethod(methodDoc, commands, imports, type, args, asyncReturnType); 
    8785        } 
    8886    } 
    8987 
    90     private void processMethod(MethodDoc methodDoc, Map<String, String> commands, Collection<String> imports, String returnType, String asyncReturnType) { 
     88    private void processMethod(MethodDoc methodDoc, Map<String, String> commands, Collection<String> imports, String returnType, Collection<String> typeArguments, String asyncReturnType) { 
    9189        Map<String, String> methodCommands = new HashMap<String, String>(commands); 
    9290 
    …… 
    9997            if (async) { 
    10098                if (!Constants.TYPE_VOID.equals(asyncReturnType)) imports.add(asyncReturnType); 
     99                getGenerator().beginMethod(0, asyncReturnType, new ArrayList<String>(), methodDoc.name()); 
    101100            } else { 
    102                 asyncReturnType = returnType; 
     101                getGenerator().beginMethod(0, returnType, typeArguments, methodDoc.name()); 
    103102            } 
    104  
    105             getGenerator().beginMethod(0, asyncReturnType, methodDoc.name()); 
    106103 
    107104            for (Parameter parameter : methodDoc.parameters()) { 
    108105                Type parameterType = parameter.type(); 
    109                 String type = getGenerator().getType(parameterType.qualifiedTypeName(), getDimensions(parameterType), parameterType.isPrimitive(), imports); 
    110                 getGenerator().addParameter(type, parameter.name()); 
     106                Collection<String> parameterArguments = getTypeArguments(parameterType); 
     107                String type = getGenerator().getType(parameterType.qualifiedTypeName(), getDimensions(parameterType), parameterType.isPrimitive(), parameterArguments != null, isEnum(parameterType), imports); 
     108                getGenerator().addParameter(type, parameterArguments, parameter.name()); 
    111109            } 
    112110 

  • trunk/src/org/fluffnstuff/asdoclet/map/ClassTypeMap.java

    r6 r8  
    55public class ClassTypeMap extends TypeMap { 
    66    @Override 
    7     public String getType(String typeName, boolean primitive, Collection<String> imports) { 
    8         String asType = super.getType(typeName, primitive, imports); 
     7    public String getType(String typeName, boolean primitive, boolean generic, boolean enumeration, Collection<String> imports) { 
     8        String asType = super.getType(typeName, primitive, generic, enumeration, imports); 
    99 
    1010        if (asType == null) { 

  • trunk/src/org/fluffnstuff/asdoclet/map/TypeMap.java

    r6 r8  
    11package org.fluffnstuff.asdoclet.map; 
    2  
    3 import org.fluffnstuff.asdoclet.util.EnumUtil; 
    42 
    53import java.util.Collection; 
    …… 
    97public class TypeMap { 
    108    protected final Map<String, String> typeMap = new HashMap<String, String>(); 
     9    protected final Map<String, String> genericTypeMap = new HashMap<String, String>(); 
    1110    private String enumType; 
    1211 
    …… 
    1514    } 
    1615 
     16    public void addGenericTypeMapping(String javaType, String asType) { 
     17        if (!genericTypeMap.containsKey(javaType)) genericTypeMap.put(javaType, asType); 
     18    } 
     19 
    1720    public void addTypeMapping(String javaType, String asType) { 
    1821        if (!typeMap.containsKey(javaType)) typeMap.put(javaType, asType); 
    1922    } 
    2023 
    21     public String getType(String typeName, boolean primitive, Collection<String> imports) { 
     24    public String getType(String typeName, boolean primitive, boolean generic, boolean enumeration, Collection<String> imports) { 
    2225        String asType = null; 
    2326 
    24         if (enumType != null && EnumUtil.isEnum(typeName)) { 
     27        if (enumType != null && enumeration) { 
    2528            asType = enumType; 
     29        } else if (generic && genericTypeMap.containsKey(typeName)) { 
     30            asType = genericTypeMap.get(typeName); 
    2631        } else if (typeMap.containsKey(typeName)) { 
    2732            asType = typeMap.get(typeName);