X-Git-Url: http://git.nikiroo.be/?a=blobdiff_plain;f=src%2Fbe%2Fnikiroo%2Futils%2Fserial%2FImporter.java;h=81814dfdbadf6a71ec2224d14be5926314bbd105;hb=601003e69e1dc81774243c6eadf7982b6b563b33;hp=a159ddedf4763859aefe8fc51ac82479d567ce0f;hpb=f157aed840bdd5b8ef04902d2326d916f71139da;p=fanfix.git diff --git a/src/be/nikiroo/utils/serial/Importer.java b/src/be/nikiroo/utils/serial/Importer.java index a159dde..81814df 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.InputStream; import java.lang.reflect.Field; import java.util.HashMap; import java.util.Map; -import java.util.Scanner; +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 @@ -43,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 @@ -56,27 +61,57 @@ public class Importer { * 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) + * @throws NullPointerException + * if the stream is empty */ - public Importer read(String data) throws NoSuchFieldException, - NoSuchMethodException, ClassNotFoundException { + public Importer read(InputStream in) throws NoSuchFieldException, + NoSuchMethodException, ClassNotFoundException, IOException, + NullPointerException { + + NextableInputStream stream = new NextableInputStream(in, + new NextableInputStreamStep('\n')); try { - Scanner scan = new Scanner(data); - scan.useDelimiter("\n"); - while (scan.hasNext()) { - String line = scan.next(); - - if (line.startsWith("ZIP:")) { - line = StringUtils.unzip64(line.substring("ZIP:".length())); - read(line); + if (in == null) { + throw new NullPointerException("InputStream is null"); + } + + 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); + + try { + read(decoded); + } finally { + decoded.close(); + } } else { - processLine(line); + processLine(stream); } } - scan.close(); - } catch (IOException e) { - throw new NoSuchMethodException( - "Internal error when decoding ZIP content: input may be corrupt"); + } finally { + stream.close(false); } return this; @@ -86,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 @@ -99,12 +134,16 @@ public class Importer { * 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 boolean processLine(String line) throws NoSuchFieldException, - NoSuchMethodException, ClassNotFoundException { + 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; @@ -115,58 +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(":")) { - // 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.nextAll() && !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)