Changeset 21:a9cf36ab3ee4 in rrlib_serialization-java


Ignore:
Timestamp:
03.09.2014 11:32:26 (5 years ago)
Author:
Max Reichardt <mreichardt@…>
Branch:
14.08
Phase:
public
Message:

Adapted rrlib_serialization-java in order to be able to support remote (C++) enum types that have custom, non-standard values

Files:
5 edited

Legend:

Unmodified
Added
Removed
  • BinaryInputStream.java

    r15 r21  
    637637        } else if (strings.length <= 0x100) { 
    638638            return readByte(); 
    639         } else if (strings.length <= 0x1000) { 
     639        } else if (strings.length <= 0x10000) { 
    640640            return readShort(); 
    641641        } else { 
    642             assert(strings.length < 0x7FFFFFFF) : "What?"; 
     642            assert(strings.length < 0x7FFFFFFF); 
    643643            return readInt(); 
    644644        } 
  • BinaryOutputStream.java

    r17 r21  
    434434    public void writeEnum(int value, Object[] constants) { 
    435435        if (constants.length == 0) { 
    436             assert(value < 0x7FFFFFFF) : "What?"; 
     436            assert(value < 0x7FFFFFFF); 
    437437            writeInt(value); 
    438438        } else if (constants.length <= 0x100) { 
    439439            writeByte((byte) value); 
    440         } else if (constants.length <= 0x1000) { 
     440        } else if (constants.length <= 0x10000) { 
    441441            writeShort((short) value); 
    442442        } else { 
    443             assert(constants.length < 0x7FFFFFFF) : "What?"; 
     443            assert(constants.length < 0x7FFFFFFF); 
    444444            writeInt(value); 
    445445        } 
  • EnumValue.java

    r0 r21  
    3737    private DataTypeBase type; 
    3838 
    39     /** Current wrapped enum value */ 
    40     private int value; 
     39    /** Current wrapped enum value (index of enum) */ 
     40    private int enumIndex; 
    4141 
    4242    public EnumValue() {} 
     
    5050    @Override 
    5151    public void serialize(BinaryOutputStream os) { 
    52         os.writeEnum(value, type.getEnumConstants()); 
     52        os.writeEnum(enumIndex, type.getEnumConstants()); 
    5353    } 
    5454 
    5555    @Override 
    5656    public void deserialize(BinaryInputStream is) { 
    57         value = is.readEnum(type.getEnumConstants()); 
     57        enumIndex = is.readEnum(type.getEnumConstants()); 
    5858    } 
    5959 
    6060    @Override 
    6161    public void serialize(StringOutputStream os) { 
    62         os.append(type.getEnumConstants()[value].toString()).append(" (").append(value).append(")"); 
     62        os.append(toString()); 
    6363    } 
    6464 
    6565    @Override 
    6666    public void deserialize(StringInputStream is) throws Exception { 
    67         value = is.readEnum(type.getEnumConstants()); 
     67        enumIndex = is.readEnum(type.getEnumConstants(), type.getNonStandardEnumValues()); 
    6868    } 
    6969 
     
    7171     * @return Enum value's ordinal 
    7272     */ 
    73     public int getOrdinal() { 
    74         return value; 
     73    public long getOrdinal() { 
     74        if (type.getNonStandardEnumValues() != null) { 
     75            return type.getNonStandardEnumValues()[enumIndex]; 
     76        } 
     77        return enumIndex; 
     78    } 
     79 
     80    /** 
     81     * @return Enum value index 
     82     */ 
     83    public int getIndex() { 
     84        return enumIndex; 
    7585    } 
    7686 
    7787    @Override 
    7888    public void copyFrom(EnumValue source) { 
    79         value = source.value; 
     89        enumIndex = source.enumIndex; 
    8090        type = source.type; 
    8191    } 
     
    99109    @Override 
    100110    public Number getNumericRepresentation() { 
    101         return value; 
     111        return getOrdinal(); 
    102112    } 
    103113 
     
    105115     * @param ordinal New ordinal value 
    106116     */ 
    107     public void set(int ordinal) { 
    108         value = ordinal; 
     117    public void setOrdinal(long ordinal) throws Exception { 
     118        if (type.getNonStandardEnumValues() != null) { 
     119            for (int i = 0; i < type.getNonStandardEnumValues().length; i++) { 
     120                if (type.getNonStandardEnumValues()[i] == ordinal) { 
     121                    enumIndex = i; 
     122                    return; 
     123                } 
     124            } 
     125            throw new Exception("No enum constant found for value " + ordinal); 
     126        } 
     127        enumIndex = (int)ordinal; 
     128    } 
     129 
     130    /** 
     131     * @param ordinal New enum index 
     132     */ 
     133    public void setIndex(int index) { 
     134        if (index > type.getEnumConstants().length) { 
     135            throw new IndexOutOfBoundsException("Invalid index " + index); 
     136        } 
     137        enumIndex = index; 
    109138    } 
    110139 
     
    120149        if (other instanceof EnumValue) { 
    121150            EnumValue o = (EnumValue)other; 
    122             return value == o.value && type == o.type; 
     151            return enumIndex == o.enumIndex && type == o.type; 
    123152        } 
    124153        return false; 
     
    126155 
    127156    public String toString() { 
    128         return Serialization.serialize(this); 
     157        return type.getEnumConstants()[enumIndex].toString() + " (" + getOrdinal() + ")"; 
    129158    } 
    130159} 
  • StringInputStream.java

    r15 r21  
    233233    @SuppressWarnings({ "rawtypes" }) 
    234234    public <E extends Enum> E readEnum(Class<E> eclass) { 
    235         return eclass.getEnumConstants()[readEnum(eclass.getEnumConstants())]; 
     235        return eclass.getEnumConstants()[readEnum(eclass.getEnumConstants(), null)]; 
    236236    } 
    237237 
    238238    /** 
    239239     * @param enumConstants Enum constants (only their toString() method is used) 
    240      * @return Enum value 
    241      */ 
    242     public int readEnum(Object[] enumConstants) { 
     240     * @param enumValue Non-standard enum value - otherwise null 
     241     * @return Enum value (index in case of non-standard values) 
     242     */ 
     243    public int readEnum(Object[] enumConstants, long[] enumValues) { 
    243244        // parse input 
    244245        String enumString = readWhile("", DIGIT | LETTER | WHITESPACE, true).trim(); 
     
    272273            throw new RuntimeException("No Number String specified"); 
    273274        } 
    274         int n = Integer.parseInt(numString); 
    275         if (n >= enumConstants.length) { 
    276             Log.log(LogLevel.ERROR, this, "Number " + n + " out of range for enum (" + enumConstants.length + ")"); 
     275        long num = Long.parseLong(numString); 
     276        if (enumValues != null) { 
     277            boolean found = false; 
     278            for (int i = 0; i < enumValues.length; i++) { 
     279                if (num == enumValues[i]) { 
     280                    found = true; 
     281                    num = i; 
     282                    break; 
     283                } 
     284            } 
     285            if (!found) { 
     286                throw new RuntimeException("Number not a valid enum constant"); 
     287            } 
     288        } 
     289 
     290        if (num >= enumConstants.length) { 
     291            Log.log(LogLevel.ERROR, this, "Number " + num + " out of range for enum (" + enumConstants.length + ")"); 
    277292            throw new RuntimeException("Number out of range"); 
    278293        } 
    279         return n; 
     294        return (int)num; 
    280295    } 
    281296 
  • rtti/DataTypeBase.java

    r19 r21  
    9999    protected Object[] enumConstants; 
    100100 
     101    /** Array with enum values - if this is a remote enum type with non-standard values */ 
     102    protected long[] enumValues; 
     103 
    101104    /** List with all registered data types (preallocated to avoid reallocations => concurrent use is possible) */ 
    102105    private static ArrayList<DataTypeBase> types = new ArrayList<DataTypeBase>(MAX_TYPES); 
     
    384387 
    385388    /** 
    386      * \return If this is as enum type, returns enum constant names - otherwise NULL 
     389     * @return If this is as enum type, returns enum constant names - otherwise NULL 
    387390     */ 
    388391    public Object[] getEnumConstants() { 
    389392        return enumConstants; 
    390393    } 
     394    /** 
     395     * @return Array with enum values - if this is a remote enum type with non-standard values 
     396     */ 
     397    public long[] getNonStandardEnumValues() { 
     398        return enumValues; 
     399    } 
    391400} 
Note: See TracChangeset for help on using the changeset viewer.