X-Git-Url: http://git.nikiroo.be/?a=blobdiff_plain;f=src%2Fbe%2Fnikiroo%2Futils%2Fserial%2FImporter.java;h=bca157c501bcb8a512fd5367585b15a06a82771e;hb=b6200792e591f13c2d8ecedc4d2015db8ff76cbe;hp=0709a96883c77b005f57ddf04de4ac15b04165ac;hpb=aad145868879e293dbe391c005c1a6885341529b;p=nikiroo-utils.git diff --git a/src/be/nikiroo/utils/serial/Importer.java b/src/be/nikiroo/utils/serial/Importer.java index 0709a96..bca157c 100644 --- a/src/be/nikiroo/utils/serial/Importer.java +++ b/src/be/nikiroo/utils/serial/Importer.java @@ -1,12 +1,11 @@ package be.nikiroo.utils.serial; +import java.io.IOException; +import java.io.UnsupportedEncodingException; +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; /** @@ -20,6 +19,9 @@ 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; @@ -27,6 +29,18 @@ 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}. + */ public Importer() { map = new HashMap(); map.put("NULL", null); @@ -36,35 +50,124 @@ public class Importer { 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 MUST 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 + * @throws IOException + * if the content cannot be read (for instance, corrupt data) + */ + public Importer read(String data) throws NoSuchFieldException, + NoSuchMethodException, ClassNotFoundException, IOException { + return read(data.getBytes("UTF-8"), 0); } - public Importer read(String data) { - try { - if (data.startsWith("ZIP:")) { - data = StringUtils.unzip64(data.substring("ZIP:".length())); + /** + * 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); } - Scanner scan = new Scanner(data); - scan.useDelimiter("\n"); - while (scan.hasNext()) { - processLine(scan.next()); + + boolean zip = id.equals("ZIP:"); + boolean b64 = id.equals("B64:"); + if (zip || b64) { + dataStart += SIZE_ID; } - scan.close(); - } catch (Exception e) { - throw new IllegalArgumentException(e); + + int count = find(data, dataStart, NEWLINE); + count -= dataStart; + if (count < 0) { + count = data.length - dataStart; + } + + 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"); + } + } else { + String line = new String(data, dataStart, count, "UTF-8"); + processLine(line); + } + + dataStart += count + NEWLINE.length; } + 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 + * @throws IOException + * if the content cannot be read (for instance, corrupt data) + */ + private boolean processLine(String line) throws NoSuchFieldException, + NoSuchMethodException, ClassNotFoundException, IOException { // Defer to latest child if any if (child != null) { if (child.processLine(line)) { @@ -85,18 +188,34 @@ public class Importer { } 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 = SerialUtils.createObject(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(":") + || 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(":"); @@ -118,8 +237,7 @@ public class Importer { } private void setField(String name, Object value) - throws NoSuchFieldException, SecurityException, - IllegalArgumentException, IllegalAccessException { + throws NoSuchFieldException { try { Field field = me.getClass().getDeclaredField(name); @@ -130,9 +248,49 @@ public class Importer { 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())); } } + /** + * 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. + * + * @return the current value + */ public Object getValue() { return me; }