en cours, 3

[nikiroo-utils.git] / src / be / nikiroo / utils / serial / SerialUtils.java

diff --git a/src/be/nikiroo/utils/serial/SerialUtils.java b/src/be/nikiroo/utils/serial/SerialUtils.java
index e2d8decea64113bfe76ac0962196e325a2fcf2d8..0dc4a35e30dc3ee08fe11bfb8cec46d2b2d5cee8 100644 (file)
--- a/src/be/nikiroo/utils/serial/SerialUtils.java
+++ b/src/be/nikiroo/utils/serial/SerialUtils.java
@@ -16,7 +16,11 @@ import java.util.List;
 import java.util.Map;
 import java.util.UnknownFormatConversionException;
 
+import be.nikiroo.utils.IOUtils;
 import be.nikiroo.utils.Image;
+import be.nikiroo.utils.NextableInputStream;
+import be.nikiroo.utils.NextableInputStreamStep;
+import be.nikiroo.utils.StringUtils;
 
 /**
  * Small class to help with serialisation.
@@ -56,50 +60,54 @@ public class SerialUtils {
                // Array types:
                customTypes.put("[]", new CustomSerializer() {
                        @Override
-                       protected String toString(Object value) {
+                       protected void toStream(OutputStream out, Object value)
+                                       throws IOException {
+                               // TODO: we use \n to separate, and b64 to un-\n -- but we could
+                               // use \\n ?
                                String type = value.getClass().getCanonicalName();
                                type = type.substring(0, type.length() - 2); // remove the []
 
-                               StringBuilder builder = new StringBuilder();
-                               builder.append(type).append("\n");
+                               write(out, type);
+                               write(out, "\n");
                                try {
                                        for (int i = 0; true; i++) {
                                                Object item = Array.get(value, i);
                                                // encode it normally if direct value
-                                               if (!SerialUtils.encode(builder, item)) {
+                                               if (!SerialUtils.encode(out, item)) {
                                                        try {
-                                                               // use ZIP: if not
-                                                               new Exporter().append(item).appendTo(builder,
-                                                                               true, false);
+                                                               // TODO: use ZIP: if not?
+                                                               new Exporter(out).append(item);
                                                        } catch (NotSerializableException e) {
                                                                throw new UnknownFormatConversionException(e
                                                                                .getMessage());
                                                        }
                                                }
-                                               builder.append("\n");
+                                               write(out, "\n");
                                        }
                                } catch (ArrayIndexOutOfBoundsException e) {
                                        // Done.
                                }
-
-                               return builder.toString();
                        }
 
                        @Override
-                       protected String getType() {
-                               return "[]";
-                       }
-
-                       @Override
-                       protected Object fromString(String content) throws IOException {
-                               String[] tab = content.split("\n");
+                       protected Object fromStream(InputStream in) throws IOException {
+                               NextableInputStream stream = new NextableInputStream(in,
+                                               new NextableInputStreamStep('\n'));
 
                                try {
+                                       List<Object> list = new ArrayList<Object>();
+                                       stream.next();
+                                       String type = IOUtils.readSmallStream(stream);
+
+                                       while (stream.next()) {
+                                               Object value = new Importer().read(stream).getValue();
+                                               list.add(value);
+                                       }
+
                                        Object array = Array.newInstance(
-                                                       SerialUtils.getClass(tab[0]), tab.length - 1);
-                                       for (int i = 1; i < tab.length; i++) {
-                                               Object value = new Importer().read(tab[i]).getValue();
-                                               Array.set(array, i - 1, value);
+                                                       SerialUtils.getClass(type), list.size());
+                                       for (int i = 0; i < list.size(); i++) {
+                                               Array.set(array, i, list.get(i));
                                        }
 
                                        return array;
@@ -110,23 +118,34 @@ public class SerialUtils {
                                        throw new IOException(e.getMessage());
                                }
                        }
+
+                       @Override
+                       protected String getType() {
+                               return "[]";
+                       }
                });
 
                // URL:
                customTypes.put("java.net.URL", new CustomSerializer() {
+
                        @Override
-                       protected String toString(Object value) {
+                       protected void toStream(OutputStream out, Object value)
+                                       throws IOException {
+                               String val = "";
                                if (value != null) {
-                                       return ((URL) value).toString();
+                                       val = ((URL) value).toString();
                                }
-                               return null;
+
+                               out.write(val.getBytes("UTF-8"));
                        }
 
                        @Override
-                       protected Object fromString(String content) throws IOException {
-                               if (content != null) {
-                                       return new URL(content);
+                       protected Object fromStream(InputStream in) throws IOException {
+                               String val = IOUtils.readSmallStream(in);
+                               if (!val.isEmpty()) {
+                                       return new URL(val);
                                }
+
                                return null;
                        }
 
@@ -139,8 +158,20 @@ public class SerialUtils {
                // Images (this is currently the only supported image type by default)
                customTypes.put("be.nikiroo.utils.Image", new CustomSerializer() {
                        @Override
-                       protected String toString(Object value) {
-                               return ((Image) value).toBase64();
+                       protected void toStream(OutputStream out, Object value)
+                                       throws IOException {
+                               Image img = (Image) value;
+                               OutputStream encoded = StringUtils.base64(out, false, false);
+                               try {
+                                       InputStream in = img.newInputStream();
+                                       try {
+                                               IOUtils.write(in, encoded);
+                                       } finally {
+                                               in.close();
+                                       }
+                               } finally {
+                                       encoded.close();
+                               }
                        }
 
                        @Override
@@ -149,9 +180,9 @@ public class SerialUtils {
                        }
 
                        @Override
-                       protected Object fromString(String content) {
+                       protected Object fromStream(InputStream in) throws IOException {
                                try {
-                                       return new Image(content);
+                                       return new Image(in);
                                } catch (IOException e) {
                                        throw new UnknownFormatConversionException(e.getMessage());
                                }