Ignore:
Timestamp:
07/18/13 23:52:25 (11 years ago)
Author:
psniegowski
Message:

HIGHLIGHTS:

  • add auto loading and saving algorithms between

frams files format and Java classes

  • respect ValueChange? events in GUI (do not reload object)
  • support results of procedures in Java server
  • make Experiment automatically convert between frams file and NetFile? object
  • add MessageLogger? (compatible with original frams server messages)
  • WorkPackageLogic? now validates results, is able to discard them, reschedule

whole package, or only uncomputed remainder

CHANGELOG:
Show just a short description in PrimeExperiment?.

Add primes_changed event to the PrimeExperiment?.

Make WorkPackageLogic? robust to frams server returning invalid results.

Add MessageLogger? to logics.

Add NetFile? interface. Support Messages from server.

Minor changes to connections.

Merge results in the PrimeExperiment?.

More netload class->file conversion to Simulator.

Move netsave parsing to Simulator.

Fix bug with inverted ordering of events firing in Experiment.

Minor changes.

Minor logging changes.

Use AccessOperations?.convert in NetLoadSaveLogic?

NetLoadSaveLogic? now encloses the conversion.

Use more generic AccessOperations? saveAll and loadAll in PrimePackage?.

Add Result class for enclosing of call invocations' results.

Improve feature request handling in Connections.

Use AccessOperations?.convert in RemoteTree? events parsing.

Minor change.

Add some information params to Java server root and CLI objects.

A draft implementation of loadAll algorithm.

That algorithm tries to load objects into a tree structure.

Add AccessOperationsTest? test.

Develop WorkPackageLogic?.

  • add state tracking fields
  • add work package generation

Add utility class SimplePrimitive?.

Meant for Java backend classes, enclose a single primitive value
and set of listeners.

Improve primitive value refresh in GUI.

When ValueChange? found in called event, do not reload whole
object, but only update GUI (no communication is performed).

Use ValueChange? in the TestClass? test.

Minor changes.

Sending all packages in PrimeExperiment? to the frams servers.

Develop AccessOperations?.loadComposites().

Remove addAccess from MultiParamLoader? interface.

There is now no default AccessProvider? in MultiParamLoader?.
User must explicitely set AccessStash? or Registry.

Improve saving algorithms in AccessOperations?.

Location:
java/main/src/main/java/com/framsticks/params
Files:
2 added
6 edited

Legend:

Unmodified
Added
Removed

  • java/main/src/main/java/com/framsticks/params/AccessOperations.java

    r102 r103  
    11package com.framsticks.params;
     2
     3import java.util.LinkedList;
     4import java.util.ListIterator;
     5
     6import javax.annotation.Nullable;
    27
    38import org.apache.logging.log4j.Logger;
    49import org.apache.logging.log4j.LogManager;
    510
     11import com.framsticks.communication.File;
     12import com.framsticks.params.types.ListParam;
     13import com.framsticks.parsers.MultiParamLoader;
    614import com.framsticks.util.FramsticksException;
     15import com.framsticks.util.FramsticksUnsupportedOperationException;
     16import com.framsticks.util.Misc;
     17import com.framsticks.util.UnimplementedException;
     18import com.framsticks.util.lang.Casting;
    719import com.framsticks.util.lang.Containers;
    820import com.framsticks.util.lang.Holder;
     21import com.framsticks.util.lang.Pair;
    922// import com.framsticks.util.lang.Containers;
    1023
    … …  
    1427public final class AccessOperations {
    1528
    16         private final static Logger log = LogManager.getLogger(SimpleAbstractAccess.class.getName());
     29        private final static Logger log = LogManager.getLogger(AccessOperations.class);
    1730
    1831        /**
    … …  
    7588        }
    7689
    77         public static void save(Access access, Sink sink) {
     90        public static <A extends Access> A assureSelected(A access) {
     91                if (access.getSelected() == null) {
     92                        access.select(access.createAccessee());
     93                }
     94                return access;
     95        }
     96
     97        public static Access loadAll(@Nullable final Access rootAccess, Source source, final Registry registry) {
     98                final MultiParamLoader loader = new MultiParamLoader();
     99                loader.setNewSource(source);
     100                final LinkedList<Access> accessesStack = new LinkedList<>();
     101                if (rootAccess != null) {
     102                        assureSelected(rootAccess);
     103                        accessesStack.add(rootAccess);
     104                }
     105                final Holder<Boolean> first = new Holder<>(true);
     106                final Holder<Boolean> needAdd = new Holder<>();
     107                final Holder<Access> currentAccess = new Holder<>();
     108                final Holder<Pair<Access, CompositeParam>> parent = new Holder<>();
     109
     110                loader.setAccessProvider(new AccessProvider() {
     111                        @Override
     112                        public Access getAccess(String name) {
     113                                if (first.get()) {
     114                                        first.set(false);
     115                                        if (rootAccess != null) {
     116                                                if (name.equals(rootAccess.getId())) {
     117                                                        needAdd.set(false);
     118                                                        currentAccess.set(rootAccess);
     119                                                        return rootAccess;
     120                                                }
     121                                        } else {
     122                                                Access access = registry.createAccess(name);
     123                                                needAdd.set(false);
     124                                                currentAccess.set(access);
     125                                                return access;
     126
     127                                        }
     128                                }
     129
     130                                ListIterator<Access> accessIterator = accessesStack.listIterator(accessesStack.size());
     131                                parent.set(null);
     132                                // log.debug("accesses stack: {}", accessesStack);
     133
     134                                while (accessIterator.hasPrevious()) {
     135                                        Access a = accessIterator.previous();
     136                                        assert a != null;
     137
     138                                        for (CompositeParam p : Containers.filterInstanceof(a.getParams(), CompositeParam.class)) {
     139                                                if (p.getContainedTypeName().equals(name)) {
     140
     141                                                        if (parent.get() != null) {
     142                                                                throw new FramsticksException().msg("ambiguity encountered during loading").arg("name", name);
     143                                                        }
     144
     145                                                        if (p instanceof ListParam) {
     146                                                                ListAccess listAccess = Casting.assertCast(ListAccess.class, registry.prepareAccess(p));
     147                                                                listAccess.select(a.get(p, Object.class));
     148                                                                parent.set(new Pair<Access, CompositeParam>(listAccess, listAccess.prepareParamFor(Integer.toString(listAccess.getParamCount()))));
     149
     150                                                        } else {
     151                                                                parent.set(Pair.make(a, p));
     152                                                        }
     153                                                }
     154                                        }
     155
     156                                        if (parent.get() == null) {
     157                                                accessIterator.remove();
     158                                        }
     159                                }
     160
     161                                if (parent.get() == null) {
     162                                        throw new FramsticksException().msg("failed to find place for loaded object").arg("name", name);
     163                                }
     164
     165                                currentAccess.set(registry.prepareAccess(parent.get().second));
     166                                Object object = parent.get().first.get(parent.get().second, Object.class);
     167                                if (object != null) {
     168                                        currentAccess.get().select(object);
     169                                        needAdd.set(false);
     170                                } else {
     171                                        object = currentAccess.get().createAccessee();
     172                                        currentAccess.get().select(object);
     173                                        needAdd.set(true);
     174                                }
     175
     176                                return currentAccess.get();
     177                        }
     178                });
     179
     180                loader.addListener(MultiParamLoader.Status.AfterObject, new MultiParamLoader.StatusListener() {
     181                        @Override
     182                        public void onStatusChange() {
     183                                if (needAdd.get()) {
     184                                        parent.get().first.set(parent.get().second, currentAccess.get().getSelected());
     185                                }
     186                                if (currentAccess.get() != rootAccess)  {
     187                                        accessesStack.add(currentAccess.get());
     188                                }
     189                                currentAccess.set(null);
     190                        }
     191                });
     192
     193                loader.go();
     194                if (accessesStack.isEmpty()) {
     195                        throw new FramsticksException().msg("failed to load from source").arg("source", source);
     196                }
     197                return accessesStack.get(0);
     198        }
     199
     200        public static void saveAll(Access access, Sink sink, Registry registry) {
     201                if (access instanceof ObjectAccess) {
     202                        savePrimitives(access, sink);
     203                }
     204                for (CompositeParam p : filterInstanceof(access.getParams(), CompositeParam.class)) {
     205                        Object child = access.get(p, Object.class);
     206                        if (child == null) {
     207                                continue;
     208                        }
     209                        saveAll(registry.prepareAccess(p).select(child), sink, registry);
     210                }
     211        }
     212
     213        public static void saveComposites(Access access, Sink sink, Registry registry) {
     214                for (CompositeParam p : filterInstanceof(access.getParams(), CompositeParam.class)) {
     215                        Object child = access.get(p, Object.class);
     216                        if (child == null) {
     217                                continue;
     218                        }
     219                        savePrimitives(registry.prepareAccess(p).select(child), sink);
     220                }
     221        }
     222
     223        public static void savePrimitives(Access access, Sink sink) {
    78224                if (access instanceof ObjectAccess) {
    79225                        ObjectAccess objectAccess = (ObjectAccess) access;
    80226                        FramsClass framsClass = access.getFramsClass();
    81227                        assert framsClass != null;
    82                         sink.print(framsClass.getId()).print(":").breakLine();
     228                        boolean headerNeeded = true;
     229                        // sink.print(framsClass.getId()).print(":").breakLine();
    83230                        for (PrimitiveParam<?> p : filterInstanceof(framsClass.getParamEntries(), PrimitiveParam.class)) {
     231
    84232                                Object value = objectAccess.get(p, Object.class);
    85233                                if ((value == null) || value.equals(p.getDef(Object.class))) {
    86234                                        continue;
    87235                                }
     236
     237                                if (headerNeeded) {
     238                                        sink.print(framsClass.getId()).print(":").breakLine();
     239                                        headerNeeded = false;
     240                                }
     241
    88242                                sink.print(p.getId()).print(":");
    89243                                p.save(sink, value);
    90244                                sink.breakLine();
    91245                        }
    92                         sink.breakLine();
     246                        if (!headerNeeded) {
     247                                sink.breakLine();
     248                        }
    93249                        return;
    94 
     250                }
     251                throw new FramsticksException().msg("invalid type of access for primitive save").arg("access", access);
     252        }
     253
     254        public static void save(Access access, Sink sink) {
     255                if (access instanceof ObjectAccess) {
     256                        savePrimitives(access, sink);
     257                        return;
    95258                }
    96259                if (access instanceof ListAccess) {
    … …  
    107270        }
    108271
     272        public static void loadComposites(Access access, Source source, final Registry registry) {
     273                if (access instanceof ObjectAccess) {
     274                        final ObjectAccess objectAccess = (ObjectAccess) access;
     275
     276                        MultiParamLoader loader = new MultiParamLoader();
     277
     278                        loader.setNewSource(source);
     279
     280                        loader.setAccessProvider(new AccessProvider() {
     281                                @Override
     282                                public Access getAccess(String name) {
     283                                        CompositeParam result = null;
     284                                        for (CompositeParam p : filterInstanceof(objectAccess.getParams(), CompositeParam.class)) {
     285                                                if (p.getContainedTypeName().equals(name)) {
     286                                                        if (result != null) {
     287                                                                throw new FramsticksException().msg("class name is ambiguous in access").arg("name", name).arg("first candidate", result).arg("second candidate", p);
     288                                                        }
     289                                                        result = p;
     290
     291                                                }
     292                                        }
     293                                        if (result == null) {
     294                                                throw new FramsticksException().msg("class name is unknown").arg("name", name).arg("in", objectAccess);
     295                                        }
     296
     297                                        return registry.prepareAccess(result).select(objectAccess.get(result, Object.class));
     298                                }
     299                        });
     300
     301
     302                        loader.go();
     303
     304                        return;
     305                }
     306                throw new UnimplementedException().msg("unknown access category").arg("access", access);
     307        }
     308
    109309        public static void load(Access access, Source source) {
    110310                if (!(access instanceof ObjectAccess)) {
    … …  
    128328                        }
    129329                }
    130 
    131330        }
    132331
    … …  
    215414        }
    216415
     416
     417        /**
     418         *
     419         * If both arguments are File, than do nothing; otherwise:
     420         *
     421         * If from argument is a File:
     422         * - if toJavaClass is Object.class, than try read using registry
     423         * - otherwise: try use loadComposites
     424         *
     425         * If to argument is a File:
     426         * - use Registry to saveAll
     427         *
     428         */
     429        public static <T, F> T convert(Class<T> toJavaClass, F from, Registry registry) {
     430                if (toJavaClass.equals(from.getClass())) {
     431                        return toJavaClass.cast(from);
     432                }
     433                if (from instanceof File) {
     434                        File file = (File) from;
     435                        return Casting.throwCast(toJavaClass, loadAll((toJavaClass.equals(Object.class) ? null : registry.createAccess(toJavaClass)), file.getContent(), registry).getSelected());
     436                }
     437                if (toJavaClass.equals(File.class)) {
     438                        ListSink sink = new ListSink();
     439                        saveAll(registry.createAccess(from.getClass()).select(from), sink, registry);
     440                        return Casting.throwCast(toJavaClass, new File("", new ListSource(sink.getOut())));
     441                }
     442
     443                throw new FramsticksUnsupportedOperationException().msg("conversion").arg("from", from.getClass()).arg("to", toJavaClass);
     444        }
     445
     446        @SuppressWarnings("serial")
     447        public static class EqualityException extends FramsticksException {
     448        }
     449
     450
     451        public static void assureEquality(Access a, Access b, Registry registry) {
     452                try {
     453                        if (a.getParamCount() != b.getParamCount()) {
     454                                throw new EqualityException().msg("param count not equal").arg("left", a.getParamCount()).arg("right", b.getParamCount());
     455                        }
     456                        for (ValueParam avp : Containers.filterInstanceof(a.getParams(), ValueParam.class)) {
     457                                Param bp = b.getParam(avp.getId());
     458                                if (bp == null) {
     459                                        throw new EqualityException().msg("param from left not present in right").arg("param", avp);
     460                                }
     461                                Misc.checkEquals(avp.getClass(), bp.getClass(), "params type not equals", null);
     462                                ValueParam bvp = (ValueParam) bp;
     463
     464                                Object oa = a.get(avp, Object.class);
     465                                Object ob = b.get(avp, Object.class);
     466
     467                                if (avp instanceof CompositeParam) {
     468                                        assureEquality(registry.prepareAccess((CompositeParam) avp).select(oa), registry.prepareAccess((CompositeParam) bvp).select(ob), registry);
     469                                        continue;
     470                                }
     471                                Misc.checkEquals(oa, ob, "values not equal", null);
     472                        }
     473                } catch (EqualityException e) {
     474                        throw e.arg("left", a).arg("right", b);
     475                }
     476        }
     477
     478        public static boolean areEqual(Access a, Access b, Registry registry) {
     479                try {
     480                        assureEquality(a, b, registry);
     481                        return true;
     482                } catch (EqualityException e) {
     483                }
     484                return false;
     485        }
     486
    217487}

  • java/main/src/main/java/com/framsticks/params/AccessProvider.java

    r101 r103  
    44
    55        public Access getAccess(String name);
    6         public void addAccess(Access access);
    76
    87}

  • java/main/src/main/java/com/framsticks/params/ListSource.java

    r101 r103  
    7373                        b.append(list.get(i));
    7474                }
     75                if (list.size() > print) {
     76                        b.append(" ...");
     77                }
    7578                return b.toString();
    7679        }

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

    r101 r103  
    88import com.framsticks.util.DoubleMap;
    99import com.framsticks.util.FramsticksException;
    10 import com.framsticks.util.FramsticksUnsupportedOperationException;
    1110import com.framsticks.util.lang.Strings;
    1211
    … …  
    166165        }
    167166
    168         @Override
    169         public void addAccess(Access access) {
    170                 throw new FramsticksUnsupportedOperationException().msg("adding accesses to Registry");
     167        public Access bindAccessFor(Object object) {
     168                return createAccess(object.getClass()).select(object);
    171169        }
    172170
     171
    173172}

  • java/main/src/main/java/com/framsticks/params/SimpleUniqueList.java

    r102 r103  
    7474                return Collections.unmodifiableMap(children);
    7575        }
     76
     77        public Map<String, T> getMap() {
     78                return children;
     79        }
    7680}

  • java/main/src/main/java/com/framsticks/params/UniqueListAccess.java

    r101 r103  
    205205        @Override
    206206        public <T> int set(int i, T value) {
    207                 throw new FramsticksUnsupportedOperationException().msg("accesing unique list through index");
     207                if (i != map.size()) {
     208                        throw new FramsticksUnsupportedOperationException().msg("setting element in unique list through index is available only for addition");
     209                }
     210                set(getUidOf(value), value);
     211                return 0;
    208212        }
    209213
Note: See TracChangeset for help on using the changeset viewer.