package be.nikiroo.utils.serial;
-import java.lang.reflect.Constructor;
+import java.io.IOException;
import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
-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()));
+ read(line);
+ } else {
+ 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)) {
} else if (line.equals("}")) { // STOP: report self to parent
return true;
} else if (line.startsWith("REF ")) { // REF: create/link self
- String ref = line.substring(4).split("@")[1];
+ String[] tab = line.substring("REF ".length()).split("@");
+ String type = tab[0];
+ tab = tab[1].split(":");
+ String ref = tab[0];
+
link = map.containsKey(ref);
if (link) {
me = map.get(ref);
} else {
- me = createSelf(line.substring(4).split("@")[0]);
+ if (line.endsWith(":")) {
+ // construct
+ me = SerialUtils.createObject(type);
+ } else {
+ // direct value
+ int pos = line.indexOf(":");
+ String encodedValue = line.substring(pos + 1);
+ me = SerialUtils.decode(encodedValue);
+ }
map.put(ref, me);
}
- } else { // FIELD: new field
+ } else { // FIELD: new field *or* direct simple value
if (line.endsWith(":")) {
// field value is compound
currentFieldName = line.substring(0, line.length() - 1);
+ } else if (line.startsWith(":") || !line.contains(":")) {
+ // not a field value but a direct value
+ me = SerialUtils.decode(line);
} else {
// field value is direct
int pos = line.indexOf(":");
return false;
}
- /**
- * Create an empty object of the given type.
- *
- * @param type
- * the object type
- * @return the object
- *
- * @throws NoSuchMethodException
- * @throws SecurityException
- * @throws InstantiationException
- * @throws IllegalAccessException
- * @throws ClassNotFoundException
- * @throws IllegalArgumentException
- * @throws InvocationTargetException
- */
- private Object createSelf(String type) throws NoSuchMethodException,
- SecurityException, InstantiationException, IllegalAccessException,
- ClassNotFoundException, IllegalArgumentException,
- InvocationTargetException {
-
- 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;
- if (className.contains("$")) {
- Object javaParent = createSelf(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 (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));
-
- }
- }
-
- 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?)");
- }
- }
- }
-
- return clazz;
- }
-
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;
}
git://git.nikiroo.be / nikiroo-utils.git / blobdiff