serial/Importer.java

   1 package be.nikiroo.utils.serial;
   2
   3 import java.io.IOException;
   4 import java.io.InputStream;
   5 import java.lang.reflect.Field;
   6 import java.util.HashMap;
   7 import java.util.Map;
   8 import java.util.zip.GZIPInputStream;
   9
  10 import be.nikiroo.utils.IOUtils;
  11 import be.nikiroo.utils.streams.Base64InputStream;
  12 import be.nikiroo.utils.streams.BufferedInputStream;
  13 import be.nikiroo.utils.streams.NextableInputStream;
  14 import be.nikiroo.utils.streams.NextableInputStreamStep;
  15
  16 /**
  17  * A simple class that can accept the output of {@link Exporter} to recreate
  18  * objects as they were sent to said exporter.
  19  * <p>
  20  * This class requires the objects (and their potential enclosing objects) to
  21  * have an empty constructor, and does not support inner classes (it does
  22  * support nested classes, though).
  23  *
  24  * @author niki
  25  */
  26 public class Importer {
  27         private Boolean link;
  28         private Object me;
  29         private Importer child;
  30         private Map<String, Object> map;
  31
  32         private String currentFieldName;
  33
  34         /**
  35          * Create a new {@link Importer}.
  36          */
  37         public Importer() {
  38                 map = new HashMap<String, Object>();
  39                 map.put("NULL", null);
  40         }
  41
  42         private Importer(Map<String, Object> map) {
  43                 this.map = map;
  44         }
  45
  46         /**
  47          * Read some data into this {@link Importer}: it can be the full serialised
  48          * content, or a number of lines of it (any given line <b>MUST</b> be
  49          * complete though) and accumulate it with the already present data.
  50          *
  51          * @param in
  52          *            the data to parse
  53          *
  54          * @return itself so it can be chained
  55          *
  56          * @throws NoSuchFieldException
  57          *             if the serialised data contains information about a field
  58          *             which does actually not exist in the class we know of
  59          * @throws NoSuchMethodException
  60          *             if a class described in the serialised data cannot be created
  61          *             because it is not compatible with this code
  62          * @throws ClassNotFoundException
  63          *             if a class described in the serialised data cannot be found
  64          * @throws IOException
  65          *             if the content cannot be read (for instance, corrupt data)
  66          * @throws NullPointerException
  67          *             if the stream is empty
  68          */
  69         public Importer read(InputStream in) throws NoSuchFieldException,
  70                         NoSuchMethodException, ClassNotFoundException, IOException,
  71                         NullPointerException {
  72
  73                 NextableInputStream stream = new NextableInputStream(in,
  74                                 new NextableInputStreamStep('\n'));
  75
  76                 try {
  77                         if (in == null) {
  78                                 throw new NullPointerException("InputStream is null");
  79                         }
  80
  81                         boolean first = true;
  82                         while (stream.next()) {
  83                                 if (stream.eof()) {
  84                                         if (first) {
  85                                                 throw new NullPointerException(
  86                                                                 "InputStream empty, normal termination");
  87                                         }
  88                                         return this;
  89                                 }
  90                                 first = false;
  91
  92                                 boolean zip = stream.startsWith("ZIP:");
  93                                 boolean b64 = stream.startsWith("B64:");
  94
  95                                 if (zip || b64) {
  96                                         stream.skip("XXX:".length());
  97
  98                                         InputStream decoded = stream.open();
  99                                         if (zip) {
 100                                                 decoded = new GZIPInputStream(decoded);
 101                                         }
 102                                         decoded = new Base64InputStream(decoded, false);
 103
 104                                         try {
 105                                                 read(decoded);
 106                                         } finally {
 107                                                 decoded.close();
 108                                         }
 109                                 } else {
 110                                         processLine(stream);
 111                                 }
 112                         }
 113                 } finally {
 114                         stream.close(false);
 115                 }
 116
 117                 return this;
 118         }
 119
 120         /**
 121          * Read a single (whole) line of serialised data into this {@link Importer}
 122          * and accumulate it with the already present data.
 123          *
 124          * @param in
 125          *            the line to parse
 126          *
 127          * @return TRUE if we are just done with one object or sub-object
 128          *
 129          * @throws NoSuchFieldException
 130          *             if the serialised data contains information about a field
 131          *             which does actually not exist in the class we know of
 132          * @throws NoSuchMethodException
 133          *             if a class described in the serialised data cannot be created
 134          *             because it is not compatible with this code
 135          * @throws ClassNotFoundException
 136          *             if a class described in the serialised data cannot be found
 137          * @throws IOException
 138          *             if the content cannot be read (for instance, corrupt data)
 139          */
 140         private boolean processLine(BufferedInputStream in)
 141                         throws NoSuchFieldException, NoSuchMethodException,
 142                         ClassNotFoundException, IOException {
 143
 144                 // Defer to latest child if any
 145                 if (child != null) {
 146                         if (child.processLine(in)) {
 147                                 if (currentFieldName != null) {
 148                                         setField(currentFieldName, child.getValue());
 149                                         currentFieldName = null;
 150                                 }
 151                                 child = null;
 152                         }
 153
 154                         return false;
 155                 }
 156
 157                 // Start/Stop object
 158                 if (in.is("{")) { // START: new child if needed
 159                         if (link != null) {
 160                                 child = new Importer(map);
 161                         }
 162                         in.end();
 163                         return false;
 164                 } else if (in.is("}")) { // STOP: report self to parent
 165                         in.end();
 166                         return true;
 167                 }
 168
 169                 // Custom objects
 170                 if (CustomSerializer.isCustom(in)) {
 171                         // not a field value but a direct value
 172                         me = SerialUtils.decode(in);
 173                         return false;
 174                 }
 175
 176                 // REF: (object)
 177                 if (in.startsWith("REF ")) { // REF: create/link self
 178                         // here, line is REF type@999:xxx
 179                         // xxx is optional
 180
 181                         NextableInputStream stream = new NextableInputStream(in,
 182                                         new NextableInputStreamStep(':'));
 183                         try {
 184                                 stream.next();
 185
 186                                 stream.skip("REF ".length());
 187                                 String header = IOUtils.readSmallStream(stream);
 188
 189                                 String[] tab = header.split("@");
 190                                 if (tab.length != 2) {
 191                                         throw new IOException("Bad import header line: " + header);
 192                                 }
 193                                 String type = tab[0];
 194                                 String ref = tab[1];
 195
 196                                 stream.nextAll();
 197
 198                                 link = map.containsKey(ref);
 199                                 if (link) {
 200                                         me = map.get(ref);
 201                                         stream.end();
 202                                 } else {
 203                                         if (stream.eof()) {
 204                                                 // construct
 205                                                 me = SerialUtils.createObject(type);
 206                                         } else {
 207                                                 // direct value
 208                                                 me = SerialUtils.decode(stream);
 209                                         }
 210                                         map.put(ref, me);
 211                                 }
 212                         } finally {
 213                                 stream.close(false);
 214                         }
 215
 216                         return false;
 217                 }
 218
 219                 if (SerialUtils.isDirectValue(in)) {
 220                         // not a field value but a direct value
 221                         me = SerialUtils.decode(in);
 222                         return false;
 223                 }
 224
 225                 if (in.startsWith("^")) {
 226                         in.skip(1);
 227
 228                         NextableInputStream nameThenContent = new NextableInputStream(in,
 229                                         new NextableInputStreamStep(':'));
 230
 231                         try {
 232                                 nameThenContent.next();
 233                                 String fieldName = IOUtils.readSmallStream(nameThenContent);
 234
 235                                 if (nameThenContent.nextAll() && !nameThenContent.eof()) {
 236                                         // field value is direct or custom
 237                                         Object value = null;
 238                                         value = SerialUtils.decode(nameThenContent);
 239
 240                                         // To support simple types directly:
 241                                         if (me == null) {
 242                                                 me = value;
 243                                         } else {
 244                                                 setField(fieldName, value);
 245                                         }
 246                                 } else {
 247                                         // field value is compound
 248                                         currentFieldName = fieldName;
 249                                 }
 250                         } finally {
 251                                 nameThenContent.close(false);
 252                         }
 253
 254                         return false;
 255                 }
 256
 257                 String line = IOUtils.readSmallStream(in);
 258                 throw new IOException("Line cannot be processed: <" + line + ">");
 259         }
 260
 261         private void setField(String name, Object value)
 262                         throws NoSuchFieldException {
 263
 264                 try {
 265                         Field field = me.getClass().getDeclaredField(name);
 266
 267                         field.setAccessible(true);
 268                         field.set(me, value);
 269                 } catch (NoSuchFieldException e) {
 270                         throw new NoSuchFieldException(String.format(
 271                                         "Field \"%s\" was not found in object of type \"%s\".",
 272                                         name, me.getClass().getCanonicalName()));
 273                 } catch (Exception e) {
 274                         throw new NoSuchFieldException(String.format(
 275                                         "Internal error when setting \"%s.%s\": %s", me.getClass()
 276                                                         .getCanonicalName(), name, e.getMessage()));
 277                 }
 278         }
 279
 280         /**
 281          * Return the current deserialised value.
 282          *
 283          * @return the current value
 284          */
 285         public Object getValue() {
 286                 return me;
 287         }
 288 }