Changeset 87 for java/main/src/main/java/com/framsticks/params/ParamBuilder.java

Timestamp:

06/28/13 11:56:03 (11 years ago)

Author:

psniegowski

Message:

HIGHLIGHTS:

• FramsClass? and contained Param are now immutable classes (like String),

which allows to refer to them concurrently without synchronization
(which for example in turn simplifies GUI management)

• also make Path immutable (which was earlier only assumed)
• add global cache for FramsClasses? created solely and automatically

on base of Java classes.

• add global cache for ReflectionAccess?.Backend precomputed proxy

representations basing on given FramsClass?

• above changes greatly improved GUI responsivness during browsing
• furtherly improve Param class hierarchy
• allow to inject actions on state changes into MultiParamLoader?
• add more tests

CHANGELOG:

Add StatusListener? to MultiParamLoader?.

Minor refactorization in MultiParamLoader?.

First step with auto append.

Add SchemaTest?.

Improve Registry.

Clean up in Registry.

Work out Registry.

Use annotations for Param.

Fix ListChange?.

Improve fluent interface of the FramsClassBuilder?.

Done caching of ReflectionAccess?.Backend

Fix hashCode of Pair.

A step on a way to cache ReflectionAccess?.Backend

Make SimpleAbstractAccess?.framsClass a final field.

Add static cache for FramsClasses? based on java.

Only classes created strictly and automatically
based on java classes are using this cache.

Make all Params immutable.

Many improvement to make Param immutable.

Make PrimitiveParam? generic type.

Several changes to make Param immutable.

Make FramsClass? immutable.

Another improvement to Path immutability.

Several improvements to Path.

Improve PathTest?.

Configurarable MutabilityDetector?.

File:

• java/main/src/main/java/com/framsticks/params/ParamBuilder.java (modified) (13 diffs)

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

@@ -4 +4 @@
 import com.framsticks.params.annotations.ParamAnnotation;
 import com.framsticks.params.types.*;
-import com.framsticks.util.lang.Numbers;
+import com.framsticks.util.FramsticksException;
+import com.framsticks.util.lang.Strings;
 
 import org.apache.log4j.Logger;
 
-import java.util.ArrayList;
+import java.lang.reflect.InvocationTargetException;
 import java.util.Arrays;
-
+import java.util.List;
 
 /**
@@ -56 +57 @@
         private Class<? extends Param> paramType;
 
-        private Param param;
-        private PrimitiveParam primitiveParam;
-        private String typeString;
+        private Object min;
+
+        private Object max;
+
+        private Object def;
+
+        String containedTypeName;
+
+        protected FramsClassBuilder classBuilder;
 
         public ParamBuilder() {
+                this(null);
+        }
+
+
+        /**
+         * @param classBuilder
+         */
+        public ParamBuilder(FramsClassBuilder classBuilder) {
+                this.classBuilder = classBuilder;
+        }
+
+
+        /**
+         * @return the min
+         */
+        public Object getMin() {
+                return min;
+        }
+
+        /**
+         * @return the max
+         */
+        public Object getMax() {
+                return max;
+        }
+
+        /**
+         * @return the def
+         */
+        public Object getDef() {
+                return def;
+        }
+
+        public String getContainedTypeName() {
+                return Strings.notEmpty(containedTypeName) ? containedTypeName : null;
+        }
+
+        /**
+         * @return the enumValues
+         */
+        public List<String> getEnumValues() {
+                return enumValues;
+        }
+
+        /**
+         * @return the procedureSignature
+         */
+        public String getProcedureSignature() {
+                return procedureSignature;
+        }
+
+        /**
+         * @return the uid
+         */
+        public String getUid() {
+                return uid;
         }
 
@@ -70 +133 @@
          *             when Param getType is not defined
          */
-        public Param finish()  {
-                assert param != null;
-                param.id = id;
-                param.name = name;
-                param.help = help;
-                param.group = group;
-                param.flags = flags;
-                param.internalId = internalId;
-                return param;
+        public Param finish() {
+                try {
+                        return paramType.getConstructor(ParamBuilder.class).newInstance(this);
+                } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException e) {
+                        throw new FramsticksException().msg("failed to create param").cause(e).arg("name", name);
+                }
         }
 
@@ -87 +147 @@
         }
 
-        protected <T extends Param> ParamBuilder internalSetType(Class<? extends Param> type, T param) {
-                this.paramType = type;
-                this.param = param;
-                if (param instanceof PrimitiveParam) {
-                        primitiveParam = (PrimitiveParam) param;
-                }
-                typeString = param.getFramsTypeName();
-                return this;
-        }
-
         public <T extends Param> ParamBuilder type(Class<T> type) {
                 assert type != null;
-                try {
-                        return internalSetType(type, type.newInstance());
-                } catch (InstantiationException | IllegalAccessException e) {
-                        e.printStackTrace();
-                }
-                return this;
-        }
-
-        public <T extends Param> ParamBuilder type(T param) {
-                return internalSetType(param.getClass(), param);
-        }
+                this.paramType = type;
+                return this;
+        }
+
+        // public <T extends Param> ParamBuilder type(T param) {
+        //      return internalSetType(param.getClass(), param);
+        // }
 
 
@@ -120 +166 @@
         }
 
+        /**
+         * @return the internalId
+         */
+        public String getInternalId() {
+                return internalId;
+        }
+
         public ParamBuilder setInternalId(String internalId) {
                 this.internalId = internalId;
@@ -144 +197 @@
 
         protected <T extends Number> void parseMinMaxDefNumber(Class<T> type, String second, String third) {
-                if (primitiveParam == null) {
-                        log.warn("param is not a primitive param");
-                        return;
-                }
                 if (second != null) {
-                        this.primitiveParam.min = Numbers.parse(second, type);
-                        if (this.primitiveParam.min == null) {
-                                log.warn("value of min attribute was invalid");
-                        }
+                        min = second;
                 }
                 if (third != null) {
-                        this.primitiveParam.max = Numbers.parse(third, type);
-                        if (this.primitiveParam.max == null) {
-                                log.warn("value of min attribute was invalid");
-                        }
-                }
-        }
+                        max = third;
+                }
+        }
+
+        protected List<String> enumValues;
+
+        public ParamBuilder enums(List<String> values) {
+                enumValues = values;
+                return type(EnumParam.class);
+        }
+
+        protected String procedureSignature;
+
+        protected String uid;
 
         @ParamAnnotation
         public ParamBuilder type(String type) {
-                typeString = type;
+                // typeString = type;
 
                 log.trace("parsing type: " + type);
@@ -175 +229 @@
                 switch (first.charAt(0)) {
                         case 'o': {
-                                type(new ObjectParam(second != null ? second : first.substring(1)));
+                                containedTypeName = second != null ? second : first.substring(1);
+                                type(ObjectParam.class);
                                 break;
                         }
                         case 'p': {
-                                ProcedureParam procedureParam = new ProcedureParam();
-                                String signature = type.substring(1);
-                                try {
-                                        procedureParam.parseSignature(signature);
-                                } catch (Exception e) {
-                                        log.error("invalid procedure signature '" + signature + "': " + e);
-                                }
-                                type(procedureParam);
+                                procedureSignature = type.substring(1);
+                                type(ProcedureParam.class);
                                 break;
                         }
@@ -193 +242 @@
                                 int tildeIndex = type.indexOf("~");
                                 if (tildeIndex != -1) {
-                                        type(new EnumParam(new ArrayList<String>(Arrays.asList(type.substring(tildeIndex + 1).split("~")))));
+                                        enums(Arrays.asList(type.substring(tildeIndex + 1).split("~")));
                                 } else {
                                         if (first.length() >= 2) {
@@ -214 +263 @@
                                                 type(BooleanParam.class);
                                         }
-                                        if (param == null) {
+                                        if (paramType == null) {
                                                 type(DecimalParam.class);
                                         }
                                 }
-                                if (this.param instanceof DecimalParam) {
+                                if (DecimalParam.class.isAssignableFrom(this.paramType)) {
                                         parseMinMaxDefNumber(Integer.class, second, third);
                                 }
@@ -243 +292 @@
                         }
                         case 'l': {
-                                type(third != null ? new UniqueListParam(second, third) : new ArrayListParam(second));
+                                containedTypeName = second;
+                                if (third != null) {
+                                        type(UniqueListParam.class);
+                                        uid = third;
+                                } else {
+                                        type(ArrayListParam.class);
+                                }
                                 break;
                         }
@@ -294 +349 @@
         @ParamAnnotation
         public String getType() {
-                return typeString;
+                return "?";
         }
 
@@ -304 +359 @@
         }
 
-        public <T> ParamBuilder min(T min) {
-                if (primitiveParam != null) {
-                        this.primitiveParam.min = min;
-                }
-                return this;
-        }
-
-        public <T> ParamBuilder max(T max) {
-                if (primitiveParam != null) {
-                        this.primitiveParam.max = max;
-                }
-                return this;
-        }
-
-        public <T> ParamBuilder def(T def) {
-                if (def != null && primitiveParam != null) {
-                        this.primitiveParam.def = def;
-                }
-                return this;
-        }
-
-        public Class<?> getStorageType() {
-                assert param != null;
-                return param.getStorageType();
-        }
+        public ParamBuilder min(Object min) {
+                this.min = min;
+                return this;
+        }
+
+        public ParamBuilder max(Object max) {
+                this.max = max;
+                return this;
+        }
+
+        public ParamBuilder def(Object def) {
+                this.def = def;
+                return this;
+        }
+
+        // public Class<?> getStorageType() {
+        //      assert param != null;
+        //      return param.getStorageType();
+        // }
 
         public Param build(String line) throws Exception {
@@ -386 +435 @@
         }
 
-
+        public ParamBuilder defaultDef(Object def) {
+                if (this.def == null) {
+                        return def(def);
+                }
+                return this;
+        }
 
 }