map)
- throws NotSerializableException {
+ /**
+ * 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 out
+ * the output {@link OutputStream} 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)
+ * @throws IOException
+ * in case of I/O errors
+ */
+ static void append(OutputStream out, Object o, Map map)
+ throws NotSerializableException, IOException {
Field[] fields = new Field[] {};
String type = "";
@@ -37,10 +326,8 @@ 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)) {
@@ -50,62 +337,112 @@ class SerialUtils {
}
}
- builder.append("{\nREF ").append(type).append("@").append(id);
- try {
- for (Field field : fields) {
- field.setAccessible(true);
+ write(out, "{\nREF ");
+ write(out, type);
+ write(out, "@");
+ write(out, id);
+ write(out, ":");
- if (field.getName().startsWith("this$")) {
- // Do not keep this links of nested classes
- continue;
- }
+ if (!encode(out, o)) { // check if direct value
+ try {
+ for (Field field : fields) {
+ field.setAccessible(true);
+
+ if (field.getName().startsWith("this$")
+ || field.isSynthetic()
+ || (field.getModifiers() & Modifier.STATIC) == Modifier.STATIC) {
+ // Do not keep this links of nested classes
+ // Do not keep synthetic fields
+ // Do not keep final fields
+ 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) {
+ 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)
+
+ write(out, "\n}");
}
- builder.append("\n}");
}
- // return true if encoded (supported)
- static boolean encode(StringBuilder builder, Object value) {
+ /**
+ * 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 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
+ * {@link OutputStream} won't be changed in case of failure)
+ *
+ * @throws IOException
+ * in case of I/O error
+ */
+ static boolean encode(OutputStream out, Object value) throws IOException {
if (value == null) {
- builder.append("NULL");
+ 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())) {
customTypes.get(value.getClass().getCanonicalName())//
- .encode(builder, value);
+ .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, (String) 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();
+ write(out, type);
+ write(out, ".");
+ write(out, ((Enum>) value).name());
+ write(out, ";");
} else {
return false;
}
@@ -113,73 +450,255 @@ class SerialUtils {
return true;
}
- static Object decode(String encodedValue) {
- String cut = "";
- if (encodedValue.length() > 1) {
- cut = encodedValue.substring(0, encodedValue.length() - 1);
+ 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 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_NAME:"content is String-encoded"
- String type = CustomSerializer.typeOf(encodedValue);
- if (customTypes.containsKey(type)) {
- return customTypes.get(type).decode(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
+ *
+ * @return the object (can be NULL for NULL encoded values)
+ *
+ * @throws IOException
+ * if the content cannot be converted
+ */
+ static Object decode(String encodedValue) throws IOException {
+ try {
+ String cut = "";
+ if (encodedValue.length() > 1) {
+ cut = encodedValue.substring(1);
+ }
+
+ if (encodedValue.equals("NULL") || encodedValue.equals("null")) {
+ return null;
+ } else if (encodedValue.startsWith("\"")) {
+ return decodeString(encodedValue);
+ } else if (encodedValue.equals("true")) {
+ return true;
+ } else if (encodedValue.equals("false")) {
+ return false;
+ } else if (encodedValue.startsWith("b")) {
+ return Byte.parseByte(cut);
+ } else if (encodedValue.startsWith("c")) {
+ return decodeString(cut).charAt(0);
+ } else if (encodedValue.startsWith("s")) {
+ return Short.parseShort(cut);
+ } else if (encodedValue.startsWith("l")) {
+ return Long.parseLong(cut);
+ } else if (encodedValue.startsWith("f")) {
+ return Float.parseFloat(cut);
+ } else if (encodedValue.startsWith("d")) {
+ return Double.parseDouble(cut);
+ } else if (encodedValue.startsWith("i")) {
+ return Integer.parseInt(cut);
+ } else if (encodedValue.startsWith("E:")) {
+ cut = cut.substring(1);
+ return decodeEnum(cut);
} else {
- throw new java.util.UnknownFormatConversionException(
- "Unknown custom type: " + type);
- }
- } else if (encodedValue.equals("NULL") || encodedValue.equals("null")) {
- return null;
- } else if (encodedValue.endsWith("\"")) {
- return decodeString(encodedValue);
- } else if (encodedValue.equals("true")) {
- return true;
- } else if (encodedValue.equals("false")) {
- return false;
- } else if (encodedValue.endsWith("b")) {
- return Byte.parseByte(cut);
- } else if (encodedValue.endsWith("c")) {
- return decodeString(cut).charAt(0);
- } else if (encodedValue.endsWith("s")) {
- return Short.parseShort(cut);
- } else if (encodedValue.endsWith("L")) {
- return Long.parseLong(cut);
- } else if (encodedValue.endsWith("F")) {
- return Float.parseFloat(cut);
- } else if (encodedValue.endsWith("d")) {
- return Double.parseDouble(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(), 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.
+ *
+ * @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;
+ }
+
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ static private Enum> decodeEnum(String escaped) {
+ // escaped: be.xxx.EnumType.VALUE;
+ int pos = escaped.lastIndexOf(".");
+ String type = escaped.substring(0, pos);
+ String name = escaped.substring(pos + 1, escaped.length() - 1);
+
+ try {
+ return Enum.valueOf((Class) getClass(type), name);
+ } catch (Exception e) {
+ throw new UnknownFormatConversionException("Unknown enum: <" + type
+ + "> " + name);
}
}
// 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;
@@ -209,6 +728,6 @@ class SerialUtils {
}
}
- return builder.substring(1, builder.length() - 1).toString();
+ return builder.substring(1, builder.length() - 1);
}
}