Version 4.0.0: java.awt dependencies move

[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 73f2027abb75480957beb087681495fa75009363..3308a756c578bd14c3f5bc758cd31e30164afcaa 100644 (file)
--- a/src/be/nikiroo/utils/serial/SerialUtils.java
+++ b/src/be/nikiroo/utils/serial/SerialUtils.java
@@ -1,17 +1,17 @@
 package be.nikiroo.utils.serial;
 
-import java.awt.image.BufferedImage;
 import java.io.IOException;
 import java.io.NotSerializableException;
 import java.lang.reflect.Array;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
+import java.net.URL;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.UnknownFormatConversionException;
 
-import be.nikiroo.utils.ImageUtils;
+import be.nikiroo.utils.Image;
 
 /**
  * Small class to help with serialisation.
@@ -37,6 +37,7 @@ import be.nikiroo.utils.ImageUtils;
  * <li>Enum (any enum whose name and value is known by the caller)</li>
  * <li>java.awt.image.BufferedImage (as a {@link CustomSerializer})</li>
  * <li>An array of the above (as a {@link CustomSerializer})</li>
+ * <li>URL</li>
  * </ul>
  * 
  * @author niki
@@ -85,7 +86,7 @@ public class SerialUtils {
                        }
 
                        @Override
-                       protected Object fromString(String content) {
+                       protected Object fromString(String content) throws IOException {
                                String[] tab = content.split("\n");
 
                                try {
@@ -98,31 +99,54 @@ public class SerialUtils {
 
                                        return array;
                                } catch (Exception e) {
-                                       throw new UnknownFormatConversionException(e.getMessage());
+                                       if (e instanceof IOException) {
+                                               throw (IOException) e;
+                                       }
+                                       throw new IOException(e.getMessage());
                                }
                        }
                });
 
-               // Images (this is currently the only supported image type by default)
-               customTypes.put("java.awt.image.BufferedImage", new CustomSerializer() {
+               // URL:
+               customTypes.put("java.net.URL", new CustomSerializer() {
                        @Override
                        protected String toString(Object value) {
-                               try {
-                                       return ImageUtils.toBase64((BufferedImage) value);
-                               } catch (IOException e) {
-                                       throw new UnknownFormatConversionException(e.getMessage());
+                               if (value != null) {
+                                       return ((URL) value).toString();
                                }
+                               return null;
+                       }
+
+                       @Override
+                       protected Object fromString(String content) throws IOException {
+                               if (content != null) {
+                                       return new URL(content);
+                               }
+                               return null;
                        }
 
                        @Override
                        protected String getType() {
-                               return "java.awt.image.BufferedImage";
+                               return "java.net.URL";
+                       }
+               });
+
+               // 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();
+                       }
+
+                       @Override
+                       protected String getType() {
+                               return "be.nikiroo.utils.Image";
                        }
 
                        @Override
                        protected Object fromString(String content) {
                                try {
-                                       return ImageUtils.fromBase64(content);
+                                       return new Image(content);
                                } catch (IOException e) {
                                        throw new UnknownFormatConversionException(e.getMessage());
                                }
@@ -326,24 +350,23 @@ public class SerialUtils {
         * 
         * @return the object (can be NULL for NULL encoded values)
         * 
-        * @throws UnknownFormatConversionException
+        * @throws IOException
         *             if the content cannot be converted
         */
-       static Object decode(String encodedValue) {
-               String cut = "";
-               if (encodedValue.length() > 1) {
-                       cut = encodedValue.substring(0, encodedValue.length() - 1);
-               }
-
+       static Object decode(String encodedValue) throws IOException {
                try {
+                       String cut = "";
+                       if (encodedValue.length() > 1) {
+                               cut = encodedValue.substring(0, encodedValue.length() - 1);
+                       }
+
                        if (CustomSerializer.isCustom(encodedValue)) {
                                // custom:TYPE_NAME:"content is String-encoded"
                                String type = CustomSerializer.typeOf(encodedValue);
                                if (customTypes.containsKey(type)) {
                                        return customTypes.get(type).decode(encodedValue);
                                }
-                               throw new UnknownFormatConversionException(
-                                               "Unknown custom type: " + type);
+                               throw new IOException("Unknown custom type: " + type);
                        } else if (encodedValue.equals("NULL")
                                        || encodedValue.equals("null")) {
                                return null;
@@ -371,10 +394,10 @@ public class SerialUtils {
                                return Integer.parseInt(encodedValue);
                        }
                } catch (Exception e) {
-                       if (e instanceof UnknownFormatConversionException) {
-                               throw (UnknownFormatConversionException) e;
+                       if (e instanceof IOException) {
+                               throw (IOException) e;
                        }
-                       throw new UnknownFormatConversionException(e.getMessage());
+                       throw new IOException(e.getMessage());
                }
        }