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

Timestamp:

09/23/13 18:54:07 (11 years ago)

Author:

psniegowski

Message:

HIGHLIGHTS:

• add SimultorProviders? hierarchy
• start Framsticks server over SSH
• FJF compatible with Framsticks 4.0rc3
• reading and writing of standard.expt
• a proof-of-concept implementation of StandardExperiment?

CHANGELOG:
Optionally return FreeAccess? from registry.

Add SimulatorRange?.

StandardExperiment? with genotypes circulation.

Automate registration around StandardState?.

More improvements to StandardExperiment?.

Skeleton version of StandardExperiment?.

Test saving of StandardState?.

Standard experiment state is being loaded.

More development towards StandardState? reading.

Work on reading standard experiment state.

Add classes for standard experiment.

Update example standard.expt

Add FreeAccess? and FreeObject?.

Made compatible with version 4.0rc3

Change deserialization policy.

Improve SSH support.

Working running simulator over SSH.

Fix joining bug in Experiment.

Working version of SimulatorRunner?.

Add more SimulatorProviders?.

Working PrimeExperimentTest? with 4.0rc3

Add references to deserialization.

Add OpaqueObject? and it's serialization.

Add deserialization of dictionaries.

Partial implementation of deserialization.

Add more tests for deserialization.

Prepare tests for deserialization.

Add proper result to prime experiment test.

Minor fixes to simulators providers.

Draft version of SimulatorProvider?.

Add SimulatorProvider? interface.

File:

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

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

@@ -2 +2 @@
 
 import java.util.ArrayList;
+// import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.TreeMap;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 import javax.annotation.Nonnull;
 
+// import org.apache.logging.log4j.Logger;
+// import org.apache.logging.log4j.LogManager;
+
 import com.framsticks.util.FramsticksException;
+import com.framsticks.util.lang.Numbers;
 
 
@@ -16 +24 @@
  */
 public abstract class ParamsUtil {
+        // private final static Logger log = LogManager.getLogger(ParamsUtil.class.getName());
+
 
         public static String readSourceToString(Source source) {
@@ -212 +222 @@
                                 return true;
                         }
+                        if (type.equals(OpaqueObject.class)) {
+                                builder.append(value.toString());
+                                return true;
+                        }
                         throw new FramsticksException().msg("invalid type for serialization").arg("type", type);
                 }
@@ -233 +247 @@
         }
 
+        public static class DeserializationContext {
+
+                public static final Pattern OPAQUE_OBJECT_PATTERN = Pattern.compile("^(\\w+)<0x([a-fA-F0-9]+)>$");
+
+                @SuppressWarnings("serial")
+                public static class Exception extends FramsticksException {
+                }
+
+                protected final ArrayList<Object> objects = new ArrayList<>();
+                protected int cursor = 0;
+                protected final String input;
+
+                /**
+                 * @param input
+                 */
+                public DeserializationContext(String input) {
+                        this.input = input;
+                        cursor = 0;
+                }
+
+                protected boolean isFinished() {
+                        return cursor == input.length();
+                }
+
+                protected boolean is(char value) {
+                        if (isFinished()) {
+                                throw fail().msg("input ended");
+                        }
+                        return input.charAt(cursor) == value;
+                }
+
+                protected boolean isOneOf(String values) {
+                        if (isFinished()) {
+                                throw fail().msg("input ended");
+                        }
+                        return values.indexOf(input.charAt(cursor)) != -1;
+                }
+
+                protected char at() {
+                        return input.charAt(cursor);
+                }
+
+                protected char at(int pos) {
+                        return input.charAt(pos);
+                }
+
+                protected FramsticksException fail() {
+                        return new Exception().arg("at", cursor).arg("input", input);
+                }
+
+                protected void force(char value) {
+                        if (!is(value)) {
+                                throw fail().msg("invalid character").arg("expected", value).arg("found", at());
+                        }
+                        next();
+                }
+
+                protected boolean isAndNext(char value) {
+                        if (!is(value)) {
+                                return false;
+                        }
+                        next();
+                        return true;
+                }
+
+                protected void next() {
+                        ++cursor;
+                        // log.info("at: {}|{}", input.substring(0, cursor), input.substring(cursor));
+                }
+
+                protected void goToNext(char value) {
+                        while (cursor < input.length()) {
+                                if (is(value)) {
+                                        return;
+                                }
+                                next();
+                        }
+                        throw fail().msg("passed end").arg("searching", value);
+                }
+
+
+                protected String forceStringRemaining() {
+                        int start = cursor;
+                        while (true) {
+                                goToNext('"');
+                                if (at(cursor - 1) != '\\') {
+                                        next();
+                                        return input.substring(start, cursor - 1);
+                                }
+                                next();
+                                // it is finishing that loop, because of throwing in goToNext()
+                        }
+                        // throw fail();
+                }
+
+                public Object deserialize() {
+                        if (isAndNext('[')) {
+                                List<Object> list = new ArrayList<>();
+                                objects.add(list);
+                                while (!isAndNext(']')) {
+                                        if (!list.isEmpty()) {
+                                                force(',');
+                                        }
+                                        Object child = deserialize();
+                                        list.add(child);
+                                }
+                                return list;
+                        }
+
+                        if (isAndNext('{')) {
+                                Map<String, Object> map = new TreeMap<>();
+                                objects.add(map);
+                                while (!isAndNext('}')) {
+                                        if (!map.isEmpty()) {
+                                                force(',');
+                                        }
+                                        force('"');
+                                        String key = forceStringRemaining();
+                                        force(':');
+                                        Object value = deserialize();
+                                        map.put(key, value);
+                                }
+                                return map;
+                        }
+
+                        if (isAndNext('"')) {
+                                return forceStringRemaining();
+                        }
+                        int start = cursor;
+                        while (!isFinished() && !isOneOf("]},")) {
+                                next();
+                        }
+                        if (start == cursor) {
+                                throw fail().msg("empty value");
+                        }
+
+                        String value = input.substring(start, cursor);
+                        if (value.equals("null")) {
+                                //TODO: add this to list?
+                                return null;
+                        }
+
+                        Matcher matcher = OPAQUE_OBJECT_PATTERN.matcher(value);
+                        if (matcher.matches()) {
+                                return new OpaqueObject(matcher.group(1), Long.parseLong(matcher.group(2), 16));
+                        }
+
+
+                        Object number = DeserializationContext.tryParseNumber(value);
+                        if (number != null) {
+                                return number;
+                        }
+
+                        if (value.charAt(0) == '^') {
+                                Integer reference = Numbers.parse(value.substring(1), Integer.class);
+                                if (reference == null) {
+                                        throw fail().msg("invalid reference").arg("reference", reference);
+                                }
+                                return objects.get(reference);
+                        }
+                        //TODO: parse ^
+                        //TODO: parse opaque object
+                        throw fail().msg("unknown entity");
+
+                }
+
+                public static Object tryParseNumber(String value) {
+                        Integer i = Numbers.parse(value, Integer.class);
+                        if (i != null) {
+                                return i;
+                        }
+
+                        Double d = Numbers.parse(value, Double.class);
+                        if (d != null) {
+                                return d;
+                        }
+
+                        return null;
+                }
+        }
+
+
+        public static Object deserialize(String value) {
+                Object number = DeserializationContext.tryParseNumber(value);
+                if (number != null) {
+                        return number;
+                }
+
+                if (!value.startsWith(SERIALIZED)) {
+                        return value;
+                }
+                return new DeserializationContext(value.substring(SERIALIZED.length())).deserialize();
+        }
+
         public static <T> T deserialize(String value, Class<T> type) {
-                return null;
+                Object object = deserialize(value);
+
+                return type.cast(object);
         }