X-Git-Url: http://git.nikiroo.be/?a=blobdiff_plain;f=src%2Fbe%2Fnikiroo%2Futils%2Fserial%2FSerialUtils.java;h=7bf1b17a3a651a4f41f5f8cd072be1cd160dfca3;hb=ce0974c4b695f842fa7ec81f3c53d016d1959854;hp=657dbec45fb069e26b77cc7423c0c606ffdc6a39;hpb=db31c35860081535d6e7ddc83ab4af573bb0522e;p=nikiroo-utils.git diff --git a/src/be/nikiroo/utils/serial/SerialUtils.java b/src/be/nikiroo/utils/serial/SerialUtils.java index 657dbec..7bf1b17 100644 --- a/src/be/nikiroo/utils/serial/SerialUtils.java +++ b/src/be/nikiroo/utils/serial/SerialUtils.java @@ -1,30 +1,161 @@ package be.nikiroo.utils.serial; import java.io.NotSerializableException; +import java.lang.reflect.Array; +import java.lang.reflect.Constructor; import java.lang.reflect.Field; +import java.util.ArrayList; import java.util.HashMap; import java.util.Map; +import java.util.UnknownFormatConversionException; /** - * Small class to help serialise/deserialise objects. + * Small class to help with serialisation. *

* Note that we do not support inner classes (but we do support nested classes) * and all objects require an empty constructor to be deserialised. * * @author niki */ -class SerialUtils { +public class SerialUtils { private static Map customTypes; static { customTypes = new HashMap(); - // TODO: add "default" custom serialisers + // TODO: add "default" custom serialisers if any (Bitmap?) + + // Array types: + customTypes.put("[]", new CustomSerializer() { + @Override + protected String toString(Object value) { + String type = value.getClass().getCanonicalName(); + type = type.substring(0, type.length() - 2); // remove the [] + + StringBuilder builder = new StringBuilder(); + builder.append(type).append("\n"); + try { + for (int i = 0; true; i++) { + Object item = Array.get(value, i); + // encode it normally if direct value + if (!SerialUtils.encode(builder, item)) { + try { + // use ZIP: if not + builder.append(new Exporter().append(item) + .toString(true)); + } catch (NotSerializableException e) { + throw new UnknownFormatConversionException(e + .getMessage()); + } + } + builder.append("\n"); + } + } catch (ArrayIndexOutOfBoundsException e) { + // Done. + } + + return builder.toString(); + } + + @Override + protected String getType() { + return "[]"; + } + + @Override + protected Object fromString(String content) { + String[] tab = content.split("\n"); + + try { + Object array = Array.newInstance( + SerialUtils.getClass(tab[0]), tab.length - 1); + for (int i = 1; i < tab.length; i++) { + Object value = new Importer().read(tab[i]).getValue(); + Array.set(array, i - 1, value); + } + + return array; + } catch (Exception e) { + throw new UnknownFormatConversionException(e.getMessage()); + } + } + }); + } + + /** + * Create an empty object of the given type. + * + * @param type + * the object type (its class name) + * + * @return the new object + * + * @throws ClassNotFoundException + * if the class cannot be found + * @throws NoSuchMethodException + * if the given class is not compatible with this code + */ + public static Object createObject(String type) + throws ClassNotFoundException, NoSuchMethodException { + + try { + Class clazz = getClass(type); + String className = clazz.getName(); + Object[] args = null; + Constructor ctor = null; + if (className.contains("$")) { + Object javaParent = createObject(className.substring(0, + className.lastIndexOf('$'))); + args = new Object[] { javaParent }; + ctor = clazz.getDeclaredConstructor(new Class[] { javaParent + .getClass() }); + } else { + args = new Object[] {}; + ctor = clazz.getDeclaredConstructor(); + } + + ctor.setAccessible(true); + return ctor.newInstance(args); + } catch (ClassNotFoundException e) { + throw e; + } catch (NoSuchMethodException e) { + throw e; + } catch (Exception e) { + throw new NoSuchMethodException("Cannot instantiate: " + type); + } } + /** + * Insert a custom serialiser that will take precedence over the default one + * or the target class. + * + * @param serializer + * the custom serialiser + */ static public void addCustomSerializer(CustomSerializer serializer) { customTypes.put(serializer.getType(), serializer); } + /** + * Serialise the given object into this {@link StringBuilder}. + *

+ * Important: If the operation fails (with a + * {@link NotSerializableException}), the {@link StringBuilder} will be + * corrupted (will contain bad, most probably not importable data). + * + * @param builder + * the output {@link StringBuilder} to serialise to + * @param o + * the object to serialise + * @param map + * the map of already serialised objects (if the given object or + * one of its descendant is already present in it, only an ID + * will be serialised) + * + * @throws NotSerializableException + * if the object cannot be serialised (in this case, the + * {@link StringBuilder} can contain bad, most probably not + * importable data) + */ static void append(StringBuilder builder, Object o, Map map) throws NotSerializableException { @@ -50,32 +181,37 @@ class SerialUtils { } } - builder.append("{\nREF ").append(type).append("@").append(id); - try { - for (Field field : fields) { - field.setAccessible(true); + builder.append("{\nREF ").append(type).append("@").append(id) + .append(":"); + if (!encode(builder, o)) { // check if direct value + try { + for (Field field : fields) { + field.setAccessible(true); - if (field.getName().startsWith("this$")) { - // Do not keep this links of nested classes - continue; - } + if (field.getName().startsWith("this$")) { + // Do not keep this links of nested classes + continue; + } - builder.append("\n"); - builder.append(field.getName()); - builder.append(":"); - Object value; + builder.append("\n"); + builder.append(field.getName()); + builder.append(":"); + Object value; - value = field.get(o); + value = field.get(o); - if (!encode(builder, value)) { - builder.append("\n"); - append(builder, value, map); + if (!encode(builder, value)) { + builder.append("\n"); + append(builder, value, map); + } } + } catch (IllegalArgumentException e) { + e.printStackTrace(); // should not happen (see + // setAccessible) + } catch (IllegalAccessException e) { + e.printStackTrace(); // should not happen (see + // setAccessible) } - } catch (IllegalArgumentException e) { - e.printStackTrace(); // should not happen (see setAccessible) - } catch (IllegalAccessException e) { - e.printStackTrace(); // should not happen (see setAccessible) } builder.append("\n}"); } @@ -84,6 +220,8 @@ class SerialUtils { static boolean encode(StringBuilder builder, Object value) { if (value == null) { builder.append("NULL"); + } else if (value.getClass().getCanonicalName().endsWith("[]")) { + customTypes.get("[]").encode(builder, value); } else if (customTypes.containsKey(value.getClass().getCanonicalName())) { customTypes.get(value.getClass().getCanonicalName())// .encode(builder, value); @@ -94,7 +232,7 @@ class SerialUtils { } else if (value instanceof Byte) { builder.append(value).append('b'); } else if (value instanceof Character) { - encodeString(builder, (String) value); + encodeString(builder, "" + value); builder.append('c'); } else if (value instanceof Short) { builder.append(value).append('s'); @@ -125,7 +263,7 @@ class SerialUtils { if (customTypes.containsKey(type)) { return customTypes.get(type).decode(encodedValue); } else { - throw new java.util.UnknownFormatConversionException( + throw new UnknownFormatConversionException( "Unknown custom type: " + type); } } else if (encodedValue.equals("NULL") || encodedValue.equals("null")) { @@ -153,6 +291,56 @@ class SerialUtils { } } + /** + * Return the corresponding class or throw an {@link Exception} if it + * cannot. + * + * @param type + * the class name to look for + * + * @return the class (will never be NULL) + * + * @throws ClassNotFoundException + * if the class cannot be found + * @throws NoSuchMethodException + * if the class cannot be created (usually because it or its + * enclosing class doesn't have an empty constructor) + */ + static private Class getClass(String type) + throws ClassNotFoundException, NoSuchMethodException { + Class clazz = null; + try { + clazz = Class.forName(type); + } catch (ClassNotFoundException e) { + int pos = type.length(); + pos = type.lastIndexOf(".", pos); + if (pos >= 0) { + String parentType = type.substring(0, pos); + String nestedType = type.substring(pos + 1); + Class javaParent = null; + try { + javaParent = getClass(parentType); + parentType = javaParent.getName(); + clazz = Class.forName(parentType + "$" + nestedType); + } catch (Exception ee) { + } + + if (javaParent == null) { + throw new NoSuchMethodException( + "Class not found: " + + type + + " (the enclosing class cannot be created: maybe it doesn't have an empty constructor?)"); + } + } + } + + if (clazz == null) { + throw new ClassNotFoundException("Class not found: " + type); + } + + return clazz; + } + // aa bb -> "aa\tbb" private static void encodeString(StringBuilder builder, String raw) { builder.append('\"');