Changeset 17:21ccef05a598 in rrlib_serialization-java


Ignore:
Timestamp:
11.08.2014 01:33:14 (5 years ago)
Author:
Max Reichardt <mreichardt@…>
Branch:
default
Phase:
public
Message:

Performed some refactoring and tidying up: DataTypeBase no longer has an inner class DataTypeInfo. Some type traits are generated and stored.

Files:
4 edited

Legend:

Unmodified
Added
Removed
  • BinaryOutputStream.java

    r15 r17  
    543543     */ 
    544544    public void writeType(DataTypeBase type) { 
    545         type = type == null ? DataTypeBase.getNullType() : type; 
     545        type = type == null ? DataTypeBase.NULL_TYPE : type; 
    546546 
    547547        if (encoding == TypeEncoding.LocalUids) { 
  • PortDataListImpl.java

    r10 r17  
    6161            if (!constType) { 
    6262                if (wrapped.get(i) == null) { 
    63                     os.writeType(DataTypeBase.getNullType()); 
     63                    os.writeType(DataTypeBase.NULL_TYPE); 
    6464                    continue; 
    6565                } 
     
    7979            if (!constType) { 
    8080                type = is.readType(); 
    81                 if (type == DataTypeBase.getNullType()) { 
     81                if (type == null || type == DataTypeBase.NULL_TYPE) { 
    8282                    wrapped.set(i, null); 
    8383                    continue; 
  • rtti/DataType.java

    r4 r17  
    2727import org.rrlib.serialization.EnumValue; 
    2828import org.rrlib.serialization.PortDataListImpl; 
     29import org.rrlib.serialization.Serialization; 
    2930 
    3031/** 
     
    3637public class DataType<T> extends DataTypeBase { 
    3738 
    38     /** 
    39      * Data type info with factory functions 
    40      */ 
    41     static class DataTypeInfo extends DataTypeInfoRaw { 
    42  
    43         DataTypeBase dataType; 
    44  
    45         public DataTypeInfo(Class<?> c) { 
    46             type = Classification.PLAIN; 
    47             javaClass = c; 
    48             name = c.getSimpleName(); 
    49             if (c.isEnum()) { 
    50                 ArrayList<String> constants = new ArrayList<String>(); 
    51                 for (Object o : c.getEnumConstants()) { 
    52                     constants.add(EnumValue.doNaturalFormatting(o.toString())); 
    53                 } 
    54                 enumConstants = constants.toArray(); 
    55             } 
    56         } 
    57  
    58         public DataTypeInfo(DataTypeBase e, Classification type) { 
    59             this.type = type; 
    60             this.elementType = e; 
    61             if (type == Classification.LIST) { 
    62                 name = "List<" + e.getName() + ">"; 
    63             } else if (type == Classification.PTR_LIST) { 
    64                 name = "List<" + e.getName() + "*>"; 
    65             } else { 
    66                 throw new RuntimeException("Unsupported"); 
    67             } 
    68         } 
    69  
    70         public DataTypeInfo() { 
    71             throw new RuntimeException("do not call in Java"); 
    72         } 
    73  
    74         @SuppressWarnings({ "rawtypes" }) 
    75         @Override 
    76         public Object createInstance() { 
    77             Object result = null; 
    78             if (dataType.getType() == Classification.LIST || dataType.getType() == Classification.PTR_LIST) { 
    79                 return new PortDataListImpl(dataType.getElementType()); 
    80             } 
    81  
    82             try { 
    83                 if (enumConstants != null) { 
    84                     return new EnumValue(dataType); 
    85                 } else if (!(javaClass.isInterface() || Modifier.isAbstract(javaClass.getModifiers()))) { 
    86                     result = javaClass.newInstance(); 
    87                 } else { // whoops we have an interface - look for inner class that implements interface 
    88                     for (Class<?> cl : javaClass.getDeclaredClasses()) { 
    89                         if (javaClass.isAssignableFrom(cl)) { 
    90                             result = cl.newInstance(); 
    91                             break; 
    92                         } 
    93                     } 
    94                     if (result == null) { 
    95                         throw new RuntimeException("Interface and no suitable inner class"); 
    96                     } 
    97                 } 
    98             } catch (Exception e) { 
    99                 throw new RuntimeException(e); 
    100             } 
    101             return result; 
    102         } 
    103  
    104         @Override 
    105         public GenericObject createInstanceGeneric() { 
    106             return new GenericObject(createInstance(), dataType, null); 
    107         } 
    108  
    109 //        @Override 
    110 //        public void deepCopy(Object src, Object dest, Factory f) { 
    111 //            RRLibSerializable s = (RRLibSerializable)src; 
    112 //            RRLibSerializable d = (RRLibSerializable)dest; 
    113 // 
    114 //            Serialization.deepCopy(s, d, f); 
    115 //        } 
     39    public DataType(Class<T> javaClass) { 
     40        this(javaClass, null); 
    11641    } 
    11742 
    118     public DataType(Class<T> c) { 
    119         this(c, null); 
    120     } 
    121  
    122     public DataType(Class<?> c, String name) { 
    123         this(c, name, true); 
     43    public DataType(Class<?> javaClass, String name) { 
     44        this(javaClass, name, true); 
    12445    } 
    12546 
    12647    @SuppressWarnings("rawtypes") 
    127     public DataType(Class<?> c, String name, boolean createListTypes) { 
    128         super(getDataTypeInfo(c)); 
    129         if (name != null) { 
    130             info.setName(name); 
     48    public DataType(Class<?> javaClass, String name, boolean createListTypes) { 
     49        setName(name != null ? name : javaClass.getSimpleName()); 
     50        type = Classification.PLAIN; 
     51        this.javaClass = javaClass; 
     52        typeTraits = (byte)((Serialization.isBinarySerializable(javaClass) ? IS_BINARY_SERIALIZABLE : 0) | 
     53                            (Serialization.isStringSerializable(javaClass) ? IS_STRING_SERIALIZABLE : 0) | (Serialization.isXmlSerializable(javaClass) ? IS_XML_SERIALIZABLE : 0)); 
     54        if (javaClass.isEnum()) { 
     55            ArrayList<String> constants = new ArrayList<String>(); 
     56            for (Object o : javaClass.getEnumConstants()) { 
     57                constants.add(EnumValue.doNaturalFormatting(o.toString())); 
     58            } 
     59            enumConstants = constants.toArray(); 
     60            typeTraits |= IS_ENUM; 
    13161        } 
    132         ((DataTypeInfo)info).dataType = this; 
    13362 
    134         if (createListTypes && ((DataTypeInfo)info).type == Classification.PLAIN && info.listType == null) { 
    135             info.listType = new DataType(this, Classification.LIST); 
    136             info.sharedPtrListType = new DataType(this, Classification.PTR_LIST); 
     63        if (createListTypes && listType == null) { 
     64            listType = new DataType(this, Classification.LIST); 
     65            //sharedPtrListType = new DataType(this, Classification.PTR_LIST); 
    13766        } 
     67    } 
     68 
     69    @SuppressWarnings("rawtypes") 
     70    public DataType(Class<?> javaClass, Class<?> dedicatedListType, String name) { 
     71        this(javaClass, name, false); 
     72        listType = new DataType(this, Classification.LIST); 
     73        listType.javaClass = dedicatedListType; 
    13874    } 
    13975 
     
    14177     * Constructor for list types 
    14278     */ 
    143     private DataType(DataTypeBase e, Classification t) { 
    144         super(new DataTypeInfo(e, t)); 
    145         ((DataTypeInfo)info).dataType = this; 
     79    private DataType(DataTypeBase e, Classification type) { 
     80        this.type = type; 
     81        this.elementType = e; 
     82        this.typeTraits = (byte)(e.typeTraits & (IS_BINARY_SERIALIZABLE | IS_STRING_SERIALIZABLE | IS_XML_SERIALIZABLE)); 
     83        if (type == Classification.LIST) { 
     84            setName("List<" + e.getName() + ">"); 
     85        } else if (type == Classification.PTR_LIST) { 
     86            setName("List<" + e.getName() + "*>"); 
     87        } else { 
     88            throw new RuntimeException("Unsupported"); 
     89        } 
    14690    } 
    14791 
    148     private static DataTypeInfoRaw getDataTypeInfo(Class<?> c) { 
    149         DataTypeBase dt = findType(c); 
    150         if (dt != null) { 
    151             return dt.info; 
     92    @SuppressWarnings({ "rawtypes" }) 
     93    @Override 
     94    public Object createInstance() { 
     95        Object result = null; 
     96        if (javaClass == null && (getType() == Classification.LIST || getType() == Classification.PTR_LIST)) { 
     97            return new PortDataListImpl(getElementType()); 
    15298        } 
    153         return new DataTypeInfo(c); 
     99 
     100        try { 
     101            if (enumConstants != null) { 
     102                return new EnumValue(this); 
     103            } else if (!(javaClass.isInterface() || Modifier.isAbstract(javaClass.getModifiers()))) { 
     104                result = javaClass.newInstance(); 
     105            } else { // whoops we have an interface - look for inner class that implements interface 
     106                for (Class<?> cl : javaClass.getDeclaredClasses()) { 
     107                    if (javaClass.isAssignableFrom(cl)) { 
     108                        result = cl.newInstance(); 
     109                        break; 
     110                    } 
     111                } 
     112                if (result == null) { 
     113                    throw new RuntimeException("Interface and no suitable inner class"); 
     114                } 
     115            } 
     116        } catch (Exception e) { 
     117            throw new RuntimeException(e); 
     118        } 
     119        return result; 
     120    } 
     121 
     122    @Override 
     123    public GenericObject createInstanceGeneric() { 
     124        return new GenericObject(createInstance(), this, null); 
    154125    } 
    155126} 
  • rtti/DataTypeBase.java

    r4 r17  
    5656    } 
    5757 
    58     /** 
    59      * Maximum number of annotations 
    60      */ 
     58    /** Relevant type traits across runtime environments */ 
     59    public static final byte IS_BINARY_SERIALIZABLE = 1 << 0; 
     60    public static final byte IS_STRING_SERIALIZABLE = 1 << 1; 
     61    public static final byte IS_XML_SERIALIZABLE = 1 << 2; 
     62    public static final byte IS_ENUM = 1 << 3; 
     63 
     64    /** Null type */ 
     65    public static DataTypeBase NULL_TYPE = new DataTypeBase(true); 
     66 
     67    /** Maximum number of annotations */ 
    6168    private static final int MAX_ANNOTATIONS = 10; 
    6269 
     
    6471    private final static int MAX_TYPES = 2000; 
    6572 
    66  
    67     /** Data type info */ 
    68     static public class DataTypeInfoRaw { 
    69  
    70         /** Type of data type */ 
    71         public Classification type; 
    72  
    73         /** Name of data type */ 
    74         public String name; 
    75  
    76         /** New info? */ 
    77         boolean newInfo = true; 
    78  
    79         /*! Is this the default name? - then it may be changed */ 
    80         public boolean defaultName = true; 
    81  
    82         /** Data type uid */ 
    83         public short uid = -1; 
    84  
    85         /** Java Class */ 
    86         public Class<?> javaClass; 
    87  
    88         /** In case of list: type of elements */ 
    89         public DataTypeBase elementType; 
    90  
    91         /** In case of element: list type (std::vector<T>) */ 
    92         public DataTypeBase listType; 
    93  
    94         /** In case of element: shared pointer list type (std::vector<std::shared_ptr<T>>) */ 
    95         public DataTypeBase sharedPtrListType; 
    96  
    97         /** Annotations to data type */ 
    98         public DataTypeAnnotation[] annotations = new DataTypeAnnotation[MAX_ANNOTATIONS]; 
    99  
    100         /** Enum Constants - if this a enum type */ 
    101         public Object[] enumConstants; 
    102  
    103         public DataTypeInfoRaw() { 
    104             defaultName = true; 
    105         } 
    106  
    107         /** 
    108          * Set name of data type 
    109          * (only valid if still default == not set before) 
    110          * 
    111          * @param newName New name of type 
    112          */ 
    113         public void setName(String newName) { 
    114             if (!defaultName) { 
    115                 assert(name.equals(newName)) : "Name already set"; 
    116                 return; 
    117             } 
    118  
    119             defaultName = false; 
    120             name = newName; 
    121         } 
    122  
    123         /** 
    124          * @return Instance of type casted to Object 
    125          */ 
    126         public Object createInstance() { 
    127             return null; 
    128         } 
    129  
    130         /** 
    131          * @return Instance of Datatype as Generic object 
    132          */ 
    133         public GenericObject createInstanceGeneric() { 
    134             return null; 
    135         } 
    136  
    137 //        /** 
    138 //         * Deep copy objects 
    139 //         * 
    140 //         * @param src Src object 
    141 //         * @param dest Destination object 
    142 //         * @param f Factory to use 
    143 //         */ 
    144 //        public void deepCopy(Object src, Object dest, Factory f) {} 
    145     } 
    146  
    147 //    /** Maximum number of types */ 
    148 //    public static final int MAX_TYPES = 2000; 
    149  
    150     /** Pointer to data type info (should not be copied every time for efficiency reasons) */ 
    151     protected final DataTypeInfoRaw info; 
    152  
    153     /** List with all registered data types */ 
     73    /** Type of data type */ 
     74    protected Classification type; 
     75 
     76    /** Name of data type */ 
     77    private String name; 
     78 
     79    /** Is this the default name? - then it may be changed */ 
     80    protected boolean defaultName = true; 
     81 
     82    /** Data type uid */ 
     83    private short uid = -1; 
     84 
     85    /** Java Class */ 
     86    protected Class<?> javaClass; 
     87 
     88    /** In case of list: type of elements */ 
     89    protected DataTypeBase elementType; 
     90 
     91    /** In case of element: list type (std::vector<T>) */ 
     92    protected DataTypeBase listType; 
     93 
     94    /** In case of element: shared pointer list type (std::vector<std::shared_ptr<T>>) */ 
     95    protected DataTypeBase sharedPtrListType; 
     96 
     97    /** Annotations to data type */ 
     98    private DataTypeAnnotation[] annotations = new DataTypeAnnotation[MAX_ANNOTATIONS]; 
     99 
     100    /** Enum Constants - if this a enum type */ 
     101    protected Object[] enumConstants; 
     102 
     103    /** List with all registered data types (preallocated to avoid reallocations => concurrent use is possible) */ 
    154104    private static ArrayList<DataTypeBase> types = new ArrayList<DataTypeBase>(MAX_TYPES); 
    155  
    156     /** Null type */ 
    157     private static DataTypeBase NULL_TYPE = new DataTypeBase(null); 
    158105 
    159106    /** Lookup for data type annotation index */ 
     
    163110    private static final AtomicInteger lastAnnotationIndex = new AtomicInteger(0); 
    164111 
    165     /** 
    166      * @param name Name of data type 
    167      */ 
    168     public DataTypeBase(DataTypeInfoRaw info) { 
    169         this.info = info; 
    170  
    171         if (info != null && info.newInfo == true) { 
    172             synchronized (types) { 
    173                 addType(info); 
    174             } 
    175         } 
    176     } 
    177  
    178     /** 
    179      * Helper for constructor (needs to be called in synchronized context) 
    180      */ 
    181     private void addType(DataTypeInfoRaw nfo) { 
    182         nfo.uid = (short)getTypes().size(); 
    183         if (getTypes().size() >= MAX_TYPES) { 
    184             Log.log(LogLevel.ERROR, this, "Maximum number of data types exceeded. Increase cMAX_TYPES."); 
    185             throw new RuntimeException("Maximum number of data types exceeded. Increase MAX_TYPES."); 
    186         } 
    187         getTypes().add(this); 
    188         nfo.newInfo = false; 
    189         String msg = "Adding data type " + getName(); 
    190         Log.log(LogLevel.DEBUG_VERBOSE_1, this, msg); 
     112    /** Type traits of this type (bit vector - see constants above) */ 
     113    protected byte typeTraits; 
     114 
     115    ///** Is this a remote type? */ 
     116    //protected boolean remoteType = false; 
     117 
     118    public DataTypeBase() { 
     119        synchronized (types) { 
     120            uid = (short)types.size(); 
     121            if (types.size() >= MAX_TYPES) { 
     122                Log.log(LogLevel.ERROR, this, "Maximum number of data types exceeded. Increase cMAX_TYPES."); 
     123                throw new RuntimeException("Maximum number of data types exceeded. Increase MAX_TYPES."); 
     124            } 
     125            types.add(this); 
     126            Log.log(LogLevel.DEBUG_VERBOSE_1, this, "Adding data type " + getName()); 
     127        } 
     128    } 
     129 
     130    private DataTypeBase(boolean nulltype) { 
     131        this.name = "NULL"; 
     132        this.uid = -1; 
     133        this.type = Classification.NULL; 
    191134    } 
    192135 
     
    195138     */ 
    196139    public String getName() { 
    197         String unknown = "NULL"; 
    198         if (info != null) { 
    199             return info.name; 
    200         } 
    201         return unknown; 
     140        return name; 
    202141    } 
    203142 
     
    206145     */ 
    207146    public static short getTypeCount() { 
    208         return (short)getTypes().size(); 
    209     } 
    210  
    211     /** 
    212      * @return uid of data type 
     147        return (short)types.size(); 
     148    } 
     149 
     150    /** 
     151     * @return Uid of data type 
    213152     */ 
    214153    public short getUid() { 
    215         if (info != null) { 
    216             return info.uid; 
    217         } 
    218         return -1; 
     154        return uid; 
    219155    } 
    220156 
     
    223159     */ 
    224160    public Classification getType() { 
    225         if (info != null) { 
    226             return info.type; 
    227         } 
    228         return Classification.NULL; 
     161        return type; 
    229162    } 
    230163 
     
    233166     */ 
    234167    public DataTypeBase getListType() { 
    235         if (info != null) { 
    236             return info.listType; 
    237         } 
    238         return getNullType(); 
     168        return listType; 
    239169    } 
    240170 
     
    243173     */ 
    244174    public DataTypeBase getElementType() { 
    245         if (info != null) { 
    246             return info.elementType; 
    247         } 
    248         return getNullType(); 
     175        return elementType; 
    249176    } 
    250177 
     
    253180     */ 
    254181    public DataTypeBase getSharedPtrListType() { 
    255         if (info != null) { 
    256             return info.sharedPtrListType; 
    257         } 
    258         return getNullType(); 
     182        return sharedPtrListType; 
    259183    } 
    260184 
     
    263187     */ 
    264188    public Class<?> getJavaClass() { 
    265         if (info != null) { 
    266             return info.javaClass; 
    267         } else { 
    268             return null; 
    269         } 
    270     } 
    271  
    272 //    /** 
    273 //     * Deep copy objects 
    274 //     * 
    275 //     * @param src Src object 
    276 //     * @param dest Destination object 
    277 //     * @param f Factory to use 
    278 //     */ 
    279 //    public void deepCopy(Object src, Object dest, Factory f) { 
    280 //        if (info == null) { 
    281 //            return; 
    282 //        } 
    283 //        info.deepCopy(src, dest, f); 
    284 //    } 
    285  
    286     /** 
    287      * Helper method that safely provides static data type list 
    288      */ 
    289     static private ArrayList<DataTypeBase> getTypes() { 
    290         return types; 
     189        return javaClass; 
     190    } 
     191 
     192    /** 
     193     * @return Bit vector of type traits 
     194     */ 
     195    public byte getTypeTraits() { 
     196        return typeTraits; 
    291197    } 
    292198 
     
    299205    static public DataTypeBase findType(Class<?> c) { 
    300206        for (DataTypeBase db : types) { 
    301             if (db.info.javaClass == c) { 
     207            if (db.javaClass == c) { 
    302208                return db; 
    303209            } 
     
    308214    /** 
    309215     * @param uid Data type uid 
    310      * @return Data type with specified uid 
     216     * @return Data type with specified uid (possibly NULL_TYPE); null if no data type with this uid exists 
    311217     */ 
    312218    static public DataTypeBase getType(short uid) { 
    313219        if (uid == -1) { 
    314             return getNullType(); 
    315         } 
    316         return getTypes().get(uid); 
     220            return NULL_TYPE; 
     221        } 
     222        return types.get(uid); 
    317223    } 
    318224 
     
    321227     * 
    322228     * @param name Data Type name 
    323      * @return Data type with specified name (NULL if it could not be found) 
     229     * @return Data type with specified name (possibly NULL_TYPE); null if it could not be found 
    324230     */ 
    325231    static public DataTypeBase findType(String name) { 
    326         boolean nulltype = name.equals("NULL"); 
    327         if (nulltype) { 
    328             return getNullType(); 
    329         } 
    330  
    331         for (int i = 0; i < getTypes().size(); i++) { 
    332             DataTypeBase dt = getTypes().get(i); 
    333             boolean eq = name.equals(dt.getName()); 
    334             if (eq) { 
     232        if (name.equals(NULL_TYPE.name)) { 
     233            return NULL_TYPE; 
     234        } 
     235 
     236        for (int i = 0; i < types.size(); i++) { 
     237            DataTypeBase dt = types.get(i); 
     238            if (name.equals(dt.getName())) { 
    335239                return dt; 
    336240            } 
     
    345249 
    346250    /** 
    347      * @return Instance of Datatype T casted to void* 
     251     * @return Instance of Datatype T 
    348252     */ 
    349253    public Object createInstance() { 
    350         if (info == null) { 
    351             return null; 
    352         } 
    353         return info.createInstance(); 
     254        return null; 
    354255    } 
    355256 
     
    357258     * @return Instance of Datatype as Generic object 
    358259     */ 
    359     GenericObject createInstanceGeneric() { 
    360         if (info == null) { 
    361             return null; 
    362         } 
    363         return info.createInstanceGeneric(); 
     260    protected GenericObject createInstanceGeneric() { 
     261        return null; 
    364262    } 
    365263 
     
    405303 
    406304    /** 
    407      * @return Nulltype 
    408      */ 
    409     public static DataTypeBase getNullType() { 
    410         return NULL_TYPE; 
    411     } 
    412  
    413     /** 
    414      * @return DataTypeInfo object 
    415      */ 
    416     public DataTypeInfoRaw getInfo() { 
    417         return info; 
    418     } 
    419  
    420     /** 
    421305     * Can object of this data type be converted to specified type? 
    422306     * (In C++ currently only returns true, when types are equal) 
     
    430314            return true; 
    431315        } 
    432         if (info == null || dataType.info == null) { 
     316        if (type == Classification.NULL || dataType.type == Classification.NULL) { 
    433317            return false; 
    434318        } 
     
    439323            return getElementType().isConvertibleTo(dataType.getElementType()); 
    440324        } 
    441         if ((info.javaClass != null) && (dataType.info.javaClass != null)) { 
    442             return dataType.getInfo().javaClass.isAssignableFrom(info.javaClass); 
     325        if ((javaClass != null) && (dataType.javaClass != null)) { 
     326            return dataType.javaClass.isAssignableFrom(javaClass); 
    443327        } 
    444328        return false; 
     
    451335     */ 
    452336    public <T extends DataTypeAnnotation> void addAnnotation(T ann) { 
    453         if (info != null) { 
    454  
    455             assert(ann.annotatedType == null) : "Already used as annotation in other object. Not allowed (double deleteting etc.)"; 
    456             ann.annotatedType = this; 
    457             int annIndex = -1; 
    458             synchronized (types) { 
    459                 Integer i = annotationIndexLookup.get(ann.getClass()); 
    460                 if (i == null) { 
    461                     i = lastAnnotationIndex.incrementAndGet(); 
    462                     annotationIndexLookup.put(ann.getClass(), i); 
    463                 } 
    464                 annIndex = i; 
    465             } 
    466  
    467             assert(annIndex > 0 && annIndex < MAX_ANNOTATIONS); 
    468             assert(info.annotations[annIndex] == null); 
    469  
    470             info.annotations[annIndex] = ann; 
    471         } else { 
    472             throw new RuntimeException("Nullptr"); 
    473         } 
     337        assert(ann.annotatedType == null) : "Already used as annotation in other object. Not allowed (double deleteting etc.)"; 
     338        ann.annotatedType = this; 
     339        int annIndex = -1; 
     340        synchronized (types) { 
     341            Integer i = annotationIndexLookup.get(ann.getClass()); 
     342            if (i == null) { 
     343                i = lastAnnotationIndex.incrementAndGet(); 
     344                annotationIndexLookup.put(ann.getClass(), i); 
     345            } 
     346            annIndex = i; 
     347        } 
     348 
     349        assert(annIndex > 0 && annIndex < MAX_ANNOTATIONS); 
     350        assert(annotations[annIndex] == null); 
     351 
     352        annotations[annIndex] = ann; 
    474353    } 
    475354 
     
    482361    @SuppressWarnings("unchecked") 
    483362    public <T extends DataTypeAnnotation> T getAnnotation(Class<T> c) { 
    484         if (info != null) { 
    485             return (T)info.annotations[annotationIndexLookup.get(c)]; 
    486         } else { 
    487             throw new RuntimeException("Nullptr"); 
    488         } 
     363        return (T)annotations[annotationIndexLookup.get(c)]; 
    489364    } 
    490365 
     
    497372     */ 
    498373    public Object[] getEnumConstants() { 
    499         if (info != null) { 
    500             return info.enumConstants; 
    501         } 
    502         return null; 
     374        return enumConstants; 
     375    } 
     376 
     377    /** 
     378     * Set name of data type 
     379     * (only valid if still default == not set before) 
     380     * 
     381     * @param newName New name of type 
     382     */ 
     383    protected void setName(String newName) { 
     384        if (!defaultName) { 
     385            assert(name.equals(newName)) : "Name already set"; 
     386            return; 
     387        } 
     388        defaultName = false; 
     389        name = newName; 
     390 
     391        for (int i = 0; i < types.size(); i++) { 
     392            if (i != uid && types.get(i).getName().equals(newName)) { 
     393                Log.log(LogLevel.WARNING, "Two types with the same name were registered: " + newName); 
     394            } 
     395        } 
    503396    } 
    504397} 
Note: See TracChangeset for help on using the changeset viewer.