Changeset 105 for java/main/src/main/java/com/framsticks/params/ParamsUtil.java

Timestamp:

09/10/13 21:11:41 (11 years ago)

Author:

psniegowski

Message:

HIGHLIGHTS:

• import refactorization: move Tree, Path, etc.

from core to structure package

• initial serialization implementation
• improve PrimeExperiment? test
• many organizational changes and convenience improvements

CHANGELOG:
Make registry in AbstractTree? final.

Move most classes from core to structure package.

Minor changes.

Switch names of Future and FutureHandler?.

Rename ExceptionResultHandler? to ExceptionHandler?.

Rename ExceptionHandler? to ExceptionDispatcherHandler?.

Fix bug in ParamCandidate? cache.

Add missing synchronization to the BufferedDispatcher?.

Develop @Serialized support.

Rework serialization further.

Add serialization/deserialization interface to ValueParam?.

Move getStorageType and isNumeric from Param down to params hierarchy.

Minor changes.

Improve param type induction.

Add TestSerializedClass? for testing new serialization.

Add info files gor GenePool? and Population.

Add standard.expt exemplary netfile.

Add type name field to PropertiesObject?.

Use PropertiesObject? for PropertiesAccess? instead of ordinary map.

Hide getFramsClass is several more places.

More unification accross FramsClass?, Access and Path.

Add ParamCollection?.

Simplify interface for getting params from FramsClass?, Access
or Path.

Make Access.call() interface variadic.

Add arguments(args) convenience wrapper around new Object[] {args}.

Upgrade to apache.commons.lang version 3.1

Minor improvement with Response constructors.

Develop proper result printing in ClientAtServer?.

Add experimentNetsave to PrimeExperiment?.

File:

• java/main/src/main/java/com/framsticks/params/ParamsUtil.java (modified) (3 diffs)

java/main/src/main/java/com/framsticks/params/ParamsUtil.java

@@ -3 +3 @@
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
+
+import javax.annotation.Nonnull;
 
 import com.framsticks.util.FramsticksException;
@@ -29 +32 @@
                         Object object = a.getSelected();
                         if (!type.isInstance(object)) {
-                                throw new FramsticksException().msg("extracted object is of invalid type").arg("object", object).arg("desired", type).arg("actual", object.getClass()).arg("framsclass", a.getFramsClass());
+                                throw new FramsticksException().msg("extracted object is of invalid type").arg("object", object).arg("desired", type).arg("actual", object.getClass()).arg("access", a);
                         }
                         result.add(type.cast(object));
@@ -88 +91 @@
         }
 
+        public static Object[] arguments(Object... args) {
+                return args;
+        }
+
+        public static Param getParam(ParamCollection collection, int i) {
+                return collection.getParam(i);
+        }
+
+        public static Param getParam(ParamCollection collection, String id) {
+                return collection.getParam(id);
+        }
+
+        public static @Nonnull <T extends Param> T castedParam(ParamCollection collection, @Nonnull final Param param, @Nonnull final Class<T> type, Object name) {
+                if (param == null) {
+                        // return null;
+                        throw new FramsticksException().msg("param is missing").arg("name", name).arg("in", collection);
+                }
+                if (!type.isInstance(param)) {
+                        // return null;
+                        throw new FramsticksException().msg("wrong type of param").arg("actual", param.getClass()).arg("requested", type).arg("in", collection);
+                }
+                return type.cast(param);
+        }
+
+        /**
+         * Gets the param entry.
+         *
+         * @param i
+         *            the offset of parameter
+         * @return the param entry
+         */
+        public static @Nonnull <T extends Param> T getParam(ParamCollection collection, final int i, @Nonnull final Class<T> type) {
+                return castedParam(collection, collection.getParam(i), type, i);
+        }
+
+        /**
+         * Gets the param entry.
+         *
+         * @param id
+         *            the getId of parameter
+         * @return the param entry
+         */
+        public static @Nonnull <T extends Param> T getParam(ParamCollection collection, @Nonnull final String id, @Nonnull final Class<T> type) {
+                return castedParam(collection, collection.getParam(id), type, id);
+        }
+
+        public static final String SERIALIZED = "@Serialized:";
+
+        public static class SerializationContext {
+                protected final StringBuilder builder = new StringBuilder();
+                protected final ArrayList<Object> objects = new ArrayList<>();
+
+                protected void appendString(String value) {
+                        builder.append('"').append(value).append('"');
+                }
+
+                protected boolean serializeInternal(Object value) {
+                        if (value == null) {
+                                builder.append("null");
+                                return true;
+                        }
+                        /** indexOf is not used here, because it uses equals() internally, which results in StackOverflowError */
+                        Class<?> type = value.getClass();
+                        if (type.equals(String.class)) {
+                                String stringValue = (String) value;
+                                appendString(stringValue);
+                                return stringValue.startsWith(SERIALIZED);
+                        }
+                        if (type.equals(Boolean.class)) {
+                                builder.append(((Boolean) value) ? "1" : "0");
+                                return false;
+                        }
+                        if (type.equals(Double.class) || type.equals(Integer.class)) {
+                                builder.append(value.toString());
+                                return false;
+                        }
+
+                        for (int i = 0; i < objects.size(); ++i) {
+                                if (objects.get(i) == value) {
+                                        builder.append("^").append(i);
+                                        return true;
+                                }
+                        }
+
+                        if (List.class.isAssignableFrom(type)) {
+                                objects.add(value);
+                                List<?> list = (List<?>) value;
+                                boolean placeComma = false;
+                                builder.append("[");
+                                for (Object element : list) {
+                                        if (placeComma) {
+                                                builder.append(",");
+                                        } else {
+                                                placeComma = true;
+                                        }
+                                        serializeInternal(element);
+                                }
+                                builder.append("]");
+                                return true;
+                        }
+                        if (Map.class.isAssignableFrom(type)) {
+                                objects.add(value);
+                                Map<?, ?> map = (Map<?, ?>) value;
+                                boolean placeComma = false;
+                                builder.append("{");
+                                for (Map.Entry<?, ?> entry : map.entrySet()) {
+                                        if (placeComma) {
+                                                builder.append(",");
+                                        } else {
+                                                placeComma = true;
+                                        }
+                                        if (!(entry.getKey() instanceof String)) {
+                                                throw new FramsticksException().msg("non string keys are not allowed in serialization").arg("key type", entry.getKey().getClass());
+                                        }
+                                        appendString((String) entry.getKey());
+                                        builder.append(":");
+                                        serializeInternal(entry.getValue());
+                                }
+                                builder.append("}");
+                                return true;
+                        }
+                        throw new FramsticksException().msg("invalid type for serialization").arg("type", type);
+                }
+
+                public String serialize(Object value) {
+                        if (value instanceof String) {
+                                String stringValue = (String) value;
+                                if (!stringValue.startsWith(SERIALIZED)) {
+                                        return stringValue;
+                                }
+                        }
+                        boolean complex = serializeInternal(value);
+                        return (complex ? SERIALIZED : "") + builder.toString();
+                }
+
+        }
+
+
+        public static <T> String serialize(T value) {
+                return new SerializationContext().serialize(value);
+        }
+
+        public static <T> T deserialize(String value, Class<T> type) {
+                return null;
+        }
+
 }