Changeset 2:cf7b6a32c923 in rrlib_serialization-java


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

Added generic serialization functions to stream classes

Files:
5 edited

Legend:

Unmodified
Added
Removed
  • BinaryInputStream.java

    r1 r2  
    2323 
    2424import java.io.ByteArrayOutputStream; 
     25import java.io.StringReader; 
    2526 
    2627import org.rrlib.serialization.rtti.DataTypeBase; 
     28import org.rrlib.xml.XMLDocument; 
     29import org.rrlib.xml.XMLNode; 
     30import org.xml.sax.InputSource; 
    2731 
    2832/** 
     
    815819        } 
    816820    } 
     821 
     822    /** 
     823     * Deserializes object of specified type 
     824     * 
     825     * @param type Type object must have 
     826     * @param encoding Data encoding 
     827     * @return Deserialized object (new object for immutable types, provided object in case of a mutable type) 
     828     */ 
     829    public Object readObject(Class<?> type, Serialization.DataEncoding encoding) throws Exception { 
     830        return readObject(null, type, encoding); 
     831    } 
     832 
     833    /** 
     834     * Deserializes object of specified type 
     835     * 
     836     * @param deserializeTo Object to call deserialize() on (optional; will contain result of deserialization, in case type is a mutable type) 
     837     * @param type Type object must have 
     838     * @param encoding Data encoding 
     839     * @return Deserialized object (new object for immutable types, provided object in case of a mutable type) 
     840     */ 
     841    public Object readObject(Object deserializeTo, Class<?> type, Serialization.DataEncoding encoding) throws Exception { 
     842        if (encoding == Serialization.DataEncoding.BINARY) { 
     843            return readObject(deserializeTo, type); 
     844        } else if (encoding == Serialization.DataEncoding.STRING) { 
     845            StringInputStream sis = new StringInputStream(readString()); 
     846            try { 
     847                deserializeTo = sis.readObject(deserializeTo, type); 
     848            } finally { 
     849                sis.close(); 
     850            } 
     851            return deserializeTo; 
     852        } else { 
     853            assert(encoding == Serialization.DataEncoding.XML); 
     854            XMLDocument d = new XMLDocument(new InputSource(new StringReader(readString())), false); 
     855            XMLNode n = d.getRootNode(); 
     856            return Serialization.deserialize(n, deserializeTo, type); 
     857        } 
     858    } 
     859 
     860 
    817861} 
  • BinaryOutputStream.java

    r1 r2  
    2323 
    2424import org.rrlib.serialization.rtti.DataTypeBase; 
     25import org.rrlib.xml.XMLDocument; 
     26import org.rrlib.xml.XMLNode; 
    2527 
    2628/** 
     
    602604    } 
    603605 
     606    /** 
     607     * Write object to stream (without any type information) 
     608     * 
     609     * @param object Object to write to stream 
     610     * @param type Type of object (if serialization is consistent, could be base class) 
     611     * @param encoding Desired data encoding 
     612     */ 
     613    public void writeObject(Object object, Class<?> type, Serialization.DataEncoding encoding) { 
     614        if (encoding == Serialization.DataEncoding.BINARY) { 
     615            writeObject(object, type); 
     616        } else if (encoding == Serialization.DataEncoding.STRING) { 
     617            writeString(Serialization.serialize(object)); 
     618        } else { 
     619            assert(encoding == Serialization.DataEncoding.XML); 
     620            XMLDocument d = new XMLDocument(); 
     621            try { 
     622                XMLNode n = d.addRootNode("value"); 
     623                Serialization.serialize(n, object); 
     624                writeString(d.getXMLDump(true)); 
     625            } catch (Exception e) { 
     626                e.printStackTrace(); 
     627                writeString("error generating XML code."); 
     628            } 
     629        } 
     630    } 
     631 
    604632//    /** 
    605633//     * Serialize Object of arbitrary type to stream 
  • Serialization.java

    r0 r2  
    153153 
    154154    /** 
    155      * Standard XML serialization fallback implementation 
    156      * (for Java, because we don't have multiple inheritance here) 
     155     * Serialize object to XML node (without any type information) 
    157156     * 
    158157     * @param node XML node 
    159      * @param rs Serializable object 
    160      */ 
    161     public static void serialize(XMLNode node, StringSerializable rs) throws Exception { 
    162         node.setContent(serialize(rs)); 
     158     * @param object Serializable object 
     159     */ 
     160    public static void serialize(XMLNode node, Object object) throws Exception { 
     161        Class<?> type = object.getClass(); 
     162        if (XMLSerializable.class.isAssignableFrom(type)) { 
     163            ((XMLSerializable)object).serialize(node); 
     164        } else { // try string serialization (if this does not work, we would have to throw an exception anyway, because there are currently no more alternatives) 
     165            node.setContent(serialize(object)); 
     166        } 
     167    } 
     168 
     169    /** 
     170     * Deserialize object from XML node (without any type information) 
     171     * 
     172     * @param node XML node 
     173     * @param deserializeTo Object to call deserialize() on (optional; will contain result of deserialization, in case type is a mutable type) 
     174     * @param type Type object must have 
     175     * @return Deserialized object (new object for immutable types, provided object in case of a mutable type) 
     176     */ 
     177    public static Object deserialize(XMLNode node, Object deserializeTo, Class<?> type) throws Exception { 
     178        if (XMLSerializable.class.isAssignableFrom(type)) { 
     179            if (deserializeTo == null) { 
     180                deserializeTo = type.newInstance(); 
     181            } 
     182            ((XMLSerializable)deserializeTo).deserialize(node); 
     183            return deserializeTo; 
     184        } else { // try string deserialization (if this does not work, we would have to throw an exception anyway, because there are currently no more alternatives) 
     185            StringInputStream sis = new StringInputStream(node.getTextContent()); 
     186            deserializeTo = sis.readObject(deserializeTo, type); 
     187            sis.close(); 
     188            return deserializeTo; 
     189        } 
    163190    } 
    164191 
     
    167194     * (convenience function) 
    168195     * 
    169      * @param cs Serializable 
     196     * @param s Serializable 
    170197     * @return String 
    171198     */ 
    172     public static String serialize(StringSerializable rs) { 
     199    public static String serialize(Object s) { 
    173200        StringOutputStream os = new StringOutputStream(); 
    174         rs.serialize(os); 
     201        os.appendObject(s); 
    175202        return os.toString(); 
    176203    } 
     
    305332        vector.resize(newSize); 
    306333    } 
    307  
    308 //    /** 
    309 //     * Serialize data to binary output stream - possibly using non-binary encoding 
    310 //     * 
    311 //     * @param os Binary output stream 
    312 //     * @param s Object to serialize 
    313 //     * @param enc Encoding to use 
    314 //     */ 
    315 //    static public void serialize(BinaryOutputStream os, RRLibSerializable s, DataEncoding enc) { 
    316 //        if (enc == DataEncoding.BINARY) { 
    317 //            s.serialize(os); 
    318 //        } else if (enc == DataEncoding.STRING) { 
    319 //            os.writeString(serialize(s)); 
    320 //        } else { 
    321 //            assert(enc == DataEncoding.XML); 
    322 //            XMLDocument d = new XMLDocument(); 
    323 //            try { 
    324 //                XMLNode n = d.addRootNode("value"); 
    325 //                s.serialize(n); 
    326 //                os.writeString(d.getXMLDump(true)); 
    327 //            } catch (Exception e) { 
    328 //                e.printStackTrace(); 
    329 //                os.writeString("error generating XML code."); 
    330 //            } 
    331 //        } 
    332 //    } 
    333 // 
    334 //    /** 
    335 //     * Deserialize data from binary input stream - possibly using non-binary encoding 
    336 //     * 
    337 //     * @param os Binary input stream 
    338 //     * @param s Object to deserialize 
    339 //     * @param enc Encoding to use 
    340 //     */ 
    341 //    static public void deserialize(BinaryInputStream is, RRLibSerializable s, DataEncoding enc) { 
    342 //        if (enc == DataEncoding.BINARY) { 
    343 //            s.deserialize(is); 
    344 //        } else if (enc == DataEncoding.STRING) { 
    345 //            StringInputStream sis = new StringInputStream(is.readString()); 
    346 //            try { 
    347 //                s.deserialize(sis); 
    348 //            } catch (Exception e) { 
    349 //                e.printStackTrace(); 
    350 //            } 
    351 //            sis.close(); 
    352 //        } else { 
    353 //            assert(enc == DataEncoding.XML); 
    354 //            try { 
    355 //                XMLDocument d = new XMLDocument(new InputSource(new StringReader(is.readString())), false); 
    356 //                XMLNode n = d.getRootNode(); 
    357 //                s.deserialize(n); 
    358 //            } catch (Exception e) { 
    359 //                e.printStackTrace(); 
    360 //            } 
    361 //        } 
    362 //    } 
    363334} 
  • StringInputStream.java

    r0 r2  
    279279        return n; 
    280280    } 
     281 
     282    /** 
     283     * Deserialize boolean from string stream 
     284     * 
     285     * @return Boolean value 
     286     */ 
     287    public boolean readBoolean() { 
     288        String s = readWhile("", StringInputStream.LETTER | StringInputStream.DIGIT | StringInputStream.WHITESPACE, true); 
     289        return s.toLowerCase().equals("true") || s.equals("1"); 
     290    } 
     291 
     292    /** 
     293     * Deserializes object of specified type 
     294     * 
     295     * @param type Type object must have 
     296     * @return Deserialized object (new object for immutable types, provided object in case of a mutable type) 
     297     */ 
     298    public Object readObject(Class<?> type) throws Exception { 
     299        return readObject(null, type); 
     300    } 
     301 
     302    /** 
     303     * Deserializes object of specified type 
     304     * 
     305     * @param deserializeTo Object to call deserialize() on (optional; will contain result of deserialization, in case type is a mutable type) 
     306     * @param type Type object must have 
     307     * @return Deserialized object (new object for immutable types, provided object in case of a mutable type) 
     308     */ 
     309    @SuppressWarnings({ "rawtypes", "unchecked" }) 
     310    public Object readObject(Object deserializeTo, Class<?> type) throws Exception { 
     311        if (StringSerializable.class.isAssignableFrom(type)) { 
     312            if (deserializeTo == null) { 
     313                deserializeTo = type.newInstance(); 
     314            } 
     315            ((StringSerializable)deserializeTo).deserialize(this); 
     316            return deserializeTo; 
     317        } else if (type.isPrimitive()) { 
     318            if (type == boolean.class) { 
     319                return readBoolean(); 
     320            } else if (type == float.class || type == double.class) { 
     321                String s = readWhile("-.", StringInputStream.DIGIT | StringInputStream.WHITESPACE | StringInputStream.LETTER, true); 
     322                return type == float.class ? Float.parseFloat(s) : Double.parseDouble(s); 
     323            } else { 
     324                String s = readWhile("-", StringInputStream.DIGIT | StringInputStream.WHITESPACE, true); 
     325                if (type == byte.class) { 
     326                    return Byte.parseByte(s); 
     327                } else if (type == short.class) { 
     328                    return Short.parseShort(s); 
     329                } else if (type == int.class) { 
     330                    return Integer.parseInt(s); 
     331                } else if (type == long.class) { 
     332                    return Long.parseLong(s); 
     333                } else { 
     334                    throw new Exception("Unsupported primitive type"); 
     335                } 
     336            } 
     337        } else { 
     338            assert(deserializeTo != null && (deserializeTo.getClass() == type)); 
     339            if (type.isEnum()) { 
     340                return readEnum((Class<? extends Enum>)type); 
     341            } else if (type == String.class) { 
     342                return readAll(); 
     343            } else { 
     344                throw new RuntimeException("Unsupported type"); 
     345            } 
     346        } 
     347    } 
    281348} 
  • StringOutputStream.java

    r0 r2  
    4444    } 
    4545 
    46     public StringBuilder append(String str) { 
    47         return wrapped.append(str); 
     46    public StringOutputStream append(String str) { 
     47        wrapped.append(str); 
     48        return this; 
    4849    } 
    4950 
    50     public StringBuilder append(StringBuffer sb) { 
    51         return wrapped.append(sb); 
     51    public StringOutputStream append(StringBuffer sb) { 
     52        wrapped.append(sb); 
     53        return this; 
    5254    } 
    5355 
    54     public StringBuilder append(CharSequence s) { 
    55         return wrapped.append(s); 
     56    public StringOutputStream append(CharSequence s) { 
     57        wrapped.append(s); 
     58        return this; 
    5659    } 
    5760 
    58     public StringBuilder append(CharSequence s, int start, int end) { 
    59         return wrapped.append(s, start, end); 
     61    public StringOutputStream append(CharSequence s, int start, int end) { 
     62        wrapped.append(s, start, end); 
     63        return this; 
    6064    } 
    6165 
    62     public StringBuilder append(char[] str) { 
    63         return wrapped.append(str); 
     66    public StringOutputStream append(char[] str) { 
     67        wrapped.append(str); 
     68        return this; 
    6469    } 
    6570 
    66     public StringBuilder append(char[] str, int offset, int len) { 
    67         return wrapped.append(str, offset, len); 
     71    public StringOutputStream append(char[] str, int offset, int len) { 
     72        wrapped.append(str, offset, len); 
     73        return this; 
    6874    } 
    6975 
    70     public StringBuilder append(boolean b) { 
    71         return wrapped.append(b); 
     76    public StringOutputStream append(boolean b) { 
     77        wrapped.append(b); 
     78        return this; 
    7279    } 
    7380 
    74     public StringBuilder append(char c) { 
    75         return wrapped.append(c); 
     81    public StringOutputStream append(char c) { 
     82        wrapped.append(c); 
     83        return this; 
    7684    } 
    7785 
    78     public StringBuilder append(int i) { 
    79         return wrapped.append(i); 
     86    public StringOutputStream append(int i) { 
     87        wrapped.append(i); 
     88        return this; 
    8089    } 
    8190 
    82     public StringBuilder append(long lng) { 
    83         return wrapped.append(lng); 
     91    public StringOutputStream append(long lng) { 
     92        wrapped.append(lng); 
     93        return this; 
    8494    } 
    8595 
    86     public StringBuilder append(float f) { 
    87         return wrapped.append(f); 
     96    public StringOutputStream append(float f) { 
     97        wrapped.append(f); 
     98        return this; 
    8899    } 
    89100 
    90     public StringBuilder append(double d) { 
    91         return wrapped.append(d); 
     101    public StringOutputStream append(double d) { 
     102        wrapped.append(d); 
     103        return this; 
    92104    } 
    93105 
    94     public StringBuilder append(Enum<?> d) { 
    95         return wrapped.append(EnumValue.doNaturalFormatting(d.toString())).append(" (").append(d.ordinal()).append(")"); 
     106    public StringOutputStream append(Enum<?> d) { 
     107        wrapped.append(EnumValue.doNaturalFormatting(d.toString())).append(" (").append(d.ordinal()).append(")"); 
     108        return this; 
     109    } 
     110 
     111    /** 
     112     * Write object to stream (without any type information) 
     113     * 
     114     * @param object Object to write to stream 
     115     */ 
     116    public StringOutputStream appendObject(Object object) { 
     117        return appendObject(object, object.getClass()); 
     118    } 
     119 
     120    /** 
     121     * Write object to stream (without any type information) 
     122     * 
     123     * @param object Object to write to stream 
     124     * @param type Type of object (if serialization is consistent, could be base class) 
     125     */ 
     126    @SuppressWarnings("rawtypes") 
     127    public StringOutputStream appendObject(Object object, Class<?> type) { 
     128        if (StringSerializable.class.isAssignableFrom(type)) { 
     129            ((StringSerializable)object).serialize(this); 
     130        } else if (type.isPrimitive()) { 
     131            append(object.toString()); 
     132        } else { 
     133            assert(object != null && (object.getClass() == type)); 
     134            if (type.isEnum()) { 
     135                append((Enum)object); 
     136            } else if (type == String.class) { 
     137                append(object.toString()); 
     138            } else { 
     139                throw new RuntimeException("Unsupported type"); 
     140            } 
     141        } 
     142        return this; 
    96143    } 
    97144 
Note: See TracChangeset for help on using the changeset viewer.