package be.nikiroo.utils.serial;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.io.NotSerializableException;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.Map;
import java.util.UnknownFormatConversionException;
import be.nikiroo.utils.ImageUtils;
/**
* 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
*/
public class SerialUtils {
private static Map customTypes;
static {
customTypes = new HashMap();
// 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());
}
}
});
// Images (this is currently the only supported image type by default)
customTypes.put("java.awt.image.BufferedImage", new CustomSerializer() {
@Override
protected String toString(Object value) {
try {
return ImageUtils.toBase64((BufferedImage) value);
} catch (IOException e) {
throw new UnknownFormatConversionException(e.getMessage());
}
}
@Override
protected String getType() {
return "java.awt.image.BufferedImage";
}
@Override
protected Object fromString(String content) {
try {
return ImageUtils.fromBase64(content);
} catch (IOException 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 {
Field[] fields = new Field[] {};
String type = "";
String id = "NULL";
if (o != null) {
int hash = System.identityHashCode(o);
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));
}
id = Integer.toString(hash);
if (map.containsKey(hash)) {
fields = new Field[] {};
} else {
map.put(hash, o);
}
}
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$")
|| 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;
value = field.get(o);
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)
}
}
builder.append("\n}");
}
// return true if encoded (supported)
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);
} else if (value instanceof String) {
encodeString(builder, (String) value);
} else if (value instanceof Boolean) {
builder.append(value);
} else if (value instanceof Byte) {
builder.append(value).append('b');
} else if (value instanceof Character) {
encodeString(builder, "" + value);
builder.append('c');
} else if (value instanceof Short) {
builder.append(value).append('s');
} else if (value instanceof Integer) {
builder.append(value);
} else if (value instanceof Long) {
builder.append(value).append('L');
} else if (value instanceof Float) {
builder.append(value).append('F');
} else if (value instanceof Double) {
builder.append(value).append('d');
} else if (value instanceof Enum) {
String type = value.getClass().getCanonicalName();
builder.append(type).append(".").append(((Enum>) value).name())
.append(";");
} else {
return false;
}
return true;
}
static Object decode(String encodedValue) {
String cut = "";
if (encodedValue.length() > 1) {
cut = encodedValue.substring(0, encodedValue.length() - 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 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 if (encodedValue.endsWith(";")) {
return decodeEnum(encodedValue);
} else {
return Integer.parseInt(encodedValue);
}
}
/**
* 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" })
private static 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) {
e.printStackTrace();
throw new UnknownFormatConversionException("Unknown enum: <" + type
+ "> " + name);
}
}
// aa bb -> "aa\tbb"
private static void encodeString(StringBuilder builder, String raw) {
builder.append('\"');
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;
}
}
builder.append('\"');
}
// "aa\tbb" -> aa bb
private static String decodeString(String escaped) {
StringBuilder builder = new StringBuilder();
boolean escaping = false;
for (char car : escaped.toCharArray()) {
if (!escaping) {
if (car == '\\') {
escaping = true;
} else {
builder.append(car);
}
} else {
switch (car) {
case '\\':
builder.append('\\');
break;
case 'r':
builder.append('\r');
break;
case 'n':
builder.append('\n');
break;
case '"':
builder.append('"');
break;
}
escaping = false;
}
}
return builder.substring(1, builder.length() - 1).toString();
}
}