X-Git-Url: http://git.nikiroo.be/?a=blobdiff_plain;f=src%2Fbe%2Fnikiroo%2Futils%2Fserial%2FSerialUtils.java;h=ad3b5d4da2a8dae4955e12ce28f2cfd9a51fc5f7;hb=5584adbbbf5444c0039fed2b35dc7d5bb57b71b1;hp=3308a756c578bd14c3f5bc758cd31e30164afcaa;hpb=805005449dacb1e7b825db63836bf100e472ddd0;p=nikiroo-utils.git diff --git a/src/be/nikiroo/utils/serial/SerialUtils.java b/src/be/nikiroo/utils/serial/SerialUtils.java index 3308a75..ad3b5d4 100644 --- a/src/be/nikiroo/utils/serial/SerialUtils.java +++ b/src/be/nikiroo/utils/serial/SerialUtils.java @@ -1,17 +1,28 @@ package be.nikiroo.utils.serial; import java.io.IOException; +import java.io.InputStream; import java.io.NotSerializableException; +import java.io.OutputStream; import java.lang.reflect.Array; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Modifier; import java.net.URL; +import java.util.ArrayList; import java.util.HashMap; +import java.util.List; import java.util.Map; import java.util.UnknownFormatConversionException; +import be.nikiroo.utils.IOUtils; import be.nikiroo.utils.Image; +import be.nikiroo.utils.StringUtils; +import be.nikiroo.utils.streams.Base64InputStream; +import be.nikiroo.utils.streams.Base64OutputStream; +import be.nikiroo.utils.streams.BufferedInputStream; +import be.nikiroo.utils.streams.NextableInputStream; +import be.nikiroo.utils.streams.NextableInputStreamStep; /** * Small class to help with serialisation. @@ -51,50 +62,56 @@ public class SerialUtils { // Array types: customTypes.put("[]", new CustomSerializer() { @Override - protected String toString(Object value) { + protected void toStream(OutputStream out, Object value) + throws IOException { + String type = value.getClass().getCanonicalName(); type = type.substring(0, type.length() - 2); // remove the [] - StringBuilder builder = new StringBuilder(); - builder.append(type).append("\n"); + write(out, type); try { for (int i = 0; true; i++) { Object item = Array.get(value, i); + // encode it normally if direct value - if (!SerialUtils.encode(builder, item)) { + write(out, "\r"); + if (!SerialUtils.encode(out, item)) { try { - // use ZIP: if not - builder.append(new Exporter().append(item) - .toString(true)); + write(out, "B64:"); + OutputStream out64 = new Base64OutputStream( + out, true); + new Exporter(out64).append(item); + out64.flush(); } 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) throws IOException { - String[] tab = content.split("\n"); + protected Object fromStream(InputStream in) throws IOException { + NextableInputStream stream = new NextableInputStream(in, + new NextableInputStreamStep('\r')); try { + List list = new ArrayList(); + stream.next(); + String type = IOUtils.readSmallStream(stream); + + while (stream.next()) { + Object value = new Importer().read(stream).getValue(); + list.add(value); + } + 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); + SerialUtils.getClass(type), list.size()); + for (int i = 0; i < list.size(); i++) { + Array.set(array, i, list.get(i)); } return array; @@ -105,23 +122,33 @@ public class SerialUtils { throw new IOException(e.getMessage()); } } + + @Override + protected String getType() { + return "[]"; + } }); // URL: customTypes.put("java.net.URL", new CustomSerializer() { @Override - protected String toString(Object value) { + protected void toStream(OutputStream out, Object value) + throws IOException { + String val = ""; if (value != null) { - return ((URL) value).toString(); + val = ((URL) value).toString(); } - return null; + + out.write(StringUtils.getBytes(val)); } @Override - protected Object fromString(String content) throws IOException { - if (content != null) { - return new URL(content); + protected Object fromStream(InputStream in) throws IOException { + String val = IOUtils.readSmallStream(in); + if (!val.isEmpty()) { + return new URL(val); } + return null; } @@ -134,8 +161,21 @@ public class SerialUtils { // Images (this is currently the only supported image type by default) customTypes.put("be.nikiroo.utils.Image", new CustomSerializer() { @Override - protected String toString(Object value) { - return ((Image) value).toBase64(); + protected void toStream(OutputStream out, Object value) + throws IOException { + Image img = (Image) value; + OutputStream encoded = new Base64OutputStream(out, true); + try { + InputStream in = img.newInputStream(); + try { + IOUtils.write(in, encoded); + } finally { + in.close(); + } + } finally { + encoded.flush(); + // Cannot close! + } } @Override @@ -144,9 +184,11 @@ public class SerialUtils { } @Override - protected Object fromString(String content) { + protected Object fromStream(InputStream in) throws IOException { try { - return new Image(content); + // Cannot close it! + InputStream decoded = new Base64InputStream(in, false); + return new Image(decoded); } catch (IOException e) { throw new UnknownFormatConversionException(e.getMessage()); } @@ -170,27 +212,68 @@ public class SerialUtils { public static Object createObject(String type) throws ClassNotFoundException, NoSuchMethodException { + String desc = null; try { Class clazz = getClass(type); String className = clazz.getName(); - Object[] args = null; + List args = new ArrayList(); + List> classes = new ArrayList>(); 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() }); + for (String parentName = className.substring(0, + className.lastIndexOf('$'));; parentName = parentName + .substring(0, parentName.lastIndexOf('$'))) { + Object parent = createObject(parentName); + args.add(parent); + classes.add(parent.getClass()); + + if (!parentName.contains("$")) { + break; + } + } + + // Better error description in case there is no empty + // constructor: + desc = ""; + String end = ""; + for (Class parent = clazz; parent != null + && !parent.equals(Object.class); parent = parent + .getSuperclass()) { + if (!desc.isEmpty()) { + desc += " [:"; + end += "]"; + } + desc += parent; + } + desc += end; + // + + try { + ctor = clazz.getDeclaredConstructor(classes + .toArray(new Class[] {})); + } catch (NoSuchMethodException nsme) { + // TODO: it seems we do not always need a parameter for each + // level, so we currently try "ALL" levels or "FIRST" level + // only -> we should check the actual rule and use it + ctor = clazz.getDeclaredConstructor(classes.get(0)); + Object firstParent = args.get(0); + args.clear(); + args.add(firstParent); + } + desc = null; } else { - args = new Object[] {}; ctor = clazz.getDeclaredConstructor(); } ctor.setAccessible(true); - return ctor.newInstance(args); + return ctor.newInstance(args.toArray()); } catch (ClassNotFoundException e) { throw e; } catch (NoSuchMethodException e) { + if (desc != null) { + throw new NoSuchMethodException("Empty constructor not found: " + + desc); + } throw e; } catch (Exception e) { throw new NoSuchMethodException("Cannot instantiate: " + type); @@ -209,14 +292,14 @@ public class SerialUtils { } /** - * Serialise the given object into this {@link StringBuilder}. + * Serialise the given object into this {@link OutputStream}. *

* 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 out + * the output {@link OutputStream} to serialise to * @param o * the object to serialise * @param map @@ -228,9 +311,11 @@ public class SerialUtils { * if the object cannot be serialised (in this case, the * {@link StringBuilder} can contain bad, most probably not * importable data) + * @throws IOException + * in case of I/O errors */ - static void append(StringBuilder builder, Object o, Map map) - throws NotSerializableException { + static void append(OutputStream out, Object o, Map map) + throws NotSerializableException, IOException { Field[] fields = new Field[] {}; String type = ""; @@ -241,10 +326,8 @@ public class SerialUtils { fields = o.getClass().getDeclaredFields(); type = o.getClass().getCanonicalName(); if (type == null) { - throw new NotSerializableException( - String.format( - "Cannot find the class for this object: %s (it could be an inner class, which is not supported)", - o)); + // Anonymous inner classes support + type = o.getClass().getName(); } id = Integer.toString(hash); if (map.containsKey(hash)) { @@ -254,9 +337,13 @@ public class SerialUtils { } } - builder.append("{\nREF ").append(type).append("@").append(id) - .append(":"); - if (!encode(builder, o)) { // check if direct value + write(out, "{\nREF "); + write(out, type); + write(out, "@"); + write(out, id); + write(out, ":"); + + if (!encode(out, o)) { // check if direct value try { for (Field field : fields) { field.setAccessible(true); @@ -270,16 +357,15 @@ public class SerialUtils { continue; } - builder.append("\n"); - builder.append(field.getName()); - builder.append(":"); - Object value; + write(out, "\n^"); + write(out, field.getName()); + write(out, ":"); - value = field.get(o); + Object value = field.get(o); - if (!encode(builder, value)) { - builder.append("\n"); - append(builder, value, map); + if (!encode(out, value)) { + write(out, "\n"); + append(out, value, map); } } } catch (IllegalArgumentException e) { @@ -289,52 +375,74 @@ public class SerialUtils { e.printStackTrace(); // should not happen (see // setAccessible) } + + write(out, "\n}"); } - builder.append("\n}"); } /** - * Encode the object into the given builder if possible (if supported). + * Encode the object into the given {@link OutputStream} if possible and if + * supported. + *

+ * A supported object in this context means an object we can directly + * encode, like an Integer or a String. Custom objects and arrays are also + * considered supported, but compound objects are not supported here. + *

+ * For compound objects, you should use {@link Exporter}. * - * @param builder - * the builder to append to + * @param out + * the {@link OutputStream} to append to * @param value * the object to encode (can be NULL, which will be encoded) * - * @return TRUE if success, FALSE if not (the content of the builder won't - * be changed in case of failure) + * @return TRUE if success, FALSE if not (the content of the + * {@link OutputStream} won't be changed in case of failure) + * + * @throws IOException + * in case of I/O error */ - static boolean encode(StringBuilder builder, Object value) { + static boolean encode(OutputStream out, Object value) throws IOException { if (value == null) { - builder.append("NULL"); - } else if (value.getClass().getCanonicalName().endsWith("[]")) { - return customTypes.get("[]").encode(builder, value); + write(out, "NULL"); + } else if (value.getClass().getSimpleName().endsWith("[]")) { + // Simple name does support [] suffix and do not return NULL for + // inner anonymous classes + customTypes.get("[]").encode(out, value); } else if (customTypes.containsKey(value.getClass().getCanonicalName())) { - return customTypes.get(value.getClass().getCanonicalName())// - .encode(builder, value); + customTypes.get(value.getClass().getCanonicalName())// + .encode(out, value); } else if (value instanceof String) { - encodeString(builder, (String) value); + encodeString(out, (String) value); } else if (value instanceof Boolean) { - builder.append(value); + write(out, value); } else if (value instanceof Byte) { - builder.append(value).append('b'); + write(out, "b"); + write(out, value); } else if (value instanceof Character) { - encodeString(builder, "" + value); - builder.append('c'); + write(out, "c"); + encodeString(out, "" + value); } else if (value instanceof Short) { - builder.append(value).append('s'); + write(out, "s"); + write(out, value); } else if (value instanceof Integer) { - builder.append(value); + write(out, "i"); + write(out, value); } else if (value instanceof Long) { - builder.append(value).append('L'); + write(out, "l"); + write(out, value); } else if (value instanceof Float) { - builder.append(value).append('F'); + write(out, "f"); + write(out, value); } else if (value instanceof Double) { - builder.append(value).append('d'); + write(out, "d"); + write(out, value); } else if (value instanceof Enum) { + write(out, "E:"); String type = value.getClass().getCanonicalName(); - builder.append(type).append(".").append(((Enum) value).name()) - .append(";"); + write(out, type); + write(out, "."); + write(out, ((Enum) value).name()); + write(out, ";"); } else { return false; } @@ -342,8 +450,85 @@ public class SerialUtils { return true; } + static boolean isDirectValue(BufferedInputStream encodedValue) + throws IOException { + if (CustomSerializer.isCustom(encodedValue)) { + return false; + } + + for (String fullValue : new String[] { "NULL", "null", "true", "false" }) { + if (encodedValue.is(fullValue)) { + return true; + } + } + + for (String prefix : new String[] { "c\"", "\"", "b", "s", "i", "l", + "f", "d", "E:" }) { + if (encodedValue.startsWith(prefix)) { + return true; + } + } + + return false; + } + /** - * Decode the data into an equivalent source object. + * Decode the data into an equivalent supported source object. + *

+ * A supported object in this context means an object we can directly + * encode, like an Integer or a String (see + * {@link SerialUtils#decode(String)}. + *

+ * Custom objects and arrays are also considered supported here, but + * compound objects are not. + *

+ * For compound objects, you should use {@link Importer}. + * + * @param encodedValue + * the encoded data, cannot be NULL + * + * @return the object (can be NULL for NULL encoded values) + * + * @throws IOException + * if the content cannot be converted + */ + static Object decode(BufferedInputStream encodedValue) throws IOException { + if (CustomSerializer.isCustom(encodedValue)) { + // custom^TYPE^ENCODED_VALUE + NextableInputStream content = new NextableInputStream(encodedValue, + new NextableInputStreamStep('^')); + try { + content.next(); + @SuppressWarnings("unused") + String custom = IOUtils.readSmallStream(content); + content.next(); + String type = IOUtils.readSmallStream(content); + content.nextAll(); + if (customTypes.containsKey(type)) { + return customTypes.get(type).decode(content); + } + content.end(); + throw new IOException("Unknown custom type: " + type); + } finally { + content.close(false); + encodedValue.end(); + } + } + + String encodedString = IOUtils.readSmallStream(encodedValue); + return decode(encodedString); + } + + /** + * Decode the data into an equivalent supported source object. + *

+ * A supported object in this context means an object we can directly + * encode, like an Integer or a String. + *

+ * For custom objects and arrays, you should use + * {@link SerialUtils#decode(InputStream)} or directly {@link Importer}. + *

+ * For compound objects, you should use {@link Importer}. * * @param encodedValue * the encoded data, cannot be NULL @@ -357,50 +542,61 @@ public class SerialUtils { try { String cut = ""; if (encodedValue.length() > 1) { - cut = encodedValue.substring(0, encodedValue.length() - 1); + cut = encodedValue.substring(1); } - if (CustomSerializer.isCustom(encodedValue)) { - // custom:TYPE_NAME:"content is String-encoded" - String type = CustomSerializer.typeOf(encodedValue); - if (customTypes.containsKey(type)) { - return customTypes.get(type).decode(encodedValue); - } - throw new IOException("Unknown custom type: " + type); - } else if (encodedValue.equals("NULL") - || encodedValue.equals("null")) { + if (encodedValue.equals("NULL") || encodedValue.equals("null")) { return null; - } else if (encodedValue.endsWith("\"")) { + } else if (encodedValue.startsWith("\"")) { return decodeString(encodedValue); } else if (encodedValue.equals("true")) { return true; } else if (encodedValue.equals("false")) { return false; - } else if (encodedValue.endsWith("b")) { + } else if (encodedValue.startsWith("b")) { return Byte.parseByte(cut); - } else if (encodedValue.endsWith("c")) { + } else if (encodedValue.startsWith("c")) { return decodeString(cut).charAt(0); - } else if (encodedValue.endsWith("s")) { + } else if (encodedValue.startsWith("s")) { return Short.parseShort(cut); - } else if (encodedValue.endsWith("L")) { + } else if (encodedValue.startsWith("l")) { return Long.parseLong(cut); - } else if (encodedValue.endsWith("F")) { + } else if (encodedValue.startsWith("f")) { return Float.parseFloat(cut); - } else if (encodedValue.endsWith("d")) { + } else if (encodedValue.startsWith("d")) { return Double.parseDouble(cut); - } else if (encodedValue.endsWith(";")) { - return decodeEnum(encodedValue); + } else if (encodedValue.startsWith("i")) { + return Integer.parseInt(cut); + } else if (encodedValue.startsWith("E:")) { + cut = cut.substring(1); + return decodeEnum(cut); } else { - return Integer.parseInt(encodedValue); + throw new IOException("Unrecognized value: " + encodedValue); } } catch (Exception e) { if (e instanceof IOException) { throw (IOException) e; } - throw new IOException(e.getMessage()); + throw new IOException(e.getMessage(), e); } } + /** + * Write the given {@link String} into the given {@link OutputStream} in + * UTF-8. + * + * @param out + * the {@link OutputStream} + * @param data + * the data to write, cannot be NULL + * + * @throws IOException + * in case of I/O error + */ + static void write(OutputStream out, Object data) throws IOException { + out.write(StringUtils.getBytes(data.toString())); + } + /** * Return the corresponding class or throw an {@link Exception} if it * cannot. @@ -452,7 +648,7 @@ public class SerialUtils { } @SuppressWarnings({ "unchecked", "rawtypes" }) - private static Enum decodeEnum(String escaped) { + static private Enum decodeEnum(String escaped) { // escaped: be.xxx.EnumType.VALUE; int pos = escaped.lastIndexOf("."); String type = escaped.substring(0, pos); @@ -467,32 +663,42 @@ public class SerialUtils { } // aa bb -> "aa\tbb" - private static void encodeString(StringBuilder builder, String raw) { - builder.append('\"'); + static void encodeString(OutputStream out, String raw) throws IOException { + // TODO: not. efficient. + out.write('\"'); for (char car : raw.toCharArray()) { - switch (car) { - case '\\': - builder.append("\\\\"); - break; - case '\r': - builder.append("\\r"); - break; - case '\n': - builder.append("\\n"); - break; - case '"': - builder.append("\\\""); - break; - default: - builder.append(car); - break; - } + encodeString(out, car); + } + out.write('\"'); + } + + // for encoding string, NOT to encode a char by itself! + static void encodeString(OutputStream out, char raw) throws IOException { + switch (raw) { + case '\\': + out.write('\\'); + out.write('\\'); + break; + case '\r': + out.write('\\'); + out.write('r'); + break; + case '\n': + out.write('\\'); + out.write('n'); + break; + case '"': + out.write('\\'); + out.write('\"'); + break; + default: + out.write(raw); + break; } - builder.append('\"'); } // "aa\tbb" -> aa bb - private static String decodeString(String escaped) { + static String decodeString(String escaped) { StringBuilder builder = new StringBuilder(); boolean escaping = false; @@ -522,6 +728,6 @@ public class SerialUtils { } } - return builder.substring(1, builder.length() - 1).toString(); + return builder.substring(1, builder.length() - 1); } }