Changeset 100 for java/main


Ignore:
Timestamp:
07/12/13 23:41:06 (11 years ago)
Author:
psniegowski
Message:

HIGHLIGHTS:

  • add <include/> to configuration
  • add side notes to tree
    • used to store arbitrary information alongside the tree structure
  • migrate to log4j2
    • supports lazy string evaluation of passed arguments
  • improve GUI tree
    • it stays in synchronization with actual state (even in high load test scenario)
  • improve panel management in GUI
  • make loading objects in GUI more lazy
  • offload parsing to connection receiver thread
    • info parsing
    • first step of objects parsing
  • fix connection parsing bug (eof in long values)
  • support zero-arguments procedure in table view

CHANGELOG:
Implement procedure calls from table view.

Refactorization around procedures in tables.

Add table editor for buttons.

Render buttons in the the list view.

Further improve Columns.

Add Column class for TableModel?.

Accept also non-arguments ProcedureParams? in tableView.

Increase maximal TextAreaControl? size.

Add tooltip to ProcedureControl?.

Fix bug of interpreting eofs in long values by connection reader.

Further rework connection parsing.

Simplify client connection processing.

Test ListChange? modification.

Test ListChange? events with java server.

Add TestChild?.

Fix bug with fast deregistering when connecting to running server.

Another minor refactorization in TreeOperations?.

Fix bug in SimpleAbstractAccess? loading routine.

Another minor improvement.

Minor change.

Make reading of List objects two-phase.

Another minor change.

Dispatch parsing into receiver thread.

Another step.

Enclose passing value in ObjectParam? case in closure.

Minor step.

Minor change on way to offload parsing.

Temporarily comment out single ValueParam? get.

It will be generalized to multi ValueParam?.

Process info in receiver thread.

Add DispatchingExceptionHandler?.

Make waits in browser test longer.

Use FETCHED_MARK.

It is honored in GUI, where it used to decide whether to get values

after user action.

It is set in standard algorithm for processing fetched values.

Add remove operation to side notes.

Make loading more lazy.

Improve loading policy.

On node choose load itself, on node expansion, load children.

Minor improvement.

Fix bug with panel interleaving.

Minor improvements.

Improve panel management.

More cleaning around panels.

Reorganize panels.

Further improve tree.

Fix bug in TreeModel?.

Remove children from TreeNode?.

Implement TreeNode? hashCode and equals.

Make TreeNode? delegate equals and hashcode to internal reference.

Move listeners from TreeNode? to side notes.

Store path.textual as a side note.

Side note params instead of accesses for objects.

More refactorizations.

In TreeNode? bindAccess based on side notes.

Minor step.

Hide createAccess.

Rename AccessInterface? to Access.

Minor changes.

Several improvements in high load scenarios.

Change semantics of ArrayListAccess?.set(index, null);

It now removes the element, making list shorter
(it was set to null before).

Add path remove handler.

Handle exceptions in Connection.

Update .gitignore

Configure logging to file.

Move registration to TreeModel?.

Further refactorization.

Minor refactorization.

Minor improvements.

Use specialized event also for Modify action of ListChange?.

Use remove events.

Use the insertion events for tree.

Further improve tree refreshing.

Further improve reacting on events in GUI.

Fix problem with not adding objects on addition list change.

Migrate to log4j lazy String construction interface.

Migrate imports to log4j2.

Drop dependency on adapter to version 1.2.

Switch log4j implementation to log4j2.

Add dirty mark to the NodeAtFrame?.

Make selecting in AccessInterfaces? type safe.

Ignore containers size settings in Model and Genotype.

Use tree side notes to remember local changes and panels.

Add sideNotes to tree.

They will be used to store various accompanying information
right in the tree.

Use ReferenceIdentityMap? from apache in TreeNode?.

It suits the need perfectly (weak semantics on both key and value).

Make ArrayListParam? do not react size changes.

Guard in TableModel? before not yet loaded objects.

Add <include/> clause and AutoInjector?.

Extract common columns configuration to separate xml,
that can be included by other configurations.

Location:
java/main
Files:
16 added
4 deleted
113 edited

Legend:

Unmodified
Added
Removed

  • java/main/pom.xml

    r99 r100  
    3636                </dependency>
    3737                <dependency>
    38                         <groupId>log4j</groupId>
    39                         <artifactId>log4j</artifactId>
    40                         <version>1.2.16</version>
    41                         <scope>compile</scope>
     38                        <groupId>org.apache.logging.log4j</groupId>
     39                        <artifactId>log4j-api</artifactId>
     40                        <version>2.0-beta7</version>
    4241                </dependency>
     42                <dependency>
     43                        <groupId>org.apache.logging.log4j</groupId>
     44                        <artifactId>log4j-core</artifactId>
     45                        <version>2.0-beta7</version>
     46                </dependency>
     47                <!-- <dependency> -->
     48                <!--    <groupId>org.apache.logging.log4j</groupId> -->
     49                <!--    <artifactId>log4j-1.2-api</artifactId> -->
     50                <!--    <version>2.0-beta7</version> -->
     51                <!-- </dependency> -->
    4352                <dependency>
    4453                        <groupId>commons-collections</groupId>
    … …  
    101110                                <version>2.9</version>
    102111                                <configuration>
    103                                         <forkedProcessTimeoutInSeconds>60</forkedProcessTimeoutInSeconds>
     112                                        <forkedProcessTimeoutInSeconds>120</forkedProcessTimeoutInSeconds>
    104113                                        <useFile>false</useFile>
    105114                                </configuration>
    … …  
    134143                                                <argument>-ea</argument>
    135144                                                <argument>-Xdebug</argument>
    136                                                 <argument>-Xrunjdwp:transport=dt_socket,address=4711,server=y,suspend=n</argument>
     145                                                <!-- <argument>-Xrunjdwp:transport=dt_socket,address=4711,server=y,suspend=n</argument> -->
    137146                                                <argument>-classpath</argument>
    138147                                                <classpath />

  • java/main/src/main/java/com/framsticks/communication/ClientSideManagedConnection.java

    r99 r100  
    1717import com.framsticks.util.dispatching.FutureHandler;
    1818import com.framsticks.util.dispatching.JoinableState;
     19import com.framsticks.util.lang.Casting;
    1920import com.framsticks.util.lang.Pair;
    2021import com.framsticks.util.lang.Strings;
    2122import com.framsticks.params.EventListener;
    2223
    23 import org.apache.log4j.Logger;
     24import org.apache.logging.log4j.Logger;
     25import org.apache.logging.log4j.LogManager;
    2426
    2527import java.util.*;
    2628import java.util.regex.Matcher;
     29
     30import javax.annotation.Nonnull;
     31import javax.annotation.Nullable;
     32
    2733import com.framsticks.util.dispatching.RunAt;
    2834
    … …  
    3238public class ClientSideManagedConnection extends ManagedConnection {
    3339
    34         private final static Logger log = Logger.getLogger(ClientSideManagedConnection.class);
     40        private final static Logger log = LogManager.getLogger(ClientSideManagedConnection.class);
    3541
    3642        private final List<Runnable> applicationRequestsBuffer = new LinkedList<>();
    … …  
    6066
    6167
    62         private static abstract class InboundMessage {
    63                 protected String currentFilePath;
    64                 protected List<String> currentFileContent;
    65                 protected final List<File> files = new ArrayList<File>();
    66 
    67                 public abstract void eof();
    68 
    69                 protected void initCurrentFile(String path) {
    70                         currentFileContent = new LinkedList<String>();
    71                         currentFilePath = path;
    72                 }
    73 
    74                 protected void finishCurrentFile() {
    75                         if (currentFileContent == null) {
    76                                 return;
    77                         }
    78                         files.add(new File(currentFilePath, new ListSource(currentFileContent)));
    79                         currentFilePath = null;
    80                         currentFileContent = null;
    81                 }
    82 
    83                 public abstract void startFile(String path);
    84 
    85                 public final void addLine(String line) {
    86                         assert line != null;
    87                         assert currentFileContent != null;
    88                         currentFileContent.add(line);
    89                 }
    90 
    91                 public List<File> getFiles() {
    92                         return files;
    93                 }
    94         }
    9568
    9669        protected List<String> readFileContent() {
    9770                List<String> content = new LinkedList<String>();
    9871                String line;
    99                 while (!(line = getLine()).startsWith("eof")) {
     72                boolean longValue = false;
     73                while (true) {
     74                        line = getLine();
     75                        if (longValue) {
     76                                if (line.endsWith("~") && !line.endsWith("\\~")) {
     77                                        longValue = false;
     78                                }
     79                        } else {
     80                                if (line.equals("eof")) {
     81                                        break;
     82                                }
     83                                if (line.endsWith(":~")) {
     84                                        longValue = true;
     85                                }
     86                        }
    10087                        content.add(line);
    10188                }
    … …  
    10390        }
    10491
    105         private static class SentQuery<C> extends InboundMessage {
     92        private static class SentQuery<C> {
     93
    10694                Request request;
    10795                ClientSideResponseFuture callback;
    10896                Dispatcher<C> dispatcher;
    109 
    110                 public void startFile(String path) {
    111                         finishCurrentFile();
    112                         if (!Strings.notEmpty(path)) {
    113                                 assert request instanceof ApplicationRequest;
    114                                 path = ((ApplicationRequest) request).getPath();
    115                         }
    116                         Strings.assureNotEmpty(path);
    117                         initCurrentFile(path);
    118                 }
    119 
    120                 public void eof() {
    121                         assert Strings.notEmpty(currentFilePath);
    122                         finishCurrentFile();
    123                         //no-operation
     97                protected final List<File> files = new ArrayList<File>();
     98
     99                public List<File> getFiles() {
     100                        return files;
    124101                }
    125102
    … …  
    169146
    170147                if (getState().ordinal() > JoinableState.RUNNING.ordinal()) {
    171                         log.fatal("not connected");
    172                         return;
     148                        throw new FramsticksException().msg("connection is not connected").arg("connection", this);
    173149                }
    174150
    … …  
    211187                                putLine(out);
    212188                                flushOut();
    213                                 log.debug("sending query: " + out);
     189                                log.debug("sending query: {}", out);
    214190
    215191                        }
    … …  
    217193                /*
    218194                synchronized (this) {
    219                         log.debug("queueing query: " + query);
     195                        log.debug("queueing query: {}", query);
    220196                        queryQueue.offer(sentQuery);
    221197                        notifyAll();
    … …  
    253229        }
    254230
    255         private synchronized SentQuery<?> fetchQuery(Integer id, boolean remove) {
    256                 if (id == null) {
    257                         if (requestIdEnabled) {
    258                                 return null;
    259                         }
    260                         SentQuery<?> result = currentlySentQuery;
    261                         if (remove) {
    262                                 currentlySentQuery = null;
    263                                 notifyAll();
    264                         }
    265                         return result;
    266                 }
    267                 if (queryMap.containsKey(id)) {
     231        private synchronized @Nonnull SentQuery<?> fetchQuery(@Nullable Integer id, boolean remove) {
     232                try {
     233                        if (id == null) {
     234                                if (requestIdEnabled) {
     235                                        throw new FramsticksException().msg("request_id is enabled and id is missing");
     236                                }
     237                                SentQuery<?> result = currentlySentQuery;
     238                                if (remove) {
     239                                        currentlySentQuery = null;
     240                                        notifyAll();
     241                                }
     242                                return result;
     243                        }
     244
     245                        if (!queryMap.containsKey(id)) {
     246                                throw new FramsticksException().msg("id is unknown").arg("id", id);
     247                        }
     248
    268249                        SentQuery<?> result = queryMap.get(id);
    269250                        if (remove) {
    … …  
    271252                        }
    272253                        return result;
    273                 }
    274                 return null;
     254
     255                } catch (FramsticksException e) {
     256                        throw new FramsticksException().msg("failed to match response to sent query").cause(e);
     257                }
    275258        }
    276259
    277260        private int nextQueryId = 0;
    278 
    279         protected void processMessage(InboundMessage inboundMessage) {
    280                 if (inboundMessage == null) {
    281                         log.error("failed to use any inbound message");
    282                         return;
    283                 }
    284 
    285                 String line;
    286                 while (!(line = getLine()).startsWith("eof")) {
    287                         // log.debug("line: " + line);
    288                         inboundMessage.addLine(line);
    289                 }
    290                 inboundMessage.eof();
    291         }
    292261
    293262        protected void processEvent(String rest) {
    … …  
    303272                String eventCalleePath = Request.takeGroup(rest, matcher, 2).toString();
    304273                final File file = new File("", new ListSource(readFileContent()));
    305                 log.debug("firing event " + eventObjectPath);
     274                log.debug("firing event {}", eventObjectPath);
    306275                EventListener<File> listener;
    307276                synchronized (registeredListeners) {
    … …  
    314283        }
    315284
    316         protected void processMessageStartingWith(String line) {
     285        protected void processFile(Pair<Integer, CharSequence> rest) {
     286                final SentQuery<?> sentQuery = fetchQuery(rest.first, false);
     287
     288                String currentFilePath = rest.second.toString();
     289                if (!Strings.notEmpty(currentFilePath)) {
     290                        currentFilePath = Casting.throwCast(ApplicationRequest.class, sentQuery.request).getPath();
     291                }
     292
     293                sentQuery.files.add(new File(currentFilePath, new ListSource(readFileContent())));
     294
     295        }
     296
     297        protected void processMessageStartingWith(final String header) {
    317298                try {
    318                         Pair<CharSequence, CharSequence> command = Request.takeIdentifier(line);
    319                         if (command.first.equals("event")) {
     299                        final Pair<CharSequence, CharSequence> command = Request.takeIdentifier(header);
     300                        if (command == null) {
     301                                throw new FramsticksException().msg("failed to parse command");
     302                        }
     303                        final CharSequence keyword = command.first;
     304                        if (keyword.equals("event")) {
    320305                                processEvent(command.second.toString());
    321306                                return;
    322307                        }
    323                         Pair<Integer, CharSequence> rest = takeRequestId(command.second);
    324 
    325                         if (command.first.equals("file")) {
    326                                 SentQuery<?> sentQuery = fetchQuery(rest.first, false);
    327                                 sentQuery.startFile(rest.second.toString());
    328                                 processMessage(sentQuery);
     308
     309                        final Pair<Integer, CharSequence> rest = takeRequestId(command.second);
     310                        if (rest == null) {
     311                                throw new FramsticksException().msg("failed to parse optional id and remainder");
     312                        }
     313
     314                        if (keyword.equals("file")) {
     315                                processFile(rest);
    329316                                return;
    330317                        }
    331 
    332                         SentQuery<?> sentQuery = fetchQuery(rest.first, true);
    333                         if (sentQuery == null) {
     318                        if (keyword.equals("ok") || keyword.equals("error")) {
     319
     320                                final SentQuery<?> sentQuery = fetchQuery(rest.first, true);
     321
     322                                log.debug("parsing response for request {}", sentQuery);
     323
     324                                sentQuery.dispatchResponseProcess(new Response(command.first.equals("ok"), rest.second.toString(), sentQuery.getFiles()));
    334325                                return;
    335326                        }
    336                         log.debug("parsing response for request " + sentQuery);
    337 
    338                         sentQuery.dispatchResponseProcess(new Response(command.first.equals("ok"), rest.second.toString(), sentQuery.getFiles()));
     327
     328                        throw new FramsticksException().msg("unknown command keyword").arg("keyword", keyword);
    339329                } catch (FramsticksException e) {
    340                         throw new FramsticksException().msg("failed to process message").arg("starting with line", line).cause(e);
     330                        throw new FramsticksException().msg("failed to process message").arg("starting with line", header).cause(e);
    341331                }
    342332        }

  • java/main/src/main/java/com/framsticks/communication/Connection.java

    r97 r100  
    88import com.framsticks.util.lang.Strings;
    99
    10 import org.apache.log4j.Level;
    11 import org.apache.log4j.Logger;
     10import org.apache.logging.log4j.Level;
     11import org.apache.logging.log4j.Logger;
     12import org.apache.logging.log4j.LogManager;
    1213import java.io.BufferedReader;
    1314import java.io.IOException;
    … …  
    2223
    2324import com.framsticks.util.dispatching.AbstractJoinable;
     25import com.framsticks.util.dispatching.Dispatcher;
    2426import com.framsticks.util.dispatching.Dispatching;
     27import com.framsticks.util.dispatching.ExceptionResultHandler;
    2528import com.framsticks.util.dispatching.Joinable;
    2629import com.framsticks.util.dispatching.JoinableCollection;
    … …  
    3235
    3336@FramsClassAnnotation
    34 public abstract class Connection extends AbstractJoinable implements JoinableParent {
    35 
    36         protected final static Logger log = Logger.getLogger(Connection.class);
     37public abstract class Connection extends AbstractJoinable implements JoinableParent, ExceptionResultHandler {
     38
     39        protected final static Logger log = LogManager.getLogger(Connection.class);
    3740
    3841        private PrintWriter output = null;
    … …  
    4851        protected final JoinableCollection<Thread<Connection>> threads = new JoinableCollection<>();
    4952        protected final Set<ConnectionListener> listeners = new HashSet<>();
     53
     54        protected ExceptionResultHandler exceptionHandler = ThrowExceptionHandler.getInstance();
    5055
    5156        /**
    … …  
    161166                        try {
    162167                                processNextInputBatch();
     168                        } catch (FramsticksException e) {
     169                                handle(e);
    163170                        } catch (Exception e) {
    164171                                log.log(isRunning() ? Level.ERROR : Level.DEBUG, "caught exception: ", e);
    … …  
    183190        }
    184191
    185 
    186 
    187192        @Override
    188193        protected void joinableFinish() {
    … …  
    197202                                input = null;
    198203                        }
    199 
    200204
    201205                        if (socket != null) {
    … …  
    250254        }
    251255
    252 
    253256        @Override
    254257        protected void joinableJoin() throws InterruptedException {
    … …  
    258261        protected static void startClientConnection(Connection connection) {
    259262                while (connection.isRunning() && !connection.isConnected()) {
    260                         log.debug("connecting to " + connection.address);
     263                        log.debug("connecting to {}", connection.address);
    261264                        try {
    262265                                connection.socket = new Socket(connection.getAddressObject().getHostName(), connection.getAddressObject().getPort());
    263266                        } catch (IOException e) {
    264                                 log.info(connection + " failed to connect (retrying): " + e);
     267                                log.info("{} failed to connect (retrying): ", connection, e);
    265268                                Dispatching.sleep(0.5);
    266269                        }
    267270                }
    268271
    269                 log.debug(connection + " connected");
     272                log.debug("{} connected", connection);
    270273                try {
    271274                        connection.socket.setSoTimeout(500);
    … …  
    288291        }
    289292
    290 
    291293        /**
    292294         * @return the listeners
    … …  
    294296        public Collection<ConnectionListener> getListeners() {
    295297                return listeners;
     298        }
     299
     300        /**
     301         * @return the handler
     302         */
     303        public ExceptionResultHandler getExceptionHandler() {
     304                return exceptionHandler;
     305        }
     306
     307        /**
     308         * @param handler the handler to set
     309         */
     310        public void setExceptionHandler(ExceptionResultHandler handler) {
     311                this.exceptionHandler = handler;
    296312        }
    297313
    … …  
    301317        }
    302318
     319        @Override
     320        public void handle(FramsticksException exception) {
     321                exceptionHandler.handle(exception);
     322        }
     323
     324        public Dispatcher<Connection> getReceiverDispatcher() {
     325                return receiverThread;
     326        }
     327
     328        public Dispatcher<Connection> getSenderDispatcher() {
     329                return senderThread;
     330        }
     331
     332
    303333}

  • java/main/src/main/java/com/framsticks/communication/ServerSideManagedConnection.java

    r99 r100  
    88import com.framsticks.util.lang.Strings;
    99
    10 import org.apache.log4j.Logger;
     10import org.apache.logging.log4j.Logger;
     11import org.apache.logging.log4j.LogManager;
    1112
    1213import java.net.Socket;
    … …  
    1819public class ServerSideManagedConnection extends ManagedConnection {
    1920
    20         private final static Logger log = Logger.getLogger(ServerSideManagedConnection.class);
     21        private final static Logger log = LogManager.getLogger(ServerSideManagedConnection.class);
    2122
    2223        protected final RequestHandler requestHandler;
    … …  
    6465
    6566                }
    66                 log.error("unhandled request: " + request);
     67                log.error("unhandled request: {}", request);
    6768                responseCallback.pass(new Response(false, "unhandled", null));
    6869        }
    … …  
    123124
    124125                        if (log.isTraceEnabled()) {
    125                                 log.trace("read request: " + request);
     126                                log.trace("read request: {}", request);
    126127                        }
    127128

  • java/main/src/main/java/com/framsticks/communication/util/LoggingStateCallback.java

    r97 r100  
    44import com.framsticks.communication.Response;
    55
    6 import org.apache.log4j.Logger;
     6import org.apache.logging.log4j.Logger;
    77
    88/**

  • java/main/src/main/java/com/framsticks/core/AbstractTree.java

    r99 r100  
    11package com.framsticks.core;
    22
     3import java.util.Map;
     4
    35import javax.annotation.Nonnull;
    46
    5 import org.apache.log4j.Logger;
    6 
    7 import com.framsticks.params.AccessInterface;
     7import org.apache.commons.collections.map.ReferenceIdentityMap;
     8import org.apache.logging.log4j.Logger;
     9import org.apache.logging.log4j.LogManager;
     10
     11import com.framsticks.params.Access;
    812import com.framsticks.params.CompositeParam;
    913import com.framsticks.params.FramsClass;
    … …  
    1418import com.framsticks.params.annotations.ParamAnnotation;
    1519import com.framsticks.util.FramsticksException;
     20import com.framsticks.util.Misc;
    1621import com.framsticks.util.dispatching.AbstractJoinable;
    1722import com.framsticks.util.dispatching.Dispatcher;
    … …  
    2530import com.framsticks.util.dispatching.Thread;
    2631import com.framsticks.util.dispatching.ThrowExceptionHandler;
     32import com.framsticks.util.lang.Casting;
    2733
    2834/**
    … …  
    3238public abstract class AbstractTree extends AbstractJoinable implements Dispatcher<Tree>, Tree, JoinableParent {
    3339
    34         private static final Logger log = Logger.getLogger(AbstractTree.class);
     40        private static final Logger log = LogManager.getLogger(AbstractTree.class);
    3541
    3642        private Node root = null;
    … …  
    4551                }
    4652                root = new Node(this, param, null);
    47                 log.debug("assigned root type: " + root);
     53                log.debug("assigned root type: {}", root);
    4854        }
    4955
    … …  
    5763                }
    5864                root = new Node(this, root.getParam(), object);
    59                 log.debug("assigned root object: " + root);
     65                log.debug("assigned root object: {}", root);
    6066        }
    6167
    … …  
    9399
    94100        @Override
    95         public @Nonnull AccessInterface prepareAccess(CompositeParam param) {
     101        public @Nonnull Access prepareAccess(CompositeParam param) {
    96102                return registry.prepareAccess(param);
    97103        }
    … …  
    104110        @AutoAppendAnnotation
    105111        public void usePackage(ParamsPackage paramsPackage) {
    106                 log.debug("using package " + paramsPackage + " in tree " + this);
     112                log.debug("using package {} in tree {}", paramsPackage, this);
    107113                paramsPackage.register(registry);
    108114        }
    … …  
    110116        @AutoAppendAnnotation
    111117        public void takeFromRegistry(Registry registry) {
    112                 log.debug("taking from registry " + registry + " in tree " + this);
     118                log.debug("taking from registry {} in tree {}", registry, this);
    113119                this.registry.takeAllFrom(registry);
    114120        }
    … …  
    231237        }
    232238
     239
     240        @SuppressWarnings("unchecked")
     241        protected final Map<Object, Object> sideNotes = (Map<Object, Object>) new ReferenceIdentityMap(ReferenceIdentityMap.WEAK, ReferenceIdentityMap.HARD);
     242
     243        @Override
     244        public void putSideNote(Object object, Object key, Object value) {
     245                assert isActive();
     246                Misc.throwIfNull(object);
     247                Misc.throwIfNull(key);
     248                Misc.throwIfNull(value);
     249                Object sideNote = sideNotes.get(object);
     250                if (sideNote == null) {
     251                        sideNote = new ReferenceIdentityMap(ReferenceIdentityMap.WEAK, ReferenceIdentityMap.HARD);
     252                        sideNotes.put(object, sideNote);
     253                }
     254                @SuppressWarnings("unchecked")
     255                Map<Object, Object> sideNotesMap = (Map<Object, Object>) sideNote;
     256                sideNotesMap.put(key, value);
     257        }
     258
     259        @Override
     260        public <T> T getSideNote(Object object, Object key, Class<T> valueType) {
     261                assert isActive();
     262                Misc.throwIfNull(object);
     263                Misc.throwIfNull(key);
     264                Object sideNote = sideNotes.get(object);
     265                if (sideNote == null) {
     266                        return null;
     267                }
     268                return Casting.nullOrThrowCast(valueType, ((Map<?, ?>) sideNote).get(key));
     269        }
     270
     271        @Override
     272        public boolean removeSideNote(Object object, Object key) {
     273                Object sideNote = sideNotes.get(object);
     274                if (sideNote == null) {
     275                        return false;
     276                }
     277                @SuppressWarnings("unchecked")
     278                Map<Object, Object> sideNotesMap = (Map<Object, Object>) sideNote;
     279                boolean result = (sideNotesMap.remove(key) != null);
     280                if (sideNotesMap.isEmpty()) {
     281                        sideNotes.remove(object);
     282                }
     283                return result;
     284        }
     285
    233286}
    234287

  • java/main/src/main/java/com/framsticks/core/Framsticks.java

    r99 r100  
    77import com.framsticks.util.dispatching.Monitor;
    88
    9 import org.apache.log4j.Logger;
    10 import org.apache.log4j.PropertyConfigurator;
     9import org.apache.logging.log4j.Logger;
     10import org.apache.logging.log4j.LogManager;
    1111
    1212import java.io.InputStream;
    … …  
    1717@FramsClassAnnotation
    1818public class Framsticks extends JoinableCollection<Joinable> {
    19         private static final Logger log = Logger.getLogger(Framsticks.class);
     19        private static final Logger log = LogManager.getLogger(Framsticks.class);
    2020
    2121        public Framsticks() {
    22                 PropertyConfigurator.configure(getClass().getResource("/configs/log4j.properties"));
    2322
    24                 // log.info("config is: " + System.getProperties().getProperty("framsticks.config", "/configs/framsticks.xml"));
    2523        }
    2624

  • java/main/src/main/java/com/framsticks/core/ListChange.java

    r87 r100  
    33import com.framsticks.params.annotations.FramsClassAnnotation;
    44import com.framsticks.params.annotations.ParamAnnotation;
     5import com.framsticks.util.Misc;
    56import com.framsticks.util.lang.Strings;
    67
    … …  
    89 * @author Piotr Sniegowski
    910 */
    10 @FramsClassAnnotation
     11@FramsClassAnnotation(order = {"type", "pos", "id"})
    1112public class ListChange {
     13
     14
     15        /**
     16         * @param action
     17         */
     18        public ListChange(Action action, Integer position, String identifier) {
     19                this.action = action;
     20                this.position = position;
     21                this.identifier = identifier;
     22        }
     23
     24        /**
     25         *
     26         */
     27        public ListChange() {
     28        }
    1229
    1330        public Action getAction() {
    … …  
    3754                //  */
    3855                // Action(int value) {
    39                 //      this.value = value;
     56                //      this.value = value;
    4057                // }
    4158
    … …  
    4360
    4461        public Action action = Action.Add;
    45         @ParamAnnotation(id = "pos")
     62        @ParamAnnotation(id = "pos", def = "-1")
    4663        public Integer position;
    4764        @ParamAnnotation(id = "id")
    … …  
    6481                return action + " " + identifier + " " + position;
    6582        }
     83
     84        @Override
     85        public boolean equals(Object object) {
     86                if (object instanceof ListChange) {
     87                        ListChange r = (ListChange) object;
     88                        return Misc.equals(action, r.action) && Misc.equals(position, r.position) && Misc.equals(identifier, r.identifier);
     89                }
     90                return false;
     91        }
     92
    6693}

  • java/main/src/main/java/com/framsticks/core/LocalTree.java

    r99 r100  
    11package com.framsticks.core;
    22
    3 import org.apache.log4j.Logger;
     3import org.apache.logging.log4j.Logger;
     4import org.apache.logging.log4j.LogManager;
    45
    5 import com.framsticks.params.AccessInterface;
     6import com.framsticks.params.Access;
    67import com.framsticks.params.CompositeParam;
    78import com.framsticks.params.EventListener;
    … …  
    910import com.framsticks.params.ParamBuilder;
    1011import com.framsticks.params.PrimitiveParam;
    11 import com.framsticks.params.ValueParam;
    1212import com.framsticks.params.annotations.AutoAppendAnnotation;
    1313import com.framsticks.params.annotations.FramsClassAnnotation;
    … …  
    2121@FramsClassAnnotation
    2222public final class LocalTree extends AbstractTree {
    23         private static final Logger log = Logger.getLogger(LocalTree.class);
     23        private static final Logger log = LogManager.getLogger(LocalTree.class);
    2424
    2525        protected Object rootObject;
    … …  
    3838                registry.registerAndBuild(javaClass);
    3939
    40                 AccessInterface access = registry.createAccess(javaClass);
     40                Access access = registry.createAccess(javaClass);
    4141
    4242                assignRootParam(access.buildParam(new ParamBuilder()).id(getName()).finish(CompositeParam.class));
    … …  
    6262        public void get(Path path, Future<Path> future) {
    6363                assert isActive();
    64                 log.debug("requesting: " + path);
     64                log.debug("requesting: {}", path);
    6565                path = resolveTopSync(path);
    6666                future.pass(path);
    6767        }
    6868
    69         @Override
    70         public void get(Path path, ValueParam param, Future<Object> future) {
    71                 assert isActive();
    72                 path = resolveTopSync(path);
    73                 future.pass(bindAccess(path).get(param, Object.class));
    74         }
     69        // @Override
     70        // public void get(Path path, ValueParam param, Future<Object> future) {
     71        //      assert isActive();
     72        //      path = resolveTopSync(path);
     73        //      future.pass(bindAccess(path).get(param, Object.class));
     74        // }
    7575
    7676        @Override
    … …  
    103103                        return path;
    104104                }
    105                 AccessInterface access = bindAccess(path.getUnder());
     105                Access access = bindAccess(path.getUnder());
    106106                Object object = access.get(path.getTop().getParam(), Object.class);
    107107                if (object == null) {

  • java/main/src/main/java/com/framsticks/core/Path.java

    r99 r100  
    11package com.framsticks.core;
    22
    3 import com.framsticks.params.AccessInterface;
     3import com.framsticks.params.Access;
    44import com.framsticks.params.CompositeParam;
    55import com.framsticks.params.Param;
    … …  
    2525@Immutable
    2626public final class Path {
    27         // private final static Logger log = Logger.getLogger(Path.class.getName());
     27        // private final static Logger log = LogManager.getLogger(Path.class.getName());
    2828
    2929        final Tree tree;
    … …  
    3131        final LinkedList<Node> nodes;
    3232
    33         protected static Object getKnownChild(Tree tree, AccessInterface access, CompositeParam param, ExceptionResultHandler handler) {
     33        protected static Object getKnownChild(Tree tree, Access access, CompositeParam param, ExceptionResultHandler handler) {
    3434                Object child = access.get(param, Object.class);
    3535                if (child == null) {
    … …  
    3838                try {
    3939                        tree.prepareAccess(param);
     40                        tree.putSideNote(child, CompositeParam.class, param);
    4041                        return child;
    4142                } catch (FramsticksException e) {
    … …  
    151152                        Iterator<String> i = splitPath(textual);
    152153                        while (i.hasNext() && current.getObject() != null) {
    153                                 AccessInterface access = TreeOperations.bindAccess(current);// tree.prepareAccess(current.getParam());
     154                                Access access = TreeOperations.bindAccess(current);// tree.prepareAccess(current.getParam());
    154155                                String e = i.next();
    155156                                Param p = access.getParam(e);
    … …  
    163164                                b.append("/").append(e);
    164165                                access.select(current.getObject());
     166                                tree.putSideNote(current.getObject(), CompositeParam.class, current.getParam());
    165167                                current = new Node(current.getTree(), c, getKnownChild(tree, access, c, handler));
    166168                                nodes.add(current);

  • java/main/src/main/java/com/framsticks/core/Tree.java

    r99 r100  
    33import javax.annotation.Nonnull;
    44
    5 import com.framsticks.params.AccessInterface;
     5import com.framsticks.params.Access;
    66import com.framsticks.params.CompositeParam;
    77import com.framsticks.params.EventListener;
    … …  
    99import com.framsticks.params.PrimitiveParam;
    1010import com.framsticks.params.Registry;
    11 import com.framsticks.params.ValueParam;
    1211import com.framsticks.params.types.EventParam;
    1312import com.framsticks.params.types.ProcedureParam;
    … …  
    2423        public void assignRootObject(Object object);
    2524
    26         public @Nonnull AccessInterface prepareAccess(CompositeParam param);
     25        public @Nonnull Access prepareAccess(CompositeParam param);
    2726        public void takeAllFrom(Registry source);
    2827
    … …  
    3130        public void putInfoIntoCache(FramsClass framclass);
    3231
    33         /**
    34         *
    35         * Functions accepts ValueParam, because it is also possible to get number of List elements.
    36         *
    37         */
    38         public void get(Path path, ValueParam param, Future<Object> future);
     32        // /**
     33        // *
     34        // * Functions accepts ValueParam, because it is also possible to get number of List elements.
     35        // *
     36        // */
     37        // public void get(Path path, ValueParam param, Future<Object> future);
    3938
    4039        public void get(Path path, Future<Path> future);
    … …  
    6564        public Registry getRegistry();
    6665
     66        public void putSideNote(Object object, Object key, Object value);
     67
     68        public boolean removeSideNote(Object object, Object key);
     69
     70        public <T> T getSideNote(Object object, Object key, Class<T> valueType);
     71
    6772}

  • java/main/src/main/java/com/framsticks/core/TreeOperations.java

    r99 r100  
    88import javax.annotation.Nonnull;
    99
    10 import org.apache.log4j.Logger;
     10import org.apache.logging.log4j.Logger;
     11import org.apache.logging.log4j.LogManager;
    1112
    1213import com.framsticks.communication.File;
    13 import com.framsticks.params.AccessInterface;
     14import com.framsticks.params.Access;
     15import com.framsticks.params.CompositeParam;
    1416import com.framsticks.params.EventListener;
    1517import com.framsticks.params.FramsClass;
    1618import com.framsticks.params.ListAccess;
    1719import com.framsticks.params.Param;
     20import com.framsticks.params.ParamBuilder;
    1821import com.framsticks.params.PrimitiveParam;
     22import com.framsticks.params.PropertiesAccess;
    1923import com.framsticks.params.UniqueListAccess;
    2024import com.framsticks.params.Util;
    … …  
    2529import com.framsticks.parsers.MultiParamLoader;
    2630import com.framsticks.util.FramsticksException;
     31import com.framsticks.util.dispatching.Dispatching;
    2732import com.framsticks.util.dispatching.Future;
    2833import com.framsticks.util.dispatching.FutureHandler;
    … …  
    3338public final class TreeOperations {
    3439
    35         private static final Logger log = Logger.getLogger(TreeOperations.class);
     40        private static final Logger log = LogManager.getLogger(TreeOperations.class);
    3641
    3742        private TreeOperations() {
    3843        }
    3944
     45        public static final Object FETCHED_MARK = new Object();
     46
    4047        public static @Nonnull FramsClass processFetchedInfo(Tree tree, File file) {
    4148                assert tree.isActive();
    4249                FramsClass framsClass = Loaders.loadFramsClass(file.getContent());
    43                 log.debug("process fetched info for " + tree + ": " + framsClass);
     50                log.debug("process fetched info for {}: {}", tree, framsClass);
    4451                tree.putInfoIntoCache(framsClass);
    4552                return framsClass;
    4653        }
    4754
    48         public static void processFetchedValues(Path path, List<File> files) {
    49                 Tree tree = path.getTree();
    50                 assert tree.isActive();
     55        public static Path create(Path path) {
     56                assert !path.isResolved();
     57
     58                Access access = path.getTree().prepareAccess(path.getTop().getParam());
     59                Object child = createAccessee(path.getTree(), access);
     60                assert child != null;
     61                if (path.size() == 1) {
     62                        path.getTree().assignRootObject(child);
     63                } else {
     64                        Access parentAccess = bindAccess(path.getUnder());
     65
     66                        /** this special case is not very good - maybe hide it in createAccessee? */
     67                        if (parentAccess instanceof UniqueListAccess) {
     68                                access.select(child);
     69                                access.set(((UniqueListAccess) parentAccess).getUidName(), path.getTop().getParam().getId());
     70                        }
     71
     72                        parentAccess.set(path.getTop().getParam(), child);
     73                }
     74                path = path.appendResolution(child);
     75                return path;
     76        }
     77
     78        public static void processFetchedValues(final Path path, final List<File> files, final Access access, final Future<Path> future) {
    5179                assert files.size() == 1;
    5280                assert path.isTheSame(files.get(0).getPath());
    5381
    54                 if (!path.isResolved()) {
    55                         AccessInterface access = tree.prepareAccess(path.getTop().getParam());
    56                         Object child = access.createAccessee();
    57                         assert child != null;
    58                         if (path.size() == 1) {
    59                                 tree.assignRootObject(child);
    60                         } else {
    61                                 bindAccess(path.getUnder()).set(path.getTop().getParam(), child);
    62                         }
    63                         path = path.appendResolution(child);
    64                 }
    65 
    66                 log.debug("process fetched values: " + path);
    67                 Node node = path.getTop();
    68                 MultiParamLoader loader = new MultiParamLoader();
    69                 loader.setNewSource(files.get(0).getContent());
    70                 loader.addBreakCondition(MultiParamLoader.Status.AfterObject);
    7182
    7283                try {
    73                         if (node.getParam() instanceof ObjectParam) {
    74                                 loader.addAccessInterface(bindAccess(node));
    75                                 loader.go();
    76                                 return;
    77                         }
    78 
    79                         ListAccess listAccess = (ListAccess) bindAccess(node);
    80 
    81                         Set<String> oldValuesIds = new HashSet<>();
    82                         for (Param p : listAccess.getParams()) {
    83                                 oldValuesIds.add(p.getId());
    84                         }
    85 
    86                         // listAccess.clearValues();
    87 
    88                         AccessInterface elementAccess = listAccess.getElementAccess();
    89                         AccessInterface clonerInterface = elementAccess.cloneAccess();
    90 
    91                         loader.addAccessInterface(elementAccess);
    92                         MultiParamLoader.Status status;
    93                         int number = 0;
    94                         while ((status = loader.go()) != MultiParamLoader.Status.Finished) {
    95                                 if (status == MultiParamLoader.Status.AfterObject) {
    96                                         AccessInterface accessInterface = loader.getLastAccessInterface();
    97 
    98                                         String id;
    99                                         if (listAccess instanceof UniqueListAccess) {
    100                                                 id = ((UniqueListAccess) listAccess).computeIdentifierFor(accessInterface.getSelected());
    101                                         } else {
    102                                                 id = Integer.toString(number);
    103                                         }
    104                                         ++number;
    105 
    106                                         Object childTo = listAccess.get(id, Object.class);
    107                                         boolean newOne;
    108                                         if (childTo == null) {
    109                                                 childTo = clonerInterface.createAccessee();
    110                                                 newOne = true;
    111                                         } else {
    112                                                 assert oldValuesIds.contains(id);
    113                                                 newOne = false;
    114                                         }
    115                                         oldValuesIds.remove(id);
    116                                         clonerInterface.select(childTo);
    117                                         Util.takeAllNonNullValues(clonerInterface, accessInterface);
    118                                         if (newOne) {
    119                                                 listAccess.set(id, childTo);
    120                                         }
    121 
    122                                         // listAccess.set(id, accessInterface.getSelected());
    123                                         accessInterface.select(null);
    124 
     84                        log.debug("process fetched values: {}", path);
     85                        final Access parsingAccess = new PropertiesAccess(access.getFramsClass());
     86                        final List<Object> results = MultiParamLoader.loadAll(files.get(0).getContent(), parsingAccess);
     87
     88                        Dispatching.dispatchIfNotActive(path.getTree(), new RunAt<Tree>(future) {
     89                                @Override
     90                                protected void runAt() {
     91
     92                                        Path result = path.tryResolveIfNeeded();
     93
     94                                        if (!result.isResolved()) {
     95                                                result = create(result);
     96                                        }
     97
     98                                        if (path.getTop().getParam() instanceof ObjectParam) {
     99                                                assert results.size() == 1;
     100                                                Util.takeAllNonNullValues(bindAccess(result), parsingAccess.select(results.get(0)));
     101                                                mark(result.getTree(), result.getTopObject(), FETCHED_MARK, true);
     102                                                future.pass(result);
     103                                                return;
     104                                        }
     105
     106
     107                                        final ListAccess listAccess = (ListAccess) access;
     108
     109                                        listAccess.select(result.getTopObject());
     110                                        Set<String> oldValuesIds = new HashSet<>();
     111                                        for (Param p : listAccess.getParams()) {
     112                                                oldValuesIds.add(p.getId());
     113                                        }
     114
     115                                        Access targetAccess = listAccess.getElementAccess();//.cloneAccess();
     116
     117                                        int number = 0;
     118                                        for (Object r : results) {
     119
     120                                                parsingAccess.select(r);
     121                                                String id;
     122                                                if (listAccess instanceof UniqueListAccess) {
     123                                                        id = parsingAccess.get(((UniqueListAccess) listAccess).getUidName(), String.class);
     124                                                } else {
     125                                                        id = Integer.toString(number);
     126                                                }
     127                                                ++number;
     128
     129                                                Object childTo = listAccess.get(id, Object.class);
     130                                                boolean newOne;
     131                                                if (childTo == null) {
     132                                                        childTo = createAccessee(result.getTree(), targetAccess);
     133                                                        newOne = true;
     134                                                } else {
     135                                                        assert oldValuesIds.contains(id);
     136                                                        newOne = false;
     137                                                }
     138                                                oldValuesIds.remove(id);
     139
     140                                                targetAccess.select(childTo);
     141                                                Util.takeAllNonNullValues(targetAccess, parsingAccess);
     142                                                if (newOne) {
     143                                                        listAccess.set(id, childTo);
     144                                                }
     145                                                mark(result.getTree(), childTo, FETCHED_MARK, true);
     146
     147                                        }
     148                                        mark(result.getTree(), result.getTopObject(), FETCHED_MARK, true);
     149
     150                                        /** It looks tricky for ArrayListAccess but should also work.
     151                                         *
     152                                         * They should be sorted.
     153                                         */
     154                                        for (String id : oldValuesIds) {
     155                                                listAccess.set(id, null);
     156                                        }
     157                                        future.pass(result);
    125158                                }
    126                         }
    127                         /** It looks tricky for ArrayListAccess but should also work.
    128                          *
    129                          * They should be sorted.
    130                          */
    131                         for (String id : oldValuesIds) {
    132                                 listAccess.set(id, null);
    133                         }
     159                        });
    134160
    135161                } catch (FramsticksException e) {
    … …  
    141167                Tree tree = path.getTree();
    142168                assert tree.isActive();
    143                 log.debug("get info for: " + path);
     169                log.debug("get info for: {}", path);
    144170                final String name = path.getTop().getParam().getContainedTypeName();
    145171                return tree.getInfoFromCache(name);
    … …  
    147173
    148174        public static void findInfo(final Path path, final Future<FramsClass> future) {
    149                 log.debug("find info for: " + path);
     175                log.debug("find info for: {}", path);
    150176                try {
    151177                        Tree tree = path.getTree();
    … …  
    163189
    164190
    165 
    166         public static @Nonnull AccessInterface bindAccess(Tree tree, String path) {
    167                 log.debug("bind access for textual: " + path + " in " + tree);
     191        public static @Nonnull Access bindAccessFromSideNote(Tree tree, Object object) {
     192                CompositeParam param = tree.getSideNote(object, CompositeParam.class, CompositeParam.class);
     193                if (param == null) {
     194                        throw new FramsticksException().msg("failed to bind access from side node").arg("tree", tree).arg("object", object).arg("type", object.getClass());
     195                }
     196                return tree.prepareAccess(param).select(object);
     197        }
     198
     199        public static @Nonnull Access bindAccess(Tree tree, String path) {
     200                log.debug("bind access for textual: {} in {}", path, tree);
    168201                return bindAccess(Path.to(tree, path));
    169202        }
    170203
    171         public static @Nonnull AccessInterface bindAccess(Node node) {
     204        public static @Nonnull Access bindAccess(Node node) {
    172205                Tree tree = node.getTree();
    173206                assert tree.isActive();
    … …  
    175208
    176209                try {
    177                         return tree.prepareAccess(node.getParam()).select(node.getObject());
     210                        Access access = tree.prepareAccess(node.getParam());
     211                        tree.putSideNote(node.getObject(), CompositeParam.class, node.getParam());
     212
     213                        return access.select(node.getObject());
    178214                } catch (FramsticksException e) {
    179215                        throw new FramsticksException().msg("failed to prepare access for param").arg("param", node.getParam()).cause(e);
    180                         // log.error("failed to bind access for " + node.getParam() + ": " + e);
    181                 }
    182         }
    183 
    184         public static @Nonnull AccessInterface bindAccess(Path path) {
     216                        // log.error("failed to bind access for {}: ", node.getParam(), e);
     217                }
     218        }
     219
     220        public static @Nonnull Access bindAccess(Path path) {
    185221                assert path.getTree().isActive();
    186222                path.assureResolved();
    187                 log.debug("bind access for: " + path);
     223                log.debug("bind access for: {}", path);
    188224                return bindAccess(path.getTop());
    189225        }
    … …  
    196232                        protected void runAt() {
    197233                                tree.set(path, param, value, future);
     234                        }
     235                });
     236        }
     237
     238        public static void call(final Path path, final String procedureName, final Object[] arguments, final Future<Object> future) {
     239                final Tree tree = path.getTree();
     240
     241                dispatchIfNotActive(tree, new RunAt<Tree>(future) {
     242                        @Override
     243                        protected void runAt() {
     244                                path.assureResolved();
     245                                tree.call(path, tree.getRegistry().getFramsClass(path.getTop().getParam()).getParamEntry(procedureName, ProcedureParam.class), arguments, future);
    198246                        }
    199247                });
    … …  
    241289         * */
    242290        public static void tryGet(final Tree tree, final String targetPath, final Future<Path> future) {
    243                 log.debug("resolve textual: " + targetPath + " for " + tree);
     291                log.debug("resolve textual: {} for {}", targetPath, tree);
    244292                dispatchIfNotActive(tree, new RunAt<Tree>(future) {
    245293
    … …  
    247295                        protected void runAt() {
    248296                                final Path path = Path.tryTo(tree, targetPath).tryResolveIfNeeded();
    249                                 log.debug("found: " + path);
     297                                log.debug("found: {}", path);
    250298                                if (path.isResolved()) {
    251299                                        future.pass(path);
    … …  
    257305                                        protected void result(Path result) {
    258306                                                // if (result.isResolved(targetPath)) {
    259                                                 //      future.pass(result);
    260                                                 //      return;
     307                                                //      future.pass(result);
     308                                                //      return;
    261309                                                // }
    262                                                 log.debug("retrying resolve textual: " + targetPath + " for " + tree + " with " + result);
     310                                                log.debug("retrying resolve textual: {} for {} with {}", targetPath, tree, result);
    263311                                                tryGet(tree, targetPath, future);
    264312                                        }
    … …  
    273321        }
    274322
     323        public static Object createAccessee(Tree tree, CompositeParam param) {
     324                Object object = tree.prepareAccess(param).createAccessee();
     325                tree.putSideNote(object, CompositeParam.class, param);
     326                return object;
     327        }
     328
     329        public static Object createAccessee(Tree tree, Access access) {
     330                Object object = access.createAccessee();
     331                tree.putSideNote(object, CompositeParam.class, access.buildParam(new ParamBuilder()).finish(CompositeParam.class));
     332                return object;
     333        }
     334
     335        public static boolean isMarked(Tree tree, Object object, Object mark, boolean defValue) {
     336                assert tree.isActive();
     337                Boolean v = tree.getSideNote(object, mark, Boolean.class);
     338                return (v != null ? v : defValue);
     339        }
     340
     341        public static void mark(Tree tree, Object object, Object mark, boolean value) {
     342                assert tree.isActive();
     343                tree.putSideNote(object, mark, value);
     344        }
     345
     346        public static FramsClass getFramsClass(Path path) {
     347                return path.getTree().getRegistry().getFramsClass(path.getTop().getParam());
     348        }
     349
    275350}

  • java/main/src/main/java/com/framsticks/diagnostics/Diagnostics.java

    r98 r100  
    4040                //                                      @Override
    4141                //                                      public void handle(FramsticksException exception) {
    42                 //                                              log.error("caught error during diagnostics fetching (repeating): " + exception);
     42                //                                              log.error("caught error during diagnostics fetching (repeating): {}", exception);
    4343                //                                              again();
    4444                //                                      }

  • java/main/src/main/java/com/framsticks/dumping/LoadStream.java

    r98 r100  
    1010import com.framsticks.util.lang.Pair;
    1111import com.framsticks.util.lang.Strings;
    12 import org.apache.log4j.Logger;
     12import org.apache.logging.log4j.Logger;
     13import org.apache.logging.log4j.LogManager;
    1314
    1415import java.io.BufferedReader;
    … …  
    2223public class LoadStream extends Stream {
    2324
    24         private final static Logger log = Logger.getLogger(LoadStream.class.getName());
     25        private final static Logger log = LogManager.getLogger(LoadStream.class.getName());
    2526
    2627        protected final Tree tree;
    … …  
    4950                                        query = Strings.splitIntoPair(line, ' ', "");
    5051                                        files = new LinkedList<File>();
    51                                         log.trace("loading " + line);
     52                                        log.trace("loading {}", line);
    5253                                        continue;
    5354                                }
    … …  
    8485                        }
    8586                } catch (IOException e) {
    86                         log.error("failed to load: " + e);
     87                        log.error("failed to load: {}", e);
    8788                        future.handle(new FramsticksException().msg("failed to load stream").cause(e));
    8889                        return;
    8990                }
    90                 log.info("loaded in: " + stopwatch);
     91                log.info("loaded in: {}", stopwatch);
    9192                future.pass(Path.to(tree, mountPath.getTextual()));
    9293        }

  • java/main/src/main/java/com/framsticks/dumping/SaveStream.java

    r98 r100  
    44import com.framsticks.core.Node;
    55import com.framsticks.core.Path;
    6 import com.framsticks.params.AccessInterface;
     6import com.framsticks.params.Access;
    77import com.framsticks.params.CompositeParam;
    88import com.framsticks.params.FramsClass;
    … …  
    1515import com.framsticks.util.dispatching.Future;
    1616
    17 import org.apache.log4j.Logger;
     17import org.apache.logging.log4j.Logger;
     18import org.apache.logging.log4j.LogManager;
    1819import com.framsticks.util.dispatching.RunAt;
    1920
    … …  
    2728public class SaveStream extends Stream {
    2829
    29         private final static Logger log = Logger.getLogger(SaveStream.class.getName());
     30        private final static Logger log = LogManager.getLogger(SaveStream.class.getName());
    3031
    3132        protected final SinkInterface sink;
    … …  
    5758        protected void finished() {
    5859                assert tree.isActive();
    59                 log.info("stored in " + stopwatch);
     60                log.info("stored in {}", stopwatch);
    6061                future.pass(null);
    6162        }
    … …  
    6465                assert tree.isActive();
    6566                if (!path.isResolved()) {
    66                         log.debug("path " + path + " is not resolved - skipping");
     67                        log.debug("path {} is not resolved - skipping", path);
    6768                } else {
    68                         AccessInterface access = bindAccess(path);
     69                        Access access = bindAccess(path);
    6970                        assert access != null;
    7071                        FramsClass framsClass = access.getFramsClass();

  • java/main/src/main/java/com/framsticks/gui/Browser.java

    r99 r100  
    2323import javax.swing.*;
    2424
    25 import org.apache.log4j.Logger;
     25import org.apache.logging.log4j.Logger;
     26import org.apache.logging.log4j.LogManager;
    2627
    2728import java.awt.Dimension;
    … …  
    4041public class Browser extends AbstractJoinable implements Dispatcher<Browser>, JoinableParent, ExceptionResultHandler {
    4142
    42         private static final Logger log = Logger.getLogger(Browser.class);
     43        private static final Logger log = LogManager.getLogger(Browser.class);
    4344
    4445        protected final JoinableCollection<Frame> frames = new JoinableCollection<Frame>().setObservableName("frames");
    … …  
    117118        @AutoAppendAnnotation
    118119        public void addPanelProvider(PanelProvider panelProvider) {
    119                 log.debug("added panel provider of type: " + panelProvider.getClass().getCanonicalName());
     120                log.debug("added panel provider of type: {}", panelProvider.getClass().getCanonicalName());
    120121                panelProviders.add(panelProvider);
    121122        }
    … …  
    133134        @AutoAppendAnnotation
    134135        public void addTree(Tree tree) {
    135                 log.debug("adding tree: " + tree);
     136                log.debug("adding tree: {}", tree);
    136137                tree.setDispatcher(new SwingDispatcher<Tree>());
     138                tree.setExceptionHandler(this);
    137139                trees.add(tree);
    138140        }

  • java/main/src/main/java/com/framsticks/gui/EmptyPanel.java

    r84 r100  
    11package com.framsticks.gui;
    22
    3 import com.framsticks.params.AccessInterface;
     3import com.framsticks.gui.tree.AbstractNode;
    44
    55/**
    … …  
    77 */
    88@SuppressWarnings("serial")
    9 public class EmptyPanel extends Panel {
     9public class EmptyPanel extends AbstractPanel {
    1010
    11         public EmptyPanel(Parameters parameters) {
    12                 super(parameters);
    13         }
    14 
    15         @Override
    16         public void pullValuesFromLocalToUser(AccessInterface access) {
     11        public EmptyPanel(Frame frame) {
     12                super(frame);
    1713        }
    1814
    … …  
    2117                return "Empty";
    2218        }
     19
     20        @Override
     21        public void fillPanelWith(AbstractNode node) {
     22
     23        }
    2324}

  • java/main/src/main/java/com/framsticks/gui/Frame.java

    r99 r100  
    3636import javax.swing.tree.TreeSelectionModel;
    3737
    38 import org.apache.log4j.Logger;
     38import org.apache.logging.log4j.Logger;
     39import org.apache.logging.log4j.LogManager;
    3940
    4041import com.framsticks.core.Path;
    4142import com.framsticks.core.Tree;
     43import com.framsticks.gui.tree.AbstractNode;
    4244import com.framsticks.gui.tree.MetaNode;
    4345import com.framsticks.gui.tree.TreeCellRenderer;
    … …  
    5052import com.framsticks.util.dispatching.JoinableParent;
    5153import com.framsticks.util.dispatching.JoinableState;
     54import com.framsticks.util.lang.Casting;
    5255import com.framsticks.util.swing.KeyboardModifier;
    5356import com.framsticks.util.swing.MenuConstructor;
    … …  
    5962public class Frame extends FrameJoinable implements JoinableParent {
    6063
    61         private static final Logger log = Logger.getLogger(Frame.class.getName());
     64        private static final Logger log = LogManager.getLogger(Frame.class.getName());
    6265
    6366        protected final Browser browser;
    … …  
    8992        protected JMenu windowMenu;
    9093        protected JMenu helpMenu;
     94        protected EmptyPanel emptyPanel;
    9195
    9296        protected final Map<Tree, TreeAtFrame> treeAtFrames = new IdentityHashMap<>();
    … …  
    103107                 * nor it can be removed in normal way through JSlider methods  */
    104108                UIManager.put("Slider.paintValue", false);
    105                 log.debug("creating " + this);
     109                log.debug("creating {}", this);
     110
     111                cardPanel = new JPanel();
     112                cardPanel.setName("card");
     113
     114                cardPanelLayout = new CardLayout();
     115                cardPanel.setLayout(cardPanelLayout);
     116
     117                emptyPanel = new EmptyPanel(this);
    106118
    107119                Container contentPane = getSwing().getContentPane();
    … …  
    112124                treePanel.setLayout(new BorderLayout());
    113125
    114                 rootNode = new MetaNode();
     126                rootNode = new MetaNode(this);
    115127                rootNode.setName("root");
    116128                treeModel = new TreeModel(this);
    … …  
    139151                        @Override
    140152                        public void treeExpanded(TreeExpansionEvent e) {
    141                                 // loadChildren(treeModel.convertToPath(e.getPath()), false);
     153                                treeModel.expandTreeNode(e.getPath());
    142154                        }
    143155                });
    … …  
    169181                        .join(KeyStroke.getKeyStroke('l'), KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, 0));
    170182
    171                 jtree.setCellRenderer(new TreeCellRenderer());
     183                jtree.setCellRenderer(new TreeCellRenderer(treeModel));
    172184
    173185                treeScrollPane = new JScrollPane(jtree);
    … …  
    209221                leftPanel.setForeground(Color.WHITE);
    210222
    211                 cardPanel = new JPanel();
    212                 cardPanel.setName("card");
    213223                JSplitPane split = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, leftPanel, cardPanel);
    214224                split.setPreferredSize(browser.defaultFrameDimension);
    … …  
    224234                mainPanelLayout.show(mainPanel, "browser");
    225235
    226                 cardPanelLayout = new CardLayout();
    227                 cardPanel.setLayout(cardPanelLayout);
    228236
    229237                getSwing().pack();
    230238                jtree.requestFocusInWindow();
    231239
    232                 log.debug("frame configured: " + this);
     240                log.debug("frame configured: {}", this);
    233241
    234242                new MenuConstructor(fileMenu).add(KeyStroke.getKeyStroke(KeyEvent.VK_O, ActionEvent.CTRL_MASK), new AbstractAction("Close") {
    … …  
    258266                Tree tree = path.getTree();
    259267
    260                 log.debug("trying mount: " + path);
     268                log.debug("trying mount: {}", path);
    261269                if (!tree.getAssignedRoot().isResolved()) {
    262270                        tree.get(path, new FutureHandler<Path>(this) {
    … …  
    274282                TreeAtFrame e = new TreeAtFrame(tree, this);
    275283                treeAtFrames.put(tree, e);
    276 
    277                 rootNode.getChildren().add(new TreeNode(e, Path.to(tree, "/")));
     284                Path rootPath = Path.to(tree, "/");
     285
     286                rootNode.getChildren().add(new TreeNode(e, rootPath));
    278287                e.rootNode = tree.getAssignedRoot();
    279                 treeModel.nodeStructureChanged(new TreePath(rootNode));
     288                treeModel.treeStructureChanged(new TreePath(rootNode));
    280289                // jtree.expandPath(new TreePath(rootNode));
    281290        }
    282291
    283292
    284         public void showPanel(Panel panel) {
     293        public void showPanel(AbstractPanel panel) {
    285294                assert isActive();
    286295                assert panel != null;
     296                log.debug("showing panel: {}", panel);
    287297                cardPanelLayout.show(cardPanel, panel.getUniqueName());
     298
     299                // cardPanel.revalidate();
    288300        }
    289301
    … …  
    297309
    298310                Path path = treeModel.convertToPath(treePath);
     311                if (path == null) {
     312                        return;
     313                }
    299314                treePopupMenu.removeAll();
    300315
    … …  
    311326        }
    312327
    313         public void updatePanelIfIsLeadSelection(TreePath treePath, Path path) {
     328        public void updatePanelIfIsLeadSelection(Path path) {
    314329                assert isActive();
     330                TreePath treePath = treeModel.convertToTreePath(path, true);
     331                if (treePath == null) {
     332                        return;
     333                }
    315334                if (treePath.equals(jtree.getSelectionPath())) {
    316                         treeAtFrames.get(path.getTree()).useOrCreatePanel(treePath);
    317                 }
     335                        log.debug("updating: {} -> {}", treePath, path);
     336                        showPanelForTreePath(treePath);
     337                }
     338        }
     339
     340        public void showPanelForTreePath(TreePath treePath) {
     341                assert isActive();
     342                AbstractNode node = Casting.assertCast(AbstractNode.class, treePath.getLastPathComponent());
     343
     344                AbstractPanel panel = node.getPanel();
     345                if (panel == null) {
     346                        log.error("no panel for {} found", treePath);
     347                        return;
     348                }
     349                panel.fillPanelWith(node);
     350                showPanel(panel);
     351                // cardPanel.revalidate();
    318352        }
    319353
    … …  
    323357        //      assert isActive();
    324358        //      final TreePath treePath = treeModel.convertToTreePath(path);
    325         //      log.info("go to path: " + path + "(" + treePath + ")");
    326359
    327360        //      this.dispatch(new RunAt<Frame>(this) {
    … …  
    394427
    395428        /**
     429         * @return the emptyPanel
     430         */
     431        public EmptyPanel getEmptyPanel() {
     432                return emptyPanel;
     433        }
     434
     435        /**
    396436         * @return the treeAtFrames
    397437         */

  • java/main/src/main/java/com/framsticks/gui/FrameJoinable.java

    r97 r100  
    1010import javax.swing.UIManager;
    1111
    12 import org.apache.log4j.Logger;
     12import org.apache.logging.log4j.Logger;
     13import org.apache.logging.log4j.LogManager;
    1314
    1415import com.framsticks.util.FramsticksException;
    … …  
    1920public abstract class FrameJoinable extends SwingJoinable<JFrame> implements ExceptionResultHandler {
    2021        private static final Logger log =
    21                 Logger.getLogger(FrameJoinable.class);
     22                LogManager.getLogger(FrameJoinable.class);
    2223
    2324        protected String title;
    … …  
    6566                                                boolean found = false;
    6667                                                // for (LookAndFeelInfo info : UIManager.getInstalledLookAndFeels()) {
    67                                                 //      log.info("look and feel available: " + info.getName());
     68                                                //      log.info("look and feel available: {}", info.getName());
    6869                                                //      if ("Nimbus".equals(info.getName())) {
    6970                                                //              UIManager.setLookAndFeel(info.getClassName());
    … …  
    109110        protected void joinableFinish() {
    110111                super.joinableFinish();
    111                 log.debug("disposing frame " + this);
     112                log.debug("disposing frame {}", this);
    112113                getSwing().dispose();
    113114        }

  • java/main/src/main/java/com/framsticks/gui/Gui.java

    r99 r100  
    1010import javax.swing.JPanel;
    1111
    12 import org.apache.log4j.Logger;
     12import org.apache.logging.log4j.Logger;
     13import org.apache.logging.log4j.LogManager;
    1314
    1415import com.framsticks.gui.controls.CheckBoxControl;
    … …  
    3940public final class Gui {
    4041
    41         private static final Logger log = Logger.getLogger(Gui.class.getName());
     42        private static final Logger log = LogManager.getLogger(Gui.class.getName());
    4243
    4344        private Gui() {
    … …  
    117118                        control.setOwner(owner);
    118119
    119                         log.debug("add component for " + param);
     120                        log.debug("add component for {}", param);
    120121                        JPanel line = new JPanel();
    121122                        line.setLayout(new BoxLayout(line, BoxLayout.LINE_AXIS));

  • java/main/src/main/java/com/framsticks/gui/ImageProvider.java

    r98 r100  
    44package com.framsticks.gui;
    55
    6 import org.apache.log4j.Logger;
     6import org.apache.logging.log4j.Logger;
     7import org.apache.logging.log4j.LogManager;
    78
    89import javax.swing.*;
    … …  
    1617public class ImageProvider {
    1718
    18         private final static Logger log = Logger.getLogger(ImageProvider.class.getName());
     19        private final static Logger log = LogManager.getLogger(ImageProvider.class.getName());
    1920
    2021
    … …  
    8788                        return icon;
    8889                } catch (Exception ignored) {
    89                         log.error("failed to read icon: " + resourceName);
     90                        log.error("failed to read icon: {}", resourceName);
    9091                }
    9192                return null;

  • java/main/src/main/java/com/framsticks/gui/MainFrame.java

    r97 r100  
    1111import javax.swing.WindowConstants;
    1212
    13 import org.apache.log4j.Logger;
     13import org.apache.logging.log4j.Logger;
     14import org.apache.logging.log4j.LogManager;
    1415
    1516import com.framsticks.util.swing.MenuConstructor;
    … …  
    2122public class MainFrame extends Frame {
    2223
    23         private final static Logger log = Logger.getLogger(MainFrame.class.getName());
     24        private final static Logger log = LogManager.getLogger(MainFrame.class.getName());
    2425
    2526        JButton start, stop, step;
    … …  
    127128        //      //                      public void call(Exception e) {
    128129        //      //                              if (e != null) {
    129         //      //                                      log.error("failed to resolve: " + s);
     130        //      //                                      log.error("failed to resolve: {}", s);
    130131        //      //                                      return;
    131132        //      //                              }
    132         //      //                              log.info("succeeded to resolve: " + s);
     133        //      //                              log.info("succeeded to resolve: {}", s);
    133134        //      //                      }
    134135        //      //              });

  • java/main/src/main/java/com/framsticks/gui/ModifiablePanel.java

    r99 r100  
    11package com.framsticks.gui;
    22
    3 import org.apache.log4j.Logger;
     3import org.apache.logging.log4j.Logger;
     4import org.apache.logging.log4j.LogManager;
    45
    56
    … …  
    1314 */
    1415@SuppressWarnings("serial")
    15 public abstract class ModifiablePanel extends Panel {
     16public abstract class ModifiablePanel extends TreePanel {
    1617
    17         private static final Logger log = Logger.getLogger(ModifiablePanel.class.getName());
     18        private static final Logger log = LogManager.getLogger(ModifiablePanel.class.getName());
    1819
    1920        /**
    … …  
    2728        protected Component contentComponent;
    2829
    29         public ModifiablePanel(Panel.Parameters parameters) {
     30        public ModifiablePanel(TreePanel.Parameters parameters) {
    3031                super(parameters);
    31                 log.debug("create panel for type: " + className);
     32                log.debug("create panel for type: {}", className);
    3233
    3334

  • java/main/src/main/java/com/framsticks/gui/MultiPanel.java

    r98 r100  
    11package com.framsticks.gui;
    22
    3 import com.framsticks.params.AccessInterface;
     3import com.framsticks.core.Path;
     4import com.framsticks.params.Access;
    45
    56import javax.swing.*;
    6 import javax.swing.tree.TreePath;
    77
    88import java.awt.*;
    … …  
    1313 */
    1414@SuppressWarnings("serial")
    15 public class MultiPanel extends Panel {
     15public class MultiPanel extends TreePanel {
    1616
    17         protected final List<Panel> panels;
     17        protected final List<TreePanel> panels;
    1818        protected final JTabbedPane tabbedPane;
    1919
    2020
    21         public MultiPanel(Panel.Parameters parameters, List<Panel> panels) {
     21        public MultiPanel(TreePanel.Parameters parameters, List<TreePanel> panels) {
    2222                super(parameters);
    2323                this.panels = panels;
    2424                tabbedPane = new JTabbedPane();
    2525
    26                 for (Panel p : panels) {
     26                for (TreePanel p : panels) {
    2727                        assert p.getClassName().equals(getClassName());
    2828                        assert p.getTreeAtFrame() == getTreeAtFrame();
    … …  
    3636
    3737        @Override
    38         public void pullValuesFromLocalToUser(AccessInterface access) {
    39                 for (Panel p : panels) {
     38        public void pullValuesFromLocalToUser(Access access) {
     39                for (TreePanel p : panels) {
    4040                        p.pullValuesFromLocalToUser(access);
    4141                }
    … …  
    4848
    4949        @Override
    50         public void setCurrentTreePath(TreePath currentTreePath) {
    51                 super.setCurrentTreePath(currentTreePath);
    52                 for (Panel p : panels) {
    53                         p.setCurrentTreePath(currentTreePath);
     50        public void setCurrentPath(Path currentPath) {
     51                super.setCurrentPath(currentPath);
     52                for (TreePanel p : panels) {
     53                        p.setCurrentPath(currentPath);
    5454                }
    5555        }

  • java/main/src/main/java/com/framsticks/gui/NodeAtFrame.java

    r98 r100  
    88public class NodeAtFrame {
    99
    10         protected Panel panel;
    11 
    1210        protected final Map<ValueControl, Object> localChanges = new IdentityHashMap<>();
    1311
     12        /**
     13         *
     14         */
     15        public NodeAtFrame() {
     16        }
     17
    1418}

  • java/main/src/main/java/com/framsticks/gui/ObjectPanel.java

    r99 r100  
    11package com.framsticks.gui;
    22
     3import com.framsticks.core.Path;
    34import com.framsticks.gui.controls.Control;
    45import com.framsticks.gui.controls.ControlOwner;
    56import com.framsticks.gui.controls.ValueControl;
    67import com.framsticks.gui.controls.ValueControlListener;
    7 import com.framsticks.params.AccessInterface;
     8import com.framsticks.params.Access;
    89import com.framsticks.params.Param;
    910import com.framsticks.params.ValueParam;
    1011
    11 import org.apache.log4j.Logger;
     12import org.apache.logging.log4j.Logger;
     13import org.apache.logging.log4j.LogManager;
    1214
    1315import javax.swing.*;
    14 import javax.swing.tree.TreePath;
    1516
    1617import java.util.Collection;
    … …  
    2425public class ObjectPanel extends ModifiablePanel implements ControlOwner {
    2526
    26         private static final Logger log = Logger.getLogger(ObjectPanel.class);
     27        private static final Logger log = LogManager.getLogger(ObjectPanel.class);
    2728
    2829        final protected Map<Param, Control> components = new IdentityHashMap<Param, Control>();
    … …  
    3233        protected final JScrollPane scrollPane;
    3334
    34         public ObjectPanel(Panel.Parameters parameters, Collection<Param> params) {
     35        public ObjectPanel(TreePanel.Parameters parameters, Collection<Param> params) {
    3536                super(parameters);
    3637
    … …  
    4950                                @Override
    5051                                public boolean onChange(Object newValue) {
    51                                         if (currentTreePath == null) {
     52                                        if (currentPath == null) {
    5253                                                return true;
    5354                                        }
    54                                         boolean result = treeAtFrame.changeValue(currentTreePath, c, newValue);
     55                                        boolean result = treeAtFrame.changeValue(currentPath.assureResolved().getTopObject(), c, newValue);
    5556                                        refreshControlButtons();
    5657                                        return result;
    … …  
    6667        protected void applyChanges() {
    6768                assert frame.isActive();
    68                 assert currentTreePath != null;
    69                 treeAtFrame.pushLocalChanges(currentTreePath);
     69                assert currentPath != null;
     70                treeAtFrame.pushLocalChanges(currentPath);
    7071        }
    7172
    7273        protected void refreshControlButtons() {
    7374                assert frame.isActive();
    74                 applyButton.setEnabled(treeAtFrame.hasLocalChanges(currentTreePath));
    75         }
    76 
    77         protected static void fillControlsWithValues(Map<ValueControl, Object> map) {
     75                applyButton.setEnabled(treeAtFrame.hasLocalChanges(currentPath.getTopObject()));
    7876        }
    7977
    8078        @Override
    81         public void pullValuesFromLocalToUser(AccessInterface access) {
    82                 assert currentTreePath != null;
     79        public void pullValuesFromLocalToUser(Access access) {
     80                assert currentPath != null;
    8381                log.debug("refreshing components");
    8482
    … …  
    8987
    9088
    91                 NodeAtFrame nodeAtFrame = treeAtFrame.getLocalInfo(currentTreePath);
     89                NodeAtFrame nodeAtFrame = treeAtFrame.getLocalInfo(currentPath.getTopObject());
    9290                if (nodeAtFrame != null) {
    9391                        for (Map.Entry<ValueControl, Object> e : nodeAtFrame.localChanges.entrySet()) {
    … …  
    120118
    121119        @Override
    122         public TreePath getCurrentTreePath() {
    123                 return super.getCurrentTreePath();
     120        public Path getCurrentPath() {
     121                return super.getCurrentPath();
    124122        }
    125123
    126 
    127124}

  • java/main/src/main/java/com/framsticks/gui/PanelProvider.java

    r84 r100  
    66 */
    77public interface PanelProvider {
    8         public Panel providePanel(Panel.Parameters parameters);
     8        public TreePanel providePanel(TreePanel.Parameters parameters);
    99}

  • java/main/src/main/java/com/framsticks/gui/StandardPanelProvider.java

    r88 r100  
    1717        @SuppressWarnings("unchecked")
    1818        @Override
    19         public Panel providePanel(Panel.Parameters parameters) {
     19        public TreePanel providePanel(TreePanel.Parameters parameters) {
    2020                if (parameters.param instanceof ObjectParam) {
    2121                        return new ObjectPanel(parameters, CollectionUtils.select(parameters.framsClass.getParamEntries(), new NotPredicate(new InstanceofPredicate(CompositeParam.class))));

  • java/main/src/main/java/com/framsticks/gui/StatusBar.java

    r98 r100  
    99import javax.swing.JTextField;
    1010
    11 import org.apache.log4j.Logger;
     11import org.apache.logging.log4j.Logger;
     12import org.apache.logging.log4j.LogManager;
    1213
    1314import com.framsticks.gui.controls.Control;
    … …  
    1819
    1920public class StatusBar implements ExceptionResultHandler, Dispatcher<StatusBar> {
    20         private static final Logger log = Logger.getLogger(StatusBar.class);
     21        private static final Logger log = LogManager.getLogger(StatusBar.class);
    2122
    2223        protected JTextField statusBar;
    … …  
    3637                        @Override
    3738                        protected void runAt() {
    38                                 log.error("error: ", exception);
     39                                log.error("error: {}", exception.getMessage());
    3940                                statusBar.setText(exception.getShortMessage(new StringBuilder()).toString());
    4041                                if (exceptionHandler != null) {

  • java/main/src/main/java/com/framsticks/gui/TreeAtFrame.java

    r99 r100  
    11package com.framsticks.gui;
    22
    3 import org.apache.log4j.Logger;
     3import org.apache.logging.log4j.Logger;
     4import org.apache.logging.log4j.LogManager;
    45
    56import com.framsticks.core.Tree;
    … …  
    89import com.framsticks.core.TreeOperations;
    910import com.framsticks.gui.controls.ValueControl;
    10 import com.framsticks.gui.tree.TreeNode;
    1111import com.framsticks.params.CompositeParam;
    1212import com.framsticks.params.FramsClass;
    … …  
    1414import java.util.*;
    1515
    16 import javax.swing.tree.TreePath;
    1716
    1817
    1918import com.framsticks.util.dispatching.FutureHandler;
    20 import com.framsticks.util.lang.Casting;
    2119
    2220/**
    … …  
    2523public class TreeAtFrame {
    2624
    27         private static final Logger log = Logger.getLogger(TreeAtFrame.class);
     25        private static final Logger log = LogManager.getLogger(TreeAtFrame.class);
    2826
    2927        protected final Frame frame;
    3028        protected final Tree tree;
    31         protected final Map<String, Panel> knownPanels = new HashMap<String, Panel>();
     29        protected final Map<String, TreePanel> knownPanels = new HashMap<>();
    3230        protected Node rootNode;
    33 
    34         protected Map<TreeNode, NodeAtFrame> nodesStorage = new WeakHashMap<>();
    3531
    3632        public TreeAtFrame(Tree tree, Frame frame) {
    … …  
    5046        }
    5147
    52         public void registerPanel(Panel panel) {
    53         }
    54 
    55         public Panel findPanel(String accessId) {
    56                 assert frame.isActive();
    57                 return (knownPanels.containsKey(accessId) ? knownPanels.get(accessId) : null);
    58         }
    59 
    6048        public final String getName() {
    6149                return tree.getName();
    6250        }
    6351
    64         public Panel preparePanel(CompositeParam param, FramsClass framsClass) {
     52        public TreePanel preparePanel(final CompositeParam param) {
    6553                assert frame.isActive();
    66                 Panel panel = preparePanelImpl(param, framsClass);
    67                 assert panel != null;
    68                 String accessId = param.computeAccessId();
    69                 panel.uniqueName = accessId + "@" + tree.getName();
    70                 knownPanels.put(accessId, panel);
    71                 frame.cardPanel.add(panel, panel.uniqueName);
    72                 log.debug("prepared panel for " + panel);
    73                 return panel;
    74         }
    7554
    76         protected Panel preparePanelImpl(CompositeParam param, FramsClass framsClass) {
    77                 assert frame.isActive();
    78                 List<Panel> panels = new ArrayList<Panel>();
     55                TreePanel panel = knownPanels.get(param.getFramsTypeName());
     56                if (panel != null) {
     57                        return panel;
     58                }
    7959
    80                 Panel.Parameters parameters = new Panel.Parameters(this, param, framsClass);
     60                final FramsClass framsClass = tree.getInfoFromCache(param.getContainedTypeName());
     61                final List<TreePanel> panels = new ArrayList<TreePanel>();
     62
     63                final TreePanel.Parameters parameters = new TreePanel.Parameters(this, param, framsClass);
    8164                for (PanelProvider pp : frame.browser.panelProviders) {
    82                         Panel p = pp.providePanel(parameters);
     65                        TreePanel p = pp.providePanel(parameters);
    8366                        if (p != null) {
    8467                                panels.add(p);
    … …  
    8770
    8871                if (panels.isEmpty()) {
    89                         return new EmptyPanel(parameters);
     72                        panel = new EmptyTreePanel(parameters);
     73                } else  if (panels.size() == 1) {
     74                        panel = panels.get(0);
     75                } else {
     76                        panel = new MultiPanel(parameters, panels);
    9077                }
    91                 if (panels.size() == 1) {
    92                         return panels.get(0);
    93                 }
    94                 return new MultiPanel(parameters, panels);
    9578
     79                knownPanels.put(param.getFramsTypeName(), panel);
     80
     81                log.debug("prepared panel for {}", panel);
     82                return panel;
    9683        }
    9784
    98         public boolean hasLocalChanges(TreePath treePath) {
    99                 NodeAtFrame nodeAtFrame = nodesStorage.get(treePath.getLastPathComponent());
     85
     86        public boolean hasLocalChanges(Object object) {
     87                NodeAtFrame nodeAtFrame = tree.getSideNote(object, this, NodeAtFrame.class);
    10088                if (nodeAtFrame == null) {
    10189                        return false;
    … …  
    10492        }
    10593
    106         public NodeAtFrame assureLocalInfo(TreePath treePath) {
     94        public NodeAtFrame assureLocalInfo(Object object) {
    10795                assert frame.isActive();
    108                 NodeAtFrame nodeAtFrame = nodesStorage.get(treePath.getLastPathComponent());
     96                NodeAtFrame nodeAtFrame = tree.getSideNote(object, this, NodeAtFrame.class);
    10997
    11098                if (nodeAtFrame == null) {
    11199                        nodeAtFrame = new NodeAtFrame();
    112                         nodesStorage.put(Casting.throwCast(TreeNode.class, treePath.getLastPathComponent()), nodeAtFrame);
     100                        // log.debug();
     101                        tree.putSideNote(object, this, nodeAtFrame);
    113102                }
    114103                return nodeAtFrame;
    115104        }
    116105
    117         public NodeAtFrame getLocalInfo(TreePath treePath) {
    118                 return nodesStorage.get(treePath.getLastPathComponent());
     106        public NodeAtFrame getLocalInfo(Object object) {
     107                return tree.getSideNote(object, this, NodeAtFrame.class);
    119108        }
    120109
    121         public boolean changeValue(TreePath treePath, ValueControl component, Object newValue) {
    122                 log.debug("changing value of " + component + " to '" + newValue + "'");
     110        public boolean changeValue(Object object, ValueControl component, Object newValue) {
     111                log.debug("changing value of {} to '{}'", component, newValue);
    123112
    124                 assureLocalInfo(treePath).localChanges.put(component, newValue);
     113                assureLocalInfo(object).localChanges.put(component, newValue);
    125114
    126115                return true;
    127116        }
    128117
    129         public void pushLocalChanges(TreePath treePath) {
     118        public void pushLocalChanges(Path path) {
    130119                assert frame.isActive();
     120                path.assureResolved();
    131121
    132                 NodeAtFrame nodeAtFrame = nodesStorage.get(treePath.getLastPathComponent());
     122                NodeAtFrame nodeAtFrame = getLocalInfo(path.getTopObject());
    133123                if (nodeAtFrame == null) {
    134124                        return;
    135125                }
    136                 Path path = frame.treeModel.convertToPath(treePath);
    137 
    138126                for (Map.Entry<ValueControl, Object> e : nodeAtFrame.localChanges.entrySet()) {
    139127                        TreeOperations.set(path, e.getKey().getParam(), e.getValue(), new FutureHandler<Integer>(frame) {
    … …  
    145133        }
    146134
    147         public void fillPanelWithValues(TreePath treePath) {
    148                 NodeAtFrame nodeAtFrame = assureLocalInfo(treePath);
    149                 if (nodeAtFrame == null) {
    150                         return;
    151                 }
    152 
    153                 if (nodeAtFrame.panel == null) {
    154                         return;
    155                 }
    156                 Node node = TreeNode.tryGetNode(treePath);
    157                 if (node == null) {
    158                         return;
    159                 }
    160                 nodeAtFrame.panel.setCurrentTreePath(treePath);
    161                 nodeAtFrame.panel.pullValuesFromLocalToUser(TreeOperations.bindAccess(node));
    162 
    163                 frame.showPanel(nodeAtFrame.panel);
    164 
    165         }
    166 
    167         public void useOrCreatePanel(TreePath treePath) {
    168                 // node.assureResolved();
    169                 Node node = TreeNode.tryGetNode(treePath);
    170 
    171                 NodeAtFrame nodeAtFrame = assureLocalInfo(treePath);
    172 
    173                 if (nodeAtFrame.panel == null) {
    174                         CompositeParam param = node.getParam();
    175                         nodeAtFrame.panel = findPanel(param.computeAccessId());
    176                         if (nodeAtFrame.panel == null) {
    177                                 FramsClass framsClass = node.getTree().getInfoFromCache(param.getContainedTypeName());
    178                                 nodeAtFrame.panel = preparePanel(param, framsClass);
    179                         }
    180                 }
    181                 fillPanelWithValues(treePath);
    182         }
    183135}

  • java/main/src/main/java/com/framsticks/gui/console/Console.java

    r97 r100  
    99import javax.swing.JTextPane;
    1010
    11 import org.apache.log4j.Logger;
     11import org.apache.logging.log4j.Logger;
     12import org.apache.logging.log4j.LogManager;
    1213
    1314import com.framsticks.communication.Connection;
    … …  
    2425@FramsClassAnnotation
    2526public abstract class Console extends FrameJoinable implements JoinableParent {
    26         private static final Logger log = Logger.getLogger(Console.class);
     27        private static final Logger log = LogManager.getLogger(Console.class);
    2728
    2829        /**

  • java/main/src/main/java/com/framsticks/gui/console/ConsolePainter.java

    r97 r100  
    33import com.framsticks.communication.File;
    44import com.framsticks.util.FramsticksException;
    5 // import org.apache.log4j.Logger;
     5// import org.apache.logging.log4j.Logger;
    66
    77// import java.awt.Color;
    … …  
    1616 */
    1717public class ConsolePainter {
    18         // private static final Logger log = Logger.getLogger(ConsolePainter.class.getName());
     18        // private static final Logger log = LogManager.getLogger(ConsolePainter.class.getName());
    1919
    2020        private final Document doc;

  • java/main/src/main/java/com/framsticks/gui/controls/CheckBoxControl.java

    r98 r100  
    77import javax.swing.JCheckBox;
    88
    9 import org.apache.log4j.Logger;
     9import org.apache.logging.log4j.Logger;
     10import org.apache.logging.log4j.LogManager;
    1011
    1112import com.framsticks.params.types.BooleanParam;
    … …  
    1415public class CheckBoxControl extends ValueControl {
    1516
    16         private static final Logger log = Logger.getLogger(CheckBoxControl.class.getName());
     17        private static final Logger log = LogManager.getLogger(CheckBoxControl.class.getName());
    1718
    1819        protected final JCheckBox checkBox;
    … …  
    2526                        @Override
    2627                        public void actionPerformed(ActionEvent actionEvent) {
    27                                 log.debug("change to: " + checkBox.isSelected());
     28                                log.debug("change to: {}", checkBox.isSelected());
    2829                                notifyOfChange();
    2930                        }

  • java/main/src/main/java/com/framsticks/gui/controls/Control.java

    r99 r100  
    1919        public static final int LINE_HEIGHT = 36;
    2020
    21         // private static final Logger log = Logger.getLogger(Control.class.getName());
     21        // private static final Logger log = LogManager.getLogger(Control.class.getName());
    2222
    2323        protected final Param param;

  • java/main/src/main/java/com/framsticks/gui/controls/ControlOwner.java

    r99 r100  
    22
    33import javax.swing.JPanel;
    4 import javax.swing.tree.TreePath;
    54
     5import com.framsticks.core.Path;
    66import com.framsticks.gui.Frame;
    77import com.framsticks.util.dispatching.ExceptionResultHandler;
    … …  
    1010
    1111        public JPanel getPanelForControls();
    12         public TreePath getCurrentTreePath();
     12        public Path getCurrentPath();
    1313        public Frame getFrame();
    1414

  • java/main/src/main/java/com/framsticks/gui/controls/EnumControl.java

    r98 r100  
    33import com.framsticks.params.types.EnumParam;
    44import com.framsticks.util.lang.Numbers;
    5 import org.apache.log4j.Logger;
     5import org.apache.logging.log4j.Logger;
     6import org.apache.logging.log4j.LogManager;
    67
    78import javax.swing.*;
    … …  
    1617        protected final JComboBox<String> list;
    1718
    18         private static final Logger log = Logger.getLogger(EnumControl.class.getName());
     19        private static final Logger log = LogManager.getLogger(EnumControl.class.getName());
    1920
    2021        public EnumControl(EnumParam enumParam) {

  • java/main/src/main/java/com/framsticks/gui/controls/EventControl.java

    r98 r100  
    1414@SuppressWarnings("serial")
    1515public class EventControl extends Control {
    16         // private static final Logger log = Logger.getLogger(EventControl.class.getName());
     16        // private static final Logger log = LogManager.getLogger(EventControl.class.getName());
    1717
    1818        protected final JButton button;

  • java/main/src/main/java/com/framsticks/gui/controls/ProcedureControl.java

    r99 r100  
    11package com.framsticks.gui.controls;
    22
    3 import com.framsticks.core.Tree;
    43import com.framsticks.core.Path;
    54import com.framsticks.gui.Frame;
    … …  
    109import com.framsticks.util.dispatching.ExceptionResultHandler;
    1110import com.framsticks.util.dispatching.FutureHandler;
    12 import com.framsticks.util.dispatching.RunAt;
    1311import com.framsticks.util.dispatching.ThrowExceptionHandler;
     12import com.framsticks.util.swing.TooltipConstructor;
    1413
    1514import javax.swing.*;
    1615import javax.swing.border.BevelBorder;
    17 import javax.swing.tree.TreePath;
    1816
    19 import org.apache.log4j.Logger;
     17import org.apache.logging.log4j.Logger;
     18import org.apache.logging.log4j.LogManager;
    2019
    2120import java.awt.event.ActionEvent;
    … …  
    2928public class ProcedureControl extends Control implements ControlOwner {
    3029
    31         private static final Logger log = Logger.getLogger(ProcedureControl.class);
     30        private static final Logger log = LogManager.getLogger(ProcedureControl.class);
    3231
    3332        protected final JButton procedureButton;
    … …  
    3736        public ProcedureControl(ProcedureParam procedureParam) {
    3837                super(procedureParam);
     38
     39                this.setToolTipText(new TooltipConstructor()
     40                        .append("name", procedureParam.getName())
     41                        .append("id", procedureParam.getId())
     42                        .append("help", procedureParam.getHelp())
     43                        .build());
    3944
    4045                procedureButton = new JButton("Call");
    … …  
    5661                        public void actionPerformed(ActionEvent e) {
    5762
    58                                 final Path path = getFrame().getTreeModel().convertToPath(getCurrentTreePath());
     63                                final Path path = getCurrentPath();
    5964
    6065                                final List<Object> arguments = new LinkedList<Object>();
    … …  
    6267                                        Object value = components.get(arg).getCurrentValue();
    6368                                        arguments.add(value);
    64                                         log.debug("argument " + arg + ": " + value);
     69                                        log.debug("argument {}: {}", arg, value);
    6570                                }
    6671                                //TODO FEH: make it show dialog
    67                                 final ExceptionResultHandler handler = ThrowExceptionHandler.getInstance();
     72                                callProcedure(path, getParam(), arguments.toArray());
    6873
    69                                 path.getTree().dispatch(new RunAt<Tree>(handler) {
    70                                         @Override
    71                                         protected void runAt() {
    72                                                 path.getTree().call(path, getParam(), arguments.toArray(), new FutureHandler<Object>(handler) {
    73 
    74                                                         @Override
    75                                                         public void result(Object result) {
    76 
    77                                                         }
    78                                                 });
    79                                         }
    80                                 });
    8174                        }
    8275                });
    8376                this.add(procedureButton);
    8477
     78        }
     79
     80        public static void callProcedure(final Path path, final ProcedureParam param, Object[] arguments) {
     81                final ExceptionResultHandler handler = ThrowExceptionHandler.getInstance();
     82
     83                assert path.getTree().isActive();
     84
     85                path.getTree().call(path, param, arguments, new FutureHandler<Object>(handler) {
     86
     87                        @Override
     88                        public void result(Object result) {
     89
     90                        }
     91                });
    8592        }
    8693
    … …  
    109116
    110117        @Override
    111         public TreePath getCurrentTreePath() {
    112                 return owner.getCurrentTreePath();
     118        public Path getCurrentPath() {
     119                return owner.getCurrentPath();
    113120        }
    114121

  • java/main/src/main/java/com/framsticks/gui/controls/SliderControl.java

    r98 r100  
    1515import javax.swing.event.ChangeListener;
    1616
    17 import org.apache.log4j.Logger;
     17import org.apache.logging.log4j.Logger;
     18import org.apache.logging.log4j.LogManager;
    1819
    1920import com.framsticks.params.types.DecimalParam;
    … …  
    2627public class SliderControl extends TextControl {
    2728
    28         private static final Logger log = Logger.getLogger(SliderControl.class.getName());
     29        private static final Logger log = LogManager.getLogger(SliderControl.class.getName());
    2930
    3031        protected final JSlider slider;
    … …  
    115116                                        return;
    116117                                }
    117                                 log.trace("changing " + getParam() + " with slider: " + slider.getValue());
     118                                log.trace("changing {} with slider: {}", getParam(), slider.getValue());
    118119                                changing = slider;
    119120                                text.setText(convertFromSliderDomain(slider.getValue()).toString());
    … …  
    128129                                        return;
    129130                                }
    130                                 log.trace("changing " + getParam() + " with text: " + text.getText());
     131                                log.trace("changing {} with text: {}", getParam(), text.getText());
    131132                                changing = text;
    132133                                Integer i = convertToSliderDomain(convertTextToNumber());

  • java/main/src/main/java/com/framsticks/gui/controls/TextAreaControl.java

    r98 r100  
    2323                this.setLayout(new BorderLayout());
    2424                this.add(textScrollPane, BorderLayout.CENTER);
    25                 this.setMaximumSize(new Dimension(Integer.MAX_VALUE, LINE_HEIGHT * 3));
    26                 textArea.setMaximumSize(new Dimension(Integer.MAX_VALUE, LINE_HEIGHT * 3));
     25                int maxSize = LINE_HEIGHT * 10;
     26                this.setMaximumSize(new Dimension(Integer.MAX_VALUE, maxSize));
     27                textArea.setMaximumSize(new Dimension(Integer.MAX_VALUE, maxSize));
    2728
    2829                this.revalidate();

  • java/main/src/main/java/com/framsticks/gui/controls/ValueControl.java

    r99 r100  
    11package com.framsticks.gui.controls;
    22
    3 import org.apache.log4j.Logger;
     3import org.apache.logging.log4j.Logger;
     4import org.apache.logging.log4j.LogManager;
    45
    56import com.framsticks.params.CastFailure;
    … …  
    1819public abstract class ValueControl extends Control {
    1920        private static final Logger log =
    20                 Logger.getLogger(ValueControl.class);
     21                LogManager.getLogger(ValueControl.class);
    2122
    2223        /**
    … …  
    7273                        ReassignResult<?> res = getParam().reassign(candidate, oldValue);
    7374                        if (res.getFlags() != 0) {
    74                                 log.warn("filter of param " + param + " failed: " + FlagsUtil.write(SetStateFlags.class, res.getFlags(), "0"));
     75                                log.warn("filter of param {} failed: {}", param, FlagsUtil.write(SetStateFlags.class, res.getFlags(), "0"));
    7576                        }
    7677                        return res.getValue();

  • java/main/src/main/java/com/framsticks/gui/table/ListPanel.java

    r99 r100  
    33
    44import com.framsticks.gui.ModifiablePanel;
    5 import com.framsticks.params.AccessInterface;
     5import com.framsticks.params.Access;
    66import com.framsticks.params.ListAccess;
    7 import com.framsticks.params.PrimitiveParam;
     7import com.framsticks.params.Param;
     8import com.framsticks.util.FramsticksException;
    89import com.framsticks.util.lang.Casting;
    9 import com.framsticks.util.lang.Containers;
    1010
    11 import org.apache.log4j.Logger;
     11import org.apache.logging.log4j.Logger;
     12import org.apache.logging.log4j.LogManager;
    1213
    1314import javax.swing.*;
    … …  
    1920public class ListPanel extends ModifiablePanel {
    2021
    21         private static final Logger log = Logger.getLogger(ListPanel.class.getName());
     22        private static final Logger log = LogManager.getLogger(ListPanel.class.getName());
    2223
    2324        protected final TableModel tableModel;
    … …  
    2930
    3031                final ColumnsConfig config = provider.getColumnsConfigs().get(framsClass.getName());
    31                 log.debug("creating ListPanel for " + parameters.framsClass + " using config " + config);
     32                log.debug("creating ListPanel for {} using config {}", parameters.framsClass, config);
    3233
    33                 tableModel = new TableModel();
     34                tableModel = new TableModel(this);
    3435                if (config != null) {
    3536                        for (String id : config.getColumnsNames()) {
    36                                 tableModel.addColumn(framsClass.getParamEntry(id, PrimitiveParam.class));
     37                                Param param = framsClass.getParam(id);
     38                                if (param == null) {
     39                                        throw new FramsticksException().msg("requested param not found in frams class").arg("param", id).arg("frams class", framsClass);
     40                                }
     41                                if (!tableModel.addColumnIfSupported(param)) {
     42                                        throw new FramsticksException().msg("param is not supported in table view").arg("param", param).arg("frams class", framsClass);
     43                                }
    3744                        }
    3845                } else {
    39                         for (PrimitiveParam<?> param : Containers.filterInstanceof(framsClass.getParamEntries(), PrimitiveParam.class)) {
     46                        for (Param param : framsClass.getParamEntries()) {
    4047                                if (provider.getMaximumColumnNumber() != null && tableModel.getColumnCount() >= provider.getMaximumColumnNumber()) {
    4148                                        break;
    4249                                }
    43                                 tableModel.addColumn(param);
     50                                tableModel.addColumnIfSupported(param);
    4451                        }
    4552                }
    4653
    4754                table = new JTable(tableModel);
     55                tableModel.setupTable();
     56
    4857                scrollPane = new JScrollPane(table);
    4958                setupContentComponent(scrollPane);
    … …  
    6372
    6473        @Override
    65         public void pullValuesFromLocalToUser(AccessInterface access) {
     74        public void pullValuesFromLocalToUser(Access access) {
    6675                tableModel.attachSource(Casting.throwCast(ListAccess.class, access));
    6776        }
    … …  
    7180                return "List";
    7281        }
     82
     83        /**
     84         * @return the table
     85         */
     86        public JTable getTable() {
     87                return table;
     88        }
    7389}

  • java/main/src/main/java/com/framsticks/gui/table/ListPanelProvider.java

    r99 r100  
    55import java.util.Map;
    66
    7 import com.framsticks.gui.Panel;
    87import com.framsticks.gui.PanelProvider;
     8import com.framsticks.gui.TreePanel;
    99import com.framsticks.params.annotations.AutoAppendAnnotation;
    1010import com.framsticks.params.annotations.FramsClassAnnotation;
    … …  
    2222
    2323        @Override
    24         public Panel providePanel(Panel.Parameters parameters) {
     24        public TreePanel providePanel(TreePanel.Parameters parameters) {
    2525                if (parameters.param instanceof ListParam) {
    2626                        return new ListPanel(parameters, this);

  • java/main/src/main/java/com/framsticks/gui/table/TableModel.java

    r99 r100  
    66import java.util.List;
    77
     8import javax.swing.JCheckBox;
     9import javax.swing.JComponent;
     10import javax.swing.JTable;
     11import javax.swing.UIManager;
    812import javax.swing.event.TableModelEvent;
    913import javax.swing.event.TableModelListener;
    1014
    11 import org.apache.log4j.Logger;
     15import org.apache.logging.log4j.Logger;
     16import org.apache.logging.log4j.LogManager;
    1217
    13 import com.framsticks.params.AccessInterface;
     18import com.framsticks.params.Access;
    1419import com.framsticks.params.ListAccess;
     20import com.framsticks.params.Param;
    1521import com.framsticks.params.PrimitiveParam;
    16 import com.framsticks.util.UnsupportedOperationException;
     22import com.framsticks.params.types.ProcedureParam;
    1723import com.framsticks.util.lang.Casting;
    1824
    1925public class TableModel implements javax.swing.table.TableModel {
    20         private static final Logger log =
    21                 Logger.getLogger(TableModel.class);
    2226
     27        private static final Logger log = LogManager.getLogger(TableModel.class);
    2328
    2429        protected List<TableModelListener> listeners = new LinkedList<>();
    2530        protected ListAccess access;
    26         protected AccessInterface elementAccess;
    27         protected final List<PrimitiveParam<?>> columnParams = new ArrayList<>();
     31        protected Access elementAccess;
     32        protected final List<Column> columns = new ArrayList<>();
     33        protected final ListPanel listPanel;
     34        protected JTable table;
     35
     36        /**
     37         * @param listPanel
     38         */
     39        public TableModel(ListPanel listPanel) {
     40                this.listPanel = listPanel;
     41        }
     42
     43        /**
     44         * @return the listPanel
     45         */
     46        public ListPanel getListPanel() {
     47                return listPanel;
     48        }
     49
     50        public JTable getTable() {
     51                return listPanel.getTable();
     52        }
    2853
    2954        protected void refreshAll() {
    … …  
    3156                        l.tableChanged(new TableModelEvent(this));
    3257                }
     58        }
    3359
     60        /**
     61         * @param table the table to set
     62         */
     63        public void setupTable() {
     64                getTable().setDefaultRenderer(ProcedureParam.class, new ProcedureRenderer());
     65                getTable().setDefaultEditor(ProcedureParam.class, new ProcedureEditor(new JCheckBox()));
    3466        }
    3567
    … …  
    3870
    3971                this.elementAccess = this.access.getElementAccess().cloneAccess();
    40                 log.debug("attached " + access);
     72                log.debug("attached {}", access);
    4173                refreshAll();
    4274        }
    … …  
    4981        @Override
    5082        public Class<?> getColumnClass(int columnIndex) {
    51                 // log.debug("returning column type " + columnParams.get(columnIndex).getStorageType());
    52                 return columnParams.get(columnIndex).getStorageType();
     83                // log.debug("returning column type {}", columnParams.get(columnIndex).getStorageType());
     84                return columns.get(columnIndex).getColumnClass();
    5385        }
    5486
    5587        @Override
    5688        public int getColumnCount() {
    57                 // log.debug("returning column count " + columnParams.size());
    58                 return columnParams.size();
     89                // log.debug("returning column count {}", columnParams.size());
     90                return columns.size();
    5991        }
    6092
    6193        @Override
    6294        public String getColumnName(int columnIndex) {
    63                 return columnParams.get(columnIndex).getName();
     95                return columns.get(columnIndex).getParam().getName();
    6496        }
    6597
    6698        @Override
    6799        public int getRowCount() {
    68                 // log.debug("returning row count " + access.getParamCount());
    69                 return access.getParamCount();
     100                // log.debug("returning row count {}", access.getParamCount());
     101                return access == null ? 0 : access.getParamCount();
    70102        }
    71103
    72104        @Override
    73105        public Object getValueAt(int rowIndex, int columnIndex) {
    74                 assert (rowIndex < access.getParamCount() && columnIndex < columnParams.size());
     106                assert (rowIndex < access.getParamCount() && columnIndex < columns.size());
    75107
    76                 return elementAccess.select(access.get(rowIndex, Object.class)).get(columnParams.get(columnIndex), Object.class);
     108                return columns.get(columnIndex).getValueAt(rowIndex);
    77109        }
    78110
    79111        @Override
    80112        public boolean isCellEditable(int rowIndex, int columnIndex) {
    81                 return false;
     113                return columns.get(columnIndex).isEditable();
    82114        }
    83115
    … …  
    87119        }
    88120
     121
    89122        @Override
    90123        public void setValueAt(Object value, int rowIndex, int columnIndex) {
    91                 throw new UnsupportedOperationException().msg("setting value in table");
    92 
     124                assert (rowIndex < access.getParamCount() && columnIndex < columns.size());
     125                // Object object = getObjectAt(rowIndex, columnIndex);
     126                // if (object == null) {
     127                //      return;
     128                // }
     129                columns.get(columnIndex).setValueAt(rowIndex, value);
    93130        }
    94131
    95         public void addColumn(PrimitiveParam<?> columnParam) {
    96                 log.debug("added " + columnParam);
    97                 columnParams.add(columnParam);
     132        public void addColumn(Column column) {
     133                log.debug("added {}", column);
     134                columns.add(column);
     135        }
     136
     137        /**
     138         * @return the access
     139         */
     140        public ListAccess getAccess() {
     141                return access;
     142        }
     143
     144        /**
     145         * @return the elementAccess
     146         */
     147        public Access getElementAccess() {
     148                return elementAccess;
    98149        }
    99150
    … …  
    101152         * @return the columnParams
    102153         */
    103         public List<PrimitiveParam<?>> getColumnParams() {
    104                 return Collections.unmodifiableList(columnParams);
     154        public List<Column> getColumns() {
     155                return Collections.unmodifiableList(columns);
     156        }
     157
     158
     159        public boolean addColumnIfSupported(Param param) {
     160                if (param instanceof PrimitiveParam) {
     161                        addColumn(new PrimitiveColumn((PrimitiveParam<?>) param, this));
     162                        return true;
     163                }
     164                if (param instanceof ProcedureParam) {
     165                        if (((ProcedureParam) param).getArgumentsType().size() == 0) {
     166                                addColumn(new ProcedureColumn((ProcedureParam) param, this));
     167                                return true;
     168                        }
     169                        return false;
     170                }
     171                return false;
     172        }
     173
     174        public static void transferCellAppeariance(JTable table, JComponent component, boolean isSelected) {
     175                if (isSelected) {
     176                        component.setForeground(table.getSelectionForeground());
     177                        component.setBackground(table.getSelectionBackground());
     178                } else {
     179                        component.setForeground(table.getForeground());
     180                        component.setBackground(UIManager.getColor("Button.background"));
     181                }
     182
    105183        }
    106184

  • java/main/src/main/java/com/framsticks/gui/tree/AbstractNode.java

    r99 r100  
    11package com.framsticks.gui.tree;
     2
     3import com.framsticks.gui.AbstractPanel;
    24
    35
    … …  
    911
    1012        public abstract int getChildCount();
    11         public abstract AbstractNode getChild(int number);
    12         public abstract int getIndexOfChild(AbstractNode child);
     13        public abstract Object getChild(int number);
     14        public abstract int getIndexOfChild(Object child);
    1315
    1416        public abstract boolean isLeaf();
    1517        public abstract void render(TreeCellRenderer renderer);
    1618
     19        public abstract AbstractPanel getPanel();
     20
    1721}

  • java/main/src/main/java/com/framsticks/gui/tree/EmptyNode.java

    r99 r100  
    22
    33
     4import com.framsticks.gui.AbstractPanel;
     5import com.framsticks.gui.Frame;
    46import com.framsticks.gui.ImageProvider;
    57import com.framsticks.params.CompositeParam;
    … …  
    810
    911        protected final CompositeParam param;
     12        protected final Frame frame;
    1013
    1114        /**
    1215         * @param param
    1316         */
    14         public EmptyNode(CompositeParam param) {
     17        public EmptyNode(Frame frame, CompositeParam param) {
    1518                this.param = param;
     19                this.frame = frame;
    1620        }
    1721
    … …  
    2226
    2327        @Override
    24         public AbstractNode getChild(int number) {
     28        public Object getChild(int number) {
    2529                return null;
    2630        }
    2731
    2832        @Override
    29         public int getIndexOfChild(AbstractNode child) {
     33        public int getIndexOfChild(Object child) {
    3034                return -1;
    3135        }
    … …  
    3337        @Override
    3438        public boolean isLeaf() {
    35                 return true;
     39                return false;
    3640        }
    3741
    3842        @Override
    3943        public void render(TreeCellRenderer renderer) {
    40                 renderer.setIcon(ImageProvider.loadImage(TreeCellRenderer.findIconName(param)));
     44                // TODO Auto-generated method stub
     45
     46                renderer.setToolTipText("?");
    4147                renderer.setText(param.getId());
    42                 renderer.setToolTipText("?");
     48                renderer.setIcon(ImageProvider.loadImage(ImageProvider.FOLDER_CLOSED));
     49        }
     50
     51        /**
     52         * @return the param
     53         */
     54        public CompositeParam getParam() {
     55                return param;
    4356        }
    4457
    4558        @Override
    46         public String toString() {
    47                 return param.toString();
     59        public AbstractPanel getPanel() {
     60                return frame.getEmptyPanel();
    4861        }
    4962

  • java/main/src/main/java/com/framsticks/gui/tree/MetaNode.java

    r99 r100  
    55
    66
     7import com.framsticks.gui.AbstractPanel;
     8import com.framsticks.gui.Frame;
    79import com.framsticks.gui.ImageProvider;
    810
    911public class MetaNode extends AbstractNode {
    1012
    11         protected List<AbstractNode> children = new LinkedList<>();
     13        protected final Frame frame;
     14        protected final List<Object> children = new LinkedList<>();
    1215        protected String name = "meta node";
     16
     17        /**
     18         * @param frame
     19         */
     20        public MetaNode(Frame frame) {
     21                this.frame = frame;
     22        }
    1323
    1424        /**
    1525         * @return the children
    1626         */
    17         public List<AbstractNode> getChildren() {
     27        public List<Object> getChildren() {
    1828                return children;
    1929        }
    … …  
    3949
    4050        @Override
    41         public AbstractNode getChild(int number) {
     51        public Object getChild(int number) {
    4252                return children.get(number);
    4353        }
    4454
    4555        @Override
    46         public int getIndexOfChild(AbstractNode child) {
     56        public int getIndexOfChild(Object child) {
    4757                return children.indexOf(child);
    4858        }
    … …  
    6575        }
    6676
     77        @Override
     78        public AbstractPanel getPanel() {
     79                return frame.getEmptyPanel();
     80        }
     81
    6782}

  • java/main/src/main/java/com/framsticks/gui/tree/TreeCellRenderer.java

    r99 r100  
    1515public class TreeCellRenderer extends DefaultTreeCellRenderer {
    1616
    17         public TreeCellRenderer() {
     17        protected final TreeModel treeModel;
    1818
    19                 // setOpenIcon(ImageProvider.loadImage(ImageProvider.FOLDER_OPEN));
    20                 // setClosedIcon(ImageProvider.loadImage(ImageProvider.FOLDER_CLOSED));
    21                 // setLeafIcon(ImageProvider.loadImage(ImageProvider.NODE));
     19
     20        /**
     21         * @param treeModel
     22         */
     23        public TreeCellRenderer(TreeModel treeModel) {
     24                this.treeModel = treeModel;
    2225        }
    2326
    … …  
    3538
    3639                if (!(value instanceof AbstractNode)) {
    37                         setIcon(ImageProvider.loadImage(ImageProvider.SERVER));
    38                         setText("framsticks");
     40                        setText("?");
     41                        // treeModel.renderTreeObject(Casting.throwCast(TreeNode.class, value), this);
    3942                        return this;
    4043                }
    … …  
    9295
    9396
    94 
    9597}

  • java/main/src/main/java/com/framsticks/gui/tree/TreeModel.java

    r99 r100  
    11package com.framsticks.gui.tree;
    22
    3 // import java.util.Enumeration;
     3import java.util.Enumeration;
    44import java.util.Iterator;
    55import java.util.LinkedList;
    66import java.util.List;
    77
     8import javax.annotation.Nullable;
    89import javax.swing.event.TreeModelEvent;
    910import javax.swing.event.TreeModelListener;
    1011import javax.swing.tree.TreePath;
    1112
    12 import org.apache.log4j.Logger;
    13 
    14 
     13import org.apache.logging.log4j.Logger;
     14import org.apache.logging.log4j.LogManager;
     15
     16import com.framsticks.core.ListChange;
    1517import com.framsticks.core.Node;
    1618import com.framsticks.core.Path;
    17 import com.framsticks.core.Tree;
    1819import com.framsticks.core.TreeOperations;
    1920import com.framsticks.gui.Frame;
    20 import com.framsticks.params.AccessInterface;
     21import com.framsticks.params.Access;
     22import com.framsticks.params.CompositeParam;
     23import com.framsticks.params.EventListener;
     24import com.framsticks.params.ListAccess;
     25import com.framsticks.params.PrimitiveParam;
     26import com.framsticks.params.Util;
     27import com.framsticks.params.ValueParam;
     28import com.framsticks.params.types.EventParam;
    2129import com.framsticks.util.FramsticksException;
     30import com.framsticks.util.Misc;
    2231import com.framsticks.util.UnsupportedOperationException;
    2332import com.framsticks.util.dispatching.FutureHandler;
    2433import com.framsticks.util.lang.Casting;
    2534
     35import static com.framsticks.core.TreeOperations.*;
     36
    2637public class TreeModel implements javax.swing.tree.TreeModel {
    27         private static final Logger log = Logger.getLogger(TreeModel.class);
     38        private static final Logger log = LogManager.getLogger(TreeModel.class);
    2839
    2940
    3041        protected List<TreeModelListener> listeners = new LinkedList<>();
     42
    3143
    3244        protected final Frame frame;
    … …  
    4557
    4658        @Override
    47         public AbstractNode getChild(Object parent, int number) {
    48                 return Casting.assertCast(AbstractNode.class, parent).getChild(number);
     59        public Object getChild(Object parent, int number) {
     60                return Casting.throwCast(AbstractNode.class, parent).getChild(number);
    4961        }
    5062
    5163        @Override
    5264        public int getChildCount(Object parent) {
    53                 return Casting.assertCast(AbstractNode.class, parent).getChildCount();
     65                return Casting.throwCast(AbstractNode.class, parent).getChildCount();
    5466        }
    5567
    … …  
    5971                        return -1;
    6072                }
    61                 return Casting.assertCast(AbstractNode.class, parent).getIndexOfChild(Casting.assertCast(AbstractNode.class, child));
     73                return Casting.throwCast(AbstractNode.class, parent).getIndexOfChild(child);
    6274        }
    6375
    … …  
    6981        @Override
    7082        public boolean isLeaf(Object node) {
    71                 return Casting.assertCast(AbstractNode.class, node).isLeaf();
     83                return Casting.throwCast(AbstractNode.class, node).isLeaf();
    7284        }
    7385
    … …  
    8597        protected boolean changing = false;
    8698
    87         public void nodeStructureChanged(TreePath treePath) {
     99        public void treeNodesInserted(TreeModelEvent event) {
     100                assert frame.isActive();
     101                try {
     102                        for (TreeModelListener listener : listeners) {
     103                                listener.treeNodesInserted(event);
     104                        }
     105                } catch (ArrayIndexOutOfBoundsException e) {
     106                }
     107        }
     108
     109        public void treeNodesRemoved(TreeModelEvent event) {
     110                assert frame.isActive();
     111                try {
     112                        for (TreeModelListener listener : listeners) {
     113                                listener.treeNodesRemoved(event);
     114                        }
     115                } catch (ArrayIndexOutOfBoundsException e) {
     116                }
     117        }
     118
     119        public void treeNodesChanged(TreeModelEvent event) {
     120                try {
     121                        for (TreeModelListener listener : listeners) {
     122                                listener.treeNodesChanged(event);
     123                        }
     124                } catch (ArrayIndexOutOfBoundsException e) {
     125                }
     126        }
     127
     128        public TreeModelEvent prepareModelEvent(TreePath treePath, int number, TreeNode node) {
     129                return new TreeModelEvent(this, treePath, new int[] {number}, new Object[] { node });
     130        }
     131
     132
     133        public TreeModelEvent prepareModelEventRegarding(Access access, String id, TreePath treeListPath) {
     134
     135                int number = Util.getNumberOfCompositeParamChild(access, access.get(id, Object.class));
     136                if (number == -1) {
     137                        log.debug("encountered minor tree inconsistency in {}", treeListPath);
     138                        return null;
     139                }
     140                TreeNode node = Casting.throwCast(TreeNode.class, Casting.throwCast(TreeNode.class, treeListPath.getLastPathComponent()).getChild(number));
     141                return prepareModelEvent(treeListPath, number, node);
     142        }
     143
     144        public void treeStructureChanged(TreePath treePath) {
     145
    88146                if (treePath == null) {
    89147                        return;
    … …  
    92150
    93151                changing = true;
    94                 log.debug("changing: " + treePath);
    95                 // Enumeration<TreePath> expanded = frame.jtree.getExpandedDescendants(treePath);
     152                log.debug("changing structure: {}", treePath);
     153                Enumeration<TreePath> expanded = frame.getJtree().getExpandedDescendants(treePath);
    96154                TreePath selection = frame.getJtree().getSelectionPath();
    97155
    98                 for (TreeModelListener listener : listeners) {
    99                         listener.treeStructureChanged(new TreeModelEvent(this, treePath));
    100                 }
    101                 // if (expanded != null) {
    102                 //      while (expanded.hasMoreElements()) {
    103                 //              TreePath expansion = expanded.nextElement();
    104                 //              // log.info("reexpanding: " + expansion);
    105                 //              frame.jtree.expandPath(expansion);
    106                 //      }
    107                 // }
     156                try {
     157                        for (TreeModelListener listener : listeners) {
     158                                listener.treeStructureChanged(new TreeModelEvent(this, treePath));
     159                        }
     160                } catch (ArrayIndexOutOfBoundsException e) {
     161                }
     162
     163
     164                if (expanded != null) {
     165                        while (expanded.hasMoreElements()) {
     166                                TreePath expansion = expanded.nextElement();
     167                                // log.info("reexpanding: {}", expansion);
     168                                frame.getJtree().expandPath(expansion);
     169                        }
     170                }
     171
    108172                if (selection != null) {
    109173                        frame.getJtree().setSelectionPath(selection);
    … …  
    112176        }
    113177
    114         public Path convertToPath(TreePath treePath) {
     178        /**
     179         *
     180         * This method may return null on conversion failure, which may happen in highload situations.
     181         */
     182        public @Nullable Path convertToPath(TreePath treePath) {
    115183                final Object[] components = treePath.getPath();
    116184                assert components[0] == frame.getRootNode();
    … …  
    128196                        Node node = treeNode.tryCreateNode();
    129197                        if (node == null) {
    130                                 throw new FramsticksException().msg("failed to recreate path").arg("treePath", treePath);
     198                                return null;
     199                                // throw new FramsticksException().msg("failed to recreate path").arg("treePath", treePath);
    131200                        }
    132201                        nodes.add(node);
    … …  
    137206        }
    138207
    139         public TreePath convertToTreePath(Path path) {
     208        public TreePath convertToTreePath(Path path, boolean forceComplete) {
    140209                assert frame.isActive();
    141210
    … …  
    143212                accumulator.add(getRoot());
    144213
    145                 for (AbstractNode r : getRoot().getChildren()) {
     214                for (Object r : getRoot().getChildren()) {
    146215                        if (r instanceof TreeNode) {
    147216                                TreeNode root = (TreeNode) r;
    148217                                if (root.getTree() == path.getTree()) {
     218                                        Iterator<Node> n = path.getNodes().iterator();
     219                                        TreeNode treeNode = root;
    149220                                        accumulator.add(root);
    150 
    151                                         Iterator<Node> i = path.getNodes().iterator();
    152                                         i.next();
    153                                         TreeNode treeNode = root;
    154 
    155                                         while (i.hasNext()) {
    156                                                 Node node = i.next();
    157                                                 treeNode = treeNode.getTreeNodeForChild(node.getObject());
     221                                        n.next();
     222                                        while (n.hasNext()) {
     223                                                Node node = n.next();
     224                                                treeNode = treeNode.prepareTreeNodeForChild(Path.build().tree(path.getTree()).buildUpTo(path.getNodes(), node).finish());
    158225                                                if (treeNode == null) {
    159226                                                        break;
    … …  
    161228                                                accumulator.add(treeNode);
    162229                                        }
    163 
    164230                                        break;
    165231                                }
    … …  
    167233                }
    168234                return new TreePath(accumulator.toArray());
     235        }
     236
     237        /**
     238         * @return the listeners
     239         */
     240        public List<TreeModelListener> getListeners() {
     241                return listeners;
    169242        }
    170243
    … …  
    180253                        return;
    181254                }
    182                 AccessInterface access = TreeOperations.bindAccess(path);
     255                Access access = TreeOperations.bindAccess(path);
    183256
    184257                int count = access.getCompositeParamCount();
    … …  
    193266                        return;
    194267                }
    195                 if (path.isResolved() && !reload) {
     268                if (!reload && path.isResolved() && isMarked(path.getTree(), path.getTopObject(), FETCHED_MARK, false)) {
    196269                        return;
    197270                }
    … …  
    199272                        @Override
    200273                        protected void result(Path result) {
    201                                 final TreePath treePath = convertToTreePath(result);
    202 
    203                                 nodeStructureChanged(treePath);
    204                                 frame.updatePanelIfIsLeadSelection(treePath, result);
     274                                final TreePath treePath = convertToTreePath(result, true);
     275
     276
     277                                if (treePath != null) {
     278                                        treeStructureChanged(treePath);
     279                                        frame.updatePanelIfIsLeadSelection(result);
     280                                }
    205281                        }
    206282                });
    207283        }
    208284
    209         public void chooseTreeNode(final TreePath treePath) {
     285        public void expandTreeNode(TreePath treePath) {
    210286                assert frame.isActive();
    211287                if (treePath == null) {
    … …  
    215291                        return;
    216292                }
    217 
    218293                Path path = convertToPath(treePath);
    219294                if (path == null) {
    220295                        return;
    221296                }
     297                loadChildren(path.assureResolved(), false);
     298        }
     299
     300        public void chooseTreeNode(final TreePath treePath) {
     301                assert frame.isActive();
     302                if (treePath == null) {
     303                        return;
     304                }
     305                if (isChanging()) {
     306                        return;
     307                }
     308
     309                Path path = convertToPath(treePath);
     310                if (path == null) {
     311                        return;
     312                }
    222313                path = path.assureResolved();
    223                 final Tree tree = path.getTree();
    224 
    225                 frame.getTreeAtFrames().get(tree).useOrCreatePanel(treePath);
    226                 loadChildren(path, false);
    227 
    228         }
     314
     315                log.debug("choosing {}", path);
     316                frame.showPanelForTreePath(treePath);
     317                loadPath(path, false);
     318
     319        }
     320
     321
     322        protected void registerForEventParam(final TreeNode treeNode, Path path, final EventParam eventParam, ValueParam valueParam) {
     323                /** TODO make this listener not bind hold the reference to this TreeNode, maybe hold WeakReference internally */
     324                if (valueParam instanceof PrimitiveParam) {
     325
     326                        treeNode.tryAddListener(path, eventParam, Object.class, new EventListener<Object>() {
     327                                @Override
     328                                public void action(Object argument) {
     329                                        loadPath(treeNode.assurePath(), true);
     330                                }
     331                        });
     332
     333                } else if (valueParam instanceof CompositeParam) {
     334
     335                        final CompositeParam compositeParam = (CompositeParam) valueParam;
     336
     337                        treeNode.tryAddListener(path, eventParam, ListChange.class, new EventListener<ListChange>() {
     338                                @Override
     339                                public void action(ListChange listChange) {
     340                                        assert treeNode.getTree().isActive();
     341
     342                                        Path parentPath = treeNode.assurePath();
     343                                        final Path listPath = parentPath.appendParam(compositeParam).tryFindResolution();
     344                                        if (!listPath.isResolved()) {
     345                                                /** that situation is quietly ignored - it may happen if first event comes before the container was resolved */
     346                                                return;
     347                                        }
     348
     349                                        log.debug("reacting to change {} in {}", listChange, listPath);
     350                                        final TreePath treeListPath = convertToTreePath(listPath, true);
     351                                        if (treeListPath == null) {
     352                                                throw new FramsticksException().msg("path was not fully converted").arg("path", listPath);
     353                                        }
     354
     355                                        if ((listChange.getAction().equals(ListChange.Action.Modify)) && (listChange.getPosition() == -1)) {
     356                                                // get(listPath, future);
     357                                                // treeModel.nodeStructureChanged(treePath);
     358                                                // frame.updatePanelIfIsLeadSelection(treePath, result);
     359                                                return;
     360                                        }
     361                                        final String id = listChange.getBestIdentifier();
     362
     363                                        final ListAccess access = (ListAccess) bindAccess(listPath);
     364                                        switch (listChange.getAction()) {
     365                                                case Add: {
     366                                                        Path childPath = listPath.appendParam(access.prepareParamFor(id)).tryFindResolution();
     367                                                        if (!childPath.isResolved()) {
     368                                                                childPath = create(childPath);
     369
     370                                                                TreeModelEvent event = prepareModelEventRegarding(access, id, treeListPath);
     371                                                                if (event != null) {
     372                                                                        treeNodesInserted(event);
     373                                                                } else {
     374                                                                        treeStructureChanged(treeListPath);
     375                                                                }
     376                                                                frame.updatePanelIfIsLeadSelection(listPath);
     377                                                        }
     378
     379                                                        listPath.getTree().get(childPath, new FutureHandler<Path>(frame) {
     380                                                                @Override
     381                                                                protected void result(Path result) {
     382                                                                        if (!result.isResolved()) {
     383                                                                                log.warn("inconsistency after addition list change: {}", result);
     384                                                                        }
     385                                                                        assert frame.isActive();
     386                                                                        final TreePath treePath = Misc.throwIfNull(frame.getTreeModel().convertToTreePath(result, true));
     387
     388                                                                        // treeModel.nodeStructureChanged(treePath);
     389                                                                        frame.updatePanelIfIsLeadSelection(result);
     390
     391                                                                        log.debug("added {}({}) updated {}", id, result, treePath);
     392                                                                }
     393                                                        });
     394                                                        break;
     395                                                }
     396                                                case Remove: {
     397
     398                                                        TreeModelEvent event = prepareModelEventRegarding(access, id, treeListPath);
     399                                                        access.set(id, null);
     400                                                        if (event != null) {
     401                                                                treeNodesRemoved(event);
     402                                                        } else {
     403                                                                treeStructureChanged(treeListPath);
     404                                                        }
     405
     406                                                        frame.updatePanelIfIsLeadSelection(listPath);
     407
     408                                                        break;
     409                                                }
     410                                                case Modify: {
     411                                                        Path childPath = listPath.appendParam(access.prepareParamFor(id)).tryResolveIfNeeded();
     412                                                        listPath.getTree().get(childPath, new FutureHandler<Path>(frame) {
     413                                                                @Override
     414                                                                protected void result(Path result) {
     415                                                                        assert frame.isActive();
     416                                                                        // final TreePath treePath = frame.getTreeModel().convertToTreePath(result, true);
     417
     418                                                                        TreeModelEvent event = prepareModelEventRegarding(access, id, treeListPath);
     419                                                                        if (event != null) {
     420                                                                                treeNodesChanged(event);
     421                                                                        } else {
     422                                                                                treeStructureChanged(treeListPath);
     423                                                                        }
     424
     425                                                                        frame.updatePanelIfIsLeadSelection(listPath);
     426                                                                        frame.updatePanelIfIsLeadSelection(result);
     427                                                                }
     428                                                        });
     429                                                        break;
     430                                                }
     431                                        }
     432                                }
     433                        });
     434                }
     435
     436        }
     437
     438
     439
     440        protected final Object createdTag = new Object();
     441
     442
     443
    229444}

  • java/main/src/main/java/com/framsticks/gui/tree/TreeNode.java

    r99 r100  
    55import java.util.LinkedList;
    66import java.util.List;
    7 import java.util.concurrent.atomic.AtomicInteger;
    8 
    9 import javax.swing.ImageIcon;
    10 import javax.swing.tree.TreePath;
    11 
    12 import org.apache.log4j.Logger;
    13 
    14 import com.framsticks.core.ListChange;
     7
     8import org.apache.logging.log4j.LogManager;
     9import org.apache.logging.log4j.Logger;
     10
    1511import com.framsticks.core.Node;
    1612import com.framsticks.core.Path;
    … …  
    1915import com.framsticks.gui.ImageProvider;
    2016import com.framsticks.gui.TreeAtFrame;
    21 import com.framsticks.params.AccessInterface;
     17import com.framsticks.gui.TreePanel;
     18import com.framsticks.params.Access;
    2219import com.framsticks.params.CompositeParam;
    2320import com.framsticks.params.EventListener;
    2421import com.framsticks.params.FramsClass;
    25 import com.framsticks.params.PrimitiveParam;
    2622import com.framsticks.params.ValueParam;
    2723import com.framsticks.params.types.EventParam;
    … …  
    3228import com.framsticks.util.lang.Casting;
    3329import com.framsticks.util.lang.Containers;
    34 import com.framsticks.util.lang.Pair;
    3530import com.framsticks.util.swing.TooltipConstructor;
     31
    3632import static com.framsticks.core.TreeOperations.*;
    3733
    3834public class TreeNode extends AbstractNode {
    39         private static final Logger log = Logger.getLogger(TreeNode.class);
    40 
    41 
    42         protected static final AtomicInteger counter = new AtomicInteger();
     35
     36        private static final Logger log = LogManager.getLogger(TreeNode.class);
    4337
    4438        protected final WeakReference<Object> reference;
     39        protected final int hashCode;
     40        protected final TreeAtFrame treeAtFrame;
     41        protected final String textual;
    4542        protected final CompositeParam param;
    46         protected final TreeAtFrame treeAtFrame;
    47         protected final List<Pair<WeakReference<Object>, WeakReference<TreeNode>>> children = new LinkedList<>();
    48         protected final int number;
    49         protected final String textualPath;
    50         protected final ImageIcon imageIcon;
    51         protected final TreeModel treeModel;
    52 
    53         protected final List<EventListener<?>> listeners = new LinkedList<>();
    54 
     43        protected TreePanel panel;
     44
     45        public TreeModel getTreeModel() {
     46                return treeAtFrame.getFrame().getTreeModel();
     47        }
     48
     49        /**
     50         * @param reference
     51         */
    5552        public TreeNode(TreeAtFrame treeAtFrame, Path path) {
    5653                path.assureResolved();
    57                 this.textualPath = path.getTextual();
     54
     55                this.reference = new WeakReference<Object>(path.getTopObject());
     56                this.textual = path.getTextual();
     57                this.treeAtFrame = treeAtFrame;
    5858                this.param = path.getTop().getParam();
    59                 this.treeAtFrame = treeAtFrame;
    60                 this.treeModel = treeAtFrame.getFrame().getTreeModel();
    61                 this.imageIcon = ImageProvider.loadImage(TreeCellRenderer.findIconName(param));
    62 
    63                 reference = new WeakReference<Object>(path.getTop().getObject());
    64                 number = counter.getAndIncrement();
     59                hashCode = System.identityHashCode(path.getTopObject());
     60
     61                if (getTree().getSideNote(path.getTopObject(), getTreeModel().createdTag, Object.class) == getTreeModel().createdTag) {
     62                        return;
     63                }
     64
     65                // path.getTree().putSideNote(path.getTopObject(), Textual.class, path.getTextual());
     66                path.getTree().putSideNote(path.getTopObject(), getTreeModel().createdTag, getTreeModel().createdTag);
    6567
    6668                /** Iterate over all EventParams and for matching ValueParams register listeners. */
    67                 if (param instanceof ObjectParam) {
    68                         AccessInterface access = bindAccess(path);
     69                if (path.getTop().getParam() instanceof ObjectParam) {
     70                        Access access = bindAccess(path);
    6971                        FramsClass framsClass = access.getFramsClass();
    7072                        for (EventParam eventParam : Containers.filterInstanceof(framsClass.getParamEntries(), EventParam.class)) {
    … …  
    7779                                        continue;
    7880                                }
    79                                 registerForEventParam(path, eventParam, valueParam);
    80                         }
    81                 }
    82         }
    83 
    84         protected <A> void tryAddListener(final Path path, final EventParam eventParam, Class<A> argumentType, final EventListener<A> listener) {
    85                 treeAtFrame.getTree().addListener(path, eventParam, listener, argumentType, new FutureHandler<Void>(treeAtFrame.getFrame()) {
    86                         @Override
    87                         protected void result(Void result) {
    88                                 assert treeAtFrame.getFrame().isActive();
    89                                 log.debug("registered gui listener for " + eventParam + " at " + path);
    90                                 listeners.add(listener);
    91                         }
    92                 });
    93         }
    94 
    95         protected void registerForEventParam(Path path, EventParam eventParam, ValueParam valueParam) {
    96                 /** TODO make this listener not bind hold the reference to this TreeNode, maybe hold WeakReference internally */
    97                 if (valueParam instanceof PrimitiveParam) {
    98 
    99                         tryAddListener(path, eventParam, Object.class, new EventListener<Object>() {
    100                                 @Override
    101                                 public void action(Object argument) {
    102                                         treeModel.loadPath(assurePath(), true);
    103                                 }
    104                         });
    105 
    106                 } else if (valueParam instanceof CompositeParam) {
    107 
    108                         final CompositeParam compositeParam = (CompositeParam) valueParam;
    109 
    110                         tryAddListener(path, eventParam, ListChange.class, new EventListener<ListChange>() {
    111                                 @Override
    112                                 public void action(ListChange listChange) {
    113                                         assert treeAtFrame.getTree().isActive();
    114 
    115                                         final Path listPath = assurePath().appendParam(compositeParam).tryFindResolution().assureResolved();
    116                                         log.debug("reacting to change " + listChange + " in " + listPath);
    117 
    118                                         if ((listChange.getAction().equals(ListChange.Action.Modify)) && (listChange.getPosition() == -1)) {
    119                                                 // get(listPath, future);
    120                                                 return;
    121                                         }
    122                                         final String id = listChange.getBestIdentifier();
    123 
    124                                         AccessInterface access = bindAccess(listPath);
    125                                         switch (listChange.getAction()) {
    126                                                 case Add: {
    127                                                         tryGet(listPath.getTree(), Path.appendString(listPath.getTextual(), id), new FutureHandler<Path>(treeAtFrame.getFrame()) {
    128                                                                 @Override
    129                                                                 protected void result(Path result) {
    130                                                                         final Frame frame = treeAtFrame.getFrame();
    131                                                                         assert frame.isActive();
    132                                                                         final TreePath treePath = frame.getTreeModel().convertToTreePath(listPath);
    133                                                                         treeModel.nodeStructureChanged(treePath);
    134                                                                         frame.updatePanelIfIsLeadSelection(treePath, listPath);
    135                                                                         log.debug("added " + id + "(" + result + ") updated " + treePath);
    136                                                                 }
    137                                                         });
    138                                                         break;
    139                                                 }
    140                                                 case Remove: {
    141                                                         access.set(id, null);
    142                                                         Frame frame = treeAtFrame.getFrame();
    143                                                         treeModel.nodeStructureChanged(frame.getTreeModel().convertToTreePath(listPath));
    144                                                         break;
    145                                                 }
    146                                                 case Modify: {
    147                                                         tryGet(listPath.getTree(), Path.appendString(listPath.getTextual(), id), new FutureHandler<Path>(treeAtFrame.getFrame()) {
    148                                                                 @Override
    149                                                                 protected void result(Path result) {
    150                                                                         final Frame frame = treeAtFrame.getFrame();
    151                                                                         assert frame.isActive();
    152                                                                         final TreePath treePath = frame.getTreeModel().convertToTreePath(result);
    153                                                                         treeModel.nodeStructureChanged(treePath);
    154                                                                         frame.updatePanelIfIsLeadSelection(treePath, listPath);
    155                                                                 }
    156                                                         });
    157                                                         break;
    158                                                 }
    159                                         }
    160                                 }
    161                         });
    162                 }
    163 
    164         }
    165 
    166         protected Path assurePath() {
    167                 return Path.to(treeAtFrame.getTree(), textualPath).assureResolved();
    168         }
    169 
    170         public Node tryCreateNode() {
    171                 Object child = lock();
    172                 if (child == null) {
    173                         return null;
    174                 }
    175                 return Path.to(treeAtFrame.getTree(), textualPath).assureResolved().getTop();
    176         }
    177 
    178         @Override
    179         public int getChildCount() {
    180                 Object referent = lock();
    181                 if (referent == null) {
    182                         return 0;
    183                 }
    184                 AccessInterface access = bindAccessFor(referent);
    185                 final int count = access.getCompositeParamCount();
    186                 return count;
    187         }
    188 
    189         public TreeNode getTreeNodeForChild(Object child) {
    190                 Iterator<Pair<WeakReference<Object>, WeakReference<TreeNode>>> i = children.iterator();
    191                 while (i.hasNext()) {
    192                         Pair<WeakReference<Object>, WeakReference<TreeNode>> p = i.next();
    193                         Object object = p.first.get();
    194                         if (object == null) {
    195                                 i.remove();
    196                                 continue;
    197                         }
    198                         TreeNode treeNode = p.second.get();
    199                         if (treeNode == null) {
    200                                 i.remove();
    201                                 continue;
    202                         }
    203                         if (object == child) {
    204                                 return treeNode;
    205                         }
    206                 }
    207                 return null;
    208 
    209                 // WeakReference<GuiTreeNode> resultReference = children.get(child);
    210                 // if (resultReference == null) {
    211                 //      return null;
    212                 // }
    213                 // return resultReference.get();
     81                                getTreeModel().registerForEventParam(this, path, eventParam, valueParam);
     82                        }
     83                }
     84        }
     85
     86        @Override
     87        public int hashCode() {
     88                return hashCode;
     89        }
     90
     91        @Override
     92        public boolean equals(Object obj) {
     93                if (obj instanceof TreeNode) {
     94                        return lock() == ((TreeNode) obj).lock();
     95                }
     96                return false;
    21497        }
    21598
    … …  
    220103                        throw new FramsticksException().msg("invalid state - missing referent");
    221104                }
    222                 AccessInterface access = bindAccessFor(referent);
     105                Tree tree = getTree();
     106                Access access = bindAccessForTreeObject(referent);
    223107
    224108                final int count = access.getCompositeParamCount();
    … …  
    227111                }
    228112
     113                /** textual path may be not valid anymore*/
    229114                CompositeParam childParam = access.getCompositeParam(number);
    230                 Object child = access.get(childParam, Object.class);
    231                 if (child == null) {
    232                         log.debug("returning dummy node for " + childParam + " in " + referent);
    233                         return new EmptyNode(childParam);
    234                 }
    235 
    236                 TreeNode result = getTreeNodeForChild(child);
    237                 if (result != null) {
    238                         return result;
    239                 }
    240                 Path path = Path.to(treeAtFrame.getTree(), Path.appendString(textualPath, childParam.getId())).assureResolved();
    241                 result = new TreeNode(treeAtFrame, path);
    242 
    243                 children.add(Pair.make(new WeakReference<Object>(child), new WeakReference<TreeNode>(result)));
    244 
    245                 return result;
    246 
     115
     116                try {
     117                        Path path = Path.to(tree, getTextual()).appendParam(childParam).tryFindResolution();
     118                        if (!path.isResolved()) {
     119                                path = create(path);
     120                        }
     121                        return prepareTreeNodeForChild(path);
     122                } catch (FramsticksException e) {
     123                }
     124                return new EmptyNode(getFrame(), childParam);
     125
     126        }
     127
     128        public TreeNode prepareTreeNodeForChild(Path path) {
     129                assert path.getTree() == getTree();
     130                Object parent = lock();
     131                Iterator<Node> n = path.getNodes().iterator();
     132                while (n.hasNext()) {
     133                        if (n.next().getObject() == parent) {
     134                                break;
     135                        }
     136                }
     137                if (!n.hasNext()) {
     138                        return null;
     139                        // throw new FramsticksException().msg("tree node is not on path (or is last)").arg("path", path).arg("node", this);
     140                }
     141                return new TreeNode(treeAtFrame, path);
    247142        }
    248143
    … …  
    252147
    253148        @Override
    254         public int getIndexOfChild(AbstractNode child) {
     149        public int getIndexOfChild(Object child) {
    255150                final TreeNode treeChild = Casting.tryCast(TreeNode.class, child);
    256151                if (treeChild == null) {
    … …  
    262157                        return -1;
    263158                }
    264                 final AccessInterface access = bindAccessFor(parentObject);
     159                final Access access = bindAccessForTreeObject(parentObject);
    265160
    266161                final int count = access.getCompositeParamCount();
    … …  
    271166                        }
    272167                }
    273                 log.debug(child + " not found in " + this);
     168                log.debug("{} not found in {}", child, this);
    274169                return -1;
    275170        }
    276171
    277         /**
    278          * @return the param
    279          */
    280         public CompositeParam getParam() {
    281                 return param;
    282         }
    283 
    284         /**
    285          * @return the tree
    286          */
     172        public Frame getFrame() {
     173                return getTreeAtFrame().getFrame();
     174        }
     175
     176        public TreeAtFrame getTreeAtFrame() {
     177                return treeAtFrame;
     178        }
     179
    287180        public Tree getTree() {
    288                 return treeAtFrame.getTree();
    289         }
    290 
     181                return getTreeAtFrame().getTree();
     182        }
     183
     184        protected Path assurePath() {
     185                return Path.to(getTree(), getTextual()).assureResolved();
     186        }
    291187
    292188        @Override
    293189        public String toString() {
    294                 return param.toString();
    295         }
    296 
    297         public static Node tryGetNode(TreePath treePath) {
    298                 return Casting.throwCast(TreeNode.class, treePath.getLastPathComponent()).tryCreateNode();
     190                return getTextual();
     191        }
     192
     193        public Node tryCreateNode() {
     194                Object child = lock();
     195                if (child == null) {
     196                        return null;
     197                }
     198                String textual = getTextual();
     199                Path path = Path.tryTo(getTree(), textual);
     200                if (path.isResolved(textual)) {
     201                        return path.getTop();
     202                }
     203                return null;
     204        }
     205
     206        @Override
     207        public int getChildCount() {
     208                Object referent = lock();
     209                if (referent == null) {
     210                        return 0;
     211                }
     212                Access access = bindAccessForTreeObject(referent);
     213                final int count = access.getCompositeParamCount();
     214                return count;
    299215        }
    300216
    … …  
    305221                        return true;
    306222                }
    307                 return bindAccessFor(referent).getCompositeParamCount() == 0;
    308         }
    309 
    310         protected AccessInterface bindAccessFor(Object child) {
    311                 return treeAtFrame.getTree().prepareAccess(param).select(child);
     223                return bindAccessForTreeObject(referent).getCompositeParamCount() == 0;
     224        }
     225
     226        protected Access bindAccessForTreeObject(Object child) {
     227                return bindAccessFromSideNote(getTree(), child);
    312228        }
    313229
    314230        @Override
    315231        public void render(TreeCellRenderer renderer) {
     232
     233                Object child = lock();
     234                if (child == null) {
     235                        renderer.setToolTipText("?");
     236                        renderer.setText("?");
     237                        renderer.setIcon(ImageProvider.loadImage(ImageProvider.FOLDER_CLOSED));
     238                        return;
     239                }
     240                Access access = bindAccessForTreeObject(child);
     241                CompositeParam param = getTree().getSideNote(child, CompositeParam.class, CompositeParam.class);
    316242                String name = param.getId();
    317243
    318                 Object child = lock();
    319                 if (child != null) {
    320                         AccessInterface access = bindAccessFor(child);
    321 
    322                         StringParam nameParam = Casting.tryCast(StringParam.class, access.getParam("name"));
    323 
    324                         if (nameParam != null) {
    325                                 name = access.get(nameParam, String.class);
    326                         }
    327 
    328                         renderer.setToolTipText(new TooltipConstructor()
     244                StringParam nameParam = Casting.tryCast(StringParam.class, access.getParam("name"));
     245
     246                if (nameParam != null) {
     247                        name = access.get(nameParam, String.class);
     248                }
     249
     250                renderer.setToolTipText(new TooltipConstructor()
    329251                                .append("frams", access.getId())
    330252                                .append("java", child.getClass().getCanonicalName())
    … …  
    333255                                .append("id", param.getId())
    334256                                .append("object", Integer.toHexString(System.identityHashCode(child)))
    335                                 .append("number", number)
    336                                 .append("textual path", textualPath)
     257                                .append("size", access.getCompositeParamCount())
    337258                                .build());
    338                 } else {
    339                         renderer.setToolTipText(new TooltipConstructor()
    340                                 .append("param", param)
    341                                 .append("textual path", textualPath)
    342                                 .build());
    343                 }
     259
     260                renderer.setIcon(ImageProvider.loadImage(TreeCellRenderer.findIconName(param)));
    344261                renderer.setText(name);
    345                 renderer.setIcon(imageIcon);
    346 
     262        }
     263
     264        // public static class Textual {
     265        // }
     266
     267        public String getTextual() {
     268                return textual;
     269                // return getTree().getSideNote(lock(), Textual.class, String.class);
     270        }
     271
     272        protected final Object listenersTag = new Object();
     273
     274        public List<EventListener<?>> getListeners() {
     275                @SuppressWarnings("unchecked")
     276                List<EventListener<?>> result = getTree().getSideNote(lock(), listenersTag, List.class);
     277                if (result == null) {
     278                        result = new LinkedList<>();
     279                        getTree().putSideNote(lock(), listenersTag, result);
     280                }
     281
     282                return result;
     283        }
     284
     285        protected <A> void tryAddListener(final Path path, final EventParam eventParam, Class<A> argumentType, final EventListener<A> listener) {
     286                getTree().addListener(path, eventParam, listener, argumentType, new FutureHandler<Void>(getFrame()) {
     287                        @Override
     288                        protected void result(Void result) {
     289                                assert getFrame().isActive();
     290                                log.debug("registered gui listener for {} at {}", eventParam, path);
     291                                getListeners().add(listener);
     292                        }
     293                });
     294        }
     295
     296        @Override
     297        public TreePanel getPanel() {
     298                if (panel != null) {
     299                        return panel;
     300                }
     301                panel = getTreeAtFrame().preparePanel(param);
     302                return panel;
    347303        }
    348304

  • java/main/src/main/java/com/framsticks/gui/windows/ServerLogFrame.java

    r85 r100  
    22
    33import com.framsticks.gui.ImageProvider;
    4 import org.apache.log4j.Logger;
     4import org.apache.logging.log4j.LogManager;
    55
    66import javax.swing.*;
    … …  
    8585                        if (popUp && !this.isVisible())
    8686                                this.setVisible(true);
    87                         Logger.getLogger(ServerLogFrame.class).error(
     87                        LogManager.getLogger(ServerLogFrame.class).error(
    8888                                        "level " + level + " class " + clazz + " function "
    8989                                                        + function + " msg " + message);

  • java/main/src/main/java/com/framsticks/hosting/Cli.java

    r99 r100  
    44import java.util.TreeMap;
    55
    6 import org.apache.log4j.Logger;
     6import org.apache.logging.log4j.Logger;
     7import org.apache.logging.log4j.LogManager;
    78
    89import com.framsticks.communication.Response;
    … …  
    2021public class Cli {
    2122        private static final Logger log =
    22                 Logger.getLogger(Cli.class);
     23                LogManager.getLogger(Cli.class);
    2324
    2425
    … …  
    3940
    4041        public void addListener(Path path, EventParam param, String pathPrefix, ServerSideResponseFuture responseFuture) {
    41                 log.debug("adding listener for " + path + ": " + param);
     42                log.debug("adding listener for {}: {}", path, param);
    4243
    4344                final CliEvent event = new CliEvent();
    … …  
    5354                        @Override
    5455                        public void action(Object argument) {
    55                                 log.debug("registered event " + event + " happened with " + argument);
     56                                log.debug("registered event {} happened with {}", event, argument);
    5657
    5758                                client.connection.sendFile(

  • java/main/src/main/java/com/framsticks/hosting/CliEvent.java

    r99 r100  
    5656
    5757        @ParamAnnotation
     58        public String getUid() {
     59                return id;
     60        }
     61
     62        @ParamAnnotation
    5863        public String getName() {
    5964                return id;

  • java/main/src/main/java/com/framsticks/hosting/ClientAtServer.java

    r99 r100  
    8181                rootTree.getRegistry().registerAndBuild(CliEvent.class);
    8282
    83                 AccessInterface access = new PropertiesAccess(rootFramsClass);
    84 
    85                 root = access.createAccessee();
     83                Access access = new PropertiesAccess(rootFramsClass);
     84
     85                root = createAccessee(rootTree, access);
    8686                access.select(root);
    8787                access.set(id, treeRootObject);
    … …  
    112112        }
    113113
    114         public static File printToFile(String path, AccessInterface access) {
     114        public static File printToFile(String path, Access access) {
    115115                ListSink sink = new ListSink();
    116116                access.save(sink);
    … …  
    128128                                }
    129129
    130                                 // final AccessInterface access = tree.prepareAccess(path);
    131                                 final AccessInterface access = bindAccess(path);
     130                                // final Access access = tree.prepareAccess(path);
     131                                final Access access = bindAccess(path);
    132132
    133133                                if (request instanceof GetRequest) {

  • java/main/src/main/java/com/framsticks/hosting/Server.java

    r98 r100  
    11package com.framsticks.hosting;
    22
    3 import org.apache.log4j.Level;
    4 import org.apache.log4j.Logger;
     3import org.apache.logging.log4j.Level;
     4import org.apache.logging.log4j.Logger;
     5import org.apache.logging.log4j.LogManager;
    56
    67import com.framsticks.core.Tree;
    … …  
    2829public class Server extends AbstractJoinable implements JoinableParent {
    2930
    30         private final static Logger log = Logger.getLogger(Server.class);
     31        private final static Logger log = LogManager.getLogger(Server.class);
    3132
    3233        protected int port;
    … …  
    131132                                        final Socket socket = acceptSocket.accept();
    132133                                        assert socket != null;
    133                                         log.debug("accepted socket: " + socket.getInetAddress().getHostAddress());
     134                                        log.debug("accepted socket: {}", socket.getInetAddress().getHostAddress());
    134135                                        hosted.dispatch(new RunAt<Tree>(this) {
    135136                                                @Override
    … …  
    137138                                                        ClientAtServer client = new ClientAtServer(Server.this, socket);
    138139                                                        clients.add(client);
    139                                                         log.info("client connected: " + client);
     140                                                        log.info("client connected: {}", client);
    140141                                                }
    141142                                        });
    142143                                } catch (IOException e) {
    143                                         log.log((isRunning() ? Level.ERROR : Level.DEBUG), "failed to accept socket: " + e);
     144                                        log.log((isRunning() ? Level.ERROR : Level.DEBUG), "failed to accept socket: {}", e);
    144145                                }
    145146                                acceptNext();
    … …  
    154155                                try {
    155156                                        acceptSocket.bind(new InetSocketAddress(port));
    156                                         log.debug("started accepting on port " + port);
     157                                        log.debug("started accepting on port {}", port);
    157158                                        acceptNext();
    158159                                        return;
    159160                                } catch (IOException e) {
    160                                         log.warn("failed to accept on port " + port + " (repeating): " + e);
     161                                        log.warn("failed to accept on port {} (repeating): ", port, e);
    161162                                }
    162163                                tryBind(1000);
    … …  
    201202        //      } catch (ClassNotFoundException ignored) {
    202203        //      } catch (ConstructionException e) {
    203         //              log.error("failed to use info from cache: " + e);
     204        //              log.error("failed to use info from cache: {}", e);
    204205        //      }
    205206
    … …  
    213214        //      FramsClass framsClass = getInfoFromCache(path.getTop().getObject().getClass().getCanonicalName());
    214215        //      if (framsClass == null) {
    215         //              log.error("failed to create frams class for: " + path.getTop().getObject().getClass());
     216        //              log.error("failed to create frams class for: {}", path.getTop().getObject().getClass());
    216217        //              future.result(null, new Exception());
    217218        //              return;

  • java/main/src/main/java/com/framsticks/model/Genotype.java

    r86 r100  
    55
    66
    7 // import org.apache.log4j.Logger;
     7// import org.apache.logging.log4j.Logger;
    88
    99@FramsClassAnnotation
    1010public class Genotype extends Model {
    11         // private final static Logger log = Logger.getLogger(Genotype.class);
     11        // private final static Logger log = LogManager.getLogger(Genotype.class);
    1212
    1313        @ParamAnnotation
    … …  
    8787        public double getStrsiz() { return getNumparts(); }
    8888        @ParamAnnotation
    89         public void setStrsiz(double strsiz) { setNumparts(strsiz); }
     89        public void setStrsiz(double strsiz) {}
    9090
    9191
    … …  
    9393        public double getStrjoints() { return getNumjoints(); }
    9494        @ParamAnnotation
    95         public void setStrjoints(double strjoints) { setNumjoints(strjoints); }
     95        public void setStrjoints(double strjoints) {}
    9696
    9797
    … …  
    9999        public double getNnsiz() { return getNumneurons(); }
    100100        @ParamAnnotation
    101         public void setNnsiz(double nnsiz) { setNumneurons(nnsiz); }
     101        public void setNnsiz(double nnsiz) {}
    102102
    103103

  • java/main/src/main/java/com/framsticks/model/Model.java

    r99 r100  
    33import com.framsticks.params.annotations.FramsClassAnnotation;
    44import com.framsticks.params.annotations.ParamAnnotation;
    5 import com.framsticks.util.lang.Containers;
    65
    76import java.util.ArrayList;
    … …  
    4847        //this is impossible to use, because numparts field is marked as readonly
    4948        @ParamAnnotation
    50         public void setNumparts(double numparts) { Containers.resizeList(parts, (int) (double) numparts); }
     49        public void setNumparts(double numparts) {}
    5150        @ParamAnnotation
    52         public void setNumjoints(double numjoints) { Containers.resizeList(joints, (int)(double)numjoints); }
     51        public void setNumjoints(double numjoints) {}
    5352        @ParamAnnotation
    54         public void setNumneurons(double numneurons) { Containers.resizeList(neuroDefinitions, (int)(double)numneurons); }
     53        public void setNumneurons(double numneurons) {}
    5554
    5655        public List<Part> getParts() { return parts; }

  • java/main/src/main/java/com/framsticks/model/ModelBuilder.java

    r90 r100  
    3535                        }
    3636                        F0Parser parser = new F0Parser(schema, stream);
    37                         components.addAll(Util.stripAccessInterface(parser.parse(), ModelComponent.class));
     37                        components.addAll(Util.stripAccess(parser.parse(), ModelComponent.class));
    3838                }
    3939                return build();

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

    r99 r100  
    99import java.util.List;
    1010import java.util.ListIterator;
     11import static com.framsticks.params.SetStateFlags.*;
    1112
    1213/**
    … …  
    1819
    1920
    20         public ArrayListAccess(AccessInterface elementAccess) {
     21        public ArrayListAccess(Access elementAccess) {
    2122                super(elementAccess);
    2223        }
    … …  
    7677        @Override
    7778        public <T> int set(int i, T value) {
    78                 while (i >= list.size()) {
    79                         list.add(null);
     79                if (value != null) {
     80                        while (i >= list.size()) {
     81                                list.add(null);
     82                        }
     83                        list.set(i, value);
     84                        return 0;
    8085                }
    81                 list.set(i, value);
     86                if (i >= list.size()) {
     87                        return PSET_HITMAX;
     88                }
     89                list.remove(i);
     90                // for (int j = i + 1; j < list.size(); ++j) {
     91                //      if (list.get(j) != null) {
     92                //              list.set(i, null);
     93                //              return 0;
     94                //      }
     95                // }
     96                // while (list.size() > i) {
     97                //      list.remove(i);
     98                // }
    8299                return 0;
    83100        }
    … …  
    107124        @Override
    108125        public ArrayListAccess select(Object object) {
    109                 list = (List<Object>) object;
     126                list = Util.selectObjectForAccess(this, object, List.class);
    110127                return this;
    111128        }

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

    r98 r100  
    2828        }
    2929
    30         public abstract AccessInterface prepareAccessInterface(AccessInterface access);
     30        public abstract Access prepareAccess(Access access);
    3131
    3232        public abstract String computeAccessId();

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

    r99 r100  
    1313import javax.annotation.concurrent.Immutable;
    1414
    15 import org.apache.log4j.Logger;
     15import org.apache.logging.log4j.Logger;
     16import org.apache.logging.log4j.LogManager;
    1617
    1718/**
    … …  
    3132public class FramsClass {
    3233
    33         private final static Logger log = Logger.getLogger(FramsClass.class);
     34        private final static Logger log = LogManager.getLogger(FramsClass.class);
    3435
    3536        protected final String id;
    … …  
    7374                }
    7475
    75                 log.trace("created framsclass " + this);
     76                log.trace("created framsclass {}", this);
    7677
    7778        }

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

    r99 r100  
    1414import java.util.Map;
    1515
    16 import org.apache.log4j.Logger;
     16import org.apache.logging.log4j.Logger;
     17import org.apache.logging.log4j.LogManager;
    1718
    1819import com.framsticks.params.annotations.AutoAppendAnnotation;
    … …  
    2930public class FramsClassBuilder implements Builder<FramsClass> {
    3031        private static final Logger log =
    31                 Logger.getLogger(FramsClassBuilder.class);
     32                LogManager.getLogger(FramsClassBuilder.class);
    3233
    3334        public static String getName(FramsClassAnnotation fca, Class<?> javaClass) {
    … …  
    7576                        //TODO parametrize this
    7677                        if (map) {
    77                                 b.append(" name");
     78                                b.append(" uid");
    7879                        }
    7980
    … …  
    224225                }
    225226
    226                 log.debug("building for class " + javaClass);
     227                log.debug("building for class {}", javaClass);
    227228
    228229                FramsClassAnnotation fca = javaClass.getAnnotation(FramsClassAnnotation.class);

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

    r99 r100  
    77import com.framsticks.params.types.EventParam;
    88import com.framsticks.params.types.ProcedureParam;
     9import com.framsticks.util.UnimplementedException;
    910
    1011/**
    1112 * @author Piotr Sniegowski
    1213 */
    13 public abstract class ListAccess implements AccessInterface {
     14public abstract class ListAccess implements Access {
    1415
    15         final AccessInterface elementAccess;
     16        final Access elementAccess;
    1617        final String containedTypeName;
    1718
    1819        protected final ParamBuilder paramBuilder;
    1920
    20         public ListAccess(AccessInterface elementAccess) {
     21        public ListAccess(Access elementAccess) {
    2122                this.elementAccess = elementAccess;
    2223                this.containedTypeName = elementAccess.getId();
    … …  
    6667        @Override
    6768        public void load(SourceInterface stream) {
     69                throw new UnimplementedException().msg("load in list access");
    6870        }
    6971
    70         public AccessInterface getElementAccess() {
     72        public Access getElementAccess() {
    7173                return elementAccess;
    7274        }
    … …  
    120122                return b.toString();
    121123        }
     124
     125        public CompositeParam prepareParamFor(String id) {
     126                return paramBuilder.id(id).finish(CompositeParam.class);
     127        }
    122128};

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

    r99 r100  
    1010import com.framsticks.util.lang.Strings;
    1111
    12 import org.apache.log4j.Logger;
     12import org.apache.logging.log4j.Logger;
     13import org.apache.logging.log4j.LogManager;
    1314
    1415import java.lang.reflect.InvocationTargetException;
    … …  
    3233@FramsClassAnnotation(name = "prop", id = "prop")
    3334public class ParamBuilder implements Builder<Param> {
    34         private final static Logger log = Logger.getLogger(ParamBuilder.class.getName());
     35        private final static Logger log = LogManager.getLogger(ParamBuilder.class.getName());
    3536
    3637        private static final String ID_FIELD = "id";
    … …  
    265266                assert type != null;
    266267
    267                 log.trace("parsing type: " + type);
     268                log.trace("parsing type: {}", type);
    268269
    269270                String[] typeSplitted = type.split(" ");
    … …  
    301302                                                        }
    302303                                                        default: {
    303                                                                 log.error("unknown type: " + first);
     304                                                                log.error("unknown type: {}", first);
    304305                                                                return this;
    305306                                                        }
    … …  
    349350                }
    350351                default: {
    351                         log.error("unknown type: " + first);
     352                        log.error("unknown type: {}", first);
    352353                        return this;
    353354                }
    … …  
    445446
    446447                if (paramEntryValues.length == 0) {
    447                         log.warn("field empty or wrong format (" + line
    448                                         + ") - omitting");
     448                        log.warn("field empty or wrong format ({}) - omitting", line);
    449449                        return null;
    450450                }
    … …  
    464464                        /** everything is ok, parameters have just finished*/
    465465                } catch (NumberFormatException ex) {
    466                         log.warn("wrong format of entry: " + line
    467                                         + ", omitting");
     466                        log.warn("wrong format of entry: {}, omitting", line);
    468467                        return null;
    469468                }
    … …  
    492491                                break;
    493492                        default:
    494                                 log.error("unknown field for Param: " + key);
     493                                log.error("unknown field for Param: {}", key);
    495494                                break;
    496495                }

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

    r99 r100  
    213213                        return false;
    214214                }
    215                 if (Collection.class.isAssignableFrom(getRawType())) {
    216                         return false;
    217                 }
    218                 if (setter.has()) {
    219                         return false;
    220                 }
    221215                if (field.has()) {
    222216                        return Modifier.isFinal(field.get().getModifiers());
     217                }
     218                if (setter.has()) {
     219                        return false;
     220                }
     221                if (Collection.class.isAssignableFrom(getRawType())) {
     222                        return false;
    223223                }
    224224                return true;

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

    r99 r100  
    7676        @Override
    7777        public PropertiesAccess select(Object object) {
    78                 this.properties = (Map<String, Object>)object;
     78                properties = Util.selectObjectForAccess(this, object, Map.class);
    7979                return this;
    8080        }
    … …  
    116116        }
    117117
     118        @Override
     119        public String toString() {
     120                StringBuilder b = new StringBuilder();
     121                b.append(framsClass);
     122                if (getSelected() != null) {
     123                        b.append("(").append(getSelected().size()).append(")");
     124                }
     125                return b.toString();
     126        }
    118127}

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

    r99 r100  
    1414import javax.annotation.concurrent.Immutable;
    1515
    16 import org.apache.log4j.Logger;
     16import org.apache.logging.log4j.Logger;
     17import org.apache.logging.log4j.LogManager;
    1718
    1819import com.framsticks.params.annotations.AutoAppendAnnotation;
    … …  
    3334 */
    3435public class ReflectionAccess extends SimpleAbstractAccess {
    35         private final static Logger log = Logger.getLogger(ReflectionAccess.class.getName());
     36        private final static Logger log = LogManager.getLogger(ReflectionAccess.class.getName());
    3637
    3738        protected final Class<?> javaClass;
    … …  
    8889                        }
    8990
    90                         log.debug("constructing backend for " + id);
     91                        log.debug("constructing backend for {}", id);
    9192                        backend = new Backend();
    9293
    … …  
    9697                                for (final ProcedureParam pp : filterInstanceof(framsClass.getParamEntries(), ProcedureParam.class)) {
    9798                                        if (!candidates.containsKey(pp.getId())) {
    98                                                 log.trace("java class does implement method " + pp);
     99                                                log.trace("java class does implement method {}", pp);
    99100                                                continue;
    100101                                        }
    … …  
    114115                                for (final EventParam ep : filterInstanceof(framsClass.getParamEntries(), EventParam.class)) {
    115116                                        if (!candidates.containsKey(ep.getId())) {
    116                                                 log.trace("java class does not implement the event param " + ep);
     117                                                log.trace("java class does not implement the event param {}", ep);
    117118                                                continue;
    118119                                        }
    … …  
    312313                                if (s == null) {
    313314                                        throw new FramsticksException().msg("trying to set unsettable");
     315                                        // return;
     316                                        // if (value != backend.getters.get(param).get(object, Object.class)) {
     317                                        // }
    314318                                }
    315319                                s.set(object, value);
    … …  
    412416        @Override
    413417        public ReflectionAccess select(Object object) {
    414                 assert object == null || javaClass.isInstance(object);
    415                 this.object = object;
     418                this.object = Util.selectObjectForAccess(this, object, javaClass);
    416419                return this;
    417420        }
    … …  
    447450                        e.printStackTrace();
    448451                }
    449                 log.fatal("failed to create reflected object of class " + javaClass.getCanonicalName() + " for frams type " + framsClass.getId());
     452                log.fatal("failed to create reflected object of class {} for frams type {}", javaClass.getCanonicalName(), framsClass.getId());
    450453                return null;
    451454        }
    … …  
    459462                                if (m.getParameterTypes()[0].isAssignableFrom(value.getClass())) {
    460463                                        try {
    461                                                 log.trace("auto appending with value " + value + " with method " + m);
     464                                                log.trace("auto appending with value {} with method {}", value, m);
    462465                                                m.invoke(object, value);
    463466                                                return;
    … …  
    474477        }
    475478
     479        @Override
     480        public String toString() {
     481                StringBuilder b = new StringBuilder();
     482                b.append(framsClass);
     483                if (getSelected() != null) {
     484                        b.append("(").append(getSelected()).append(")");
     485                }
     486                return b.toString();
     487        }
    476488}
    477489

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

    r99 r100  
    11package com.framsticks.params;
    22
    3 import org.apache.log4j.Logger;
     3import org.apache.logging.log4j.Logger;
     4import org.apache.logging.log4j.LogManager;
    45
    56import com.framsticks.params.annotations.FramsClassAnnotation;
    … …  
    2021@FramsClassAnnotation
    2122public class Registry {
    22         private static final Logger log = Logger.getLogger(Registry.class.getName());
     23        private static final Logger log = LogManager.getLogger(Registry.class.getName());
    2324
    2425        protected final DoubleMap<String, Class<?>> javaClasses = new DoubleMap<>();
    … …  
    8485        }
    8586
    86         public @Nonnull AccessInterface createAccess(String name, FramsClass framsClass) throws ConstructionException {
     87        public @Nonnull Access createAccess(String name, FramsClass framsClass) throws ConstructionException {
    8788                // assert framsClasses.containsValue(framsClass);
    8889                if (javaClasses.containsKey(name)) {
    … …  
    9394
    9495        public FramsClass putFramsClass(FramsClass framsClass) {
    95                 log.debug("caching info for " + framsClass);
     96                log.debug("caching info for {}", framsClass);
    9697                framsClasses.put(framsClass.getId(), framsClass.getName(), framsClass);
    9798                return framsClass;
     99        }
     100
     101        public FramsClass getFramsClass(@Nonnull CompositeParam param) {
     102                return framsClasses.get(param.getContainedTypeName());
    98103        }
    99104
    … …  
    102107        }
    103108
    104         public static @Nonnull AccessInterface wrapAccessWithListIfNeeded(@Nonnull CompositeParam param, @Nonnull AccessInterface access) {
    105                 return param.prepareAccessInterface(access);
     109        public static @Nonnull Access wrapAccessWithListIfNeeded(@Nonnull CompositeParam param, @Nonnull Access access) {
     110                return param.prepareAccess(access);
    106111        }
    107112
    108         public @Nonnull AccessInterface prepareAccess(CompositeParam param) throws ConstructionException {
     113        public @Nonnull Access prepareAccess(CompositeParam param) throws ConstructionException {
    109114                return wrapAccessWithListIfNeeded(param, createAccess(param.getContainedTypeName()));
    110115        }
    111116
    112         public @Nonnull AccessInterface createAccess(@Nonnull String name) throws ConstructionException {
     117        public @Nonnull Access createAccess(@Nonnull String name) throws ConstructionException {
    113118                try {
    114119                        Strings.assureNotEmpty(name);

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

    r99 r100  
    44import static com.framsticks.util.lang.Containers.filterInstanceof;
    55
    6 import org.apache.log4j.Logger;
     6import org.apache.logging.log4j.Logger;
     7import org.apache.logging.log4j.LogManager;
    78
    89import com.framsticks.params.types.ObjectParam;
    … …  
    1112
    1213/**
    13  * The Class SimpleAbstractAccess implements all the methods of AccessInterface
    14  * which actions can be implemented with usage of {@link AccessInterface} methods
     14 * The Class SimpleAbstractAccess implements all the methods of Access
     15 * which actions can be implemented with usage of {@link Access} methods
    1516 * or concern schema, which is stored in {@link #framsClass}
    1617 *
    … …  
    2223 * @author Piotr Sniegowski
    2324 */
    24 public abstract class SimpleAbstractAccess implements AccessInterface {
    25 
    26         private final static Logger log = Logger.getLogger(SimpleAbstractAccess.class.getName());
     25public abstract class SimpleAbstractAccess implements Access {
     26
     27        private final static Logger log = LogManager.getLogger(SimpleAbstractAccess.class.getName());
    2728
    2829        protected final FramsClass framsClass;
    … …  
    190191        }
    191192
    192         private Entry readEntry(SourceInterface source) {
     193        private static Entry readEntry(SourceInterface source) {
    193194
    194195                String line;
    195196                String key = null;
    196197                StringBuilder value = null;
    197                 while ((line = source.readLine()) != null)
    198                 {
     198                while ((line = source.readLine()) != null) {
    199199                        if (key == null) {
    200200                                int colonIndex = line.indexOf(':');
    … …  
    216216                                value.append(System.getProperty("line.separator"));
    217217                        }
    218                         if (line.contains("~")) {
    219                                 value.append(line.substring(0, line.indexOf("~")));
    220                                 return new Entry(key, value.toString());
     218                        if (line.endsWith("~") && !line.endsWith("\\~")) {
     219                                value.append(line.substring(0, line.length() - 1));
     220                                return new Entry(key, value.toString().replaceAll("\\\\~", "~"));
    221221                        }
    222222                        value.append(line);
    223                         /*
    224                         if (line.contains("~")) {
    225                                 String lastLine = line.substring(0, line.indexOf("~"));
    226                                 if (lastLine.length() > 0) {
    227                                         appendToValue(value, lastLine);
    228                                 }
    229                                 return new Entry(key, value.toString());
    230                         }
    231                         appendToValue(value, line);
    232                         */
    233223                }
    234224                return null;
    … …  
    244234                        Param param = getParam(entry.key);
    245235                        if (param == null) {
    246                                 continue;
     236                                throw new FramsticksException().msg("param not found in access").arg("name", entry.key).arg("access", this);
    247237                        }
    248238                        if (!(param instanceof ValueParam)) {
    249                                 log.warn("param " + param + " is not a ValueParam");
    250                                 continue;
    251                         }
    252                         if ((param.getFlags() & ParamFlags.DONTLOAD) != 0) {
    253                                 log.debug("DontLoad flag was set - not loading...");
    254                         } else {
     239                                throw new FramsticksException().msg("param is not a value param").arg("param", param).arg("access", this);
     240                        }
     241                        if ((param.getFlags() & ParamFlags.DONTLOAD) == 0) {
    255242                                int retFlags = this.set((ValueParam) param, entry.value);
    256243                                if ((retFlags & (PSET_HITMIN | PSET_HITMAX)) != 0) {
    257244                                        String which = ((retFlags & PSET_HITMIN) != 0) ? "small" : "big";
    258                                         log.warn("value of key '" + entry.key + "' was too " + which + ", adjusted");
     245                                        log.warn("value of key '{}' was too {}, adjusted", entry.key, which);
    259246                                }
    260247                        }
    … …  
    297284        }*/
    298285
    299         @Override
    300         public String toString() {
    301                 StringBuilder b = new StringBuilder();
    302                 b.append(framsClass);
    303                 if (getSelected() != null) {
    304                         b.append("(").append(getSelected()).append(")");
    305                 }
    306                 return b.toString();
    307         }
    308286
    309287        @Override

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

    r99 r100  
    77import com.framsticks.util.lang.Casting;
    88import com.framsticks.util.lang.Numbers;
    9 import org.apache.log4j.Logger;
     9import org.apache.logging.log4j.Logger;
     10import org.apache.logging.log4j.LogManager;
    1011
    1112import java.util.*;
    … …  
    1617public class UniqueListAccess extends ListAccess {
    1718
    18         private static final Logger log = Logger.getLogger(UniqueListAccess.class);
     19        private static final Logger log = LogManager.getLogger(UniqueListAccess.class);
    1920
    2021        Map<String, Object> map;
    2122
    22         final String uidName;
    23 
    24         public UniqueListAccess(AccessInterface elementAccess, String uidName) {
     23        protected final String uidName;
     24        protected final Access uidAccess;
     25
     26        public UniqueListAccess(Access elementAccess, String uidName) {
    2527                super(elementAccess);
    2628                this.uidName = uidName;
     29                uidAccess = elementAccess.cloneAccess();
    2730        }
    2831
    … …  
    3538        }
    3639
     40        /**
     41         * @return the uidName
     42         */
     43        public String getUidName() {
     44                return uidName;
     45        }
     46
    3747        public static class UidComparator implements Comparator<String> {
    3848
    39                 protected String name;
     49                protected Object description;
     50
    4051
    4152                /**
    42                  * @param name
     53                 * @param description
    4354                 */
    44                 public UidComparator(String name) {
    45                         this.name = name;
     55                public UidComparator(Object description) {
     56                        this.description = description;
    4657                }
    4758
    … …  
    6576                @Override
    6677                public String toString() {
    67                         return "comparator " + name;
    68                 }
    69 
    70 
     78                        return "comparator " + description;
     79                }
     80
     81
     82        }
     83
     84        public static <T> Map<String, T> createMap(Class<T> type, Object description) {
     85                return new TreeMap<String, T>(new UidComparator(description));
     86        }
     87
     88        public static <M, T extends M> int getNumberInMap(Map<String, M> map, T object) {
     89                Iterator<Map.Entry<String, M>> iterator = map.entrySet().iterator();
     90                int number = 0;
     91                while (iterator.hasNext()) {
     92                        if (iterator.next().getValue() == object) {
     93                                return number;
     94                        }
     95                        ++number;
     96                }
     97                return -1;
    7198        }
    7299
    73100        @Override
    74101        public Map<String, Object> createAccessee() {
    75                 return new TreeMap<String, Object>(new UidComparator(elementAccess.toString()));
     102                return createMap(Object.class, elementAccess);
    76103        }
    77104
    … …  
    92119                        return null;
    93120                }
    94                 return paramBuilder.id(getUidOf(iterator.next().getValue())).finish(CompositeParam.class);
     121                return paramBuilder.id(iterator.next().getKey()).finish(CompositeParam.class);
    95122        }
    96123
    … …  
    110137                return paramBuilder.id(id).finish(CompositeParam.class);
    111138        }
     139
    112140
    113141        @Override
    … …  
    156184
    157185        public String getUidOf(Object value) {
    158                 Object tmp = elementAccess.getSelected();
    159                 elementAccess.select(value);
    160                 String uid = elementAccess.get(uidName, String.class);
    161                 elementAccess.select(tmp);
    162                 return uid;
     186                return uidAccess.select(value).get(uidName, String.class);
    163187        }
    164188
    … …  
    227251        @Override
    228252        public UniqueListAccess select(Object object) {
    229                 assert (object instanceof Map);
    230                 map = (Map<String, Object>) object;
     253                map = Util.selectObjectForAccess(this, object, Map.class);
    231254                return this;
    232255        }
    … …  
    242265        }
    243266
    244         public String computeIdentifierFor(Object selected) {
    245                 String uid = getUidOf(selected);
    246                 if (uid == null) {
    247                         log.error("missing uid field");
    248                         return null;
    249                 }
    250                 return uid;
    251         }
     267        // public String computeIdentifierFor(Object selected) {
     268        //      String uid = getUidOf(selected);
     269        //      if (uid == null) {
     270        //              log.error("missing uid field");
     271        //              return null;
     272        //      }
     273        //      return uid;
     274        // }
    252275
    253276        @Override

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

    r99 r100  
    2424        }
    2525
    26         public static <T> List<T> stripAccessInterface(List<AccessInterface> accesses, Class<T> type) {
     26        public static <T> List<T> stripAccess(List<Access> accesses, Class<T> type) {
    2727                List<T> result = new ArrayList<T>();
    28                 for (AccessInterface a : accesses) {
     28                for (Access a : accesses) {
    2929                        Object object = a.getSelected();
    3030                        if (!type.isInstance(object)) {
    … …  
    3636        }
    3737
    38         public static int takeAllNonNullValues(AccessInterface to, AccessInterface from) {
     38        public static int takeAllNonNullValues(Access to, Access from) {
    3939                int copied = 0;
    4040                for (ValueParam f : filterInstanceof(from.getParams(), ValueParam.class)) {
    … …  
    4343                                continue;
    4444                        }
     45                        // if (to.get(f, Object.class) != null) {
     46                        //      continue;
     47                        // }
    4548                        to.set(f, v);
    4649                        ++copied;
    … …  
    4952        }
    5053
    51         public static int copyExistingParamsTypeSafe(AccessInterface to, AccessInterface from) {
     54        public static int copyExistingParamsTypeSafe(Access to, Access from) {
    5255                int copied = 0;
    5356                for (ValueParam f : filterInstanceof(from.getParams(), ValueParam.class)) {
    … …  
    6568        }
    6669
     70        public static <T> T selectObjectForAccess(Access access, Object object, Class<T> type) {
     71                if (object == null) {
     72                        return null;
     73                }
     74                if (!type.isInstance(object)) {
     75                        throw new FramsticksException().msg("trying to select object of wrong type").arg("object", object).arg("type", object.getClass()).arg("in", access);
     76                }
     77                return type.cast(object);
     78        }
     79
     80        public static int getNumberOfCompositeParamChild(Access access, Object child) {
     81                int count = access.getCompositeParamCount();
     82                for (int i = 0; i < count; ++i) {
     83                        if (access.get(i, Object.class) == child) {
     84                                return i;
     85                        }
     86                }
     87                return -1;
     88        }
     89
    6790}

  • java/main/src/main/java/com/framsticks/params/types/ArrayListParam.java

    r87 r100  
    11package com.framsticks.params.types;
    22
    3 import com.framsticks.params.AccessInterface;
     3import com.framsticks.params.Access;
    44import com.framsticks.params.ArrayListAccess;
    55import com.framsticks.params.CastFailure;
    … …  
    77import com.framsticks.params.ReassignResult;
    88import com.framsticks.util.lang.Casting;
    9 import com.framsticks.util.lang.Containers;
    109import com.framsticks.util.lang.Numbers;
    1110
    12 import java.util.ArrayList;
    1311import java.util.List;
    1412
    … …  
    3230
    3331        @Override
    34         public AccessInterface prepareAccessInterface(AccessInterface access) {
     32        public Access prepareAccess(Access access) {
    3533                return new ArrayListAccess(access);
    3634        }
    … …  
    4947                if (size != null) {
    5048                        //return oldValue;
    51                         List<?> list;
    52                         if (oldValue == null) {
    53                                 list = new ArrayList<Object>();
    54                         } else {
    55                                 list = Casting.tryCast(List.class, oldValue);
    56                                 if (list == null) {
    57                                         throw new CastFailure();
    58                                 }
    59                         }
    60                         Containers.resizeList(list, size);
    61                         return new ReassignResult<List<?>>(list);
     49                        // List<?> list;
     50                        // if (oldValue == null) {
     51                        //      list = new ArrayList<Object>();
     52                        // } else {
     53                        //      list = Casting.tryCast(List.class, oldValue);
     54                        //      if (list == null) {
     55                        //              throw new CastFailure();
     56                        //      }
     57                        // }
     58                        // Containers.resizeList(list, size);
     59                        return new ReassignResult<List<?>>(Casting.tryCast(List.class, oldValue));
     60                        // return new ReassignResult<List<?>>(list);
    6261                }
    63                 if (oldValue != null) {
    64                         return new ReassignResult<List<?>>(Casting.throwCast(List.class, oldValue));
    65                 }
     62                // if (oldValue != null) {
     63                //      return new ReassignResult<List<?>>(Casting.throwCast(List.class, oldValue));
     64                // }
    6665                return new ReassignResult<List<?>>(Casting.throwCast(List.class, newValue));
    6766        }

  • java/main/src/main/java/com/framsticks/params/types/ObjectParam.java

    r98 r100  
    11package com.framsticks.params.types;
    22
    3 import com.framsticks.params.AccessInterface;
     3import com.framsticks.params.Access;
    44import com.framsticks.params.CastFailure;
    55import com.framsticks.params.CompositeParam;
    … …  
    4141
    4242        @Override
    43         public AccessInterface prepareAccessInterface(AccessInterface access) {
     43        public Access prepareAccess(Access access) {
    4444                return access;
    4545        }

  • java/main/src/main/java/com/framsticks/params/types/UniqueListParam.java

    r98 r100  
    11package com.framsticks.params.types;
    22
    3 import com.framsticks.params.AccessInterface;
     3import com.framsticks.params.Access;
    44import com.framsticks.params.CastFailure;
    55import com.framsticks.params.ParamBuilder;
    … …  
    3838
    3939        @Override
    40         public AccessInterface prepareAccessInterface(AccessInterface access) {
     40        public Access prepareAccess(Access access) {
    4141                return new UniqueListAccess(access, uidName);
    4242        }

  • java/main/src/main/java/com/framsticks/parsers/F0Parser.java

    r99 r100  
    2121import com.framsticks.util.lang.Pair;
    2222import com.framsticks.util.lang.Strings;
    23 import org.apache.log4j.Logger;
     23import org.apache.logging.log4j.Logger;
     24import org.apache.logging.log4j.LogManager;
    2425
    2526import com.framsticks.params.FramsClass;
    26 import com.framsticks.params.AccessInterface;
     27import com.framsticks.params.Access;
    2728import static com.framsticks.params.ParamFlags.*;
    2829import static com.framsticks.params.SetStateFlags.*;
    … …  
    3334public class F0Parser {
    3435
    35         private final static Logger log = Logger.getLogger(F0Parser.class);
     36        private final static Logger log = LogManager.getLogger(F0Parser.class);
    3637
    3738        /** The schema proper for f0 representation. */
    3839        protected final Schema schema;
    3940        protected final InputStream is;
    40         protected final List<AccessInterface> result = new ArrayList<AccessInterface>();
     41        protected final List<Access> result = new ArrayList<Access>();
    4142        int lineNumber = 0;
    4243
    … …  
    4849        }
    4950
    50         protected AccessInterface processLine(String line) {
     51        protected Access processLine(String line) {
    5152                try {
    5253
    … …  
    5758                                throw new Exception("unknown class id: " + classId);
    5859                        }
    59                         AccessInterface access = schema.getRegistry().createAccess(classId, framsClass);
     60                        Access access = schema.getRegistry().createAccess(classId, framsClass);
    6061                        access.select(access.createAccessee());
    6162                        for (Exception e : loadFromLine(access, p.second)) {
    … …  
    8485         *             the parse exception
    8586         */
    86         public List<AccessInterface> parse() {
     87        public List<Access> parse() {
    8788
    8889                try (InputStreamReader reader = new InputStreamReader(is, Encoding.getDefaultCharset())) {
    … …  
    105106                                        continue;
    106107                                }
    107                                 AccessInterface access = processLine(line);
     108                                Access access = processLine(line);
    108109                                if (access != null) {
    109110                                        result.add(access);
    … …  
    123124
    124125        private static void warn(int lineNumber, String message, Exception e) {
    125                 log.warn("in line " + lineNumber + " the following error occurred (" + message + "): " + e);
     126                log.warn("in line {} the following error occurred ({}): {}", lineNumber, message, e);
    126127        }
    127128
    … …  
    170171        }
    171172
    172         public List<Exception> loadFromLine(AccessInterface access, String parameters) throws Exception {
     173        public List<Exception> loadFromLine(Access access, String parameters) throws Exception {
    173174
    174175                List<Entry> entries = breakIntoEntries(parameters);
    … …  
    250251        }
    251252
    252         private static Exception createBoundaryHitException(AccessInterface access, PrimitiveParam<?> param, String value, int flag) {
     253        private static Exception createBoundaryHitException(Access access, PrimitiveParam<?> param, String value, int flag) {
    253254                boolean minimum = (flag & PSET_HITMIN) != 0;
    254255                String boundary = (minimum ? param.getMin(Object.class) : param.getMax(Object.class)).toString();

  • java/main/src/main/java/com/framsticks/parsers/F0Writer.java

    r99 r100  
    3030        }
    3131
    32         protected void write(AccessInterface access) {
     32        protected void write(Access access) {
    3333                if (access instanceof ListAccess) {
    3434                        // TODO
    … …  
    4545                for (ValueParam param : filterInstanceof(access.getParams(), ValueParam.class)) {
    4646                        if (param instanceof CompositeParam) {
    47                                 AccessInterface a = schema.getRegistry().prepareAccess((CompositeParam) param);
     47                                Access a = schema.getRegistry().prepareAccess((CompositeParam) param);
    4848                                a.select(access.get((ValueParam) param, Object.class));
    4949                                write(a);
    … …  
    8181
    8282        public void write() {
    83                 AccessInterface access = schema.getRegistry().createAccess("m");
     83                Access access = schema.getRegistry().createAccess("m");
    8484                access.select(model);
    8585                write(access);

  • java/main/src/main/java/com/framsticks/parsers/GenotypeLoader.java

    r99 r100  
    55import com.framsticks.params.types.*;
    66
    7 import org.apache.log4j.Logger;
     7import org.apache.logging.log4j.Logger;
     8import org.apache.logging.log4j.LogManager;
    89import static com.framsticks.params.ParamFlags.*;
    910
    1011public class GenotypeLoader extends MultiParamLoader {
    1112        private Genotype genotypeReturnObject = new Genotype();
    12         private static Logger logger = Logger.getLogger(GenotypeLoader.class);
     13        private static Logger logger = LogManager.getLogger(GenotypeLoader.class);
    1314
    1415        public GenotypeLoader() throws Exception {
    … …  
    5455                        .finish();
    5556
    56                 AccessInterface reflectionParam = new PropertiesAccess(entries);
    57                 addAccessInterface(reflectionParam);
     57                Access reflectionParam = new PropertiesAccess(entries);
     58                addAccess(reflectionParam);
    5859                addBreakCondition(Status.AfterObject);
    5960        }

  • java/main/src/main/java/com/framsticks/parsers/Loaders.java

    r96 r100  
    44
    55import com.framsticks.params.*;
    6 // import org.apache.log4j.Logger;
     6// import org.apache.logging.log4j.Logger;
    77
    88/**
    … …  
    1111public class Loaders {
    1212
    13         // private static final Logger log = Logger.getLogger(Loaders.class.getName());
     13        // private static final Logger log = LogManager.getLogger(Loaders.class.getName());
    1414
    1515        public static @Nonnull FramsClass loadFramsClass(SourceInterface source) throws ConstructionException {
    … …  
    1919                final FramsClassBuilder builder = FramsClass.build();
    2020
    21                 final AccessInterface framsClassAccess = new ReflectionAccess(FramsClassBuilder.class, FramsClass.build().forClass(FramsClassBuilder.class));
    22                 AccessInterface paramBuilderAccess = new ReflectionAccess(ParamBuilder.class, FramsClass.build().forClass(ParamBuilder.class));
     21                final Access framsClassAccess = new ReflectionAccess(FramsClassBuilder.class, FramsClass.build().forClass(FramsClassBuilder.class));
     22                Access paramBuilderAccess = new ReflectionAccess(ParamBuilder.class, FramsClass.build().forClass(ParamBuilder.class));
    2323                framsClassAccess.select(builder);
    24                 loader.addAccessInterface(framsClassAccess);
    25                 loader.addAccessInterface(paramBuilderAccess);
     24                loader.addAccess(framsClassAccess);
     25                loader.addAccess(paramBuilderAccess);
    2626
    2727                loader.addListener(MultiParamLoader.Status.AfterObject, new MultiParamLoader.StatusListener() {

  • java/main/src/main/java/com/framsticks/parsers/MultiParamLoader.java

    r97 r100  
    22
    33import com.framsticks.params.*;
    4 import org.apache.log4j.Logger;
     4import org.apache.logging.log4j.Logger;
     5import org.apache.logging.log4j.LogManager;
    56
    67import java.util.*;
    … …  
    1213        }
    1314
    14         private final static Logger log = Logger.getLogger(MultiParamLoader.class);
     15        private final static Logger log = LogManager.getLogger(MultiParamLoader.class);
    1516
    1617        /**
    … …  
    1819         * should be passed.
    1920         */
    20         public AccessInterface getLastAccessInterface() {
    21                 return lastAccessInterface;
     21        public Access getLastAccess() {
     22                return lastAccess;
    2223        }
    2324
    … …  
    3940        }
    4041
    41         protected AccessInterface lastAccessInterface;
     42        protected Access lastAccess;
    4243
    4344        protected static final FramsClass emptyFramsClass = FramsClass.build().idAndName("<empty>").finish();
    … …  
    4647         * objects in the file.
    4748         */
    48         protected AccessInterface emptyParam = new PropertiesAccess(emptyFramsClass);
     49        protected Access emptyParam = new PropertiesAccess(emptyFramsClass);
    4950
    5051        /**
    … …  
    8788         * List of known classes.
    8889         */
    89         private Map<String, AccessInterface> knownParamInterfaces = new HashMap<String, AccessInterface>();
     90        private Map<String, Access> knownParamInterfaces = new HashMap<String, Access>();
    9091
    9192        /**
    … …  
    132133                                }
    133134                        }
    134                         log.trace("read line: " + currentLine);
     135                        log.trace("read line: {}", currentLine);
    135136
    136137                        // empty line
    … …  
    158159                        }
    159160
    160                         // log.warn("unknown line: " + currentLine);
     161                        // log.warn("unknown line: {}", currentLine);
    161162                        changeStatus(Status.OnError);
    162163                        if (action == LoopAction.Break) {
    … …  
    177178         */
    178179        private LoopAction tryReadObject() {
    179                 if (status == Status.BeforeObject
    180                                 || (status == Status.BeforeUnknown && lastAccessInterface != null)) {
     180                if (status == Status.BeforeObject || (status == Status.BeforeUnknown && lastAccess != null)) {
    181181                        // found object - let it load data
    182                         if (lastAccessInterface.getSelected() == null) {
    183                                 lastAccessInterface.select(lastAccessInterface.createAccessee());
    184                         }
    185                         log.trace("loading into " + lastAccessInterface);
    186                         lastAccessInterface.load(currentSource);
     182                        if (lastAccess.getSelected() == null) {
     183                                lastAccess.select(lastAccess.createAccessee());
     184                        }
     185                        log.trace("loading into {}", lastAccess);
     186                        lastAccess.load(currentSource);
    187187
    188188                        if (changeStatus(Status.AfterObject)) {
    … …  
    191191                        return LoopAction.Continue;
    192192                } else if (status == Status.BeforeUnknown) {
    193                         log.warn("omitting unknown object: " + lastUnknownObjectName);
     193                        log.warn("omitting unknown object: {}", lastUnknownObjectName);
    194194
    195195                        // found unknown object
    … …  
    262262                if (line.charAt(line.length() - 1) == ':') {
    263263                        String typeName = line.substring(0, line.length() - 1);
    264                         lastAccessInterface = knownParamInterfaces.get(typeName);
    265 
    266                         if (lastAccessInterface != null) {
     264                        lastAccess = knownParamInterfaces.get(typeName);
     265
     266                        if (lastAccess != null) {
    267267                                if (changeStatus(Status.BeforeObject)) {
    268268                                        return LoopAction.Break;
    … …  
    299299         * Adds another class.
    300300         */
    301         public void addAccessInterface(AccessInterface accessInterface) {
     301        public void addAccess(Access access) {
    302302                /**TODO: by id or by name? rather by id, because from file is always lowercase*/
    303                 knownParamInterfaces.put(accessInterface.getId(), accessInterface);
     303                knownParamInterfaces.put(access.getId(), access);
    304304        }
    305305
    … …  
    325325
    326326        public boolean setNewSource(SourceInterface source) {
    327                 log.debug("switching current source to " + source.getFilename() + "...");
     327                log.debug("switching current source to {}...", source.getFilename());
    328328
    329329                currentSource = source;
    … …  
    345345                // check if it is already included and break if it is
    346346                if (isAlreadyIncluded(includeFilename)) {
    347                         log.debug("circular reference ignored (" + includeFilename
    348                                         + ")");
     347                        log.debug("circular reference ignored ({})", includeFilename);
    349348                        return;
    350349                }
    351350
    352                 log.info("including file " + includeFilename + "...");
     351                log.info("including file {}...", includeFilename);
    353352
    354353                SourceInterface newSource = currentSource.openInclude(includeFilename);
    … …  
    369368                for (String file : fileStack) {
    370369                        if (filename.equals(file)) {
    371                                 log.warn("file " + filename + " was already included");
     370                                log.warn("file {} was already included", filename);
    372371                                return true;
    373372                        }
    … …  
    400399         */
    401400        private boolean changeStatus(Status status) {
    402                 log.trace("changing status: " + this.status.toString() + " -> " + status.toString());
     401                log.trace("changing status: {} -> {}", this.status.toString(), status.toString());
    403402                this.status = status;
    404403                if (listeners.containsKey(status)) {
    … …  
    411410
    412411        public Object returnObject() {
    413                 assert lastAccessInterface != null;
    414                 Object result = lastAccessInterface.getSelected();
     412                assert lastAccess != null;
     413                Object result = lastAccess.getSelected();
    415414                if (result == null) {
    416415                        return null;
    417416                }
    418                 lastAccessInterface.select(null);
     417                lastAccess.select(null);
    419418                return result;
    420419        }
    … …  
    426425                listeners.get(status).add(listener);
    427426        }
     427
     428        public static List<Object> loadAll(SourceInterface source, Access access) {
     429                final List<Object> result = new LinkedList<>();
     430
     431                final MultiParamLoader loader = new MultiParamLoader();
     432                loader.setNewSource(source);
     433                loader.addAccess(access);
     434                loader.addListener(MultiParamLoader.Status.AfterObject, new StatusListener() {
     435                        @Override
     436                        public void onStatusChange() {
     437                                result.add(loader.returnObject());
     438                        }
     439                });
     440                loader.go();
     441                return result;
     442        }
    428443}

  • java/main/src/main/java/com/framsticks/parsers/Savers.java

    r96 r100  
    1010        public static <S extends SinkInterface> S saveFramsClass(S sink, FramsClass framsClass) {
    1111
    12                 AccessInterface framsClassAccess = new ReflectionAccess(FramsClass.class);
    13                 AccessInterface paramAccess = new ReflectionAccess(Param.class);
     12                Access framsClassAccess = new ReflectionAccess(FramsClass.class);
     13                Access paramAccess = new ReflectionAccess(Param.class);
    1414                framsClassAccess.select(framsClass);
    1515                framsClassAccess.save(sink);

  • java/main/src/main/java/com/framsticks/parsers/XmlLoader.java

    r99 r100  
    11package com.framsticks.parsers;
    22
     3import java.io.File;
     4import java.io.FileInputStream;
     5import java.io.FileNotFoundException;
    36import java.io.InputStream;
    47import java.util.LinkedList;
    … …  
    811import javax.xml.parsers.DocumentBuilderFactory;
    912
    10 import org.apache.log4j.Logger;
     13import org.apache.logging.log4j.Logger;
     14import org.apache.logging.log4j.LogManager;
    1115import org.w3c.dom.Document;
    1216import org.w3c.dom.Element;
    … …  
    1519import org.w3c.dom.NodeList;
    1620
    17 import com.framsticks.params.AccessInterface;
     21import com.framsticks.params.Access;
    1822import com.framsticks.params.Registry;
    1923import com.framsticks.util.AutoBuilder;
    … …  
    2226
    2327public class XmlLoader {
    24         private static final Logger log = Logger.getLogger(XmlLoader.class);
     28        private static final Logger log = LogManager.getLogger(XmlLoader.class);
    2529
    2630        protected Registry registry = new Registry();
    … …  
    3034         */
    3135        public XmlLoader() {
     36                registry.registerAndBuild(AutoInjector.class);
    3237        }
    3338
    … …  
    5661        }
    5762
    58         public Object processElement(Element element) {
     63        public Object processElement(Element element, Class<?> enclosingClass) {
    5964                final String name = mangleName(element.getNodeName());
    6065                if (name.equals("import")) {
    … …  
    6772                        }
    6873                }
     74                if (name.equals("include")) {
     75                        String fileName = element.getAttribute("file");
     76                        if (Strings.notEmpty(fileName)) {
     77                                try {
     78                                        return load(new FileInputStream(new File(fileName)), enclosingClass);
     79                                } catch (FileNotFoundException e) {
     80                                        throw new FramsticksException().msg("failed to include file").arg("file", fileName).cause(e);
     81                                }
     82                        }
     83                        String resourceName = element.getAttribute("resource");
     84                        if (Strings.notEmpty(resourceName)) {
     85                                Class<?> javaClass = enclosingClass;
     86                                String className = element.getAttribute("class");
     87                                if (Strings.notEmpty(className)) {
     88                                        try {
     89                                                javaClass = Class.forName(className);
     90                                        } catch (ClassNotFoundException e) {
     91                                                throw new FramsticksException().msg("failed to find class for resource loading").arg("class name", className).cause(e);
     92                                        }
     93                                }
    6994
    70                 AccessInterface access = registry.createAccess(name);
     95                                return load(javaClass.getResourceAsStream(resourceName), enclosingClass);
     96                        }
     97                        throw new FramsticksException().msg("invalid <include/> node");
     98                }
     99
     100                Access access = registry.createAccess(name);
    71101
    72102                Object object = access.createAccessee();
    … …  
    81111
    82112                NodeList children = element.getChildNodes();
    83                 log.debug("found " + children.getLength() + " children in " + object);
     113                log.debug("found {} children in {}", children.getLength(), object);
    84114                for (int i = 0; i < children.getLength(); ++i) {
    85115                        Node childNode = children.item(i);
    … …  
    87117                                continue;
    88118                        }
    89                         Object childObject = processElement((Element) childNode);
     119                        Object childObject = processElement((Element) childNode, object.getClass());
    90120                        if (childObject == null) {
    91121                                continue;
    … …  
    104134                        }
    105135                }
    106                 log.debug("loaded " + object);
     136                log.debug("loaded {}", object);
    107137
    108138                return object;
    109139        }
    110140
    111         public Object load(InputStream stream) {
     141        protected Object load(InputStream stream, Class<?> enclosingClass) {
    112142                try {
    113143                        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    … …  
    119149                        assert element != null;
    120150
    121                         return processElement(element);
     151                        return processElement(element, enclosingClass);
    122152
    123153                } catch (Exception e) {
    … …  
    129159                registry.registerAndBuild(type);
    130160
    131                 Object object = load(stream);
     161                Object object = load(stream, type);
    132162                if (type.isAssignableFrom(object.getClass())) {
    133163                        return type.cast(object);

  • java/main/src/main/java/com/framsticks/portals/Portal.java

    r98 r100  
    2828        //              public void run() {
    2929        //                      ++counter;
    30         //                      log.debug("counter is now: " + counter);
     30        //                      log.debug("counter is now: {}", counter);
    3131        //                      again();
    3232        //              }

  • java/main/src/main/java/com/framsticks/remote/RecursiveFetcher.java

    r99 r100  
    55import com.framsticks.core.Node;
    66import com.framsticks.core.Path;
    7 import com.framsticks.params.AccessInterface;
     7import com.framsticks.params.Access;
    88import com.framsticks.params.CompositeParam;
    99import com.framsticks.params.FramsClass;
    … …  
    1515import com.framsticks.util.Logging;
    1616import com.framsticks.util.Stopwatch;
    17 import org.apache.log4j.Logger;
     17import org.apache.logging.log4j.Logger;
     18import org.apache.logging.log4j.LogManager;
    1819import static com.framsticks.util.lang.Containers.filterInstanceof;
    1920import com.framsticks.util.dispatching.RunAt;
    … …  
    2425public class RecursiveFetcher {
    2526
    26         private final static Logger log = Logger.getLogger(RecursiveFetcher.class.getName());
     27        private final static Logger log = LogManager.getLogger(RecursiveFetcher.class.getName());
    2728
    2829        protected final Tree tree;
    … …  
    4041        protected void finished() {
    4142                assert tree.isActive();
    42                 log.info("recursively fetched in " + stopwatch);
     43                log.info("recursively fetched in {}", stopwatch);
    4344                future.pass(null);
    4445        }
    … …  
    4748                assert tree.isActive();
    4849                if (path == null || !path.isResolved()) {
    49                         log.warn("path " + path + " is not resolved - skipping");
     50                        log.warn("path {} is not resolved - skipping", path);
    5051                } else {
    51                         AccessInterface access = bindAccess(path);
     52                        Access access = bindAccess(path);
    5253                        FramsClass framsClass = access.getFramsClass();
    5354                        assert framsClass != null;
    … …  
    8687                        @Override
    8788                        public void handle(FramsticksException e) {
    88                                 log.error("failed to fetch values for " + path + ": " + e);
     89                                log.error("failed to fetch values for {}: ", path, e);
    8990                                process(null);
    9091                        }

  • java/main/src/main/java/com/framsticks/remote/RemoteTree.java

    r99 r100  
    1515import com.framsticks.params.types.EventParam;
    1616import com.framsticks.params.types.ProcedureParam;
     17import com.framsticks.parsers.Loaders;
    1718import com.framsticks.parsers.MultiParamLoader;
    1819import com.framsticks.core.Tree;
    1920import com.framsticks.util.*;
     21import com.framsticks.util.dispatching.AtOnceDispatcher;
    2022import com.framsticks.util.dispatching.Dispatching;
    2123import com.framsticks.util.dispatching.Dispatching.DispatcherWaiter;
     24import com.framsticks.util.dispatching.DispatchingFuture;
     25import com.framsticks.util.dispatching.ExceptionResultHandler;
    2226import com.framsticks.util.dispatching.Future;
    2327import com.framsticks.util.dispatching.FutureHandler;
    … …  
    3438import javax.annotation.Nonnull;
    3539
    36 import org.apache.log4j.Logger;
     40import org.apache.logging.log4j.Logger;
     41import org.apache.logging.log4j.LogManager;
    3742
    3843/**
    … …  
    4247public final class RemoteTree extends AbstractTree implements JoinableParent {
    4348
    44         private final static Logger log = Logger.getLogger(RemoteTree.class);
     49        private final static Logger log = LogManager.getLogger(RemoteTree.class);
    4550
    4651        protected ClientSideManagedConnection connection;
    … …  
    6267        public void setConnection(final ClientSideManagedConnection connection) {
    6368                this.connection = connection;
     69                this.connection.setExceptionHandler(this);
    6470        }
    6571
    … …  
    7480        }
    7581
    76         @Override
    77         public void get(final Path path, final ValueParam param, final Future<Object> future) {
    78                 assert isActive();
    79                 assert param != null;
    80                 // assert path.isResolved();
    81                 //TODO only do that if needed
    82                 connection.send(new GetRequest().field(param.getId()).path(path.getTextual()), this, new ClientSideResponseFuture(future) {
    83                         @Override
    84                         protected void processOk(Response response) {
    85                                 assert isActive();
    86                                 processFetchedValues(path, response.getFiles());
    87                                 future.pass(bindAccess(path.tryResolveIfNeeded()).get(param, Object.class));
    88                         }
    89                 });
    90         }
     82        protected ExceptionResultHandler pathRemoveHandler(final Path path, final ExceptionResultHandler handler) {
     83                return new ExceptionResultHandler() {
     84
     85                        @Override
     86                        public void handle(final FramsticksException exception) {
     87                                Dispatching.dispatchIfNotActive(RemoteTree.this, new RunAt<RemoteTree>(RemoteTree.this) {
     88
     89                                        @Override
     90                                        protected void runAt() {
     91                                                assert path.getTree().isActive();
     92                                                log.info("path is invalid (removing): {}", path);
     93                                                bindAccess(path.getUnder()).set(path.getTop().getParam(), null);
     94                                                handler.handle(exception);
     95                                        }
     96                                });
     97                        }
     98                };
     99        }
     100
     101        // @Override
     102        // public void get(final Path path, final ValueParam param, final Future<Object> future) {
     103        //      assert isActive();
     104        //      assert param != null;
     105        //      // assert path.isResolved();
     106        //      //TODO only do that if needed
     107        //      connection.send(new GetRequest().field(param.getId()).path(path.getTextual()), this, new ClientSideResponseFuture(pathRemoveHandler(path, future)) {
     108        //              @Override
     109        //              protected void processOk(Response response) {
     110        //                      assert isActive();
     111        //                      processFetchedValues(path, response.getFiles());
     112        //                      future.pass(bindAccess(path.tryResolveIfNeeded()).get(param, Object.class));
     113        //              }
     114        //      });
     115        // }
    91116
    92117        protected final Map<String, Set<Future<FramsClass>>> infoRequests = new HashMap<String, Set<Future<FramsClass>>>();
    … …  
    103128                }
    104129
    105                 log.debug("issuing info request for " + name);
     130                log.debug("issuing info request for {}", name);
    106131                final Set<Future<FramsClass>> futures = new HashSet<Future<FramsClass>>();
    107132                futures.add(future);
    108133                infoRequests.put(name, futures);
    109134
    110                 final Future<FramsClass> compositeFuture = new Future<FramsClass>() {
     135                final Future<FramsClass> compositeFuture = DispatchingFuture.create(this, new Future<FramsClass>() {
    111136
    112137                        @Override
    … …  
    122147                        protected void result(FramsClass framsClass) {
    123148                                assert isActive();
     149                                putInfoIntoCache(framsClass);
    124150                                infoRequests.remove(name);
    125151                                for (Future<FramsClass> f : futures) {
    … …  
    127153                                }
    128154                        }
    129                 };
     155                });
    130156
    131157                //TODO: if the info is in the cache, then don't communicate
    132                 connection.send(new InfoRequest().path(path.getTextual()), this, new ClientSideResponseFuture(compositeFuture) {
     158                connection.send(new InfoRequest().path(path.getTextual()), AtOnceDispatcher.getInstance(), new ClientSideResponseFuture(compositeFuture) {
    133159                        @Override
    134160                        protected void processOk(Response response) {
    135                                 assert isActive();
     161                                assert connection.getReceiverDispatcher().isActive();
    136162
    137163                                if (response.getFiles().size() != 1) {
    … …  
    141167                                        throw new FramsticksException().msg("path mismatch").arg("returned path", response.getFiles().get(0).getPath());
    142168                                }
    143                                 FramsClass framsClass = processFetchedInfo(RemoteTree.this, response.getFiles().get(0));
     169                                FramsClass framsClass = Loaders.loadFramsClass(response.getFiles().get(0).getContent());
    144170
    145171                                CompositeParam thisParam = path.getTop().getParam();
    … …  
    155181        public void get(final Path path, final Future<Path> future) {
    156182                assert isActive();
    157 
    158                 log.trace("fetching values for " + path);
    159                 findInfo(path, new FutureHandler<FramsClass>(future) {
     183                final ExceptionResultHandler remover = pathRemoveHandler(path, future);
     184
     185                log.trace("fetching values for {}", path);
     186                findInfo(path, new FutureHandler<FramsClass>(remover) {
    160187                        @Override
    161188                        protected void result(FramsClass result) {
    162189
    163                                 connection.send(new GetRequest().path(path.getTextual()), RemoteTree.this, new ClientSideResponseFuture(future) {
     190                                final Access access = registry.prepareAccess(path.getTop().getParam());
     191                                connection.send(new GetRequest().path(path.getTextual()), AtOnceDispatcher.getInstance(), new ClientSideResponseFuture(remover) {
    164192                                        @Override
    165193                                        protected void processOk(Response response) {
    166                                                 assert isActive();
    167                                                 Path p = path.tryResolveIfNeeded();
    168                                                 processFetchedValues(p, response.getFiles());
    169                                                 future.pass(p.tryResolveIfNeeded().assureResolved());
     194                                                processFetchedValues(path, response.getFiles(), access, future);
    170195                                        }
    171196                                });
    … …  
    179204                final Integer flag = bindAccess(path).set(param, value);
    180205
    181                 log.trace("storing value " + param + " for " + path);
     206                log.trace("storing value {} for {}", param, path);
    182207                //TODO break in passing exception handler is here
    183208                connection.send(new SetRequest().value(value.toString()).field(param.getId()).path(path.getTextual()), this, new ClientSideResponseFuture(future) {
    … …  
    274299                                                        return;
    275300                                                }
    276                                                 AccessInterface access = registry.createAccess(argumentType);
     301                                                Access access = registry.createAccess(argumentType);
    277302                                                Object argument = access.createAccessee();
    278303                                                access.select(argument);
    … …  
    282307                                                A typedArgument = argumentType.cast(argument);
    283308
    284                                                 // log.info("executing event with argument " + argumentType);
     309                                                // log.info("executing event with argument {}", argumentType);
    285310                                                MultiParamLoader loader = new MultiParamLoader();
    286311                                                loader.setNewSource(file.getContent());
    287312                                                loader.addBreakCondition(MultiParamLoader.Status.AfterObject);
    288                                                 loader.addAccessInterface(access);
     313                                                loader.addAccess(access);
    289314                                                loader.go();
    290315

  • java/main/src/main/java/com/framsticks/running/ExternalProcess.java

    r97 r100  
    1212
    1313
    14 import org.apache.log4j.Logger;
     14import org.apache.logging.log4j.Logger;
     15import org.apache.logging.log4j.LogManager;
    1516
    1617import com.framsticks.params.annotations.AutoAppendAnnotation;
    … …  
    3132@FramsClassAnnotation
    3233public class ExternalProcess extends AbstractJoinable implements JoinableParent {
    33         private static final Logger log = Logger.getLogger(ExternalProcess.class);
     34        private static final Logger log = LogManager.getLogger(ExternalProcess.class);
    3435
    3536        protected List<String> arguments = new ArrayList<>();
    … …  
    8384                        try {
    8485                                while ((line = output.readLine()) != null) {
    85                                         log.trace("read line: " + line);
     86                                        log.trace("read line: {}", line);
    8687                                        synchronized (listeners) {
    8788                                                for (OutputListener l : listeners) {
    … …  
    9899                                throw new FramsticksException().msg("failed to wait for process").cause(e);
    99100                        }
    100                         log.debug("process ended " + this);
     101                        log.debug("process ended {}", this);
    101102                        // process = null;
    102103                } catch (FramsticksException e) {
    103                         log.error("exception caught in process " + this, e);
     104                        log.error("exception caught in process {}", this, e);
    104105                }
    105106                interrupt();
    … …  
    119120        @Override
    120121        protected void joinableStart() {
    121                 log.debug("running process with arguments: " + arguments);
     122                log.debug("running process with arguments: {}", arguments);
    122123                builder.command(arguments);
    123124                try {

  • java/main/src/main/java/com/framsticks/running/LoggingOutputListener.java

    r90 r100  
    11package com.framsticks.running;
    22
    3 import org.apache.log4j.Logger;
     3import org.apache.logging.log4j.Logger;
     4import org.apache.logging.log4j.LogManager;
    45
    56import com.framsticks.params.annotations.FramsClassAnnotation;
    … …  
    89public class LoggingOutputListener implements OutputListener {
    910        private static final Logger log =
    10                 Logger.getLogger(LoggingOutputListener.class);
     11                LogManager.getLogger(LoggingOutputListener.class);
    1112
    1213

  • java/main/src/main/java/com/framsticks/test/TestClass.java

    r99 r100  
    11package com.framsticks.test;
    22
     3import java.util.Collections;
    34import java.util.LinkedList;
    45import java.util.List;
     6import java.util.Map;
    57
    6 import org.apache.log4j.Logger;
     8import org.apache.logging.log4j.Logger;
     9import org.apache.logging.log4j.LogManager;
    710
     11import com.framsticks.core.ListChange;
    812import com.framsticks.params.EventListener;
     13import com.framsticks.params.UniqueListAccess;
    914import com.framsticks.params.annotations.FramsClassAnnotation;
    1015import com.framsticks.params.annotations.ParamAnnotation;
    1116import com.framsticks.params.types.ProcedureParam;
    1217
    13 @FramsClassAnnotation(order = {"name", "history", "history_changed", "appendHistory", "resetHistory"}, register = {ChangeEvent.class})
     18@FramsClassAnnotation(
     19        order = {
     20                "name",
     21                "history",
     22                "history_changed",
     23                "appendHistory",
     24                "resetHistory",
     25                "children",
     26                "createChild",
     27                "children_changed"
     28        },
     29        register = {
     30                ChangeEvent.class,
     31                TestChild.class,
     32                ListChange.class
     33        }
     34)
    1435public class TestClass {
    1536        private static final Logger log =
    16                 Logger.getLogger(TestClass.class);
     37                LogManager.getLogger(TestClass.class);
    1738
    1839
    … …  
    2041        protected String history = "initial|";
    2142        protected final List<EventListener<ChangeEvent>> historyListeners = new LinkedList<>();
     43        protected final List<EventListener<ListChange>> childrenListeners = new LinkedList<>();
     44
     45        protected final Map<String, TestChild> children = UniqueListAccess.createMap(TestChild.class, this);
     46        protected int counter = 0;
     47
     48        /**
     49         *
     50         */
     51        public TestClass() {
     52        }
    2253
    2354        /**
    … …  
    5384        }
    5485
     86        /**
     87         * @return the children
     88         */
     89        @ParamAnnotation
     90        public Map<String, TestChild> getChildren() {
     91                return Collections.unmodifiableMap(children);
     92        }
     93
    5594        @ParamAnnotation(paramType = ProcedureParam.class)
    5695        public int appendHistory(String line) {
    57                 log.debug("appending '" + line + "'");
     96                log.debug("appending '{}'", line);
    5897                history = history + line + "|";
    5998                fireHistoryChange();
    … …  
    68107        }
    69108
     109        @ParamAnnotation(paramType = ProcedureParam.class)
     110        public void createChild(String name) {
     111                TestChild child = new TestChild(this);
     112                child.name = name;
     113                children.put(child.getUid(), child);
     114                fireChildrenChange(child, ListChange.Action.Add);
     115        }
     116
    70117        protected void fireHistoryChange() {
    71118                for (EventListener<ChangeEvent> l : historyListeners) {
    … …  
    73120                        event.history = history;
    74121                        l.action(event);
     122                }
     123        }
     124
     125        protected void fireChildrenChange(TestChild child, ListChange.Action action) {
     126                ListChange change = new ListChange(action, UniqueListAccess.getNumberInMap(children, child), child.getUid());
     127                for (EventListener<ListChange> l : childrenListeners) {
     128                        l.action(change);
    75129                }
    76130        }
    … …  
    86140        }
    87141
     142        @ParamAnnotation(id = "children_changed")
     143        public void addChildrenListener(EventListener<ListChange> listener) {
     144                childrenListeners.add(listener);
     145        }
     146
     147        @ParamAnnotation(id = "children_changed")
     148        public void removeChildrenListener(EventListener<ListChange> listener) {
     149                childrenListeners.remove(listener);
     150        }
     151
    88152        @Override
    89153        public String toString() {

  • java/main/src/main/java/com/framsticks/util/Logging.java

    r96 r100  
    11package com.framsticks.util;
    22
    3 import org.apache.log4j.Logger;
     3import org.apache.logging.log4j.Logger;
    44
    55import com.framsticks.util.dispatching.ExceptionResultHandler;
    … …  
    2828                };
    2929        }
     30
     31        public static <T> T passThru(Logger log, String header, T value) {
     32                log.info("{}: {}", header, value);
     33                return value;
     34        }
    3035}

  • java/main/src/main/java/com/framsticks/util/Misc.java

    r88 r100  
    11package com.framsticks.util;
    22
    3 // import org.apache.log4j.Logger;
     3// import org.apache.logging.log4j.Logger;
    44
    55/**
    … …  
    88public class Misc {
    99        // private static final Logger log =
    10         //      Logger.getLogger(Misc.class);
     10        //      LogManager.getLogger(Misc.class);
    1111
    1212        public static class WithType {
    … …  
    3434
    3535        public static boolean equals(Object a, Object b) {
    36                 // log.info("equality of " + withType(a) + " ? " + withType(b));
     36                // log.info("equality of {} ? {}", withType(a), withType(b));
    3737                if (a != null) {
    3838                        return (b != null && a.equals(b));

  • java/main/src/main/java/com/framsticks/util/dispatching/AbstractJoinable.java

    r97 r100  
    1010
    1111import org.apache.commons.collections.CollectionUtils;
    12 import org.apache.log4j.Logger;
     12import org.apache.logging.log4j.Logger;
     13import org.apache.logging.log4j.LogManager;
    1314
    1415import com.framsticks.util.FramsticksException;
    … …  
    1617public abstract class AbstractJoinable implements Joinable {
    1718
    18         private static final Logger log = Logger.getLogger(AbstractJoinable.class);
     19        private static final Logger log = LogManager.getLogger(AbstractJoinable.class);
    1920
    2021        protected final Set<JoinableParent> owners = new HashSet<JoinableParent>();
    … …  
    4142                        }
    4243                }
    43                 log.debug("state: " + b);
     44                log.debug("state: {}", b);
    4445        }
    4546
    … …  
    5354                this.state = state;
    5455
    55                 log.debug(this + " is notifying " + joinableListeners.size() + " parents");
     56                log.debug("{} is notifying {} parents", this, joinableListeners.size());
    5657
    5758                List<JoinableParent> parents = new LinkedList<>();
    … …  
    141142                        }
    142143                        start = owners.isEmpty();
    143                         log.debug(owner + " is using " + this);
     144                        log.debug("{} is using {}", owner, this);
    144145                        owners.add(owner);
    145146                        joinableListeners.add(owner);
    … …  
    161162                        }
    162163                        // assert owners.containsKey(owner);
    163                         log.debug(owner + " is droping " + this);
     164                        log.debug("{} is droping {}", owner, this);
    164165                        owners.remove(owner);
    165166                        stop = owners.isEmpty();

  • java/main/src/main/java/com/framsticks/util/dispatching/Dispatching.java

    r99 r100  
    11package com.framsticks.util.dispatching;
    22
    3 import org.apache.log4j.Logger;
     3import org.apache.logging.log4j.Logger;
     4import org.apache.logging.log4j.LogManager;
    45
    56import com.framsticks.util.FramsticksException;
    … …  
    910 */
    1011public abstract class Dispatching {
    11         private static final Logger log = Logger.getLogger(Dispatching.class);
     12        private static final Logger log = LogManager.getLogger(Dispatching.class);
    1213
    1314        public static boolean isThreadSafe() {
    … …  
    5758
    5859        public static void use(final Joinable joinable, final JoinableParent owner) {
    59                 log.debug("using " + joinable + " by " + owner);
     60                log.debug("using {} by {}", joinable, owner);
    6061                if (joinable.use(owner)) {
    61                         log.debug("started " + joinable);
     62                        log.debug("started {}", joinable);
    6263                } else {
    63                         log.debug("start of " + joinable + " already happened");
     64                        log.debug("start of {} already happened", joinable);
    6465                }
    6566        }
    6667
    6768        public static void drop(final Joinable joinable, final JoinableParent owner) {
    68                 log.debug("droping " + joinable + " by " + owner);
     69                log.debug("droping {} by {}", joinable, owner);
    6970                if (joinable.drop(owner)) {
    70                         log.debug("stoped " + joinable);
     71                        log.debug("stoped {}", joinable);
    7172                } else {
    72                         log.debug("stop of " + joinable + " deferred");
     73                        log.debug("stop of {} deferred", joinable);
    7374                }
    7475        }
    7576
    7677        public static void join(Joinable joinable) throws InterruptedException {
    77                 log.debug("joining " + joinable);
     78                log.debug("joining {}", joinable);
    7879                try {
    7980                        joinable.join();
    8081                } catch (InterruptedException e) {
    81                         log.debug("failed to join " + joinable);
     82                        log.debug("failed to join {}", joinable);
    8283                        throw e;
    8384                }
    84                 log.debug("joined " + joinable);
     85                log.debug("joined {}", joinable);
    8586        }
    8687
    … …  
    9293                        @Override
    9394                        protected void runAt() {
    94                                 log.debug("joinable " + joinable + " is notifying parent " + parent + " about change to " + state);
     95                                log.debug("joinable {} is notifying parent {} about change to {}", joinable, parent, state);
    9596                                parent.childChangedState(joinable, state);
    9697                        }
    … …  
    108109
    109110        public static void joinAbsolutely(Joinable joinable) {
    110                 log.debug("joining absolutely " + joinable);
     111                log.debug("joining absolutely {}", joinable);
    111112                while (true) {
    112113                        try {
    … …  
    116117                                // throw new FramsticksException().msg("failed to join").arg("dispatcher", dispatcher).cause(e);
    117118                        }
    118                         log.debug("waiting for " + joinable);
     119                        log.debug("waiting for {}", joinable);
    119120                        wait(joinable, 500);
    120121                }

  • java/main/src/main/java/com/framsticks/util/dispatching/Monitor.java

    r96 r100  
    11package com.framsticks.util.dispatching;
    22
    3 import org.apache.log4j.Logger;
     3import org.apache.logging.log4j.Logger;
     4import org.apache.logging.log4j.LogManager;
    45import com.framsticks.util.dispatching.Dispatching;
    56import java.lang.Thread;
    … …  
    78public class Monitor implements JoinableParent {
    89        private static final Logger log =
    9                 Logger.getLogger(Monitor.class);
     10                LogManager.getLogger(Monitor.class);
    1011
    1112        protected final Joinable joinable;
    … …  
    3031                Runtime.getRuntime().addShutdownHook(shutdownHook);
    3132
    32                 log.debug(this + " is using");
     33                log.debug("{} is using", this);
    3334                Dispatching.use(joinable, this);
    3435                return this;
    … …  
    4142
    4243        public Monitor waitFor() {
    43                 log.debug(this + " is waiting");
     44                log.debug("{} is waiting", this);
    4445                synchronized (this) {
    4546                        while (joinable.getState().ordinal() < JoinableState.FINISHING.ordinal()) {
    … …  
    4748                        }
    4849                }
    49                 log.debug(this + " ended waiting");
     50                log.debug("{} ended waiting", this);
    5051                return this;
    5152        }
    … …  
    5354
    5455        public Monitor drop() {
    55                 log.debug(this + " is droping");
     56                log.debug("{} is droping", this);
    5657                Dispatching.drop(joinable, this);
    5758                return this;
    … …  
    5960
    6061        public Monitor join() {
    61                 log.debug(this + " is joining");
     62                log.debug("{} is joining", this);
    6263                Dispatching.joinAbsolutely(joinable);
    63                 log.debug(this + " is joined");
     64                log.debug("{} is joined", this);
    6465
    6566                try {
    … …  
    7879                        this.notify();
    7980                }
    80                 log.debug(this + " received notification about transition to " + state);
     81                log.debug("{} received notification about transition to {}", this, state);
    8182        }
    8283

  • java/main/src/main/java/com/framsticks/util/dispatching/Thread.java

    r99 r100  
    11package com.framsticks.util.dispatching;
    22
    3 import org.apache.log4j.Logger;
     3import org.apache.logging.log4j.Logger;
     4import org.apache.logging.log4j.LogManager;
    45
    56import java.util.LinkedList;
    … …  
    1516public class Thread<C> extends AbstractJoinable implements JoinableDispatcher<C> {
    1617
    17         private static final Logger log = Logger.getLogger(Thread.class);
     18        private static final Logger log = LogManager.getLogger(Thread.class);
    1819
    1920        protected final java.lang.Thread thread;
    … …  
    4647
    4748        protected void routine() {
    48                 log.debug("starting thread " + this);
     49                log.debug("starting thread {}", this);
    4950                assert getMonitor() != null;
    5051                ExceptionHandler exceptionHandler = getMonitor().getTaskExceptionHandler();
    … …  
    8384                        }
    8485                }
    85                 log.debug("finishing thread " + this);
     86                log.debug("finishing thread {}", this);
    8687                finish();
    8788        }
    … …  
    138139        protected void joinableJoin() throws InterruptedException {
    139140                thread.join(500);
    140                 log.debug("joined " + this);
     141                log.debug("joined {}", this);
    141142        }
    142143

  • java/main/src/main/java/com/framsticks/util/lang/Casting.java

    r99 r100  
    2929                return class_.cast(object);
    3030        }
     31
     32        public static <T> T nullOrThrowCast(Class<T> class_, Object object) {
     33                if (object == null) {
     34                        return null;
     35                }
     36                return class_.cast(object);
     37        }
    3138}

  • java/main/src/main/java/com/framsticks/util/lang/FlagsUtil.java

    r99 r100  
    22
    33import java.lang.reflect.Field;
    4 import org.apache.log4j.Logger;
     4import org.apache.logging.log4j.Logger;
     5import org.apache.logging.log4j.LogManager;
    56
    67import com.framsticks.util.lang.Delimeted;
    … …  
    89public final class FlagsUtil {
    910
    10         private final static Logger log = Logger.getLogger(FlagsUtil.class);
     11        private final static Logger log = LogManager.getLogger(FlagsUtil.class);
    1112
    1213        private FlagsUtil() {
    … …  
    4142                                        allFlags |= Integer.parseInt(field.get(null).toString());
    4243                                } catch (SecurityException e) {
    43                                         log.warn("security exception was thrown while trying to read flag (" + flag + ")");
     44                                        log.warn("security exception was thrown while trying to read flag ({})", flag);
    4445                                } catch (NoSuchFieldException | IllegalArgumentException | IllegalAccessException e) {
    45                                         log.warn("selected flag is not known (" + flag + ")");
     46                                        log.warn("selected flag is not known ({})", flag);
    4647                                }
    4748                        }

  • java/main/src/main/java/com/framsticks/visualization/SingleViewPanel.java

    r84 r100  
    11package com.framsticks.visualization;
    22
    3 import com.framsticks.gui.Panel;
     3import com.framsticks.gui.TreePanel;
    44import com.framsticks.model.Model;
    5 import com.framsticks.params.AccessInterface;
     5import com.framsticks.params.Access;
    66
    77import javax.swing.*;
    … …  
    1212 */
    1313@SuppressWarnings("serial")
    14 public class SingleViewPanel extends Panel {
     14public class SingleViewPanel extends TreePanel {
    1515
    1616        Viewer viewer;
    1717
    18         public SingleViewPanel(Panel.Parameters parameters) {
     18        public SingleViewPanel(TreePanel.Parameters parameters) {
    1919                super(parameters);
    2020                //viewer = new Viewer();
    … …  
    2626
    2727        @Override
    28         public void pullValuesFromLocalToUser(AccessInterface access) {
     28        public void pullValuesFromLocalToUser(Access access) {
    2929                Object object = access.getSelected();
    3030                if (!(object instanceof Model)) {

  • java/main/src/main/java/com/framsticks/visualization/SingleViewPanelProvider.java

    r84 r100  
    11package com.framsticks.visualization;
    22
    3 import com.framsticks.gui.Panel;
    43import com.framsticks.gui.PanelProvider;
     4import com.framsticks.gui.TreePanel;
    55
    66/**
    … …  
    99public class SingleViewPanelProvider implements PanelProvider {
    1010        @Override
    11         public Panel providePanel(Panel.Parameters parameters) {
     11        public TreePanel providePanel(TreePanel.Parameters parameters) {
    1212                if (parameters.param.getContainedTypeName().equals("Model")) {
    1313                        return new SingleViewPanel(parameters);

  • java/main/src/main/java/com/framsticks/visualization/Viewer.java

    r85 r100  
    1919import java.io.*;
    2020
    21 import org.apache.log4j.Logger;
     21import org.apache.logging.log4j.Logger;
     22import org.apache.logging.log4j.LogManager;
    2223
    2324public class Viewer {
    2425
    25         private static Logger log = Logger.getLogger(Viewer.class);
     26        private static Logger log = LogManager.getLogger(Viewer.class);
    2627
    2728        Canvas3D canvas3d;

  • java/main/src/main/java/com/framsticks/visualization/ViewerTest.java

    r84 r100  
    33import com.sun.j3d.utils.universe.*;
    44import com.sun.j3d.utils.geometry.ColorCube;
    5 import org.apache.log4j.Logger;
     5import org.apache.logging.log4j.Logger;
     6import org.apache.logging.log4j.LogManager;
    67
    78import javax.media.j3d.*;
    … …  
    1718@SuppressWarnings("serial")
    1819public class ViewerTest extends JPanel {
    19         private static final Logger log = Logger.getLogger(ViewerTest.class.getName());
     20        private static final Logger log = LogManager.getLogger(ViewerTest.class.getName());
    2021
    2122        private SimpleUniverse univ = null;

  • java/main/src/main/resources/configs/framsticks.xml

    r99 r100  
    2121                <!-- </LocalTree> -->
    2222                <RemoteTree name="remote" address="localhost:9007" />
    23                 <ColumnsConfig className="Genotype" columnsNames="uid name" />
     23                <include resource="/configs/common-columns.xml" />
     24                <!-- <ColumnsConfig className="Genotype" columnsNames="uid name" /> -->
    2425        </Browser>
    2526        <Server name="server" port="9007">

  • java/main/src/test/java/com/framsticks/core/ListChangeTest.java

    r87 r100  
    11package com.framsticks.core;
     2
     3import java.util.Arrays;
    24
    35import org.testng.annotations.BeforeMethod;
    … …  
    68import com.framsticks.core.ListChange.Action;
    79import com.framsticks.params.FramsClass;
     10import com.framsticks.params.ListSink;
    811import com.framsticks.params.ListSource;
    912import com.framsticks.params.ReflectionAccess;
    … …  
    5760        @Test(dependsOnMethods = "createReflectionAccess")
    5861        public void load() throws Exception {
    59                 access.select(listChange).load(ListSource.createFrom("type:2", "pos:5", "id:test"));
     62                access.select(listChange).load(ListSource.createFrom("type:2", "pos:0", "id:test"));
    6063
    6164                assertThat(listChange.action).isEqualTo(Action.Modify);
    62                 assertThat(listChange.position).isEqualTo(5);
     65                assertThat(listChange.position).isEqualTo(0);
    6366                assertThat(listChange.identifier).isEqualTo("test");
     67
     68                ListSink sink = new ListSink();
     69                access.select(listChange).save(sink);
     70                assertThat(sink.getOut()).isEqualTo(Arrays.asList("ListChange:", "type:2", "pos:0", "id:test", ""));
    6471        }
    6572

  • java/main/src/test/java/com/framsticks/core/LocalTreeTest.java

    r99 r100  
    1616import com.framsticks.util.dispatching.Monitor;
    1717import com.framsticks.util.dispatching.RunAt;
    18 import com.framsticks.params.AccessInterface;
     18import com.framsticks.params.Access;
    1919import com.framsticks.params.ReflectionAccess;
    2020import com.framsticks.params.types.FloatParam;
    … …  
    7272                                Path path = Path.to(tree, "/");
    7373                                assertThat(path.isResolved());
    74                                 AccessInterface access = TreeOperations.bindAccess(path);
     74                                Access access = TreeOperations.bindAccess(path);
    7575                                assertThat(access.get("se", Double.class)).isEqualTo(1.0);
    7676

  • java/main/src/test/java/com/framsticks/dumping/StreamTest.java

    r97 r100  
    1616                //                              public void result(Path result, Exception e) {
    1717                //                                      if (e != null) {
    18                 //                                              log.error("failed to load file: " + e);
     18                //                                              log.error("failed to load file: {}", e);
    1919                //                                              fireRun(e);
    2020                //                                              return;
    … …  
    2626                //                      stream.load();
    2727                //              } catch (IOException e) {
    28                 //                      log.error("io failure: " + e);
     28                //                      log.error("io failure: {}", e);
    2929                //                      fireRun(e);
    3030                //              }

  • java/main/src/test/java/com/framsticks/gui/BrowserBaseTest.java

    r99 r100  
    33import javax.swing.JFrame;
    44
    5 import org.apache.log4j.Logger;
     5import org.apache.logging.log4j.Logger;
     6import org.apache.logging.log4j.LogManager;
    67import org.fest.swing.edt.GuiQuery;
    78import org.fest.swing.fixture.FrameFixture;
    … …  
    1819public abstract class BrowserBaseTest extends GuiTest {
    1920
    20         private static final Logger log = Logger.getLogger(BrowserTest.class);
     21        private static final Logger log = LogManager.getLogger(BrowserTest.class);
    2122
    2223        protected Browser browser;
    … …  
    5253                Dispatching.sleep(2.0);
    5354                tree.expandPath(path);
     55                Dispatching.sleep(2.0);
    5456                robot.waitForIdle();
    5557        }

  • java/main/src/test/java/com/framsticks/gui/BrowserTest.java

    r99 r100  
    77
    88
    9 import org.apache.log4j.Logger;
     9import org.apache.logging.log4j.Logger;
     10import org.apache.logging.log4j.LogManager;
    1011import org.fest.swing.edt.GuiTask;
    1112import org.testng.annotations.Test;
    … …  
    1718public class BrowserTest extends BrowserBaseTest {
    1819
    19         private static final Logger log = Logger.getLogger(BrowserTest.class);
     20        private static final Logger log = LogManager.getLogger(BrowserTest.class);
    2021
    2122        RemoteTree localhost;
    … …  
    3435        }
    3536
    36         @Test(timeOut = 30000)
     37        @Test(timeOut = 60000)
    3738        public void testShow() {
    3839                Dispatching.synchronize(localhost, 1.0);

  • java/main/src/test/java/com/framsticks/gui/LocalTreeBrowserTest.java

    r99 r100  
    2929        }
    3030
    31         @Test(timeOut = 10000)
     31        @Test(timeOut = 30000)
    3232        public void testShow() {
    3333                tree.dispatch(new RunAt<Tree>(failOnException) {

  • java/main/src/test/java/com/framsticks/gui/ProcedureBrowserTest.java

    r99 r100  
    1010import com.framsticks.core.Tree;
    1111import com.framsticks.core.LocalTree;
    12 import com.framsticks.params.AccessInterface;
     12import com.framsticks.params.Access;
    1313import com.framsticks.params.EventListener;
    1414import com.framsticks.params.FramsClass;
    … …  
    6262                        @Override
    6363                        protected void runAt() {
    64                                 AccessInterface access = bindAccess(tree, "/");
     64                                Access access = bindAccess(tree, "/");
    6565                                assertThat(access).isInstanceOf(ReflectionAccess.class);
    6666                                FramsClass framsClass = access.getFramsClass();
    67                                 assertThat(framsClass.getParamCount()).isEqualTo(5);
    6867                                assertThat(framsClass.getParam(0).getId()).isEqualTo("name");
    6968                                assertThat(framsClass.getParam(1).getId()).isEqualTo("history");
    … …  
    9493                        @Override
    9594                        protected void runAt() {
    96                                 AccessInterface access = bindAccess(tree, "/");
     95                                Access access = bindAccess(tree, "/");
    9796                                assertThat(access.get("history", String.class)).isEqualTo("initial|Żółw|");
    9897
    … …  
    107106                        @Override
    108107                        protected void runAt() {
    109                                 AccessInterface access = bindAccess(tree, "/");
     108                                Access access = bindAccess(tree, "/");
    110109                                assertThat(access.get("history", String.class)).isEqualTo("");
    111110

  • java/main/src/test/java/com/framsticks/hosting/ServerTest.java

    r99 r100  
    88import org.testng.annotations.Test;
    99
     10import com.framsticks.core.ListChange;
    1011import com.framsticks.core.LocalTree;
    1112import com.framsticks.core.Path;
    … …  
    1819import com.framsticks.core.Tree;
    1920import com.framsticks.params.FramsClass;
    20 import com.framsticks.params.AccessInterface;
     21import com.framsticks.params.Access;
    2122import com.framsticks.params.EventListener;
    2223import com.framsticks.params.PrimitiveParam;
    2324import com.framsticks.params.PropertiesAccess;
    2425import com.framsticks.params.types.EventParam;
     26import com.framsticks.params.types.StringParam;
    2527// import com.framsticks.params.types.EventParam;
    2628import com.framsticks.params.types.ProcedureParam;
    … …  
    4446        protected TestClass hostedObject;
    4547        protected EventListener<ChangeEvent> listener;
     48        protected EventListener<ListChange> childListener;
     49
    4650        protected List<String> listenerArguments = new LinkedList<>();
     51        protected List<ListChange> childrenChanges = new LinkedList<>();
     52
    4753
    4854        @Override
    … …  
    9096                                assertThat(path.isResolved()).isTrue();
    9197                                remotePath = path;
    92                                 AccessInterface access = bindAccess(path);
     98                                Access access = bindAccess(path);
    9399                                assertThat(access).isInstanceOf(PropertiesAccess.class);
    94100                                assertThat(access.get("name", String.class)).isEqualTo("a test name");
    … …  
    167173        }
    168174
    169         @Test(dependsOnMethods = "callMethod")
     175
     176        @Test(dependsOnMethods = "deregisterListener")
     177        public void registerChildListener() {
     178
     179                childListener = new EventListener<ListChange>() {
     180                        @Override
     181                        public void action(ListChange listChange) {
     182                                childrenChanges.add(listChange);
     183                        }
     184                };
     185
     186                addListener(remotePath, remoteTestFramsClass.getParamEntry("children_changed", EventParam.class), childListener, ListChange.class, produceWaiter(1.0).passInFuture(Void.class));
     187        }
     188
     189        @Test(dependsOnMethods = "registerChildListener")
     190        public void createChild() {
     191                final Waiter waiter = produceWaiter(2.0);
     192                call(remotePath, "createChild", new Object[] { "a child" }, produceWaiter(2.0).passInFuture(Object.class));
     193                call(remotePath, "createChild", new Object[] { "another child" }, produceWaiter(2.0).passInFuture(Object.class));
     194
     195                tryGet(remote, "/testClass/children/c0", new FutureHandler<Path>(failOnException) {
     196
     197                        @Override
     198                        protected void result(Path result) {
     199                                set(result, getFramsClass(result).getParamEntry("name", StringParam.class), "new_name", new FutureHandler<Integer>(failOnException) {
     200
     201                                        @Override
     202                                        protected void result(Integer result) {
     203                                                waiter.pass();
     204                                        }
     205                                });
     206                        }
     207                });
     208        }
     209
     210        @Test(dependsOnMethods = "createChild")
     211        public void deregisterChildListener() {
     212                removeListener(remotePath, remoteTestFramsClass.getParamEntry("children_changed", EventParam.class), childListener, produceWaiter(1.0).passInFuture(Void.class));
     213        }
     214
     215        @Test(dependsOnMethods = "deregisterChildListener")
     216        public void checkListChanges() {
     217                assertThat(childrenChanges).isEqualTo(Arrays.asList(
     218                        new ListChange(ListChange.Action.Add, 0, "c0"),
     219                        new ListChange(ListChange.Action.Add, 1, "c1"),
     220                        new ListChange(ListChange.Action.Modify, 0, "c0")
     221                ));
     222        }
     223
     224        @Test(dependsOnMethods = "checkListChanges")
    170225        public void endWait() {
    171226                monitor.useFor(1.0);

  • java/main/src/test/java/com/framsticks/model/ModelPackageTest.java

    r90 r100  
    2121        @Test(dataProvider = "classesList")
    2222        public void testFramsClass(Class<?> javaClass, String name, int paramCount, Object[][] paramsTests) throws InstantiationException, IllegalAccessException {
    23                 // log.info("testing " + name + " " + javaClass + " " + Package.class.getResource(filename));
    2423                String filename = "/info/" + name + ".info";
    2524                InputStream stream = ModelPackage.class.getResourceAsStream(filename);

  • java/main/src/test/java/com/framsticks/params/FramsClassBuilderTest.java

    r99 r100  
    3434        @Test
    3535        public void checkProcedureParams() {
    36                 assertThat(framsClass.getParamCount()).isEqualTo(5);
     36                assertThat(framsClass.getParamCount()).isEqualTo(8);
    3737
    3838                assertThat(framsClass.getParam("name")).isInstanceOf(StringParam.class);
    … …  
    8080                                        "name:ResetHistory",
    8181                                        "type:p()",
     82                                        "",
     83                                        "prop:",
     84                                        "id:children",
     85                                        "name:Children",
     86                                        "type:l TestChild uid",
     87                                        "flags:1",
     88                                        "",
     89                                        "prop:",
     90                                        "id:createChild",
     91                                        "name:CreateChild",
     92                                        "type:p(s arg0)",
     93                                        "",
     94                                        "prop:",
     95                                        "id:children_changed",
     96                                        "name:ChildrenListener",
     97                                        "type:e ListChange",
    8298                                        ""
    8399                                )

  • java/main/src/test/java/com/framsticks/params/ParamBuilderTest.java

    r96 r100  
    1414        ParamBuilder builder;
    1515        FramsClass builderFramsClass;
    16         AccessInterface access;
     16        Access access;
    1717
    1818        @Test
    … …  
    3434                MultiParamLoader loader = new MultiParamLoader();
    3535                loader.setNewSource(source);
    36                 loader.addAccessInterface(access);
     36                loader.addAccess(access);
    3737                loader.addBreakCondition(MultiParamLoader.Status.AfterObject);
    3838

  • java/main/src/test/java/com/framsticks/parsers/F0ParserTest.java

    r90 r100  
    2424
    2525        private Schema schema;
    26         private List<AccessInterface> accesses;
     26        private List<Access> accesses;
    2727        private List<ModelComponent> components;
    2828        private Model model;
    … …  
    7272
    7373        @Test(dependsOnMethods = {"readF0"})
    74         public void stripAccessInterface() {
    75                 components = Util.stripAccessInterface(accesses, ModelComponent.class);
     74        public void stripAccess() {
     75                components = Util.stripAccess(accesses, ModelComponent.class);
    7676
    7777                assertThat(components.get(1)).isInstanceOf(Part.class);
    … …  
    8181        }
    8282
    83         @Test(dependsOnMethods = {"stripAccessInterface"})
     83        @Test(dependsOnMethods = {"stripAccess"})
    8484        public void buildModel() {
    8585                model = new ModelBuilder().addComponents(components).finish();

  • java/main/src/test/java/com/framsticks/test/TestConfiguration.java

    r99 r100  
    66import java.util.Set;
    77
    8 import org.apache.log4j.Logger;
    9 import org.apache.log4j.PropertyConfigurator;
     8import org.apache.logging.log4j.Logger;
     9import org.apache.logging.log4j.LogManager;
    1010import org.testng.annotations.*;
    1111
    … …  
    2121public class TestConfiguration {
    2222
    23         private static final Logger log = Logger.getLogger(TestConfiguration.class);
     23        private static final Logger log = LogManager.getLogger(TestConfiguration.class);
    2424
    2525        @BeforeClass
    2626        public void setUpConfiguration() {
    27                 PropertyConfigurator.configure(TestConfiguration.class.getResource("/log4j.properties"));
    28                 log.info("testing " + this.getClass());
     27                log.info("testing {}", this.getClass());
    2928        }
    3029
    … …  
    8685        @BeforeMethod
    8786        public void clearWaiters() {
    88                 waiters.clear();
     87                synchronized (waiters) {
     88                        waiters.clear();
     89                }
    8990        }
    9091
    9192        protected Dispatching.Waiter produceWaiter(double timeOut) {
    9293                Waiter waiter = new Waiter(timeOut, failOnException);
    93                 waiters.add(waiter);
     94                synchronized (waiters) {
     95                        waiters.add(waiter);
     96                }
    9497                return waiter;
    9598        }
    … …  
    98101                @Override
    99102                public void handle(FramsticksException e) {
    100                         log.error("passing exception as assertion in " + TestConfiguration.this.getClass(), e);
     103                        log.error("passing exception as assertion in {}", TestConfiguration.this.getClass(), e);
    101104                        addAsyncAssertion(e);
    102105                }
Note: See TracChangeset for help on using the changeset viewer.