Changeset 90 for java/main/src/main/java/com/framsticks/params/Registry.java

Timestamp:

07/02/13 16:20:07 (11 years ago)

Author:

psniegowski

Message:

HIGHLIGHTS:

• add ObjectInstance? for holding local object trees
• fix params ordering issue in automically created FramsClasses?
• support for automated Builders in XmlLoader?
• fix bug preventing multiple GUI tests in single test run
• implement Groups in FramsClass?
• improve ProcedureParam?:
  • calling in ObjectInstance?
  • support in GUI

CHANGELOG:
Make ProcedureParam? hold only ValueParams?.

Use id instead of names when naming gui components internally.

Basic procedure calling in GUI.

The actual procedure call is currently only backed
by the ObjectInstance?.

Add UnimplementedException?.

Improve naming of various gui elements.

Allow easy navigating in FEST Swing testing.

Add optional explicit order attribute to FramsClassAnnotation?.

That's because java reflection does return declared members
in any specific order. That ordering is needed only for
classes that have no representation in framsticks and need
a deterministic ordering of params.

Add ControlOwner? interface.

Add test for procedure calling in Browser.

First version of ParamAnnotation? for procedures.

Development of ProcedureParam?.

Add draft version of ProcedureParam? implementation in ReflectionAccess?.

Allow viewing FramsClasses? in gui Browser.

Extract ResourceBuilder? from ModelBuilder?.

Remove internalId from Param.

It was currently completely not utilised. Whether it is still needed
after introduction of ParamAnnotation? is arguable.

Add remaining param attributes to ParamAnnotation?.

Change AutoBuilder? semantics.

AutoBuilder? returns list of objects that are to be appended
with methods @AutoAppendAnnotation?.

This allows to omit explicit addition of ModelPackage? to instance
if the instance uses ModelBuilder? (registration of ModelPackage? comes
from schema).

Fix params ordering problem in auto created FramsClasses?.

Improve ObjectInstance?.

Several fixes to ModelBuilder?.

Improve test for ObjectInstance? in Browser.

Make initialization of robot static.

With robot recreated for second browser test, the test hanged
deep in AWT.

Add base convenience base test for Browser tests.

More tests to ObjectInstance?.

Rename Dispatcher.invokeLater() to dispatch().

Add assertDispatch.

It allows assertions in other threads, than TestNGInvoker.
Assertions are gathered after each method invocation and rethrown.

Use timeOut annotation attribute for tests involving some waiting.

Remove firstTask method (merge with joinableStart).

Clean up leftovers.

Remove unused FavouritesXMLFactory (the reading part is already
completely done with generic XmlLoader?, and writing part will be done
based on the same approach if needed).
Move UserFavourite? to the com.framsticks.gui.configuration package.

Remove GenotypeBrowser? as to specific.

This functionality will be available in ObjectInstance?.

Add interface ParamsPackage?.

Package containing registration of Java classes meant to use with
ReflectionAccess? may be in Instance using configuration.

Minor changes.

Make Group immutable.

Add AutoBuilder? interface extending Builder - only those would
be used to automatically build from XML.

Fix groups in FramsClass?.

Minor naming cleanup in Registry.

Add ModelComponent? interface.

All class creating the Model are implementing that interface.

Extract Model.build into ModelBuilder?.

ModelBuilder? will be compatible with other builders
and allow using it from configuration.

Fix NeuroConnection?.

Add synchronous get operation for dispatchers.

Rename JoinableMonitor? to Monitor.

Add ObjectInstance?.

This class is mainly for demonstration
and testing purposes.

Improve FramsServer? runner.

• improve ExternalProcess? runner,
• runner can kill the server but also react properly, when the server exists on it's own,
• set default path to search for framsticks server installation,
• add LoggingOutputListener?.

File:

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

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

@@ -4 +4 @@
 
 import com.framsticks.params.annotations.FramsClassAnnotation;
+import com.framsticks.params.annotations.ParamAnnotation;
 import com.framsticks.util.DoubleMap;
 import com.framsticks.util.FramsticksException;
 
+import java.util.HashMap;
+import java.util.Map;
 import java.util.Set;
+
+import javax.annotation.Nonnull;
 
 /**
  * Author: Piotr Śniegowski
  */
+@FramsClassAnnotation
 public class Registry {
         private static final Logger log = Logger.getLogger(Registry.class.getName());
 
-        // protected void internalRegisterClass(FramsClass framsClass, @Nullable Class<?> javaClass) {
-        //      assert framsClass.getName() != null;
-        //      assert framsClass.getId() != null;
-        //      infoCacheByName.put(framsClass.getName(), framsClass);
-        //      infoCacheById.put(framsClass.getId(), framsClass);
-
-        //      if (javaClass != null) {
-        //              reflectedClasses.put(framsClass, javaClass);
-        //              infoCacheByJavaName.put(javaClass.getCanonicalName(), framsClass);
-        //      }
-        // }
         protected final DoubleMap<String, Class<?>> javaClasses = new DoubleMap<>();
         protected final DoubleMap<String, FramsClass> framsClasses = new DoubleMap<>();
+        protected final Map<Class<?>, FramsClass> javaToFramsAssociation = new HashMap<>();
 
-        public void registerReflectedClass(String name, String id, Class<?> reflectedClass) {
-                javaClasses.put(id, name, reflectedClass);
+        /**
+         *
+         */
+        public Registry() {
+                // registerAndBuild(Registry.class);
+                // registerAndBuild(FramsClass.class);
+                // registerAndBuild(Param.class);
         }
 
-        public Registry registerAndBuild(Class<?> reflectedClass) {
-                register(reflectedClass);
-                putInfoIntoCache(FramsClass.build().forClass(reflectedClass));
+        public void registerReflectedClass(String name, String id, Class<?> javaClass) {
+                javaClasses.put(id, name, javaClass);
+        }
+
+        public void associate(Class<?> javaClass, FramsClass framsClass) {
+                javaToFramsAssociation.put(javaClass, framsClass);
+        }
+
+        public Registry registerAndBuild(Class<?> javaClass) {
+                register(javaClass);
+                associate(javaClass, putFramsClass(FramsClass.build().forClass(javaClass)));
                 return this;
         }
 
-        public Registry register(Class<?> reflectedClass) {
-                FramsClassAnnotation a = reflectedClass.getAnnotation(FramsClassAnnotation.class);
+        public Registry register(Class<?> javaClass) {
+                FramsClassAnnotation a = javaClass.getAnnotation(FramsClassAnnotation.class);
                 if (a == null) {
-                        throw new FramsticksException().msg("class is not annotated").arg("class", reflectedClass);
+                        throw new FramsticksException().msg("class is not annotated").arg("class", javaClass);
                 }
 
-                registerReflectedClass(FramsClassBuilder.getName(a, reflectedClass), FramsClassBuilder.getId(a, reflectedClass), reflectedClass);
+                registerReflectedClass(FramsClassBuilder.getName(a, javaClass), FramsClassBuilder.getId(a, javaClass), javaClass);
                 return this;
         }
 
-        public AccessInterface createAccess(String name, FramsClass framsClass) throws ConstructionException {
+        public @Nonnull ReflectionAccess createAccess(Class<?> javaClass) throws ConstructionException {
+                try {
+                        if (!javaClasses.containsValue(javaClass)) {
+                                throw new FramsticksException().msg("java class is not registered");
+                        }
+                        if (!javaToFramsAssociation.containsKey(javaClass)) {
+                                throw new FramsticksException().msg("java class is not associated with any frams class");
+                        }
+                        return new ReflectionAccess(javaClass, javaToFramsAssociation.get(javaClass));
+                }
+                catch (FramsticksException e) {
+                        throw new FramsticksException().msg("failed to create access for java class").arg("class", javaClass).cause(e);
+                }
+        }
+
+        public @Nonnull AccessInterface createAccess(String name, FramsClass framsClass) throws ConstructionException {
                 // assert framsClasses.containsValue(framsClass);
                 if (javaClasses.containsKey(name)) {
@@ -57 +81 @@
         }
 
-        public void putInfoIntoCache(FramsClass framsClass) {
+        public FramsClass putFramsClass(FramsClass framsClass) {
                 log.debug("caching info for " + framsClass);
                 framsClasses.put(framsClass.getId(), framsClass.getName(), framsClass);
+                return framsClass;
         }
 
-        public FramsClass getInfoFromCache(String identifier) {
-                if (identifier == null) {
-                        return null;
-                }
+        public FramsClass getFramsClass(@Nonnull String identifier) {
                 return framsClasses.get(identifier);
         }
 
-        public static AccessInterface wrapAccessWithListIfNeeded(CompositeParam param, AccessInterface access) {
-                if (access == null) {
-                        return null;
-                }
+        public static @Nonnull AccessInterface wrapAccessWithListIfNeeded(@Nonnull CompositeParam param, @Nonnull AccessInterface access) {
                 return param.prepareAccessInterface(access);
         }
 
-        public AccessInterface prepareAccess(CompositeParam param) throws ConstructionException {
+        public @Nonnull AccessInterface prepareAccess(CompositeParam param) throws ConstructionException {
                 return wrapAccessWithListIfNeeded(param, createAccess(param.getContainedTypeName()));
         }
 
-        public AccessInterface createAccess(String name) throws ConstructionException {
-                if (name == null) {
-                        return null;
+        public @Nonnull AccessInterface createAccess(@Nonnull String name) throws ConstructionException {
+                try {
+                        FramsClass framsClass = getFramsClass(name);
+                        if (framsClass == null) {
+                                throw new ConstructionException().msg("framsclass is missing");
+                        }
+
+                        return createAccess(name, framsClass);
                 }
-                FramsClass framsClass = getInfoFromCache(name);
-                if (framsClass == null) {
-                        return null;
+                catch (FramsticksException e) {
+                        throw new FramsticksException().msg("failed to create access for name").arg("name", name).cause(e);
                 }
-
-                return createAccess(name, framsClass);
         }
 
@@ -96 +117 @@
         }
 
-        public Set<FramsClass> getInfoCache() {
+        public Set<FramsClass> getFramsClasses() {
                 return framsClasses.getValues();
         }
 
+        @ParamAnnotation
+        public Map<String, FramsClass> getFramsClassesById() {
+                return framsClasses.getValuesById();
+        }
+
+        public void takeAllFrom(Registry source) {
+                for (Class<?> javaClass : source.getReflectedClasses()) {
+                        register(javaClass);
+                }
+                for (FramsClass framsClass : source.getFramsClasses()) {
+                        putFramsClass(framsClass);
+                }
+
+        }
+
 }