X-Git-Url: http://git.nikiroo.be/?a=blobdiff_plain;f=src%2Fbe%2Fnikiroo%2Futils%2Fserial%2FImporter.java;h=2608db272bf85373b0fcecda52aa8e76563b904c;hb=d2219aa05bbcc5603e90aa69220fecb4a6a41f55;hp=bca157c501bcb8a512fd5367585b15a06a82771e;hpb=b6200792e591f13c2d8ecedc4d2015db8ff76cbe;p=nikiroo-utils.git
diff --git a/src/be/nikiroo/utils/serial/Importer.java b/src/be/nikiroo/utils/serial/Importer.java
index bca157c..2608db2 100644
--- a/src/be/nikiroo/utils/serial/Importer.java
+++ b/src/be/nikiroo/utils/serial/Importer.java
@@ -1,12 +1,17 @@
package be.nikiroo.utils.serial;
import java.io.IOException;
-import java.io.UnsupportedEncodingException;
+import java.io.InputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
+import java.util.zip.GZIPInputStream;
-import be.nikiroo.utils.StringUtils;
+import be.nikiroo.utils.IOUtils;
+import be.nikiroo.utils.streams.Base64InputStream;
+import be.nikiroo.utils.streams.BufferedInputStream;
+import be.nikiroo.utils.streams.NextableInputStream;
+import be.nikiroo.utils.streams.NextableInputStreamStep;
/**
* A simple class that can accept the output of {@link Exporter} to recreate
@@ -19,9 +24,6 @@ import be.nikiroo.utils.StringUtils;
* @author niki
*/
public class Importer {
- static private Integer SIZE_ID = null;
- static private byte[] NEWLINE = null;
-
private Boolean link;
private Object me;
private Importer child;
@@ -29,15 +31,6 @@ public class Importer {
private String currentFieldName;
- static {
- try {
- SIZE_ID = "EXT:".getBytes("UTF-8").length;
- NEWLINE = "\n".getBytes("UTF-8");
- } catch (UnsupportedEncodingException e) {
- // UTF-8 is mandated to exist on confirming jre's
- }
- }
-
/**
* Create a new {@link Importer}.
*/
@@ -55,7 +48,7 @@ public class Importer {
* content, or a number of lines of it (any given line MUST be
* complete though) and accumulate it with the already present data.
*
- * @param data
+ * @param in
* the data to parse
*
* @return itself so it can be chained
@@ -70,77 +63,55 @@ public class Importer {
* if a class described in the serialised data cannot be found
* @throws IOException
* if the content cannot be read (for instance, corrupt data)
+ * @throws NullPointerException
+ * if the stream is empty
*/
- public Importer read(String data) throws NoSuchFieldException,
- NoSuchMethodException, ClassNotFoundException, IOException {
- return read(data.getBytes("UTF-8"), 0);
- }
+ public Importer read(InputStream in) throws NoSuchFieldException,
+ NoSuchMethodException, ClassNotFoundException, IOException,
+ NullPointerException {
- /**
- * Read some data into this {@link Importer}: it can be the full serialised
- * content, or a number of lines of it (any given line MUST be
- * complete though) and accumulate it with the already present data.
- *
- * @param data
- * the data to parse
- * @param offset
- * the offset at which to start reading the data (we ignore
- * anything that goes before that offset)
- *
- * @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
- * @throws IOException
- * if the content cannot be read (for instance, corrupt data)
- */
- private Importer read(byte[] data, int offset) throws NoSuchFieldException,
- NoSuchMethodException, ClassNotFoundException, IOException {
-
- int dataStart = offset;
- while (dataStart < data.length) {
- String id = "";
- if (data.length - dataStart >= SIZE_ID) {
- id = new String(data, dataStart, SIZE_ID);
- }
+ NextableInputStream stream = new NextableInputStream(in,
+ new NextableInputStreamStep('\n'));
- boolean zip = id.equals("ZIP:");
- boolean b64 = id.equals("B64:");
- if (zip || b64) {
- dataStart += SIZE_ID;
+ try {
+ if (in == null) {
+ throw new NullPointerException("InputStream is null");
}
- int count = find(data, dataStart, NEWLINE);
- count -= dataStart;
- if (count < 0) {
- count = data.length - dataStart;
- }
+ boolean first = true;
+ while (stream.next()) {
+ if (stream.eof()) {
+ if (first) {
+ throw new NullPointerException(
+ "InputStream empty, normal termination");
+ }
+ return this;
+ }
+ first = false;
+
+ boolean zip = stream.startsWith("ZIP:");
+ boolean b64 = stream.startsWith("B64:");
+
+ if (zip || b64) {
+ stream.skip("XXX:".length());
+
+ InputStream decoded = stream.open();
+ if (zip) {
+ decoded = new GZIPInputStream(decoded);
+ }
+ decoded = new Base64InputStream(decoded, false);
- if (zip || b64) {
- boolean unpacked = false;
- try {
- byte[] line = StringUtils.unbase64(data, dataStart, count,
- zip);
- unpacked = true;
- read(line, 0);
- } catch (IOException e) {
- throw new IOException("Internal error when decoding "
- + (unpacked ? "unpacked " : "")
- + (zip ? "ZIP" : "B64")
- + " content: input may be corrupt");
+ try {
+ read(decoded);
+ } finally {
+ decoded.close();
+ }
+ } else {
+ processLine(stream);
}
- } else {
- String line = new String(data, dataStart, count, "UTF-8");
- processLine(line);
}
-
- dataStart += count + NEWLINE.length;
+ } finally {
+ stream.close(false);
}
return this;
@@ -150,7 +121,7 @@ public class Importer {
* Read a single (whole) line of serialised data into this {@link Importer}
* and accumulate it with the already present data.
*
- * @param line
+ * @param in
* the line to parse
*
* @return TRUE if we are just done with one object or sub-object
@@ -166,11 +137,13 @@ public class Importer {
* @throws IOException
* if the content cannot be read (for instance, corrupt data)
*/
- private boolean processLine(String line) throws NoSuchFieldException,
- NoSuchMethodException, ClassNotFoundException, IOException {
+ private boolean processLine(BufferedInputStream in)
+ throws NoSuchFieldException, NoSuchMethodException,
+ ClassNotFoundException, IOException {
+
// Defer to latest child if any
if (child != null) {
- if (child.processLine(line)) {
+ if (child.processLine(in)) {
if (currentFieldName != null) {
setField(currentFieldName, child.getValue());
currentFieldName = null;
@@ -181,59 +154,108 @@ public class Importer {
return false;
}
- if (line.equals("{")) { // START: new child if needed
+ // Start/Stop object
+ if (in.is("{")) { // START: new child if needed
if (link != null) {
child = new Importer(map);
}
- } else if (line.equals("}")) { // STOP: report self to parent
+ in.end();
+ return false;
+ } else if (in.is("}")) { // STOP: report self to parent
+ in.end();
return true;
- } else if (line.startsWith("REF ")) { // REF: create/link self
- 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 {
- if (line.endsWith(":")) {
- // construct
- me = SerialUtils.createObject(type);
+ }
+
+ // Custom objects
+ if (CustomSerializer.isCustom(in)) {
+ // not a field value but a direct value
+ me = SerialUtils.decode(in);
+ return false;
+ }
+
+ // REF: (object)
+ if (in.startsWith("REF ")) { // REF: create/link self
+ // here, line is REF type@999:xxx
+ // xxx is optional
+
+ NextableInputStream stream = new NextableInputStream(in,
+ new NextableInputStreamStep(':'));
+ try {
+ stream.next();
+
+ stream.skip("REF ".length());
+ String header = IOUtils.readSmallStream(stream);
+
+ String[] tab = header.split("@");
+ if (tab.length != 2) {
+ throw new IOException("Bad import header line: " + header);
+ }
+ String type = tab[0];
+ String ref = tab[1];
+
+ stream.nextAll();
+
+ link = map.containsKey(ref);
+ if (link) {
+ me = map.get(ref);
+ stream.end();
} else {
- // direct value
- int pos = line.indexOf(":");
- String encodedValue = line.substring(pos + 1);
- me = SerialUtils.decode(encodedValue);
+ if (stream.eof()) {
+ // construct
+ me = SerialUtils.createObject(type);
+ } else {
+ // direct value
+ me = SerialUtils.decode(stream);
+ }
+ map.put(ref, me);
}
- map.put(ref, me);
+ } finally {
+ stream.close(false);
}
- } 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(":")
- || line.startsWith("\"") || CustomSerializer.isCustom(line)) {
- // not a field value but a direct value
- me = SerialUtils.decode(line);
- } else {
- // field value is direct
- int pos = line.indexOf(":");
- String fieldName = line.substring(0, pos);
- String encodedValue = line.substring(pos + 1);
- Object value = null;
- value = SerialUtils.decode(encodedValue);
-
- // To support simple types directly:
- if (me == null) {
- me = value;
+
+ return false;
+ }
+
+ if (SerialUtils.isDirectValue(in)) {
+ // not a field value but a direct value
+ me = SerialUtils.decode(in);
+ return false;
+ }
+
+ if (in.startsWith("^")) {
+ in.skip(1);
+
+ NextableInputStream nameThenContent = new NextableInputStream(in,
+ new NextableInputStreamStep(':'));
+
+ try {
+ nameThenContent.next();
+ String fieldName = IOUtils.readSmallStream(nameThenContent);
+
+ if (nameThenContent.next() && !nameThenContent.eof()) {
+ // field value is direct or custom
+ Object value = null;
+ value = SerialUtils.decode(nameThenContent);
+
+ // To support simple types directly:
+ if (me == null) {
+ me = value;
+ } else {
+ setField(fieldName, value);
+ }
} else {
- setField(fieldName, value);
+ // field value is compound
+ currentFieldName = fieldName;
}
+ } finally {
+ nameThenContent.close(false);
}
+
+ return false;
}
- return false;
+ String line = IOUtils.readSmallStream(in);
+ throw new IOException("Line cannot be processed: <" + line + ">");
}
private void setField(String name, Object value)
@@ -255,37 +277,6 @@ public class Importer {
}
}
- /**
- * Find the given needle in the data and return its position (or -1 if not
- * found).
- *
- * @param data
- * the data to look through
- * @param offset
- * the offset at wich to start searching
- * @param needle
- * the needle to find
- *
- * @return the position of the needle if found, -1 if not found
- */
- private int find(byte[] data, int offset, byte[] needle) {
- for (int i = offset; i + needle.length - 1 < data.length; i++) {
- boolean same = true;
- for (int j = 0; j < needle.length; j++) {
- if (data[i + j] != needle[j]) {
- same = false;
- break;
- }
- }
-
- if (same) {
- return i;
- }
- }
-
- return -1;
- }
-
/**
* Return the current deserialised value.
*