package be.nikiroo.utils.serial;
+import java.io.IOException;
+import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Field;
-import be.nikiroo.utils.IOUtils;
import be.nikiroo.utils.StringUtils;
/**
this.map = map;
}
- public Importer readLine(String line) {
- try {
- processLine(line);
- } catch (Exception e) {
- throw new IllegalArgumentException(e);
- }
- return this;
- }
+ /**
+ * Read some data into this {@link Importer}: it can be the full serialised
+ * content, or a number of lines of it (any given line <b>MUST</b> be
+ * complete though) and accumulate it with the already present data.
+ *
+ * @param data
+ * the data to parse
+ *
+ * @return itself so it can be chained
+ *
+ * @throws NoSuchFieldException
+ * if the serialised data contains information about a field
+ * which does actually not exist in the class we know of
+ * @throws NoSuchMethodException
+ * if a class described in the serialised data cannot be created
+ * because it is not compatible with this code
+ * @throws ClassNotFoundException
+ * if a class described in the serialised data cannot be found
+ */
+ public Importer read(String data) throws NoSuchFieldException,
+ NoSuchMethodException, ClassNotFoundException {
- public Importer read(String data) {
try {
- if (data.startsWith("ZIP:")) {
- data = StringUtils.unzip64(data.substring("ZIP:".length()));
- }
Scanner scan = new Scanner(data);
scan.useDelimiter("\n");
while (scan.hasNext()) {
- processLine(scan.next());
+ String line = scan.next();
+
+ if (line.startsWith("ZIP:")) {
+ line = StringUtils.unzip64(line.substring("ZIP:".length()));
+ }
+ processLine(line);
+
}
scan.close();
- } catch (Exception e) {
- throw new IllegalArgumentException(e);
+ } catch (IOException e) {
+ throw new NoSuchMethodException(
+ "Internal error when decoding ZIP content: input may be corrupt");
}
+
return this;
}
- public boolean processLine(String line) throws IllegalArgumentException,
- NoSuchFieldException, SecurityException, IllegalAccessException,
- NoSuchMethodException, InstantiationException, ClassNotFoundException, InvocationTargetException {
+ /**
+ * Read a single (whole) line of serialised data into this {@link Importer}
+ * and accumulate it with the already present data.
+ *
+ * @param line
+ * the line to parse
+ *
+ * @return TRUE if we are just done with one object or sub-object
+ *
+ * @throws NoSuchFieldException
+ * if the serialised data contains information about a field
+ * which does actually not exist in the class we know of
+ * @throws NoSuchMethodException
+ * if a class described in the serialised data cannot be created
+ * because it is not compatible with this code
+ * @throws ClassNotFoundException
+ * if a class described in the serialised data cannot be found
+ */
+ private boolean processLine(String line) throws NoSuchFieldException,
+ NoSuchMethodException, ClassNotFoundException {
// Defer to latest child if any
if (child != null) {
if (child.processLine(line)) {
}
private void setField(String name, Object value)
- throws NoSuchFieldException, SecurityException,
- IllegalArgumentException, IllegalAccessException {
+ throws NoSuchFieldException {
try {
Field field = me.getClass().getDeclaredField(name);
throw new NoSuchFieldException(String.format(
"Field \"%s\" was not found in object of type \"%s\".",
name, me.getClass().getCanonicalName()));
+ } catch (Exception e) {
+ throw new NoSuchFieldException(String.format(
+ "Internal error when setting \"%s.%s\": %s", me.getClass()
+ .getCanonicalName(), name, e.getMessage()));
}
}
+ /**
+ * Return the current deserialised value.
+ *
+ * @return the current value
+ */
public Object getValue() {
return me;
}
package be.nikiroo.utils.serial;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
import java.io.NotSerializableException;
+import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
/**
- * Small class to help serialise/deserialise objects.
+ * Small class to help with serialisation.
* <p>
* Note that we do not support inner classes (but we do support nested classes)
* and all objects require an empty constructor to be deserialised.
static {
customTypes = new HashMap<String, CustomSerializer>();
- // TODO: add "default" custom serialisers
+ // TODO: add "default" custom serialisers if any (Bitmap?)
}
-
+
/**
* Create an empty object of the given type.
*
*
* @return the new object
*
- * @throws NoSuchMethodException if the given class is not compatible with this code
- * @throws ClassNotFoundException if the class cannot be found or created
+ * @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 NoSuchMethodException,
- ClassNotFoundException {
+ public static Object createObject(String type)
+ throws ClassNotFoundException, NoSuchMethodException {
try {
Class<?> clazz = getClass(type);
- if (clazz == null) {
- throw new ClassNotFoundException("Class not found: " + type);
- }
-
String className = clazz.getName();
Object[] args = null;
Constructor<?> ctor = null;
ctor.setAccessible(true);
return ctor.newInstance(args);
+ } catch (ClassNotFoundException e) {
+ throw e;
} catch (NoSuchMethodException e) {
- throw new NoSuchMethodException(
- String.format(
- "Objects of type \"%s\" cannot be created by this code: maybe the class"
- + " or its enclosing class doesn't have an empty constructor?",
- type));
-
+ throw e;
+ } catch (Exception e) {
+ throw new NoSuchMethodException("Cannot instantiate: " + type);
}
- catch (SecurityException e) { throw new ClassNotFoundException("Cannot instantiate: " + type, e); }
- catch (InstantiationException e) { throw new ClassNotFoundException("Cannot instantiate: " + type, e); }
- catch (IllegalAccessException e) { throw new ClassNotFoundException("Cannot instantiate: " + type, e); }
- catch (IllegalArgumentException e) { throw new ClassNotFoundException("Cannot instantiate: " + type, e); }
- catch (InvocationTargetException e) { throw new ClassNotFoundException("Cannot instantiate: " + type, e); }
}
+ /**
+ * 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}.
+ * <p>
+ * <b>Important: </b>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<Integer, Object> map)
throws NotSerializableException {
return Integer.parseInt(encodedValue);
}
}
-
- static private Class<?> getClass(String type) throws ClassNotFoundException,
- NoSuchMethodException {
+
+ /**
+ * 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);
}
}
+ 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('\"');
git://git.nikiroo.be / nikiroo-utils.git / commitdiff