Changeset 1:ee0db83bc281 in rrlib_serialization-java


Ignore:
Timestamp:
08.12.2013 11:37:13 (6 years ago)
Author:
Max Reichardt <mreichardt@…>
Branch:
default
Phase:
public
Message:

Cleaned up and added writeObject() and readObject() methods to binary streams

Files:
3 deleted
5 edited

Legend:

Unmodified
Added
Removed
  • BinaryInputStream.java

    r0 r1  
    763763        return readLong() / 1000000; 
    764764    } 
     765 
     766    /** 
     767     * Deserializes object of specified type 
     768     * 
     769     * @param type Type object must have 
     770     * @return Deserialized object (new object for immutable types, provided object in case of a mutable type) 
     771     */ 
     772    public Object readObject(Class<?> type) throws Exception { 
     773        return readObject(null, type); 
     774    } 
     775 
     776    /** 
     777     * Deserializes object of specified type 
     778     * 
     779     * @param deserializeTo Object to call deserialize() on (optional; will contain result of deserialization, in case type is a mutable type) 
     780     * @param type Type object must have 
     781     * @return Deserialized object (new object for immutable types, provided object in case of a mutable type) 
     782     */ 
     783    @SuppressWarnings({ "rawtypes", "unchecked" }) 
     784    public Object readObject(Object deserializeTo, Class<?> type) throws Exception { 
     785        if (BinarySerializable.class.isAssignableFrom(type)) { 
     786            if (deserializeTo == null) { 
     787                deserializeTo = type.newInstance(); 
     788            } 
     789            ((BinarySerializable)deserializeTo).deserialize(this); 
     790            return deserializeTo; 
     791        } else if (type.isPrimitive()) { 
     792            if (type == byte.class) { 
     793                return readByte(); 
     794            } else if (type == short.class) { 
     795                return readShort(); 
     796            } else if (type == int.class) { 
     797                return readInt(); 
     798            } else if (type == long.class) { 
     799                return readLong(); 
     800            } else if (type == float.class) { 
     801                return readFloat(); 
     802            } else if (type == double.class) { 
     803                return readDouble(); 
     804            } else if (type == boolean.class) { 
     805                return readBoolean(); 
     806            } else { 
     807                throw new Exception("Unsupported primitive type"); 
     808            } 
     809        } else if (type.isEnum()) { 
     810            return readEnum((Class <? extends Enum >)type); 
     811        } else if (type == String.class) { 
     812            return readString(); 
     813        } else { 
     814            throw new Exception("Unsupported type"); 
     815        } 
     816    } 
    765817} 
  • BinaryOutputStream.java

    r0 r1  
    552552    } 
    553553 
     554    /** 
     555     * Write object to stream (without any type information) 
     556     * 
     557     * @param object Object to write to stream 
     558     * @param type Type of object (if serialization is consistent, could be base class) 
     559     */ 
     560    public void writeObject(Object object) { 
     561        writeObject(object, object.getClass()); 
     562    } 
     563 
     564    /** 
     565     * Write object to stream (without any type information) 
     566     * 
     567     * @param object Object to write to stream 
     568     * @param type Type of object (if serialization is consistent, could be base class) 
     569     */ 
     570    @SuppressWarnings("rawtypes") 
     571    public void writeObject(Object object, Class<?> type) { 
     572        if (BinarySerializable.class.isAssignableFrom(type)) { 
     573            ((BinarySerializable)object).serialize(this); 
     574        } else if (type.isPrimitive()) { 
     575            if (type == byte.class) { 
     576                writeByte((Byte)object); 
     577            } else if (type == short.class) { 
     578                writeShort((Short)object); 
     579            } else if (type == int.class) { 
     580                writeInt((Integer)object); 
     581            } else if (type == long.class) { 
     582                writeLong((Long)object); 
     583            } else if (type == float.class) { 
     584                writeFloat((Float)object); 
     585            } else if (type == double.class) { 
     586                writeDouble((Double)object); 
     587            } else if (type == boolean.class) { 
     588                writeBoolean((Boolean)object); 
     589            } else { 
     590                throw new RuntimeException("Unsupported primitive type"); 
     591            } 
     592        } else { 
     593            assert(object != null && (object.getClass() == type)); 
     594            if (type.isEnum()) { 
     595                writeEnum((Enum)object); 
     596            } else if (type == String.class) { 
     597                writeString(object.toString()); 
     598            } else { 
     599                throw new RuntimeException("Unsupported type"); 
     600            } 
     601        } 
     602    } 
     603 
    554604//    /** 
    555605//     * Serialize Object of arbitrary type to stream 
  • rtti/DataType.java

    r0 r1  
    2727import org.rrlib.serialization.BinaryInputStream; 
    2828import org.rrlib.serialization.BinaryOutputStream; 
     29import org.rrlib.serialization.BinarySerializable; 
    2930import org.rrlib.serialization.EnumValue; 
    3031import org.rrlib.serialization.PortDataListImpl; 
     
    7778        @SuppressWarnings({ "rawtypes" }) 
    7879        @Override 
    79         public Object createInstance(int placement) { 
     80        public Object createInstance() { 
    8081            Object result = null; 
    8182            if (dataType.getType() == Type.LIST || dataType.getType() == Type.PTR_LIST) { 
     
    107108        @SuppressWarnings({ "unchecked", "rawtypes" }) 
    108109        @Override 
    109         public GenericObject createInstanceGeneric(int placement, int managerSize) { 
    110             return new GenericObjectInstance((RRLibSerializable)createInstance(placement), dataType, null); 
     110        public GenericObject createInstanceGeneric() { 
     111            return new GenericObject(createInstance(), dataType, null); 
    111112        } 
    112113 
    113         @Override 
    114         public void deepCopy(Object src, Object dest, Factory f) { 
    115             RRLibSerializable s = (RRLibSerializable)src; 
    116             RRLibSerializable d = (RRLibSerializable)dest; 
    117  
    118             Serialization.deepCopy(s, d, f); 
    119         } 
    120  
    121         @Override 
    122         public void serialize(BinaryOutputStream os, Object obj) { 
    123             ((RRLibSerializable)obj).serialize(os); 
    124         } 
    125  
    126         @Override 
    127         public void deserialize(BinaryInputStream is, Object obj) { 
    128             ((RRLibSerializable)obj).deserialize(is); 
    129         } 
     114//        @Override 
     115//        public void deepCopy(Object src, Object dest, Factory f) { 
     116//            RRLibSerializable s = (RRLibSerializable)src; 
     117//            RRLibSerializable d = (RRLibSerializable)dest; 
     118// 
     119//            Serialization.deepCopy(s, d, f); 
     120//        } 
    130121    } 
    131122 
  • rtti/DataTypeBase.java

    r0 r1  
    2424import java.util.ArrayList; 
    2525import java.util.HashMap; 
    26  
    27 import org.rrlib.finroc_core_utils.jc.AtomicInt; 
    28 import org.rrlib.finroc_core_utils.jc.HasDestructor; 
     26import java.util.concurrent.atomic.AtomicInteger; 
     27 
    2928import org.rrlib.logging.Log; 
    3029import org.rrlib.logging.LogLevel; 
    31 import org.rrlib.serialization.BinaryInputStream; 
    32 import org.rrlib.serialization.BinaryOutputStream; 
     30 
    3331 
    3432/** 
     
    6866 
    6967    /** Data type info */ 
    70     static public class DataTypeInfoRaw implements HasDestructor { 
     68    static public class DataTypeInfoRaw { 
    7169 
    7270        /** Type of data type */ 
     
    124122 
    125123        /** 
    126          * @param placement (Optional) Destination for placement new 
    127          * @return Instance of Datatype T casted to void* 
     124         * @return Instance of type casted to Object 
    128125         */ 
    129         public Object createInstance(int placement) { 
     126        public Object createInstance() { 
    130127            return null; 
    131128        } 
    132129 
    133130        /** 
    134          * @param placement (Optional) Destination for placement new 
    135          * @param managerSize Size of management info 
    136131         * @return Instance of Datatype as Generic object 
    137132         */ 
    138         public GenericObject createInstanceGeneric(int placement, int managerSize) { 
     133        public GenericObject createInstanceGeneric() { 
    139134            return null; 
    140135        } 
    141136 
    142         /** 
    143          * Deep copy objects 
    144          * 
    145          * @param src Src object 
    146          * @param dest Destination object 
    147          * @param f Factory to use 
    148          */ 
    149         public void deepCopy(Object src, Object dest, Factory f) {} 
    150  
    151         /** 
    152          * Serialize object to output stream 
    153          * 
    154          * @param os OutputStream 
    155          * @param obj Object to serialize 
    156          */ 
    157         public void serialize(BinaryOutputStream os, Object obj) {} 
    158  
    159         /** 
    160          * Deserialize object from input stream 
    161          * 
    162          * @param os InputStream 
    163          * @param obj Object to deserialize 
    164          */ 
    165         public void deserialize(BinaryInputStream is, Object obj) {} 
    166  
    167         @Override 
    168         public void delete() { 
    169         } 
     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) {} 
    170145    } 
    171146 
     
    186161 
    187162    /** Last annotation index that was used */ 
    188     private static final AtomicInt lastAnnotationIndex = new AtomicInt(0); 
     163    private static final AtomicInteger lastAnnotationIndex = new AtomicInteger(0); 
    189164 
    190165    /** 
     
    295270    } 
    296271 
    297     /** 
    298      * Deep copy objects 
    299      * 
    300      * @param src Src object 
    301      * @param dest Destination object 
    302      * @param f Factory to use 
    303      */ 
    304     public void deepCopy(Object src, Object dest, Factory f) { 
    305         if (info == null) { 
    306             return; 
    307         } 
    308         info.deepCopy(src, dest, f); 
    309     } 
    310  
    311     /** 
    312      * Serialize object to output stream 
    313      * 
    314      * @param os OutputStream 
    315      * @param obj Object to serialize 
    316      */ 
    317     public void serialize(BinaryOutputStream os, Object obj) { 
    318         if (info == null) { 
    319             return; 
    320         } 
    321         info.serialize(os, obj); 
    322     } 
    323  
    324     /** 
    325      * Deserialize object from input stream 
    326      * 
    327      * @param os InputStream 
    328      * @param obj Object to deserialize 
    329      */ 
    330     public void deserialize(BinaryInputStream is, Object obj) { 
    331         if (info == null) { 
    332             return; 
    333         } 
    334         info.deserialize(is, obj); 
    335     } 
     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//    } 
    336285 
    337286    /** 
     
    396345 
    397346    /** 
    398      * @param placement (Optional) Destination for placement new 
    399      * @return Instance of Datatype T casted to void* 
    400      */ 
    401     public Object createInstance(int placement) { 
    402         if (info == null) { 
    403             return null; 
    404         } 
    405         return info.createInstance(placement); 
    406     } 
    407  
    408     /** 
    409      * @param placement (Optional) Destination for placement new 
    410      * @return Instance of Datatype as Generic object 
    411      */ 
    412     GenericObject createInstanceGeneric(int placement) { 
    413         if (info == null) { 
    414             return null; 
    415         } 
    416         return info.createInstanceGeneric(placement, 0); 
    417     } 
    418  
    419     /** 
    420347     * @return Instance of Datatype T casted to void* 
    421348     */ 
     
    424351            return null; 
    425352        } 
    426         return createInstance(0); 
     353        return info.createInstance(); 
     354    } 
     355 
     356    /** 
     357     * @return Instance of Datatype as Generic object 
     358     */ 
     359    GenericObject createInstanceGeneric() { 
     360        if (info == null) { 
     361            return null; 
     362        } 
     363        return info.createInstanceGeneric(); 
    427364    } 
    428365 
     
    432369     */ 
    433370    public GenericObject createInstanceGeneric(GenericObjectManager manager) { 
    434         GenericObject result = createInstanceGeneric(0); 
     371        GenericObject result = createInstanceGeneric(); 
    435372        result.jmanager = manager; 
    436373 
  • rtti/GenericObject.java

    r0 r1  
    3636 * Memory Layout of all subclasses: vtable ptr | datatype ptr | object ptr | management info raw memory of size M 
    3737 */ 
    38 public abstract class GenericObject extends TypedObjectImpl { 
     38public class GenericObject extends TypedObjectImpl { 
    3939 
    4040    /** Wrapped object */ 
     
    4545 
    4646    /** 
    47      * @param wrapped Wrapped object 
    48      * @param dt Data Type of wrapped object 
     47     * @param wrappedObject Wrapped object 
     48     * @param dt Data type of wrapped object 
     49     * @param manager Manager of wrapped object (may be null) 
    4950     */ 
    50     GenericObject(DataTypeBase dt) { 
    51         type = dt; 
     51    public GenericObject(Object wrappedObject, DataTypeBase dt, GenericObjectManager manager) { 
     52        this.wrapped = wrappedObject; 
     53        this.type = dt; 
     54        this.jmanager = manager; 
    5255    } 
    5356 
     
    5962    } 
    6063 
    61     /** 
    62      * Deep copy source object to this object 
    63      * (types MUST match) 
    64      * 
    65      * @param source Source object 
    66      */ 
    67     @SuppressWarnings({ "unchecked", "rawtypes" }) 
    68     public void deepCopyFrom(GenericObject source, Factory f) { 
    69         if (source.type == type) { 
    70             deepCopyFrom((Object)source.wrapped, f); 
    71         } else if (Copyable.class.isAssignableFrom(type.getJavaClass())) { 
    72             ((Copyable)wrapped).copyFrom(source.wrapped); 
    73         } else { 
    74             throw new RuntimeException("Types must match"); 
    75         } 
    76     } 
    77  
    78     /** 
    79      * Deep copy source object to this object 
    80      * (types MUST match) 
    81      * 
    82      * @param source Source object 
    83      */ 
    84     protected abstract void deepCopyFrom(Object source, Factory f); 
     64//    /** 
     65//     * Deep copy source object to this object 
     66//     * (types MUST match) 
     67//     * 
     68//     * @param source Source object 
     69//     */ 
     70//    @SuppressWarnings({ "unchecked", "rawtypes" }) 
     71//    public void deepCopyFrom(GenericObject source, Factory f) { 
     72//        if (source.type == type) { 
     73//            deepCopyFrom((Object)source.wrapped, f); 
     74//        } else if (Copyable.class.isAssignableFrom(type.getJavaClass())) { 
     75//            ((Copyable)wrapped).copyFrom(source.wrapped); 
     76//        } else { 
     77//            throw new RuntimeException("Types must match"); 
     78//        } 
     79//    } 
     80// 
     81//    /** 
     82//     * Deep copy source object to this object 
     83//     * (types MUST match) 
     84//     * 
     85//     * @param source Source object 
     86//     */ 
     87//    protected void deepCopyFrom(Object source, Factory f) 
    8588 
    8689    /** 
     
    9598     * (e.g. for reusing object in pool) 
    9699     */ 
    97     public abstract void clear(); 
     100    public void clear() { 
     101        if (getData() instanceof Clearable) { 
     102            ((Clearable)getData()).clearObject(); 
     103        } 
     104    } 
    98105 
    99106//    /** 
Note: See TracChangeset for help on using the changeset viewer.