Changeset 97


Ignore:
Timestamp:
07/06/13 03:51:11 (11 years ago)
Author:
psniegowski
Message:

HIGHLIGHTS:

  • add proper exception passing between communication sides:

if exception occur during handling client request, it is
automatically passed as comment to error response.

it may be used to snoop communication between peers

  • fix algorithm choosing text controls in GUI
  • allow GUI testing in virtual frame buffer (xvfb)

FEST had some problem with xvfb but workaround was found

supports tab-completion based on requests history

CHANGELOG:
Further improve handling of exceptions in GUI.

Add StatusBar? implementing ExceptionResultHandler?.

Make completion processing asynchronous.

Minor changes.

Improve completion in console.

Improve history in InteractiveConsole?.

First working version of DirectConsole?.

Minor changes.

Make Connection.address non final.

It is more suitable to use in configuration.

Improvement of consoles.

Improve PopupMenu? and closing of FrameJoinable?.

Fix BrowserTest?.

Found bug with FEST running under xvfb.

JButtonFixture.click() is not working under xvfb.
GuiTest? has wrapper which uses JButton.doClick() directly.

Store CompositeParam? param in TreeNode?.

Simplify ClientSideManagedConnection? connecting.

There is now connectedFunctor needed, ApplicationRequests? can be
send right after creation. They are buffered until the version
and features are negotiated.

Narow down interface of ClientSideManagedConnection?.

Allow that connection specialization send only
ApplicationRequests?.

Improve policy of text control choosing.

Change name of Genotype in BrowserTest?.

Make BrowserTest? change name of Genotype.

Minor change.

First working draft of TrackConsole?.

Simplify Consoles.

More improvements with gui joinables.

Unify initialization on gui joinables.

More rework of Frame based entities.

Refactorize structure of JFrames based entities.

Extract GuiTest? from BrowserBaseTest?.

Reorganize Console classes structure.

Add Collection view to JoinableCollection?.

Configure timeout in testing.

Minor changes.

Rework connections hierarchy.

Add Mode to the get operation.

Make get and set in Tree take PrimitiveParam?.

Unify naming of operations.

Make RunAt? use the given ExceptionHandler?.

It wraps the virtual runAt() method call with
try-catch passing exception to handler.

Force RunAt? to include ExceptionHandler?.

Improve ClientAtServer?.

Minor change.

Another sweep with FindBugs?.

Rename Instance to Tree.

Minor changes.

Minor changes.

Further clarify semantics of Futures.

Add FutureHandler?.

FutureHandler? is refinement of Future, that proxifies
exception handling to ExceptionResultHandler? given
at construction time.

Remove StateFunctor? (use Future<Void> instead).

Make Connection use Future<Void>.

Unparametrize *ResponseFuture?.

Remove StateCallback? not needed anymore.

Distinguish between sides of ResponseFuture?.

Base ResponseCallback? on Future (now ResponseFuture?).

Make asynchronous store taking Future for flags.

Implement storeValue in ObjectInstance?.

Location:
java/main
Files:
43 added
21 deleted
71 edited

Legend:

Unmodified
Added
Removed

  • java/main/pom.xml

    r96 r97  
    117117                                <version>2.9</version>
    118118                                <configuration>
     119                                        <forkedProcessTimeoutInSeconds>60</forkedProcessTimeoutInSeconds>
    119120                                        <useFile>false</useFile>
    120121                                </configuration>
    … …  
    156157                                </configuration>
    157158                        </plugin>
    158 
     159                        <plugin>
     160                                <groupId>org.codehaus.mojo</groupId>
     161                                <artifactId>appassembler-maven-plugin</artifactId>
     162                                <version>1.3.1</version>
     163                                <configuration>
     164                                        <programs>
     165                                                <program>
     166                                                        <mainClass>com.framsticks.core.Framsticks</mainClass>
     167                                                        <name>framsticks</name>
     168                                                </program>
     169                                        </programs>
     170                                </configuration>
     171                        </plugin>
    159172                </plugins>
    160173        </build>

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

    r96 r97  
    11package com.framsticks.communication;
    22
     3import com.framsticks.params.annotations.AutoAppendAnnotation;
     4import com.framsticks.params.annotations.FramsClassAnnotation;
     5import com.framsticks.params.annotations.ParamAnnotation;
    36import com.framsticks.util.FramsticksException;
    47import com.framsticks.util.io.Encoding;
    5 import com.framsticks.util.lang.Pair;
     8import com.framsticks.util.lang.Strings;
     9
     10import org.apache.log4j.Level;
    611import org.apache.log4j.Logger;
    712import java.io.BufferedReader;
    … …  
    1217import java.net.Socket;
    1318import java.net.SocketTimeoutException;
     19import java.util.Collection;
     20import java.util.HashSet;
     21import java.util.Set;
    1422
    1523import com.framsticks.util.dispatching.AbstractJoinable;
    … …  
    2129import com.framsticks.util.dispatching.RunAt;
    2230import com.framsticks.util.dispatching.Thread;
    23 
     31import com.framsticks.util.dispatching.ThrowExceptionHandler;
     32
     33@FramsClassAnnotation
    2434public abstract class Connection extends AbstractJoinable implements JoinableParent {
    2535
    2636        protected final static Logger log = Logger.getLogger(Connection.class);
    2737
    28         protected PrintWriter output = null;
    29         protected BufferedReader input = null;
     38        private PrintWriter output = null;
     39        private BufferedReader input = null;
    3040
    3141        protected Socket socket = null;
    3242
    33         public boolean requestIdEnabled = false;
    34 
    35         protected int protocolVersion = -1;
    36 
    37         public String getAddress() {
    38                 return address;
    39         }
    40         protected final String address;
    41         protected final String description;
     43        protected Address address;
     44        protected String description = "connection";
    4245
    4346        protected final Thread<Connection> senderThread = new Thread<>();
    4447        protected final Thread<Connection> receiverThread = new Thread<>();
    4548        protected final JoinableCollection<Thread<Connection>> threads = new JoinableCollection<>();
    46 
    47         protected void setUpThreadNames(String name) {
    48         }
     49        protected final Set<ConnectionListener> listeners = new HashSet<>();
    4950
    5051        /**
    5152         *
    5253         */
    53         public Connection(String address, String description) {
    54                 this.address = address;
    55                 this.description = description;
    56                 threads.setObservableName(address + " connection threads");
     54        public Connection() {
    5755                threads.add(senderThread);
    5856                threads.add(receiverThread);
    5957
     58        }
     59
     60        protected void updateNames() {
     61                if (address == null) {
     62                        return;
     63                }
    6064                senderThread.setName(description + " thread " + address + " sender");
    6165                receiverThread.setName(description + " thread " + address + " receiver");
     66                threads.setObservableName(address + " connection threads");
     67        }
     68
     69        public void setDescription(String description) {
     70                this.description = description;
     71                updateNames();
     72        }
     73
     74        @AutoAppendAnnotation
     75        public Connection setAddress(Address address) {
     76                this.address = address;
     77                updateNames();
     78                return this;
     79        }
     80
     81        @ParamAnnotation
     82        public Connection setAddress(String address) {
     83                return setAddress(new Address(address));
    6284        }
    6385
    6486        public synchronized boolean isConnected() {
    6587                return socket != null && socket.isConnected();
    66         }
    67 
    68 
    69         // protected static final String ARGUMENT_PATTERN_FRAGMENT = "((?:\\S+)|(?:\\\"[^\"]*\\\"))";
    70         // protected static final Pattern REQUEST_ID_ENABLED_PATTERN = Pattern.compile("^\\s*([0-9]+)(?:\\s+" + ARGUMENT_PATTERN_FRAGMENT + ")?$");
    71         // protected static final Pattern REQUEST_ID_DISABLED_PATTERN = Pattern.compile("^\\s*" + ARGUMENT_PATTERN_FRAGMENT + "?$");
    72 
    73         // // protected final Pair<String, String> breakLine(String line)
    74         // protected final Pair<Integer, String> parseRest(String rest) {
    75         //      Matcher matcher = (requestIdEnabled ? REQUEST_ID_ENABLED_PATTERN : REQUEST_ID_DISABLED_PATTERN).matcher(rest);
    76         //      if (!matcher.matches()) {
    77         //              log.fatal("unmatched first line of input: '" + rest + "'");
    78         //              return null;
    79         //      }
    80         //      return new Pair<Integer, String>(requestIdEnabled ? Integer.parseInt(matcher.group(1)) : null, matcher.group(requestIdEnabled ? 2 : 1));
    81         // }
    82 
    83         protected final Pair<Integer, CharSequence> takeRequestId(CharSequence line) {
    84                 return Request.takeRequestId(requestIdEnabled, line);
    8588        }
    8689
    … …  
    105108                                        ++iterator;
    106109                                        bufferStart = iterator;
    107                                         return lineBuffer.toString();
     110                                        String line = lineBuffer.toString();
     111
     112                                        synchronized (listeners) {
     113                                                for (ConnectionListener l : listeners) {
     114                                                        l.connectionIncomming(line);
     115                                                }
     116                                        }
     117
     118                                        return line;
    108119                                }
    109120                                final int length = readChars - bufferStart;
    … …  
    131142        }
    132143
     144        protected void putLine(String line) {
     145                synchronized (listeners) {
     146                        for (ConnectionListener l : listeners) {
     147                                l.connectionOutgoing(line);
     148                        }
     149                }
     150                output.println(line);
     151        }
     152
     153        protected void flushOut() {
     154                output.flush();
     155        }
     156
     157        protected abstract void processNextInputBatch();
     158
     159        protected final void processInputBatchesUntilClosed() {
     160                while (isRunning() && isConnected()) {
     161                        try {
     162                                processNextInputBatch();
     163                        } catch (Exception e) {
     164                                log.log(isRunning() ? Level.ERROR : Level.DEBUG, "caught exception: ", e);
     165                                break;
     166                        }
     167                }
     168        }
     169
    133170        protected abstract void receiverThreadRoutine();
    134171
    135 
     172        // @SuppressWarnings("NN_NAKED_NOTIFY")
    136173        protected void setupStreams() {
    137174                try {
    … …  
    146183        }
    147184
    148         /**
    149          * Returns Query associated with query getId.
    150          *
    151          * @return Query associated with query getId.
    152          */
    153         public int getProtocolVersion() {
    154                 return protocolVersion;
    155         }
    156185
    157186
    … …  
    187216        @Override
    188217        public String getName() {
    189                 return description + " " + address;
     218                return address != null ? description + " " + address : description;
    190219        }
    191220
    … …  
    194223                Dispatching.use(threads, this);
    195224
    196                 senderThread.dispatch(new RunAt<Connection>() {
     225                senderThread.dispatch(new RunAt<Connection>(ThrowExceptionHandler.getInstance()) {
    197226                        @Override
    198                         public void run() {
     227                        protected void runAt() {
    199228                                synchronized (Connection.this) {
    200229                                        while (state.equals(JoinableState.RUNNING) && output == null) {
    … …  
    205234                });
    206235
    207                 receiverThread.dispatch(new RunAt<Connection>() {
     236                receiverThread.dispatch(new RunAt<Connection>(ThrowExceptionHandler.getInstance()) {
    208237                        @Override
    209                         public void run() {
     238                        protected void runAt() {
    210239                                receiverThreadRoutine();
     240                                interrupt();
     241                                finish();
    211242                        }
    212243                });
    … …  
    215246        @Override
    216247        protected void joinableInterrupt() {
    217                 protocolVersion = -1;
    218248                Dispatching.drop(threads, this);
    219249                finish();
    … …  
    226256        }
    227257
     258        protected static void startClientConnection(Connection connection) {
     259                while (connection.isRunning() && !connection.isConnected()) {
     260                        log.debug("connecting to " + connection.address);
     261                        try {
     262                                connection.socket = new Socket(connection.getAddressObject().getHostName(), connection.getAddressObject().getPort());
     263                        } catch (IOException e) {
     264                                log.info(connection + " failed to connect (retrying): " + e);
     265                                Dispatching.sleep(0.5);
     266                        }
     267                }
     268
     269                log.debug(connection + " connected");
     270                try {
     271                        connection.socket.setSoTimeout(500);
     272                        connection.setupStreams();
     273                } catch (Exception e) {
     274                        throw new FramsticksException().msg("failed to initialize socket").cause(e).arg("connection", connection);
     275                }
     276        }
     277
     278        /**
     279         * @return the address
     280         */
     281        @ParamAnnotation
     282        public String getAddress() {
     283                return Strings.toStringNullProof(address, "?");
     284        }
     285
     286        public Address getAddressObject() {
     287                return address;
     288        }
     289
     290
     291        /**
     292         * @return the listeners
     293         */
     294        public Collection<ConnectionListener> getListeners() {
     295                return listeners;
     296        }
     297
     298        public static <T extends Connection> T to(T connection, Address address) {
     299                connection.setAddress(address);
     300                return connection;
     301        }
     302
    228303}

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

    r85 r97  
    77 */
    88public interface RequestHandler {
    9         public void handle(ApplicationRequest request, ResponseCallback<?> responseCallback);
     9        public void handle(ApplicationRequest request, ServerSideResponseFuture responseCallback);
    1010}

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

    r96 r97  
    44
    55import com.framsticks.communication.queries.RegistrationRequest;
     6import com.framsticks.util.dispatching.AtOnceDispatcher;
    67import com.framsticks.util.dispatching.Dispatcher;
    78import com.framsticks.util.dispatching.Dispatching;
    89import com.framsticks.util.dispatching.RunAt;
    9 import com.framsticks.util.FramsticksException;
    10 import com.framsticks.util.StateFunctor;
     10import com.framsticks.util.dispatching.ThrowExceptionHandler;
     11
    1112import org.apache.log4j.Logger;
    1213
    … …  
    1920        private final static Logger log = Logger.getLogger(Subscription.class);
    2021
    21         private final ClientConnection connection;
     22        private final ClientSideManagedConnection connection;
    2223        private final String path;
    2324        private final String registeredPath;
    … …  
    2627        private EventCallback eventCallback;
    2728
    28         public Subscription(ClientConnection connection, String path, String registeredPath, Dispatcher<C> dispatcher) {
     29        public Subscription(ClientSideManagedConnection connection, String path, String registeredPath, Dispatcher<C> dispatcher) {
    2930                this.connection = connection;
    3031                this.path = path;
    … …  
    4647        }
    4748
    48         public void unsubscribe(final StateFunctor stateFunctor) {
     49        public void unsubscribe(final ClientSideResponseFuture future) {
    4950                //@todo remove that /cli/ prefix, when registeredPath will be a fully qualified path
    50                 connection.send(new RegistrationRequest().register(false).path(registeredPath), new ResponseCallback<Connection>() {
     51                connection.send(new RegistrationRequest().register(false).path(registeredPath), AtOnceDispatcher.getInstance(), new ClientSideResponseFuture(future) {
     52
    5153                        @Override
    52                         public void process(Response response) {
    53                                 if (!response.getOk()) {
    54                                         log.error("failed to unsunscribe " + this + ": " + response.getComment());
    55                                         stateFunctor.handle(new FramsticksException().msg("unsubscription failed").arg("comment", response.getComment()));
    56                                         return;
    57                                 }
     54                        protected void processOk(Response response) {
    5855                                assert response.hasFiles();
    5956                                log.debug("unsunscribed " + this);
    60                                 stateFunctor.call();
     57                                future.pass(response);
    6158                        }
    6259                });
    … …  
    7673
    7774        public void dispatchCall(final List<File> files) {
    78                 Dispatching.dispatchIfNotActive(dispatcher, new RunAt<C>() {
     75                //TODO TEH
     76                Dispatching.dispatchIfNotActive(dispatcher, new RunAt<C>(ThrowExceptionHandler.getInstance()) {
    7977                        @Override
    80                         public void run() {
     78                        protected void runAt() {
    8179                                eventCallback.call(files);
    8280                        }

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

    r85 r97  
    11package com.framsticks.communication;
     2
     3import com.framsticks.util.FramsticksException;
     4import com.framsticks.util.dispatching.ExceptionResultHandler;
    25
    36/**
    47 * @author Piotr Sniegowski
    58 */
    6 public interface SubscriptionCallback<C> {
    7         EventCallback subscribed(Subscription<? super C> subscription);
     9public abstract class SubscriptionCallback<C> implements ExceptionResultHandler {
     10        public abstract EventCallback subscribed(Subscription<? super C> subscription);
     11
     12        @Override
     13        public void handle(FramsticksException exception) {
     14                throw exception;
     15        }
     16
    817}

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

    r96 r97  
    11package com.framsticks.communication.util;
    22
    3 import com.framsticks.communication.StateCallback;
    4 import com.framsticks.util.FramsticksException;
     3import com.framsticks.communication.ClientSideResponseFuture;
     4import com.framsticks.communication.Response;
    55
    66import org.apache.log4j.Logger;
    … …  
    99 * @author Piotr Sniegowski
    1010 */
    11 public class LoggingStateCallback<C> extends StateCallback<C> {
     11public class LoggingStateCallback extends ClientSideResponseFuture {
    1212
    1313        protected final Logger logger;
    … …  
    1515
    1616        public LoggingStateCallback(Logger logger, String message) {
     17                super(null);
    1718                this.logger = logger;
    1819                this.message = message;
    1920        }
    2021
     22        // @Override
     23        // public void handle(FramsticksException e) {
     24        //      logger.error("failed to " + message + " with " + e);
     25        // }
     26
    2127        @Override
    22         public void handle(FramsticksException e) {
    23                 logger.error("failed to " + message + " with " + e);
     28        protected void processOk(Response response) {
     29                logger.debug(message);
    2430        }
    2531
    26         @Override
    27         public void callImpl() {
    28                 logger.debug(message);
    29         }
    3032}

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

    r85 r97  
    99 * @author Piotr Sniegowski
    1010 */
    11 public class LoggingSubscriptionCallback<C> implements SubscriptionCallback<C> {
     11public class LoggingSubscriptionCallback<C> extends SubscriptionCallback<C> {
    1212
    1313        protected final Logger logger;

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

    r96 r97  
    2929        public static void main(final String[] args) {
    3030
    31                 new Monitor(loadConfiguration(Framsticks.class.getResourceAsStream("/configs/framsticks.xml"))).use().waitFor().drop().join();
     31                String config = "/configs/framsticks.xml";
     32                if (args.length != 0) {
     33                        config = args[0];
     34                }
     35
     36                new Monitor(loadConfiguration(Framsticks.class.getResourceAsStream(config))).use().waitFor().drop().join();
    3237
    3338                log.debug("exiting main");

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

    r96 r97  
    2323        // private final static Logger log = Logger.getLogger(Path.class.getName());
    2424
    25         final Instance instance;
     25        final Tree tree;
    2626        final String textual;
    2727        final LinkedList<Node> nodes;
    2828
    29         protected static Object getKnownChild(Instance instance, AccessInterface access, CompositeParam param) {
     29        protected static Object getKnownChild(Tree tree, AccessInterface access, CompositeParam param) {
    3030                Object child = access.get(param, Object.class);
    3131                if (child == null) {
    … …  
    3333                }
    3434                try {
    35                         instance.prepareAccess(param);
     35                        tree.prepareAccess(param);
    3636                        return child;
    3737                } catch (FramsticksException e) {
    … …  
    4141
    4242        /**
    43          * @param instance
     43         * @param tree
    4444         * @param textual
    4545         * @param nodes
    4646         */
    47         Path(Instance instance, String textual, LinkedList<Node> nodes) {
    48                 this.instance = instance;
     47        Path(Tree tree, String textual, LinkedList<Node> nodes) {
     48                this.tree = tree;
    4949                this.textual = textual;
    5050                this.nodes = nodes;
    … …  
    5353        public Path appendNode(Node node) {
    5454                assert isResolved();
    55                 return new PathBuilder().instance(instance).textual(textual + ((size() == 1) ? "" : "/") + node.getParam().getId()).add(nodes).add(node).finish();
     55                return new PathBuilder().tree(tree).textual(textual + ((size() == 1) ? "" : "/") + node.getParam().getId()).add(nodes).add(node).finish();
    5656        }
    5757
    … …  
    6363        public static class PathBuilder {
    6464
    65                 Instance instance;
     65                Tree tree;
    6666                String textual;
    6767                final LinkedList<Node> nodes = new LinkedList<Node>();
    6868
    6969                public Path finish() {
    70                         assert instance != null;
     70                        assert tree != null;
    7171                        assert textual != null;
    72                         return new Path(instance, textual, nodes);
     72                        return new Path(tree, textual, nodes);
    7373                }
    7474
    … …  
    7777                }
    7878
    79                 public PathBuilder instance(Instance instance) {
    80                         this.instance = instance;
     79                public PathBuilder tree(Tree tree) {
     80                        this.tree = tree;
    8181                        return this;
    8282                }
    … …  
    130130                }
    131131
    132                 public PathBuilder resolve(@Nonnull Instance instance, String textual) {
     132                public PathBuilder resolve(@Nonnull Tree tree, String textual) {
    133133
    134134                        assert nodes.isEmpty();
    135                         assert instance.isActive();
    136                         this.instance = instance;
    137 
    138                         nodes.add(instance.getRoot());
    139                         Node current = instance.getRoot();
     135                        assert tree.isActive();
     136                        this.tree = tree;
     137
     138                        nodes.add(tree.getRoot());
     139                        Node current = tree.getRoot();
    140140
    141141                        StringBuilder b = new StringBuilder();
    142142                        Iterator<String> i = splitPath(textual);
    143143                        while (i.hasNext() && current.getObject() != null) {
    144                                 AccessInterface access = instance.prepareAccess(current.getParam());
     144                                AccessInterface access = tree.prepareAccess(current.getParam());
    145145                                if (access == null) {
    146146                                        break;
    … …  
    155155                                b.append("/").append(e);
    156156                                access.select(current.getObject());
    157                                 current = new Node(c, getKnownChild(instance, access, c));
     157                                current = new Node(c, getKnownChild(tree, access, c));
    158158                                nodes.add(current);
    159159                        }
    … …  
    170170        public Path appendResolution(Object object) {
    171171                assert !isResolved();
    172                 Path result = new PathBuilder().textual(textual).instance(instance).add(nodes).setLast(object).finish();
     172                Path result = new PathBuilder().textual(textual).tree(tree).add(nodes).setLast(object).finish();
    173173                assert size() == result.size();
    174174                return result;
    … …  
    193193
    194194        public String toString() {
    195                 return instance + textual + (!isResolved() ? "!" : "");
     195                return tree + textual + (!isResolved() ? "!" : "");
     196        }
     197
     198        public String getFullTextual() {
     199                return tree.getName() + textual;
    196200        }
    197201
    … …  
    216220        }
    217221
    218         public final @Nonnull Instance getInstance() {
    219                 assert Dispatching.isThreadSafe();
    220                 return instance;
     222        public final @Nonnull Tree getTree() {
     223                assert Dispatching.isThreadSafe();
     224                return tree;
    221225        }
    222226
    … …  
    233237         */
    234238        public Path tryFindResolution() {
    235                 assert instance.isActive();
     239                assert tree.isActive();
    236240                assert !isResolved();
    237241                if (size() == 1) {
    238                         return Path.build().resolve(instance, "/").finish();//appendResolution(instance.root.object);
    239                 }
    240                 Object child = getKnownChild(instance, InstanceUtils.bindAccess(instance, getUnder()), getTop().getParam());
     242                        return Path.build().resolve(tree, "/").finish();
     243                }
     244                Object child = getKnownChild(tree, TreeOperations.bindAccess(tree, getUnder()), getTop().getParam());
    241245                if (child == null) {
    242246                        return this;
    … …  
    247251        public boolean matches(Path p) {
    248252                assert Dispatching.isThreadSafe();
    249                 assert instance == p.instance;
     253                assert tree == p.tree;
    250254                Iterator<Node> a = nodes.iterator();
    251255                Iterator<Node> b = p.nodes.iterator();
    … …  
    264268        }
    265269
    266         public final boolean isOwner(Instance instance) {
    267                 return this.instance == instance;
    268         }
    269 
    270         // public void setInstance(Instance instance) {
    271         //      this.instance = instance;
    272         // }
     270        public final boolean isOwner(Tree tree) {
     271                return this.tree == tree;
     272        }
    273273
    274274        @SuppressWarnings("unchecked")
    … …  
    284284        }
    285285
    286         public static Path to(@Nonnull Instance instance, String textual) {
    287                 return Path.build().resolve(instance, textual).finish();
     286        public static Path to(@Nonnull Tree tree, String textual) {
     287                return Path.build().resolve(tree, textual).finish();
    288288        }
    289289}

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

    r96 r97  
    1111import org.apache.log4j.Logger;
    1212
    13 import com.framsticks.core.AbstractInstanceListener;
    14 import com.framsticks.core.Instance;
     13import com.framsticks.core.AbstractTreeListener;
     14import com.framsticks.core.Tree;
    1515import com.framsticks.core.Path;
    1616import com.framsticks.dumping.PrintWriterSink;
    … …  
    1919import com.framsticks.remote.RecursiveFetcher;
    2020import com.framsticks.util.FramsticksException;
    21 import com.framsticks.util.Logging;
    2221import com.framsticks.util.PeriodicTask;
    23 import com.framsticks.util.StateFunctor;
     22import com.framsticks.util.dispatching.ExceptionResultHandler;
     23import com.framsticks.util.dispatching.FutureHandler;
    2424import com.framsticks.util.dispatching.JoinableCollection;
     25import com.framsticks.util.dispatching.ThrowExceptionHandler;
    2526import com.framsticks.util.io.Encoding;
    2627
    … …  
    2829 * @author Piotr Sniegowski
    2930 */
    30 public class Diagnostics extends JoinableCollection<Instance> {
     31public class Diagnostics extends JoinableCollection<Tree> {
    3132        private static final Logger log = Logger.getLogger(Diagnostics.class);
    3233
    … …  
    4142
    4243
     44
    4345        @Override
    4446        @AutoAppendAnnotation
    45         public void add(final Instance instance) {
    46                 super.add(instance);
     47        public void add(final Tree tree) {
     48                super.add(tree);
    4749
    48                 instance.addListener(new AbstractInstanceListener() {
     50                tree.addListener(new AbstractTreeListener() {
    4951                        @Override
    5052                        public void onRun(Exception e) {
    … …  
    5456
    5557                                if (dumpsInterval != null) {
    56                                         new PeriodicTask<Instance>(instance, dumpsInterval * 1000) {
     58                                        new PeriodicTask<Tree>(ThrowExceptionHandler.getInstance(), tree, dumpsInterval * 1000) {
     59                                                protected final ExceptionResultHandler repeater = new ExceptionResultHandler() {
     60
     61                                                        @Override
     62                                                        public void handle(FramsticksException exception) {
     63                                                                log.error("caught error during diagnostics fetching (repeating): " + exception);
     64                                                                again();
     65                                                        }
     66
     67                                                };
    5768                                                @Override
    58                                                 public void run() {
     69                                                protected void runAt() {
    5970
    6071                                                        log.info("starting periodic dump");
    61                                                         new RecursiveFetcher(instance, Path.to(instance, "/"), new StateFunctor() {
    62                                                                 @Override
    63                                                                 public void handle(FramsticksException e) {
    64                                                                         Logging.log(log, "recursively fetch", instance, e);
    65                                                                         again();
    66                                                                 }
     72                                                        new RecursiveFetcher(tree, Path.to(tree, "/"), new FutureHandler<Void>(repeater) {
    6773
    6874                                                                @Override
    69                                                                 public void call() {
    70                                                                         log.info("instance resolved, saving");
     75                                                                protected void result(Void result) {
     76                                                                        log.info("tree resolved, saving");
    7177                                                                        try {
    72                                                                                 final String fileName = dumpsPath + "/" + instance + "_" + new SimpleDateFormat(dumpsFormat).format(new Date()) + ".param";
     78                                                                                final String fileName = dumpsPath + "/" + tree + "_" + new SimpleDateFormat(dumpsFormat).format(new Date()) + ".param";
    7379                                                                                File file = new File(fileName);
    74                                                                                 new SaveStream(new PrintWriterSink(new PrintWriter(new OutputStreamWriter(new FileOutputStream(file), Encoding.getFramsticksCharset()))), instance, Path.to(instance, "/"), new StateFunctor() {
    75                                                                                         @Override
    76                                                                                         public void handle(FramsticksException e) {
    77                                                                                                 Logging.log(log, "periodic dump in " + fileName + " of", instance, e);
    78                                                                                                 again();
    79                                                                                         }
     80                                                                                new SaveStream(new PrintWriterSink(new PrintWriter(new OutputStreamWriter(new FileOutputStream(file), Encoding.getFramsticksCharset()))), tree, Path.to(tree, "/"), new FutureHandler<Void>(repeater) {
    8081
    8182                                                                                        @Override
    82                                                                                         public void call() {
     83                                                                                        protected void result(Void result) {
    8384                                                                                                again();
    8485                                                                                        }
    8586                                                                                });
    86                                                                         } catch (IOException ex) {
    87                                                                                 log.info("failed to initiate dump: " + ex);
    88                                                                                 again();
     87                                                                        } catch (IOException e) {
     88                                                                                throw new FramsticksException().msg("failed to initiate dump").cause(e);
    8989                                                                        }
    90 
    9190                                                                }
    9291                                                        });

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

    r96 r97  
    22
    33import com.framsticks.communication.File;
    4 import com.framsticks.core.InstanceUtils;
     4import com.framsticks.core.TreeOperations;
    55import com.framsticks.core.Path;
    66import com.framsticks.params.ListSource;
    7 import com.framsticks.core.Instance;
     7import com.framsticks.core.Tree;
    88import com.framsticks.util.*;
    99import com.framsticks.util.dispatching.Future;
    … …  
    2424        private final static Logger log = Logger.getLogger(LoadStream.class.getName());
    2525
    26         protected final Instance instance;
     26        protected final Tree tree;
    2727        protected final Path mountPath;
    2828        protected final BufferedReader stream;
    … …  
    3131
    3232
    33         public LoadStream(Path mountPath, BufferedReader stream, Instance instance, Future<Path> future) {
    34                 this.instance = instance;
     33        public LoadStream(Path mountPath, BufferedReader stream, Tree tree, Future<Path> future) {
     34                this.tree = tree;
    3535                this.mountPath = mountPath;
    3636                this.stream = stream;
    … …  
    5959                                        if (line.equals("ok")) {
    6060                                                if (query.first.equals("get")) {
    61                                                         Path path = InstanceUtils.createIfNeeded(instance, query.second);
    62                                                         InstanceUtils.processFetchedValues(path, files);
     61                                                        Path path = TreeOperations.createIfNeeded(tree, query.second);
     62                                                        TreeOperations.processFetchedValues(path, files);
    6363                                                } else if (query.first.equals("info")) {
    6464                                                        assert files.size() == 1;
    65                                                         InstanceUtils.processFetchedInfo(instance, files.get(0));
     65                                                        TreeOperations.processFetchedInfo(tree, files.get(0));
    6666                                                } else {
    6767                                                        assert false;
    … …  
    8787                }
    8888                log.info("loaded in: " + stopwatch);
    89                 future.pass(Path.to(instance, mountPath.getTextual()));
     89                future.pass(Path.to(tree, mountPath.getTextual()));
    9090        }
    9191

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

    r96 r97  
    11package com.framsticks.dumping;
    22
    3 import static com.framsticks.core.InstanceUtils.*;
     3import static com.framsticks.core.TreeOperations.*;
    44import com.framsticks.core.Node;
    55import com.framsticks.core.Path;
    … …  
    1010import com.framsticks.params.SinkInterface;
    1111import com.framsticks.parsers.Savers;
    12 import com.framsticks.core.Instance;
     12import com.framsticks.core.Tree;
    1313import com.framsticks.util.*;
    1414import com.framsticks.util.dispatching.Dispatching;
     15import com.framsticks.util.dispatching.Future;
     16import com.framsticks.util.dispatching.ThrowExceptionHandler;
     17
    1518import org.apache.log4j.Logger;
    1619import com.framsticks.util.dispatching.RunAt;
    … …  
    2831
    2932        protected final SinkInterface sink;
    30         protected final Instance instance;
    31         protected final StateFunctor stateFunctor;
     33        protected final Tree tree;
     34        protected final Future<Void> future;
    3235        protected final Stopwatch stopwatch = new Stopwatch();
    3336        protected final Set<FramsClass> storedInfo = new HashSet<FramsClass>();
    … …  
    3538        private int dispatched = 0;
    3639
    37         public SaveStream(SinkInterface sink, Instance instance, Path root, StateFunctor stateFunctor) {
     40        public SaveStream(SinkInterface sink, Tree tree, Path root, Future<Void> future) {
    3841                assert Dispatching.isThreadSafe();
    3942                this.sink = sink;
    40                 this.instance = instance;
    41                 this.stateFunctor = stateFunctor;
     43                this.tree = tree;
     44                this.future = future;
    4245                dispatchWrite(root);
    4346        }
    … …  
    4548        protected void dispatchWrite(final Path path) {
    4649                ++dispatched;
    47                 instance.dispatch(new RunAt<Instance>() {
     50                //TODO TEH
     51                tree.dispatch(new RunAt<Tree>(ThrowExceptionHandler.getInstance()) {
    4852                        @Override
    49                         public void run() {
     53                        protected void runAt() {
    5054                                write(path);
    5155                        }
    … …  
    5458
    5559        protected void finished() {
    56                 assert instance.isActive();
     60                assert tree.isActive();
    5761                log.info("stored in " + stopwatch);
    58                 stateFunctor.call();
     62                future.pass(null);
    5963        }
    6064
    6165        public void write(final Path path) {
    62                 assert instance.isActive();
     66                assert tree.isActive();
    6367                if (!path.isResolved()) {
    6468                        log.debug("path " + path + " is not resolved - skipping");

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

    r96 r97  
    22
    33import com.framsticks.core.*;
     4import com.framsticks.gui.console.Console;
     5import com.framsticks.gui.console.TrackConsole;
    46import com.framsticks.params.annotations.AutoAppendAnnotation;
    57import com.framsticks.params.annotations.FramsClassAnnotation;
    68import com.framsticks.params.annotations.ParamAnnotation;
     9import com.framsticks.remote.RemoteTree;
     10import com.framsticks.util.FramsticksException;
    711import com.framsticks.util.dispatching.AbstractJoinable;
    812import com.framsticks.util.dispatching.Dispatcher;
    913import com.framsticks.util.dispatching.Dispatching;
     14import com.framsticks.util.dispatching.ExceptionResultHandler;
    1015import com.framsticks.util.dispatching.Future;
     16import com.framsticks.util.dispatching.FutureHandler;
    1117import com.framsticks.util.dispatching.Joinable;
    1218import com.framsticks.util.dispatching.JoinableCollection;
    … …  
    1925
    2026import java.awt.Dimension;
     27import java.awt.Toolkit;
     28import java.awt.datatransfer.StringSelection;
     29import java.awt.event.ActionEvent;
    2130import java.util.ArrayList;
     31import java.util.LinkedList;
    2232import java.util.List;
    2333import com.framsticks.util.dispatching.RunAt;
    … …  
    2737 */
    2838@FramsClassAnnotation
    29 public class Browser extends AbstractJoinable implements Dispatcher<Browser>, JoinableParent {
    30 
    31         private static final Logger log = Logger.getLogger(Browser.class.getName());
    32 
    33         protected JoinableCollection<Frame> frames = new JoinableCollection<Frame>().setObservableName("frames");
    34         protected JoinableCollection<Instance> instances = new JoinableCollection<Instance>().setObservableName("instances");
    35 
    36         protected MainFrame mainFrame;
    37         public List<PanelProvider> panelProviders = new ArrayList<PanelProvider>();
     39public class Browser extends AbstractJoinable implements Dispatcher<Browser>, JoinableParent, ExceptionResultHandler {
     40
     41        private static final Logger log = Logger.getLogger(Browser.class);
     42
     43        protected final JoinableCollection<Frame> frames = new JoinableCollection<Frame>().setObservableName("frames");
     44        protected final JoinableCollection<Tree> trees = new JoinableCollection<Tree>().setObservableName("trees");
     45        protected final JoinableCollection<Console> consoles = new JoinableCollection<Console>().setObservableName("consoles");
     46
     47        protected final List<PopupMenuEntryProvider> popupMenuEntryProviders = new LinkedList<>();
     48
     49        protected final MainFrame mainFrame;
     50        protected final List<PanelProvider> panelProviders = new ArrayList<PanelProvider>();
    3851        protected Dimension defaultFrameDimension;
    3952
    … …  
    5164                mainFrame = new MainFrame(Browser.this);
    5265                addFrame(mainFrame);
     66
     67                addPopupMenuEntryProvider(new PopupMenuEntryProvider() {
     68                        @Override
     69                        public void provide(JPopupMenu menu, Path path) {
     70                                menu.add(new JMenuItem(path.getFullTextual()));
     71                                menu.addSeparator();
     72                        }
     73                });
     74
     75                addPopupMenuEntryProvider(new PopupMenuEntryProvider() {
     76                        @SuppressWarnings("serial")
     77                        @Override
     78                        public void provide(JPopupMenu menu, final Path path) {
     79                                menu.add(new AbstractAction("Copy path to clipboard") {
     80                                        @Override
     81                                        public void actionPerformed(ActionEvent e) {
     82                                                Toolkit.getDefaultToolkit().getSystemClipboard().setContents(new StringSelection(path.getFullTextual()), null);
     83                                        }
     84                                });
     85                        }
     86                });
     87
     88                addPopupMenuEntryProvider(new PopupMenuEntryProvider() {
     89                        @SuppressWarnings("serial")
     90                        @Override
     91                        public void provide(JPopupMenu menu, final Path path) {
     92                                if (!(path.getTree() instanceof RemoteTree)) {
     93                                        return;
     94                                }
     95                                final RemoteTree remoteTree = (RemoteTree) path.getTree();
     96                                menu.add(new AbstractAction("Open tracking console") {
     97                                        @Override
     98                                        public void actionPerformed(ActionEvent e) {
     99                                                consoles.add(new TrackConsole().setConnection(remoteTree.getConnection()));
     100                                        }
     101                                });
     102                        }
     103                });
     104                // addNodeActionToTreePopupMenu("", new NodeAction() )
     105
    53106        }
    54107
    … …  
    60113
    61114        @AutoAppendAnnotation
    62         public void addInstance(Instance instance) {
    63                 log.info("adding instance: " + instance);
    64                 instances.add(instance);
     115        public void addPopupMenuEntryProvider(PopupMenuEntryProvider popupMenuEntryProvider) {
     116                popupMenuEntryProviders.add(popupMenuEntryProvider);
     117        }
     118
     119        @AutoAppendAnnotation
     120        public void addTree(Tree tree) {
     121                log.info("adding tree: " + tree);
     122                trees.add(tree);
    65123        }
    66124
    67125        public void autoResolvePath(final String path, final Future<Path> future) {
    68                 final Instance i = instances.get("localhost");
    69                 i.dispatch(new RunAt<Instance>() {
    70                         @Override
    71                         public void run() {
    72                                 InstanceUtils.resolveAndFetch(i, path, new Future<Path>(future) {
     126                final Tree i = trees.get("localhost");
     127                i.dispatch(new RunAt<Tree>(future) {
     128                        @Override
     129                        protected void runAt() {
     130                                TreeOperations.resolveAndGet(i, path, new FutureHandler<Path>(future) {
    73131                                        @Override
    74132                                        protected void result(final Path p) {
    75133                                                future.pass(p);
    76                                                 mainFrame.dispatch(new RunAt<Frame>() {
     134                                                mainFrame.dispatch(new RunAt<Frame>(future) {
    77135                                                        @Override
    78                                                         public void run() {
     136                                                        protected void runAt() {
    79137                                                                mainFrame.goTo(p);
    80138                                                        }
    … …  
    93151        }
    94152
    95         protected void initializeGUI() {
    96                 assert isActive();
    97                 log.debug("executing first task");
    98 
    99                 try {
    100                         boolean found = false;
    101                         // for (LookAndFeelInfo info : UIManager.getInstalledLookAndFeels()) {
    102                         //      log.info("look and feel available: " + info.getName());
    103                         //      if ("Nimbus".equals(info.getName())) {
    104                         //              UIManager.setLookAndFeel(info.getClassName());
    105                         //              found = true;
    106                         //              break;
    107                         //      }
    108                         // }
    109                         if (!found) {
    110                                 UIManager.setLookAndFeel("com.sun.java.swing.plaf.gtk.GTKLookAndFeel");
    111                         }
    112                 } catch (Exception ex) {
    113                         log.warn("failed loading Look&Feel: ", ex);
    114                 }
    115 
    116                 javax.swing.JFrame.setDefaultLookAndFeelDecorated(true);
    117 
    118 
    119                 for (Frame f : frames) {
    120                         f.configure();
    121                 }
    122 
    123                 for (final Instance i : instances) {
    124                         i.dispatch(new RunAt<Instance>() {
    125                                 @Override
    126                                 public void run() {
    127                                         final Path p = Path.to(i, "/");
    128                                         dispatch(new RunAt<Browser>() {
    129                                                 @Override
    130                                                 public void run() {
    131                                                         mainFrame.addRootPath(p);
    132                                                 }
    133                                         });
    134                                 }
    135                         });
    136                 }
    137 
    138                 for (Frame f : frames) {
    139                         f.getSwing().setVisible(true);
    140                 }
    141 
    142                 // autoResolvePath("/simulator/genepools/groups/0", null);
    143                 // autoResolvePath("/", null);
    144         }
    145 
    146153        public void createTreeNodeForChild(final Path path) {
    147154                assert !isActive();
    148                 //assert instance.isActive();
     155                //assert tree.isActive();
    149156
    150157                /*
    … …  
    174181        protected void joinableStart() {
    175182                Dispatching.use(frames, this);
    176                 Dispatching.use(instances, this);
    177 
    178                 dispatch(new RunAt<Browser>() {
    179                         @Override
    180                         public void run() {
    181                                 initializeGUI();
    182                         }
    183                 });
    184         }
    185 
    186         /**
    187          * @return the instances
    188          */
    189         public JoinableCollection<Instance> getInstances() {
    190                 return instances;
     183                Dispatching.use(trees, this);
     184                Dispatching.use(consoles, this);
     185
     186                dispatch(new RunAt<Browser>(this) {
     187                        @Override
     188                        protected void runAt() {
     189
     190                                for (final Tree i : trees) {
     191                                        i.dispatch(new RunAt<Tree>(this) {
     192                                                @Override
     193                                                protected void runAt() {
     194                                                        final Path p = Path.to(i, "/");
     195                                                        dispatch(new RunAt<Browser>(this) {
     196                                                                @Override
     197                                                                protected void runAt() {
     198                                                                        mainFrame.addRootPath(p);
     199                                                                }
     200                                                        });
     201                                                }
     202                                        });
     203                                }
     204                        }
     205                });
     206        }
     207
     208        /**
     209         * @return the tree
     210         */
     211        public JoinableCollection<Tree> getTrees() {
     212                return trees;
    191213        }
    192214
    … …  
    227249        protected void joinableJoin() throws InterruptedException {
    228250                Dispatching.join(frames);
    229                 Dispatching.join(instances);
     251                Dispatching.join(trees);
     252                Dispatching.join(consoles);
    230253                // super.join();
    231254        }
    … …  
    233256        @Override
    234257        protected void joinableInterrupt() {
     258                Dispatching.drop(consoles, this);
    235259                Dispatching.drop(frames, this);
    236                 Dispatching.drop(instances, this);
     260                Dispatching.drop(trees, this);
    237261        }
    238262
    … …  
    255279        }
    256280
     281        @Override
     282        public void handle(FramsticksException exception) {
     283                mainFrame.handle(exception);
     284        }
    257285
    258286        // @Override
    259287        // public boolean isDone() {
    260         //      return frames.isDone() && instances.isDone();
     288        //      return frames.isDone() && trees.isDone();
    261289        // }
    262290}

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

    r96 r97  
    11package com.framsticks.gui;
    22
    3 import com.framsticks.core.Instance;
    4 import com.framsticks.core.Path;
    5 import com.framsticks.gui.view.*;
    6 import com.framsticks.gui.view.TreeCellRenderer;
    7 import com.framsticks.util.dispatching.Dispatcher;
    8 import com.framsticks.util.dispatching.JoinableCollection;
    9 import com.framsticks.util.lang.ScopeEnd;
    10 import com.framsticks.util.swing.KeyboardModifier;
    11 import com.framsticks.util.swing.MenuConstructor;
    12 
    13 import org.apache.log4j.Logger;
    14 
    15 import javax.swing.*;
     3import java.awt.BorderLayout;
     4import java.awt.CardLayout;
     5import java.awt.Color;
     6import java.awt.Container;
     7import java.awt.Dimension;
     8import java.awt.Toolkit;
     9import java.awt.event.ActionEvent;
     10import java.awt.event.KeyEvent;
     11import java.awt.event.MouseAdapter;
     12import java.awt.event.MouseEvent;
     13import java.util.HashMap;
     14import java.util.Map;
     15
     16import javax.swing.AbstractAction;
     17import javax.swing.BorderFactory;
     18import javax.swing.JComponent;
     19import javax.swing.JMenu;
     20import javax.swing.JMenuBar;
     21import javax.swing.JMenuItem;
     22import javax.swing.JPanel;
     23import javax.swing.JPopupMenu;
     24import javax.swing.JScrollPane;
     25import javax.swing.JSplitPane;
     26import javax.swing.JTree;
     27import javax.swing.KeyStroke;
     28import javax.swing.ToolTipManager;
     29import javax.swing.UIManager;
    1630import javax.swing.event.TreeModelEvent;
    1731import javax.swing.event.TreeModelListener;
    1832import javax.swing.event.TreeSelectionEvent;
    1933import javax.swing.event.TreeSelectionListener;
    20 import javax.swing.tree.*;
    21 
    22 import java.awt.*;
    23 import java.awt.datatransfer.StringSelection;
    24 import java.awt.event.*;
    25 import java.util.HashMap;
    26 import java.util.Map;
     34import javax.swing.tree.DefaultMutableTreeNode;
     35import javax.swing.tree.DefaultTreeModel;
     36import javax.swing.tree.DefaultTreeSelectionModel;
     37import javax.swing.tree.TreePath;
     38import javax.swing.tree.TreeSelectionModel;
     39
     40import org.apache.log4j.Logger;
     41
     42import com.framsticks.core.Path;
     43import com.framsticks.core.Tree;
     44import com.framsticks.gui.view.TreeCellRenderer;
     45import com.framsticks.util.FramsticksException;
     46import com.framsticks.util.dispatching.Dispatching;
     47import com.framsticks.util.dispatching.ExceptionResultHandler;
     48import com.framsticks.util.dispatching.Joinable;
     49import com.framsticks.util.dispatching.JoinableCollection;
     50import com.framsticks.util.dispatching.JoinableParent;
     51import com.framsticks.util.dispatching.JoinableState;
    2752import com.framsticks.util.dispatching.RunAt;
     53import com.framsticks.util.lang.ScopeEnd;
     54import com.framsticks.util.swing.KeyboardModifier;
     55import com.framsticks.util.swing.MenuConstructor;
    2856
    2957/**
    … …  
    3159 */
    3260@SuppressWarnings("serial")
    33 public class Frame extends JoinableCollection<Instance> implements Dispatcher<Frame> {
     61public class Frame extends FrameJoinable implements JoinableParent {
    3462
    3563        private static final Logger log = Logger.getLogger(Frame.class.getName());
    … …  
    4270        protected JPanel cardPanel;
    4371
    44         protected final String title;
    45         protected JFrame swing;
    4672        protected JScrollPane treeScrollPane;
    47         protected JTree tree;
     73        protected JTree jtree;
    4874        protected DefaultTreeModel treeModel;
    4975        protected javax.swing.tree.MutableTreeNode rootNode;
    50         //final Instance instance;
    5176        protected JPanel treePanel;
    5277        protected JPopupMenu treePopupMenu;
    … …  
    5479
    5580        TreeNode currentlyPoppedTreeNode;
    56         protected JLabel statusBar;
    5781        protected JPanel mainPanel;
    5882        protected JPanel leftPanel;
    … …  
    6791        protected JMenu helpMenu;
    6892
    69         protected final Map<Instance, InstanceAtFrame> instancesAtFrames = new HashMap<Instance, InstanceAtFrame>();
    70 
    71         public Frame(String title, Browser browser) {
    72                 this.title = title;
     93        protected final Map<Tree, TreeAtFrame> treeAtFrames = new HashMap<Tree, TreeAtFrame>();
     94        protected JoinableCollection<Tree> trees = new JoinableCollection<Tree>();
     95
     96        public Frame(Browser browser) {
    7397                this.browser = browser;
    7498        }
    7599
    76         public void configure() {
    77                 swing = new JFrame(title);
    78                 swing.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
    79                 swing.addWindowListener(new WindowAdapter() {
    80                         @Override
    81                         public void windowClosing(WindowEvent e) {
    82                                 log.info("received closing");
    83                                 interrupt();
    84                         }
    85                 });
     100        protected void initializeGui() {
     101                super.initializeGui();
    86102                /** this is done to remove the current value label from above the slider,
    87103                 * because it cannot put to work properly with floating-point value sliders,
    … …  
    90106                log.debug("creating " + this);
    91107
    92                 statusBar = new JLabel("not connected");
    93 
    94                 Container contentPane = swing.getContentPane();
    95                 contentPane.setLayout(new BorderLayout());
    96 
     108
     109                Container contentPane = getSwing().getContentPane();
    97110                treePopupMenu = new JPopupMenu("title");
    98111                treePopupMenu.setName("popup");
    99                 treePopupMenuHeader = new JMenuItem();
    100                 treePopupMenuHeader.setForeground(Color.BLUE);
    101                 treePopupMenu.add(treePopupMenuHeader);
    102                 treePopupMenu.addSeparator();
    103                 //TODO: add to favourites
    104                 //TODO: remove from favourites
    105                 //TODO: open in new window as root
    106                 //TODO: refresh
    107                 //TODO: open in console
    108 
    109                 treePopupMenu.add(new JMenuItem("Refresh"));
    110                 treePopupMenu.add(new JMenuItem("Open in new frame as root"));
    111                 addNodeActionToTreePopupMenu("Copy path to clipboard", new NodeAction() {
    112                         @Override
    113                         public void actionPerformed(TreeNode treeNode) {
    114                                 Path path = treeNode.getInstancePath();
    115                                 StringSelection selection = new StringSelection(path.toString());
    116                                 swing.getToolkit().getSystemClipboard().setContents(selection, selection);
    117                         }
    118                 });
    119                 //this.add(createMenuItem("Add to favourites", null));
    120                 //this.add(createMenuItem("Remove from favourites", null));
    121112
    122113                treePanel = new JPanel();
    … …  
    147138                });
    148139
    149                 tree = new JTree(treeModel);
    150                 tree.setName("tree");
    151                 tree.setRootVisible(false);
    152                 tree.setExpandsSelectedPaths(true);
    153                 tree.setSelectionModel(new DefaultTreeSelectionModel());
    154                 ToolTipManager.sharedInstance().registerComponent(tree);
    155 
    156                 tree.addTreeSelectionListener(new TreeSelectionListener() {
     140                jtree = new JTree(treeModel);
     141                jtree.setName("tree");
     142                jtree.setRootVisible(false);
     143                jtree.setExpandsSelectedPaths(true);
     144                jtree.setSelectionModel(new DefaultTreeSelectionModel());
     145                ToolTipManager.sharedInstance().registerComponent(jtree);
     146
     147                jtree.addTreeSelectionListener(new TreeSelectionListener() {
    157148                        @Override
    158149                        public void valueChanged(TreeSelectionEvent e) {
    … …  
    161152                });
    162153
    163                 tree.setExpandsSelectedPaths(true);
    164                 tree.setEditable(false);
    165                 tree.setDoubleBuffered(true);
    166                 tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
    167                 tree.setShowsRootHandles(true);
    168                 tree.setRowHeight(26);
    169                 tree.setDoubleBuffered(true);
    170                 tree.addMouseListener(new MouseAdapter() {
     154                jtree.setExpandsSelectedPaths(true);
     155                jtree.setEditable(false);
     156                jtree.setDoubleBuffered(true);
     157                jtree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
     158                jtree.setShowsRootHandles(true);
     159                jtree.setRowHeight(26);
     160                jtree.setDoubleBuffered(true);
     161                jtree.addMouseListener(new MouseAdapter() {
    171162                        @Override
    172163                        public void mousePressed(MouseEvent e) {
    … …  
    182173                });
    183174
    184                 new KeyboardModifier(tree, JComponent.WHEN_FOCUSED).join(KeyStroke.getKeyStroke('h'), KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, 0)).join(KeyStroke.getKeyStroke('j'), KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0)).join(KeyStroke.getKeyStroke('k'), KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0)).join(KeyStroke.getKeyStroke('l'), KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, 0));
    185 
    186                 tree.setCellRenderer(new TreeCellRenderer());
    187 
    188                 treeScrollPane = new JScrollPane(tree);
     175                new KeyboardModifier(jtree, JComponent.WHEN_FOCUSED).join(KeyStroke.getKeyStroke('h'), KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, 0)).join(KeyStroke.getKeyStroke('j'), KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0)).join(KeyStroke.getKeyStroke('k'), KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0)).join(KeyStroke.getKeyStroke('l'), KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, 0));
     176
     177                jtree.setCellRenderer(new TreeCellRenderer());
     178
     179                treeScrollPane = new JScrollPane(jtree);
    189180                treeScrollPane.setBorder(BorderFactory.createEmptyBorder());
    190181
    … …  
    215206                contentPane.add(menuBar, BorderLayout.NORTH);
    216207                contentPane.add(mainPanel, BorderLayout.CENTER);
    217                 contentPane.add(statusBar, BorderLayout.SOUTH);
    218208
    219209                leftPanel = new JPanel();
    … …  
    246236                cardPanel.setLayout(cardPanelLayout);
    247237
    248                 swing.pack();
    249                 tree.requestFocusInWindow();
     238                getSwing().pack();
     239                jtree.requestFocusInWindow();
    250240
    251241                log.debug("frame configured: " + this);
    … …  
    266256        public void addRootPath(Path path) {
    267257                assert isActive();
    268                 Instance instance = path.getInstance();
    269                 assert browser.getInstances().contains(instance);
    270 
    271                 InstanceAtFrame e = new InstanceAtFrame(instance, this);
    272                 instance.addListener(e);
    273                 instancesAtFrames.put(instance, e);
     258                Tree tree = path.getTree();
     259                assert browser.getTrees().contains(tree);
     260
     261                TreeAtFrame e = new TreeAtFrame(tree, this);
     262                tree.addListener(e);
     263                treeAtFrames.put(tree, e);
    274264                TreeNode node = new TreeNode(e, path);
    275265                e.rootTreeNode = node;
    276266                treeModel.insertNodeInto(node, rootNode, rootNode.getChildCount());
    277                 tree.expandPath(new TreePath(rootNode));
    278         }
    279 
    280         @Override
    281         public boolean isActive() {
    282                 return SwingDispatcher.instance.isActive();
    283         }
    284 
    285         @Override
    286         public void dispatch(RunAt<? extends Frame> runnable) {
    287                 SwingDispatcher.getInstance().dispatch(runnable);
    288         }
    289 
    290         public Action addActionToTreePopupMenu(Action action) {
    291                 assert isActive();
    292                 treePopupMenu.add(action);
    293                 return action;
    294         }
    295 
    296         public Action addNodeActionToTreePopupMenu(String title, final NodeAction nodeAction) {
    297                 assert isActive();
    298                 return addActionToTreePopupMenu(new AbstractAction(title) {
    299                         @Override
    300                         public void actionPerformed(ActionEvent e) {
    301                                 TreeNode treeNode = getCurrentlyPoppedTreeNode();
    302                                 if (treeNode == null) {
    303                                         return;
    304                                 }
    305                                 nodeAction.actionPerformed(treeNode);
    306                         }
    307                 });
    308         }
     267                jtree.expandPath(new TreePath(rootNode));
     268        }
     269
    309270
    310271        public void showPanel(Panel panel) {
    … …  
    319280                        return;
    320281                }
    321                 currentlyPoppedTreeNode = findTreeNodeByTreePath(tree.getPathForLocation(e.getX(), e.getY()));
     282                currentlyPoppedTreeNode = findTreeNodeByTreePath(jtree.getPathForLocation(e.getX(), e.getY()));
    322283                if (currentlyPoppedTreeNode == null) {
    323284                        return;
    324285                }
     286
     287                Path path = currentlyPoppedTreeNode.getTreePath();
     288                treePopupMenu.removeAll();
     289
     290                for (PopupMenuEntryProvider provider : browser.popupMenuEntryProviders) {
     291                        provider.provide(treePopupMenu, path);
     292                }
     293                // treePopupMenuHeader.setText(path.getTree().getName() + path.getTextual());
    325294                treePopupMenu.show(e.getComponent(), e.getX(), e.getY());
    326295                //currentlyPoppedPanel.getNode().getFramsClass().getName()
    327                 //treePopupMenuHeader.setText(currentlyPoppedTreeNode.getNode().getPath());
    328         }
    329 
    330         /**
    331          * @return the swing
    332          */
    333         public JFrame getSwing() {
    334                 return swing;
    335296        }
    336297
    … …  
    344305                cardPanel.removeAll();
    345306                cardPanel.updateUI();
    346                 tree.setEnabled(false);
     307                jtree.setEnabled(false);
    347308        }
    348309
    349310        public ScopeEnd startChange(final DefaultMutableTreeNode node) {
    350311                assert isActive();
    351                 final TreePath selection = tree.getSelectionPath();
     312                final TreePath selection = jtree.getSelectionPath();
    352313                return new ScopeEnd() {
    353314                        @Override
    … …  
    355316                                assert isActive();
    356317                                treeModel.nodeChanged(node);
    357                                 tree.setSelectionPath(selection);
     318                                jtree.setSelectionPath(selection);
    358319                        }
    359320                };
    … …  
    391352        }
    392353
     354        protected final ExceptionResultHandler dialogHandler = new ExceptionResultHandler() {
     355
     356                @Override
     357                public void handle(FramsticksException exception) {
     358                        //TODO TEH
     359                        throw exception;
     360
     361                }
     362        };
     363
    393364        public void goTo(Path path) {
    394365                assert isActive();
    395                 final TreePath treePath = instancesAtFrames.get(path.getInstance()).getTreePath(path, false);
     366                final TreePath treePath = treeAtFrames.get(path.getTree()).getTreePath(path, false);
    396367                log.info("go to path: " + path + "(" + treePath + ")");
    397368
    398                 new RunAt<Frame>(this) {
    399                         @Override
    400                         public void run() {
     369                this.dispatch(new RunAt<Frame>(dialogHandler) {
     370                        @Override
     371                        protected void runAt() {
    401372                                log.info("executed");
    402                                 tree.setSelectionPath(treePath);
    403                                 tree.makeVisible(treePath);
    404                                 assert tree.isVisible(treePath);
    405                         }
    406                 };
     373                                jtree.setSelectionPath(treePath);
     374                                jtree.makeVisible(treePath);
     375                                assert jtree.isVisible(treePath);
     376                        }
     377                });
    407378
    408379        }
    … …  
    422393
    423394        @Override
     395        protected void joinableStart() {
     396                super.joinableStart();
     397                Dispatching.use(trees, this);
     398        }
     399
     400        @Override
    424401        protected void joinableInterrupt() {
    425                 assert isActive();
     402                Dispatching.drop(trees, this);
    426403                super.joinableInterrupt();
    427 
    428                 dispatch(new RunAt<Frame>() {
    429                         @Override
    430                         public void run() {
    431                                 finish();
    432                         }
    433                 });
    434404        }
    435405
    436406        @Override
    437407        protected void joinableFinish() {
    438                 assert isActive();
    439                 log.debug("disposing frame " + this);
    440                 swing.dispose();
    441         }
    442 
    443         // @Override
    444         // public boolean isDone() {
    445         //      return super.isDone() && !swing.isDisplayable();
    446         // }
    447 
    448 
    449         @Override
    450         public String getName() {
    451                 return title;
    452         }
    453 
     408                super.joinableFinish();
     409        }
     410
     411        @Override
     412        protected void joinableJoin() throws InterruptedException {
     413                Dispatching.join(trees);
     414                super.joinableJoin();
     415        }
     416
     417        @Override
     418        public void childChangedState(Joinable joinable, JoinableState state) {
     419                if (joinable == trees) {
     420                        proceedToState(state);
     421                }
     422        }
    454423
    455424}

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

    r90 r97  
    4545
    4646        public static Control createComponentForText(PrimitiveParam<?> valueParam) {
    47                 if (valueParam.getMin(Object.class) != null) {
    48                         return new TextAreaControl(valueParam);
     47                if (valueParam.getMax(Object.class) != null) {
     48                        return new TextFieldControl(valueParam);
    4949                }
    50                 return new TextFieldControl(valueParam);
     50                return new TextAreaControl(valueParam);
     51
     52
     53                // if (valueParam.getMin(Object.class) != null) {
     54                //      return new TextAreaControl(valueParam);
     55                // }
     56                // return new TextFieldControl(valueParam);
    5157        }
    5258
    … …  
    6470                                return new SliderControl(decimalParam);
    6571                        }
    66                         return createComponentForText(decimalParam);
     72                        return new TextFieldControl(decimalParam);
    6773                }
    6874                if (param instanceof FloatParam) {
    … …  
    7177                                return new SliderControl(floatParam);
    7278                        }
    73                         return createComponentForText(floatParam);
     79                        return new TextFieldControl(floatParam);
    7480                }
    7581                if (param instanceof StringParam) {
    76                         return createComponentForText((StringParam)param);
     82                        return createComponentForText((StringParam) param);
    7783                }
    7884                if (param instanceof ProcedureParam) {
    79                         return new ProcedureControl((ProcedureParam)param);
     85                        return new ProcedureControl((ProcedureParam) param);
    8086                }
    8187                if (param instanceof BinaryParam) {
    82                         return createComponentForText((BinaryParam)param);
     88                        return new TextFieldControl((BinaryParam) param);
    8389                }
    8490                if (param instanceof ColorParam) {
    85                         return createComponentForText((ColorParam) param);
     91                        return new TextFieldControl((ColorParam) param);
    8692                }
    8793                if (param instanceof UniversalParam) {
    88                         return new TextAreaControl((UniversalParam)param);
     94                        return new TextAreaControl((UniversalParam) param);
    8995                }
    9096                if (param instanceof EventParam) {
    91                         return new EventControl((EventParam)param);
     97                        return new EventControl((EventParam) param);
    9298                }
    9399                return null;

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

    r88 r97  
    11package com.framsticks.gui;
    22
    3 import com.framsticks.gui.windows.console.ConsoleFrame;
    4 import com.framsticks.util.swing.MenuConstructor;
    5 import org.apache.log4j.Logger;
    6 
    7 import javax.swing.*;
    8 import javax.swing.border.TitledBorder;
    9 import java.awt.*;
    103import java.awt.event.ActionEvent;
    11 import java.awt.event.ActionListener;
    124import java.awt.event.KeyEvent;
    135import java.awt.event.WindowAdapter;
    146import java.awt.event.WindowEvent;
     7
     8import javax.swing.AbstractAction;
     9import javax.swing.JButton;
     10import javax.swing.KeyStroke;
     11import javax.swing.WindowConstants;
     12
     13import org.apache.log4j.Logger;
     14
     15import com.framsticks.util.swing.MenuConstructor;
    1516
    1617/**
    … …  
    2829         */
    2930        public MainFrame(final Browser browser) {
    30                 super("framsticks", browser);
     31                super(browser);
     32                setTitle("framsticks");
    3133                log.debug("creating main frame");
    3234
    … …  
    3537
    3638        @Override
    37         public void configure() {
    38                 super.configure();
     39        protected void initializeGui() {
     40                super.initializeGui();
    3941
    4042                new MenuConstructor(fileMenu)
    … …  
    4244                                @Override
    4345                                public void actionPerformed(ActionEvent actionEvent) {
    44                                         showConsoleFrame();
     46                                        // showConsoleFrame();
    4547                                }
    4648                        })
    … …  
    145147        // }
    146148
    147         public void setSimulationRunning(final boolean run) {
    148                 assert isActive();
    149                 /*
    150                 remoteInstance.invokeLater(new Runnable() {
    151                         @Override
    152                         public void run() {
    153                                 remoteInstance.setRunning(run);
    154                         }
    155                 });
    156                 */
    157         }
    158 
    159         /**
    160          * Creates panel with start, step, stop buttons.
    161          */
    162         @Override
    163         protected JPanel createLeftTopPanel() {
    164                 assert isActive();
    165                 Dimension buttonDimension = new Dimension(45, 45);
    166 
    167                 JPanel panel = new JPanel();
    168 
    169                 stop = new JButton(ImageProvider.loadImage(ImageProvider.SIM_STOP));
    170                 stop.addActionListener(new ActionListener() {
    171 
    172                         public void actionPerformed(ActionEvent e) {
    173                                 setSimulationRunning(false);
    174                         }
    175 
    176                 });
    177 
    178                 stop.setPreferredSize(buttonDimension);
    179                 stop.setToolTipText("Simulation Stop");
    180                 stop.setEnabled(false);
    181 
    182                 step = new JButton(ImageProvider.loadImage(ImageProvider.SIM_STEP));
    183                 /*
    184                 step.addActionListener(new ActionListener() {
    185 
    186                         public void actionPerformed(ActionEvent e) {
    187                                 connection.send(new CallQuery().setMethod("step").setPath("/simulator"));
    188                         }
    189 
    190                 });
    191                 */
    192 
    193                 step.setPreferredSize(buttonDimension);
    194                 step.setToolTipText("Simulation Step");
    195 
    196                 start = new JButton(ImageProvider.loadImage(ImageProvider.SIM_START));
    197                 start.addActionListener(new ActionListener() {
    198 
    199                         public void actionPerformed(ActionEvent e) {
    200                                 setSimulationRunning(true);
    201                         }
    202 
    203                 });
    204 
    205                 start.setPreferredSize(buttonDimension);
    206                 start.setToolTipText("Start Simulation");
    207 
    208                 JPanel buttonPanel = new JPanel();
    209                 buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.LINE_AXIS));
    210                 buttonPanel.add(Box.createHorizontalStrut(5));
    211                 buttonPanel.add(stop);
    212                 buttonPanel.add(Box.createHorizontalStrut(10));
    213                 buttonPanel.add(step);
    214                 buttonPanel.add(Box.createHorizontalStrut(10));
    215                 buttonPanel.add(start);
    216                 buttonPanel.add(Box.createHorizontalStrut(5));
    217 
    218                 buttonPanel.setBorder(BorderFactory.createTitledBorder(BorderFactory
    219                                 .createRaisedBevelBorder(), "Simulation Control",
    220                                 TitledBorder.CENTER, TitledBorder.DEFAULT_POSITION
    221                                 ));
    222 
    223                 panel.setLayout(new BoxLayout(panel, BoxLayout.LINE_AXIS));
    224                 panel.add(Box.createHorizontalGlue());
    225                 panel.add(buttonPanel);
    226                 panel.add(Box.createHorizontalGlue());
    227                 return panel;
    228         }
     149
     150        // /**
     151        //  * Creates panel with start, step, stop buttons.
     152        //  */
     153        // @Override
     154        // protected JPanel createLeftTopPanel() {
     155        //      assert isActive();
     156        //      Dimension buttonDimension = new Dimension(45, 45);
     157
     158        //      JPanel panel = new JPanel();
     159
     160        //      stop = new JButton(ImageProvider.loadImage(ImageProvider.SIM_STOP));
     161        //      stop.addActionListener(new ActionListener() {
     162
     163        //              public void actionPerformed(ActionEvent e) {
     164        //                      setSimulationRunning(false);
     165        //              }
     166
     167        //      });
     168
     169        //      stop.setPreferredSize(buttonDimension);
     170        //      stop.setToolTipText("Simulation Stop");
     171        //      stop.setEnabled(false);
     172
     173        //      step = new JButton(ImageProvider.loadImage(ImageProvider.SIM_STEP));
     174        //      /*
     175        //      step.addActionListener(new ActionListener() {
     176
     177        //              public void actionPerformed(ActionEvent e) {
     178        //                      connection.send(new CallQuery().setMethod("step").setPath("/simulator"));
     179        //              }
     180
     181        //      });
     182        //      */
     183
     184        //      step.setPreferredSize(buttonDimension);
     185        //      step.setToolTipText("Simulation Step");
     186
     187        //      start = new JButton(ImageProvider.loadImage(ImageProvider.SIM_START));
     188        //      start.addActionListener(new ActionListener() {
     189
     190        //              public void actionPerformed(ActionEvent e) {
     191        //                      setSimulationRunning(true);
     192        //              }
     193
     194        //      });
     195
     196        //      start.setPreferredSize(buttonDimension);
     197        //      start.setToolTipText("Start Simulation");
     198
     199        //      JPanel buttonPanel = new JPanel();
     200        //      buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.LINE_AXIS));
     201        //      buttonPanel.add(Box.createHorizontalStrut(5));
     202        //      buttonPanel.add(stop);
     203        //      buttonPanel.add(Box.createHorizontalStrut(10));
     204        //      buttonPanel.add(step);
     205        //      buttonPanel.add(Box.createHorizontalStrut(10));
     206        //      buttonPanel.add(start);
     207        //      buttonPanel.add(Box.createHorizontalStrut(5));
     208
     209        //      buttonPanel.setBorder(BorderFactory.createTitledBorder(BorderFactory
     210        //                      .createRaisedBevelBorder(), "Simulation Control",
     211        //                      TitledBorder.CENTER, TitledBorder.DEFAULT_POSITION
     212        //                      ));
     213
     214        //      panel.setLayout(new BoxLayout(panel, BoxLayout.LINE_AXIS));
     215        //      panel.add(Box.createHorizontalGlue());
     216        //      panel.add(buttonPanel);
     217        //      panel.add(Box.createHorizontalGlue());
     218        //      return panel;
     219        // }
    229220
    230221        /**
    … …  
    233224        private void setFrameProperties() {
    234225                assert isActive();
    235                 swing.setMinimumSize(swing.getPreferredSize());
    236                 swing.setSize(swing.getPreferredSize());
    237                 swing.setMaximumSize(screenDimension);
    238                 swing.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    239 
    240                 swing.setIconImage(ImageProvider.loadImage(ImageProvider.LOGO)
     226                getSwing().setMinimumSize(getSwing().getPreferredSize());
     227                getSwing().setSize(getSwing().getPreferredSize());
     228                getSwing().setMaximumSize(screenDimension);
     229                getSwing().setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
     230
     231                getSwing().setIconImage(ImageProvider.loadImage(ImageProvider.LOGO)
    241232                                .getImage());
    242233
    243234
    244                 swing.addWindowListener(new WindowAdapter() {
     235                getSwing().addWindowListener(new WindowAdapter() {
    245236                        public void windowClosing(WindowEvent e) {
    246237                                assert isActive();
    … …  
    251242                                */
    252243                                onWindowClosing();
    253                                 swing.dispose();
     244                                getSwing().dispose();
    254245                        }
    255246                });
    256247        }
    257248
    258         public ConsoleFrame showConsoleFrame() {
    259                 assert isActive();
    260                 /*
    261                 ConsoleFrame consoleFrame = new ConsoleFrame(connection);
    262                 consoleFrame.show(MainFrame.this);
    263                 return consoleFrame;
    264                 */
    265                 return null;
    266         }
     249        // public ConsoleFrame showConsoleFrame() {
     250        //      assert isActive();
     251        //      /*
     252        //      ConsoleFrame consoleFrame = new ConsoleFrame(connection);
     253        //      consoleFrame.show(MainFrame.this);
     254        //      return consoleFrame;
     255        //      */
     256        //      return null;
     257        // }
    267258
    268259        /**
    … …  
    271262        private void disconnect() {
    272263                assert isActive();
    273                 //remoteInstance.disconnect();
    274264                browser.clear();
    275265                onWindowClosing();
    276                 statusBar.setText("You are disconnected");
     266                // statusBar.setText("You are disconnected");
    277267        }
    278268

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

    r84 r97  
    3939
    4040                applyButton = new JButton("Apply");
     41                applyButton.setName("apply");
     42
    4143                applyButton.addActionListener(new ActionListener() {
    4244                        public void actionPerformed(ActionEvent e) {

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

    r88 r97  
    2424                for (Panel p : panels) {
    2525                        assert p.getClassName().equals(getClassName());
    26                         assert p.getInstanceAtFrame() == getInstanceAtFrame();
     26                        assert p.getTreeAtFrame() == getTreeAtFrame();
    2727                        tabbedPane.add(p.getTitle(), p);
    2828                }

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

    r90 r97  
    1717import java.util.Map;
    1818import static com.framsticks.util.lang.Containers.filterInstanceof;
     19
     20import com.framsticks.util.FramsticksException;
    1921import com.framsticks.util.dispatching.RunAt;
    2022
    … …  
    7072        public void pullValuesFromLocalToUser(AccessInterface access) {
    7173                assert currentTreeNode != null;
    72                 assert currentTreeNode.path.getInstance().isActive();
     74                assert currentTreeNode.path.getTree().isActive();
    7375                log.debug("refreshing components");
    7476
    … …  
    7880                }
    7981
    80                 frame.dispatch(new RunAt<Frame>() {
     82                frame.dispatch(new RunAt<Frame>(frame) {
    8183                        @Override
    82                         public void run() {
     84                        protected void runAt() {
    8385                                if (currentTreeNode.localChanges != null) {
    8486                                        for (Map.Entry<ValueControl, Object> e : currentTreeNode.localChanges.entrySet()) {
    … …  
    111113        }
    112114
     115        @Override
     116        public void handle(FramsticksException exception) {
     117                frame.handle(exception);
     118        }
     119
    113120        // public void updateValue() {
    114121        //      //assert panel.getFrame().isActive();

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

    r88 r97  
    1515
    1616        public static class Parameters {
    17                 public final InstanceAtFrame instanceAtFrame;
     17                public final TreeAtFrame treeAtFrame;
    1818                public final CompositeParam param;
    1919                public final FramsClass framsClass;
    2020
    21                 public Parameters(InstanceAtFrame instanceAtFrame, CompositeParam param, FramsClass framsClass) {
    22                         this.instanceAtFrame = instanceAtFrame;
     21                public Parameters(TreeAtFrame treeAtFrame, CompositeParam param, FramsClass framsClass) {
     22                        this.treeAtFrame = treeAtFrame;
    2323                        this.param = param;
    2424                        this.framsClass = framsClass;
    … …  
    2929
    3030        protected TreeNode currentTreeNode;
    31         protected final InstanceAtFrame instanceAtFrame;
     31        protected final TreeAtFrame treeAtFrame;
    3232        protected final Frame frame;
    3333        protected final String className;
    … …  
    3737
    3838        public Panel(Parameters parameters) {
    39                 this.instanceAtFrame = parameters.instanceAtFrame;
    40                 this.frame = parameters.instanceAtFrame.getFrame();
     39                this.treeAtFrame = parameters.treeAtFrame;
     40                this.frame = parameters.treeAtFrame.getFrame();
    4141                this.framsClass = parameters.framsClass;
    4242                this.param = parameters.param;
    … …  
    5757        }
    5858
    59         public final InstanceAtFrame getInstanceAtFrame() {
    60                 return instanceAtFrame;
     59        public final TreeAtFrame getTreeAtFrame() {
     60                return treeAtFrame;
    6161        }
    6262

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

    r90 r97  
    33import com.framsticks.util.dispatching.Dispatcher;
    44import com.framsticks.util.dispatching.Task;
     5import com.framsticks.util.dispatching.ThrowExceptionHandler;
    56
    67import javax.swing.*;
    … …  
    2122
    2223        public SwingDispatcher() {
    23                 dispatch(new RunAt<C>() {
     24                dispatch(new RunAt<C>(ThrowExceptionHandler.getInstance()) {
    2425                        @Override
    25                         public void run() {
     26                        protected void runAt() {
    2627                                Thread.currentThread().setName("gui");
    2728                        }

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

    r96 r97  
    11package com.framsticks.gui;
    22
    3 import com.framsticks.communication.Connection;
    43import com.framsticks.communication.Subscription;
    54import com.framsticks.communication.util.LoggingStateCallback;
    6 import com.framsticks.core.Instance;
    7 import com.framsticks.core.InstanceUtils;
     5import com.framsticks.core.Mode;
     6import com.framsticks.core.Tree;
     7import com.framsticks.core.TreeOperations;
    88import com.framsticks.core.ListChange;
    99import com.framsticks.core.Path;
    … …  
    1818import com.framsticks.util.lang.Holder;
    1919import com.framsticks.util.swing.TooltipConstructor;
    20 import com.framsticks.util.dispatching.Future;
    21 import com.framsticks.util.AbstractStateFunctor;
     20import com.framsticks.util.dispatching.ExceptionResultHandler;
     21import com.framsticks.util.dispatching.FutureHandler;
     22import com.framsticks.util.FramsticksException;
    2223import com.framsticks.util.Logging;
    2324import org.apache.log4j.Logger;
    … …  
    3132import static com.framsticks.util.lang.Containers.filterInstanceof;
    3233import com.framsticks.util.swing.TreeNodeUtils;
    33 import static com.framsticks.core.InstanceUtils.*;
     34import static com.framsticks.core.TreeOperations.*;
    3435
    3536/**
    … …  
    3738 */
    3839@SuppressWarnings("serial")
    39 public class TreeNode extends DefaultMutableTreeNode implements NodeListener {
     40public class TreeNode extends DefaultMutableTreeNode implements NodeListener, ExceptionResultHandler {
    4041
    4142        private static final Logger log = Logger.getLogger(TreeNode.class.getName());
    … …  
    4445
    4546        final protected Frame frame;
    46         final protected InstanceAtFrame instanceAtFrame;
     47        final protected TreeAtFrame treeAtFrame;
    4748
    4849        final protected Map<EventParam, Subscription<?>> userSubscriptions = new HashMap<>();
    … …  
    5051        protected String tooltip;
    5152        protected String name;
    52         protected final String paramId;
     53        protected final CompositeParam param;
    5354        protected String iconName;
    5455        protected Path path;
    5556
    56         public TreeNode(InstanceAtFrame instanceAtFrame, final Path path) {
    57                 this.frame = instanceAtFrame.getFrame();
    58                 assert frame.isActive();
    59                 this.paramId = path.getLastElement();
    60                 this.name = this.paramId;
     57        public TreeNode(TreeAtFrame treeAtFrame, final Path path) {
     58                this.frame = treeAtFrame.getFrame();
     59                assert frame.isActive();
     60                this.param = path.getTop().getParam();
     61                this.name = this.param.getId();
    6162                log.debug("creating treenode " + name + ": " + path);
    6263                this.path = path;
    63                 this.instanceAtFrame = instanceAtFrame;
     64                this.treeAtFrame = treeAtFrame;
    6465
    6566                iconName = TreeCellRenderer.findIconName(name, path.getTextual());
    6667                tooltip = "?";
    67                 path.getInstance().dispatch(new RunAt<Instance>() {
    68                         @Override
    69                         public void run() {
     68                path.getTree().dispatch(new RunAt<Tree>(this) {
     69                        @Override
     70                        protected void runAt() {
    7071                                updateDescriptions(path);
    7172                        }
    … …  
    7475
    7576        public void fetch(final Path p) {
    76                 assert p.getInstance().isActive();
     77                assert p.getTree().isActive();
    7778                log.debug("fetching: " + p);
    78                 p.getInstance().fetchValues(p, new AbstractStateFunctor() {
    79                         @Override
    80                         public void call() {
    81                                 // reactForFetchResult(p, e);
     79                p.getTree().get(p, Mode.FETCH, new FutureHandler<Object>(this) {
     80                        @Override
     81                        protected void result(Object result) {
     82
    8283                        }
    8384                });
    … …  
    8586
    8687        protected void reactForFetchResult(final Path p, Exception e) {
    87                 assert p.getInstance().isActive();
     88                assert p.getTree().isActive();
    8889                if (Logging.log(log, "fetch", TreeNode.this, e)) {
    89                         frame.dispatch(new RunAt<Frame>() {
     90                        frame.dispatch(new RunAt<Frame>(this) {
    9091                                @Override
    91                                 public void run() {
     92                                protected void runAt() {
    9293                                        log.debug("removing node from tree: " + p);
    9394                                        frame.treeModel.removeNodeFromParent(TreeNode.this);
    … …  
    9798                }
    9899                updateChildren(p);
    99                 frame.dispatch(new RunAt<Frame>() {
    100                         @Override
    101                         public void run() {
     100                frame.dispatch(new RunAt<Frame>(this) {
     101                        @Override
     102                        protected void runAt() {
    102103                                //TODO maybe this should be called from some better place
    103104                                useOrCreatePanel();
    … …  
    109110                assert !frame.isActive();
    110111                /** TODO those two actions could be merged into single closure */
    111                 frame.dispatch(new RunAt<Frame>() {
    112                         @Override
    113                         public void run() {
     112                frame.dispatch(new RunAt<Frame>(this) {
     113                        @Override
     114                        protected void runAt() {
    114115                                updatePath(newPath);
    115116                        }
    … …  
    140141         */
    141142        protected void updateChildren(final Path p) {
    142                 assert p.getInstance().isActive();
     143                assert p.getTree().isActive();
    143144                log.debug("updating children of " + this);
    144                 AccessInterface access = InstanceUtils.bindAccess(p.getInstance(), p.getTop());
    145                 if (access == null) {
    146                         return;
    147                 }
     145                AccessInterface access = TreeOperations.bindAccess(p.getTree(), p.getTop());
    148146                final List<Path> childrenPaths = new LinkedList<Path>();
    149147                /**Prepare path for each child.*/
    … …  
    154152                /**If some child were found, update in frame context.*/
    155153                if (childrenPaths.size() > 0) {
    156                         frame.dispatch(new RunAt<Frame>() {
     154                        frame.dispatch(new RunAt<Frame>(this) {
    157155                                @Override
    158                                 public void run() {
     156                                protected void runAt() {
    159157                                        // TreePath treePath = frame.startChange();
    160158                                        updatePath(p);
    … …  
    173171                                                }
    174172                                                log.debug("update: treenode for " + p);
    175                                                 TreeNode childNode = new TreeNode(instanceAtFrame, childPath);
     173                                                TreeNode childNode = new TreeNode(treeAtFrame, childPath);
    176174
    177175                                                frame.addNode(childNode, TreeNode.this);
    … …  
    191189                final Path p = path;
    192190
    193                 p.getInstance().dispatch(new RunAt<Instance>() {
    194                         @Override
    195                         public void run() {
     191                p.getTree().dispatch(new RunAt<Tree>(this) {
     192                        @Override
     193                        protected void runAt() {
    196194                                final Path updated = (p.isResolved()) ? p : p.tryFindResolution();
    197195                                if (updated.isResolved()) {
    … …  
    201199                                        return;
    202200                                }
    203                                 p.getInstance().resolve(updated, new Future<Path>(Logging.logger(log, "resolve and select", TreeNode.this)) {
     201                                p.getTree().resolve(updated, new FutureHandler<Path>(Logging.logger(log, "resolve and select", TreeNode.this)) {
    204202                                        @Override
    205203                                        protected void result(Path result) {
    … …  
    224222
    225223        protected void updateDescriptions(Path p) {
    226                 assert p.getInstance().isActive();
     224                assert p.getTree().isActive();
    227225
    228226                if (!p.isResolved()) {
    229227                        return;
    230228                }
    231                 AccessInterface access = InstanceUtils.bindAccess(p);
    232 
    233                 final String tooltip = new TooltipConstructor()
    234                         .append("frams", access.getId())
    235                         .append("java", p.getTopObject().getClass().getCanonicalName())
    236                         .append("access", access.getClass().getSimpleName())
    237                         .append("name", name)
    238                         .append("id", paramId)
    239                         .append("object", Integer.toHexString(System.identityHashCode(this)))
    240                         .build()
    241                         ;
     229                AccessInterface access = TreeOperations.bindAccess(p);
     230
     231                final String tooltip = new TooltipConstructor().append("frams", access.getId()).append("java", p.getTopObject().getClass().getCanonicalName()).append("access", access.getClass().getSimpleName()).append("name", name).append("id", param.getId()).append("object", Integer.toHexString(System.identityHashCode(this))).build();
    242232
    243233                StringParam nameParam = Casting.tryCast(StringParam.class, access.getParam("name"));
    244234                final String name = (nameParam != null ? access.get(nameParam, String.class) : path.getTop().getParam().getId());
    245235
    246                 frame.dispatch(new RunAt<Frame>() {
    247                         @Override
    248                         public void run() {
     236                frame.dispatch(new RunAt<Frame>(this) {
     237                        @Override
     238                        protected void runAt() {
    249239                                TreeNode.this.tooltip = tooltip;
    250240                                TreeNode.this.name = name;
    … …  
    254244                });
    255245        }
    256 
    257 /*
    258         public void updateData() {
    259                 assert browser.isActive();
    260                 final Node node = getNode();
    261                 browser.manager.invokeLater(new Runnable() {
    262                         @Override
    263                         public void run() {
    264                                 node.fetchValues(new StateFunctor() {
    265                                         @Override
    266                                         public void call(Exception e) {
    267                                                 if (e != null) {
    268                                                         return;
    269                                                 }
    270                                                 browser.invokeLater(new Runnable() {
    271                                                         @Override
    272                                                         public void run() {
    273                                                                 assert browser.isActive();
    274                                                                 if (panel.getCurrentTreeNode() == TreeNode.this) {
    275                                                                         panel.refreshComponents();
    276                                                                 }
    277 
    278                                                                 browser.tree.repaint();
    279                                                                 panel.refreshComponents();
    280                                                         }
    281                                                 });
    282                                         }
    283                                 });
    284                         }
    285                 });
    286         }
    287 */
    288246
    289247        public void showPanel() {
    … …  
    301259                assert p.isResolved();
    302260                panel.setCurrentTreeNode(this);
    303                 p.getInstance().dispatch(new RunAt<Instance>() {
    304                         @Override
    305                         public void run() {
    306                                 AccessInterface access = InstanceUtils.bindAccess(p);
     261                p.getTree().dispatch(new RunAt<Tree>(this) {
     262                        @Override
     263                        protected void runAt() {
     264                                AccessInterface access = TreeOperations.bindAccess(p);
    307265                                panel.pullValuesFromLocalToUser(access);
    308266
    309                                 frame.dispatch(new RunAt<Frame>() {
     267                                frame.dispatch(new RunAt<Frame>(this) {
    310268                                        @Override
    311                                         public void run() {
     269                                        protected void runAt() {
    312270                                                showPanel();
    313271                                        }
    … …  
    331289
    332290                CompositeParam param = path.getTop().getParam();
    333                 panel = instanceAtFrame.findPanel(param.computeAccessId());
     291                panel = treeAtFrame.findPanel(param.computeAccessId());
    334292                if (panel != null) {
    335293                        log.debug("found prepared panel for: " + path);
    … …  
    339297                final Path p = path;
    340298                log.debug("preparing panel: " + p);
    341                 p.getInstance().dispatch(new RunAt<Instance>() {
    342                         @Override
    343                         public void run() {
    344                                 assert p.getInstance().isActive();
     299                p.getTree().dispatch(new RunAt<Tree>(this) {
     300                        @Override
     301                        protected void runAt() {
     302                                assert p.getTree().isActive();
    345303                                final CompositeParam param = p.getTop().getParam();
    346                                 final FramsClass framsClass = p.getInstance().getInfoFromCache(param.getContainedTypeName());
    347                                 frame.dispatch(new RunAt<Frame>() {
     304                                final FramsClass framsClass = p.getTree().getInfoFromCache(param.getContainedTypeName());
     305                                frame.dispatch(new RunAt<Frame>(this) {
    348306                                        @Override
    349                                         public void run() {
    350                                                 panel = instanceAtFrame.preparePanel(param, framsClass);
     307                                        protected void runAt() {
     308                                                panel = treeAtFrame.preparePanel(param, framsClass);
    351309                                                fillPanelWithValues();
    352310                                        }
    … …  
    360318                return tooltip;
    361319        }
    362 
    363 
    364 
    365320
    366321        /*public void subscribe(final EventParam eventParam) {
    … …  
    408363                        return;
    409364                }
    410                 userSubscriptions.get(eventParam).unsubscribe(new LoggingStateCallback<Connection>(log, "unsubscribed " + eventParam));
     365                userSubscriptions.get(eventParam).unsubscribe(new LoggingStateCallback(log, "unsubscribed " + eventParam));
    411366                userSubscriptions.remove(eventParam);
    412367        }
    413368
    414 /*
    415 
    416         @Override
    417         public void onChildChange(final Child child, ListChange.Action action) {
    418                 assert browser.manager.isActive();
    419 
    420                 switch (action) {
    421                         case Remove: {
    422                                 Dispatching.invokeDispatch(browser, browser.manager, new Runnable() {
    423                                         @Override
    424                                         public void run() {
    425                                                 assert browser.manager.isActive();
    426                                                 final TreeNode treeNode = (TreeNode) child.getUserObject();
    427                                                 if (treeNode == null) {
    428                                                         log.error("child " + child + " had no tree node attached");
    429                                                         return;
    430                                                 }
    431                                                 browser.invokeLater(new Runnable() {
    432                                                         @Override
    433                                                         public void run() {
    434                                                                 assert browser.isActive();
    435                                                                 TreePath path = browser.startChange();
    436                                                                 //assert treeNode.getParent() == TreeNode.this;
    437                                                                 if (treeNode.getParent() != null) {
    438                                                                         browser.treeModel.removeNodeFromParent(treeNode);
    439                                                                 }
    440                                                                 //remove(treeNode);
    441                                                                 browser.markNodeChanged(TreeNode.this, path);
    442                                                         }
    443                                                 });
    444                                         }
    445                                 });
    446                                 break;
    447                         }
    448                 }
    449 
    450         }
    451 */
     369        // @Override
     370        // public void onChildChange(final Child child, ListChange.Action action) {
     371        // assert browser.manager.isActive();
     372
     373        // switch (action) {
     374        // case Remove: {
     375        // Dispatching.invokeDispatch(browser, browser.manager, new Runnable() {
     376        // @Override
     377        // public void run() {
     378        // assert browser.manager.isActive();
     379        // final TreeNode treeNode = (TreeNode) child.getUserObject();
     380        // if (treeNode == null) {
     381        // log.error("child " + child + " had no tree node attached");
     382        // return;
     383        // }
     384        // browser.invokeLater(new Runnable() {
     385        // @Override
     386        // public void run() {
     387        // assert browser.isActive();
     388        // TreePath path = browser.startChange();
     389        // //assert treeNode.getParent() == TreeNode.this;
     390        // if (treeNode.getParent() != null) {
     391        // browser.treeModel.removeNodeFromParent(treeNode);
     392        // }
     393        // //remove(treeNode);
     394        // browser.markNodeChanged(TreeNode.this, path);
     395        // }
     396        // });
     397        // }
     398        // });
     399        // break;
     400        // }
     401        // }
     402
     403        // }
    452404
    453405        public String getName() {
    … …  
    486438        }
    487439
    488         public Path getInstancePath() {
     440        public Path getTreePath() {
    489441                assert frame.isActive();
    490442                return path;
    … …  
    501453                final Path p = path;
    502454
    503                 for (Map.Entry<ValueControl, Object> e : localChanges.entrySet()) {
    504                         storeValue(p, e.getKey().getParam(), e.getValue(), new AbstractStateFunctor() {
     455                for (Map.Entry<ValueControl, Object> e : changes.entrySet()) {
     456                        set(p, e.getKey().getParam(), e.getValue(), new FutureHandler<Integer>(this) {
    505457                                @Override
    506                                 public void call() {
     458                                protected void result(Integer flag) {
    507459                                        counter.set(counter.get() - 1);
    508460                                        if (counter.get() != 0) {
    … …  
    510462                                        }
    511463                                        log.debug("applied changes for: " + p);
    512                                         frame.dispatch(new RunAt<Frame>() {
     464                                        frame.dispatch(new RunAt<Frame>(this) {
    513465                                                @Override
    514                                                 public void run() {
     466                                                protected void runAt() {
    515467                                                        fillPanelWithValues();
    516468                                                }
    517469                                        });
    518470                                }
     471
    519472                        });
    520473                }
    521474        }
     475
     476        @Override
     477        public void handle(FramsticksException exception) {
     478                frame.handle(exception);
     479        }
    522480}

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

    r90 r97  
    66import javax.swing.JPanel;
    77
    8 import com.framsticks.gui.Frame;
    98import com.framsticks.params.Flags;
    109import com.framsticks.params.Param;
     10import com.framsticks.util.FramsticksException;
     11import com.framsticks.util.dispatching.ExceptionResultHandler;
    1112
    1213/**
    … …  
    1415 */
    1516@SuppressWarnings("serial")
    16 public abstract class Control extends JPanel {
     17public abstract class Control extends JPanel implements ExceptionResultHandler {
    1718
    1819        public static final int LINE_HEIGHT = 36;
    … …  
    2021        // private static final Logger log = Logger.getLogger(Control.class.getName());
    2122
    22         protected Frame frame;
    2323        protected final Param param;
    2424        protected ControlOwner owner;
    … …  
    3636        }
    3737
    38         public void setFrame(Frame frame) {
    39                 this.frame = frame;
    40         }
    41 
    4238        public void setOwner(ControlOwner owner) {
    4339                this.owner = owner;
    … …  
    5349                return param.toString();
    5450        }
     51
     52        @Override
     53        public void handle(FramsticksException exception) {
     54                owner.handle(exception);
     55        }
    5556}

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

    r90 r97  
    44
    55import com.framsticks.gui.TreeNode;
     6import com.framsticks.util.dispatching.ExceptionResultHandler;
    67
    7 public interface ControlOwner {
     8public interface ControlOwner extends ExceptionResultHandler {
    89
    910        public JPanel getPanel();

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

    r96 r97  
    11package com.framsticks.gui.controls;
    22
    3 import com.framsticks.core.Instance;
     3import com.framsticks.core.Tree;
    44import com.framsticks.core.Path;
    55import com.framsticks.gui.Gui;
    … …  
    88import com.framsticks.params.ValueParam;
    99import com.framsticks.params.types.ProcedureParam;
    10 import com.framsticks.util.FramsticksException;
    11 import com.framsticks.util.Logging;
    12 import com.framsticks.util.dispatching.Future;
     10import com.framsticks.util.dispatching.ExceptionResultHandler;
     11import com.framsticks.util.dispatching.FutureHandler;
    1312import com.framsticks.util.dispatching.RunAt;
     13import com.framsticks.util.dispatching.ThrowExceptionHandler;
    1414
    1515import javax.swing.*;
    … …  
    5858
    5959                                log.debug("calling " + getParam() + " on " + treeNode);
    60                                 final Path path = treeNode.getInstancePath();
     60                                final Path path = treeNode.getTreePath();
    6161
    6262                                final List<Object> arguments = new LinkedList<Object>();
    6363                                for (Param arg : getParam().getArgumentsType()) {
    64                                         arguments.add(((ValueControl) components.get(arg)).getCurrentValue());
     64                                        Object value = components.get(arg).getCurrentValue();
     65                                        arguments.add(value);
     66                                        log.debug("argument " + arg + ": " + value);
    6567                                }
     68                                //TODO FEH: make it show dialog
     69                                final ExceptionResultHandler handler = ThrowExceptionHandler.getInstance();
    6670
    67                                 path.getInstance().dispatch(new RunAt<Instance>() {
     71                                path.getTree().dispatch(new RunAt<Tree>(handler) {
    6872                                        @Override
    69                                         public void run() {
    70                                                 path.getInstance().call(path, getParam(), arguments.toArray(), new Future<Object>() {
    71 
    72                                                         @Override
    73                                                         public void handle(FramsticksException e) {
    74                                                                 Logging.log(log, "call procedure", path, e);
    75                                                         }
     73                                        protected void runAt() {
     74                                                path.getTree().call(path, getParam(), arguments.toArray(), new FutureHandler<Object>(handler) {
    7675
    7776                                                        @Override

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

    r84 r97  
    104104
    105105                JPanel sliderPanel = new JPanel();
    106                 sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.LINE_AXIS));
     106                // sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.LINE_AXIS));
    107107
    108108

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

    r87 r97  
    99public class TextAreaControl extends TextControl {
    1010
    11         // private static final Logger log = Logger.getLogger(TextAreaControl.class.getName());
    12 
    13         protected JTextArea textArea;
    14         protected JScrollPane textScrollPane;
     11        protected final JTextArea textArea;
     12        protected final JScrollPane textScrollPane;
    1513
    1614        public TextAreaControl(PrimitiveParam<?> valueParam) {
    1715                super(valueParam);
    1816                textArea = new JTextArea();
     17                textArea.setName("value");
    1918                textArea.setLineWrap(true);
    2019                textArea.setWrapStyleWord(true);

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

    r90 r97  
    77import com.framsticks.params.PrimitiveParam;
    88import com.framsticks.params.ReassignResult;
     9import com.framsticks.util.FramsticksException;
    910import com.framsticks.util.swing.TooltipConstructor;
    1011
    … …  
    7374                        return res.getValue();
    7475                } catch (CastFailure e) {
    75                         log.error("cast failure when setting param " + param + " to value " + candidate + ": " + e);
     76                        //TODO just throw here, but check where that function is being used
     77                        handle(new FramsticksException().msg("invalid value in control").arg("param", param).arg("value", candidate).cause(e));
    7678                }
    7779                return oldValue;

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

    r96 r97  
    44import org.apache.log4j.Logger;
    55
    6 import com.framsticks.core.Instance;
     6import com.framsticks.core.Tree;
    77import com.framsticks.params.annotations.AutoAppendAnnotation;
    88import com.framsticks.params.annotations.FramsClassAnnotation;
    … …  
    1717import com.framsticks.util.dispatching.RunAt;
    1818import com.framsticks.util.dispatching.Task;
     19import com.framsticks.util.dispatching.ThrowExceptionHandler;
    1920
    2021import java.io.IOException;
    … …  
    3233
    3334        protected ServerSocket acceptSocket;
    34         protected Instance hosted;
    35         protected final JoinableCollection<InstanceClient> clients = new JoinableCollection<InstanceClient>();
     35        protected Tree hosted;
     36        protected final JoinableCollection<ClientAtServer> clients = new JoinableCollection<ClientAtServer>();
    3637
    3738        public static class Accept {
    … …  
    8081         * @return the hosted
    8182         */
    82         public Instance getHosted() {
     83        public Tree getHosted() {
    8384                return hosted;
    8485        }
    8586
    8687        @AutoAppendAnnotation
    87         public void setHosted(Instance hosted) {
     88        public void setHosted(Tree hosted) {
    8889                if (this.hosted != null) {
    89                         throw new FramsticksException().msg("hosted instance is already set").arg("current", this.hosted);
     90                        throw new FramsticksException().msg("hosted tree is already set").arg("current", this.hosted);
    9091                }
    9192                this.hosted = hosted;
    … …  
    123124                        return;
    124125                }
    125                 acceptThread.dispatch(new RunAt<Accept>() {
     126                //TODO TEH
     127                acceptThread.dispatch(new RunAt<Accept>(ThrowExceptionHandler.getInstance()) {
    126128                        @Override
    127                         public void run() {
     129                        protected void runAt() {
    128130                                try {
    129131                                        log.debug("accepting");
    … …  
    131133                                        assert socket != null;
    132134                                        log.debug("accepted socket: " + socket.getInetAddress().getHostAddress());
    133                                         hosted.dispatch(new RunAt<Instance>() {
     135                                        hosted.dispatch(new RunAt<Tree>(this) {
    134136                                                @Override
    135                                                 public void run() {
    136                                                         InstanceClient client = new InstanceClient(Server.this, socket);
     137                                                protected void runAt() {
     138                                                        ClientAtServer client = new ClientAtServer(Server.this, socket);
    137139                                                        clients.add(client);
    138140                                                        log.info("client connected: " + client);
    … …  
    148150
    149151        protected void tryBind(int when) {
    150                 acceptThread.dispatch(new Task<Accept>(when) {
     152                acceptThread.dispatch(new Task<Accept>(ThrowExceptionHandler.getInstance(), when) {
    151153                        @Override
    152                         public void run() {
     154                        protected void runAt() {
    153155                                try {
    154156                                        acceptSocket.bind(new InetSocketAddress(port));

  • java/main/src/main/java/com/framsticks/model/f0/Schema.java

    r90 r97  
    3535        }
    3636
    37         protected static Schema defaultSchema;
     37        private static Schema defaultSchema;
    3838
    3939        public synchronized static Schema getDefaultSchema() {

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

    r96 r97  
    5656        void save(SinkInterface sink);
    5757
    58         void load(SourceInterface stream) throws Exception;
     58        void load(SourceInterface stream);
    5959
    6060        /**

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

    r96 r97  
    6363
    6464        @Override
    65         public void load(SourceInterface stream) throws Exception {
     65        public void load(SourceInterface stream) {
    6666        }
    6767

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

    r96 r97  
    504504        }
    505505
    506         private static Pattern addressPattern = Pattern.compile("^([^\\(]+)?\\(([^\\)]*)\\)$");
     506        private static Pattern signaturePattern = Pattern.compile("^([^\\(]+)?\\(([^\\)]*)\\)$");
    507507
    508508        public ParamBuilder signature(String signature) {
    … …  
    513513                        return this;
    514514                }
    515                 Matcher matcher = addressPattern.matcher(signature);
     515                Matcher matcher = signaturePattern.matcher(signature);
    516516                if (!matcher.matches()) {
    517517                        throw new FramsticksException().msg("invalid signature");

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

    r96 r97  
    11package com.framsticks.params;
    22
    3 import java.io.IOException;
    43import java.util.Collection;
    54
    … …  
    149148        public void setMin(int i) {
    150149                PrimitiveParam<?> entry = framsClass.getParamEntry(i, PrimitiveParam.class);
    151                 if (entry == null) {
    152                         return;
    153                 }
    154150                Object min = entry.getMin(entry.getStorageType());
    155151                if (min != null) {
    … …  
    168164        public void setMax(int i) {
    169165                PrimitiveParam<?> entry = framsClass.getParamEntry(i, PrimitiveParam.class);
    170                 if (entry == null) {
    171                         return;
    172                 }
    173166                Object max = entry.getMax(entry.getStorageType());
    174167                if (max != null) {
    … …  
    205198        }
    206199
    207         private Entry readEntry(SourceInterface source)
    208                         throws IOException {
     200        private Entry readEntry(SourceInterface source) {
    209201
    210202                String line;
    … …  
    252244
    253245        @Override
    254         public void load(SourceInterface source) throws Exception {
     246        public void load(SourceInterface source) {
    255247                //TODO not clearing values, because get from manager gives only fields, not children
    256248                //this.clearValues();

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

    r96 r97  
    2626                resultType = builder.getResultType();
    2727                argumentsType = builder.getArgumentsType();
     28                assert argumentsType != null;
    2829
    2930                StringBuilder b = new StringBuilder().append("p");
    … …  
    4950
    5051                signatureString = b.toString();
    51                 assert argumentsType != null;
    5252        }
    5353

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

    r90 r97  
    1919import com.framsticks.params.PrimitiveParam;
    2020import com.framsticks.util.FramsticksException;
     21import com.framsticks.util.io.Encoding;
    2122import com.framsticks.util.lang.Containers;
    2223import com.framsticks.util.lang.Pair;
    … …  
    8586        public List<AccessInterface> parse() {
    8687
    87                 try (InputStreamReader reader = new InputStreamReader(is, "UTF-8")) {
     88                try (InputStreamReader reader = new InputStreamReader(is, Encoding.getDefaultCharset())) {
    8889                        BufferedReader br = new BufferedReader(reader);
    8990                        while (br.ready()) {

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

    r88 r97  
    44import org.apache.log4j.Logger;
    55
    6 import java.io.FileNotFoundException;
    7 import java.io.IOException;
    86import java.util.*;
    97
    … …  
    110108         * Starts reading the file.
    111109         */
    112         public Status go() throws Exception {
     110        public Status go() {
    113111                log.trace("go");
    114112
    … …  
    159157                                continue;
    160158                        }
    161                         log.warn("unknown line: " + currentLine);
     159
     160                        // log.warn("unknown line: " + currentLine);
     161                        changeStatus(Status.OnError);
     162                        if (action == LoopAction.Break) {
     163                                break;
     164                        }
     165                        if (action == LoopAction.Continue) {
     166                                continue;
     167                        }
    162168                }
    163169
    … …  
    170176         * @throws Exception
    171177         */
    172         private LoopAction tryReadObject() throws Exception {
     178        private LoopAction tryReadObject() {
    173179                if (status == Status.BeforeObject
    174180                                || (status == Status.BeforeUnknown && lastAccessInterface != null)) {
    … …  
    201207         * Checks whether some additional file shouldn't be included.
    202208         */
    203         private LoopAction isIncludeLine(String line) throws FileNotFoundException {
     209        private LoopAction isIncludeLine(String line) {
    204210                try {
    205211                        // found comment
    … …  
    374380         * Returns from included file.
    375381         */
    376         private boolean returnFromIncluded() throws IOException {
     382        private boolean returnFromIncluded() {
    377383                if (fileStack.size() == 0) {
    378384                        return false;

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

    r96 r97  
    6464                AccessInterface access = registry.createAccess(name);
    6565
    66                 if (access == null) {
    67                         throw new FramsticksException().msg("failed to find access interface").arg("name", name);
    68                 }
    6966                Object object = access.createAccessee();
    7067                assert object != null;

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

    r96 r97  
    22
    33
    4 import com.framsticks.core.AbstractInstanceListener;
    5 import com.framsticks.core.Instance;
    6 import com.framsticks.core.InstanceUtils;
     4import com.framsticks.core.AbstractTreeListener;
     5import com.framsticks.core.Tree;
     6import com.framsticks.core.TreeOperations;
    77import com.framsticks.core.Path;
    88import com.framsticks.params.annotations.FramsClassAnnotation;
    … …  
    1010import com.framsticks.util.Logging;
    1111import com.framsticks.util.dispatching.Dispatching;
    12 import com.framsticks.util.dispatching.Future;
     12import com.framsticks.util.dispatching.FutureHandler;
    1313import com.framsticks.util.dispatching.JoinableCollection;
    1414import com.framsticks.util.dispatching.RunAt;
     15import com.framsticks.util.dispatching.ThrowExceptionHandler;
    1516
    1617import org.apache.log4j.Logger;
    … …  
    2122 */
    2223@FramsClassAnnotation
    23 public class Portal extends JoinableCollection<Instance> {
     24public class Portal extends JoinableCollection<Tree> {
    2425
    2526        private final static Logger log = Logger.getLogger(Portal.class.getName());
    … …  
    3334        // @Override
    3435        // public void run() {
    35         //      super.run();
    36         //      new PeriodicTask<Portal>(this, 1000) {
     36        //      super.run();
     37        //      new PeriodicTask<Portal>(this, 1000) {
    3738
    38         //              @Override
    39         //              public void run() {
    40         //                      ++counter;
    41         //                      log.debug("counter is now: " + counter);
    42         //                      again();
    43         //              }
    44         //      };
     39        //              @Override
     40        //              public void run() {
     41        //                      ++counter;
     42        //                      log.debug("counter is now: " + counter);
     43        //                      again();
     44        //              }
     45        //      };
    4546        // }
    4647
    4748        @Override
    48         public void add(final Instance instance) {
    49                 super.add(instance);
    50                 instance.addListener(new AbstractInstanceListener() {
     49        public void add(final Tree tree) {
     50                super.add(tree);
     51                tree.addListener(new AbstractTreeListener() {
    5152                        @Override
    5253                        public void onRun(Exception e) {
    … …  
    5960                                }
    6061                                final String path = "/simulator/genepools/groups/0/genotypes";
    61                                 instance.dispatch(new RunAt<Instance>() {
     62                                tree.dispatch(new RunAt<Tree>(ThrowExceptionHandler.getInstance()) {
    6263                                        @Override
    63                                         public void run() {
    64                                                 InstanceUtils.resolve(instance, path, new Future<Path>(Logging.logger(log, "resolve", path)) {
     64                                        protected void runAt() {
     65                                                TreeOperations.resolve(tree, path, new FutureHandler<Path>(Logging.logger(log, "resolve", path)) {
    6566                                                        @Override
    6667                                                        public void result(Path result) {

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

    r96 r97  
    11package com.framsticks.remote;
    22
    3 import static com.framsticks.core.InstanceUtils.*;
     3import static com.framsticks.core.TreeOperations.*;
     4
     5import com.framsticks.core.Mode;
    46import com.framsticks.core.Node;
    57import com.framsticks.core.Path;
    … …  
    79import com.framsticks.params.CompositeParam;
    810import com.framsticks.params.FramsClass;
    9 import com.framsticks.core.Instance;
     11import com.framsticks.core.Tree;
    1012import com.framsticks.util.dispatching.Future;
     13import com.framsticks.util.dispatching.FutureHandler;
     14import com.framsticks.util.dispatching.ThrowExceptionHandler;
    1115import com.framsticks.util.FramsticksException;
    1216import com.framsticks.util.Logging;
    13 import com.framsticks.util.StateFunctor;
    1417import com.framsticks.util.Stopwatch;
    1518import org.apache.log4j.Logger;
    … …  
    2427        private final static Logger log = Logger.getLogger(RecursiveFetcher.class.getName());
    2528
    26         protected final Instance instance;
    27         protected final StateFunctor stateFunctor;
     29        protected final Tree tree;
     30        protected final Future<Void> future;
    2831        protected int dispatched;
    2932        protected final Stopwatch stopwatch = new Stopwatch();
    3033
    31         public RecursiveFetcher(Instance instance, final Path path, StateFunctor stateFunctor) {
    32                 this.instance = instance;
    33                 this.stateFunctor = stateFunctor;
     34        public RecursiveFetcher(Tree tree, final Path path, Future<Void> future) {
     35                this.tree = tree;
     36                this.future = future;
    3437                dispatched = 1;
    3538                process(path);
    … …  
    3740
    3841        protected void finished() {
    39                 assert instance.isActive();
     42                assert tree.isActive();
    4043                log.info("recursively fetched in " + stopwatch);
    41                 stateFunctor.call();
     44                future.pass(null);
    4245        }
    4346
    4447        protected void process(final Path path) {
    45                 assert instance.isActive();
     48                assert tree.isActive();
    4649                if (path == null || !path.isResolved()) {
    4750                        log.warn("path " + path + " is not resolved - skipping");
    … …  
    5558                                if (childPath.isResolved() && getInfoFromCache(childPath) != null) {
    5659                                        ++dispatched;
    57                                         instance.dispatch(new RunAt<Instance>() {
     60                                        tree.dispatch(new RunAt<Tree>(ThrowExceptionHandler.getInstance()) {
    5861                                                @Override
    59                                                 public void run() {
     62                                                protected void runAt() {
    6063                                                        fetch(childPath);
    6164                                                }
    … …  
    6467                                }
    6568                                ++dispatched;
    66                                 instance.resolve(childPath, new Future<Path>(Logging.logger(log, "resolve", RecursiveFetcher.this)) {
     69                                tree.resolve(childPath, new FutureHandler<Path>(Logging.logger(log, "resolve", RecursiveFetcher.this)) {
    6770                                        @Override
    6871                                        protected void result(Path result) {
    69                                                 assert instance.isActive();
     72                                                assert tree.isActive();
    7073                                                fetch(result);
    7174                                        }
    … …  
    8083
    8184        protected void fetch(final Path path) {
    82                 instance.fetchValues(path, new StateFunctor() {
     85                tree.get(path, Mode.FETCH, new Future<Object>() {
     86
    8387                        @Override
    8488                        public void handle(FramsticksException e) {
    … …  
    8892
    8993                        @Override
    90                         public void call() {
     94                        protected void result(Object object) {
    9195                                process(path);
    9296                        }

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

    r96 r97  
    2626import com.framsticks.util.dispatching.RunAt;
    2727import com.framsticks.util.dispatching.Thread;
     28import com.framsticks.util.dispatching.ThrowExceptionHandler;
    2829import com.framsticks.util.io.Encoding;
    2930
    … …  
    129130                }
    130131
    131                 readerThread.dispatch(new RunAt<ExternalProcess>() {
     132                readerThread.dispatch(new RunAt<ExternalProcess>(ThrowExceptionHandler.getInstance()) {
    132133
    133134                        @Override
    134                         public void run() {
     135                        protected void runAt() {
    135136                                readerTask();
    136137                        }

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

    r96 r97  
    11package com.framsticks.test;
     2
     3import org.apache.log4j.Logger;
    24
    35import com.framsticks.params.annotations.FramsClassAnnotation;
    … …  
    79@FramsClassAnnotation(order = {"name", "history", "appendHistory", "resetHistory"})
    810public class TestClass {
     11        private static final Logger log =
     12                Logger.getLogger(TestClass.class);
     13
    914
    1015        protected String name = "test";
    11         protected String history = "";
     16        protected String history = "initial|";
    1217
    1318        /**
    … …  
    4550        @ParamAnnotation(paramType = ProcedureParam.class)
    4651        public int appendHistory(String line) {
     52                log.debug("appending '" + line + "'");
    4753                history = history + line + "|";
    4854                return history.length();
    … …  
    5157        @ParamAnnotation(paramType = ProcedureParam.class)
    5258        public void resetHistory() {
     59                log.debug("reseting");
    5360                history = "";
    5461        }

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

    r96 r97  
    3535        }
    3636
    37         public void getShortMessage(StringBuilder b) {
     37        public StringBuilder getShortMessage(StringBuilder b) {
    3838                if (message != null) {
    3939                        b.append(message);
    … …  
    5050                        b.append("(").append(d.build()).append(")");
    5151                }
     52                return b;
    5253        }
    5354

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

    r96 r97  
    22
    33import com.framsticks.util.dispatching.Dispatcher;
     4import com.framsticks.util.dispatching.ExceptionResultHandler;
    45import com.framsticks.util.dispatching.Task;
    56import com.framsticks.util.dispatching.RunAt;
    … …  
    1314        protected Dispatcher<? super C> dispatcher;
    1415
    15         public PeriodicTask(Dispatcher<? super C> dispatcher, long period) {
     16        public PeriodicTask(ExceptionResultHandler handler, Dispatcher<? super C> dispatcher, long period) {
     17                super(handler);
    1618                this.period = period;
    1719                this.dispatcher = dispatcher;
    … …  
    2123
    2224        public void again() {
    23                 dispatcher.dispatch(new Task<C>(period) {
     25                dispatcher.dispatch(new Task<C>(handler, period) {
    2426                        @Override
    25                         public void run() {
    26                                 PeriodicTask.this.run();
     27                        protected void runAt() {
     28                                PeriodicTask.this.runAt();
    2729                        }
    2830                });

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

    r90 r97  
    3535
    3636        @ParamAnnotation
    37         public ResourceBuilder<T>  resource(String resource) {
     37        public ResourceBuilder<T> resource(String resource) {
    3838                this.resource = resource;
    3939                return stream(getClass().getResourceAsStream(resource));

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

    r77 r97  
    55 */
    66public interface UnaryFunctor <Ret, Arg> {
    7                 Ret call(Arg arg);
     7        Ret call(Arg arg);
    88}

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

    r96 r97  
    137137                boolean start = false;
    138138                synchronized (this) {
    139                         assert !owners.contains(owner);
     139                        if (owners.contains(owner)) {
     140                                throw new FramsticksException().msg("owner is already using that joinable").arg("joinable", this).arg("owner", owner);
     141                        }
    140142                        start = owners.isEmpty();
    141143                        log.debug(owner + " is using " + this);
    … …  
    164166                }
    165167                if (stop) {
    166                         Dispatching.dispatcherGuardedInvoke(this, new RunAt<Object>() {
     168                        Dispatching.dispatcherGuardedInvoke(this, new RunAt<Object>(ThrowExceptionHandler.getInstance()) {
    167169                                @Override
    168                                 public void run() {
     170                                protected void runAt() {
    169171                                        interrupt();
    170172                                }

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

    r90 r97  
    2121        @Override
    2222        public final void dispatch(RunAt<? extends C> runnable) {
    23                 runnable.run();
     23                runnable.runAt();
    2424        }
    2525

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

    r96 r97  
    44
    55import com.framsticks.util.FramsticksException;
    6 import com.framsticks.util.StateFunctor;
    76
    87/**
    … …  
    1817        public static <C> void dispatchIfNotActive(Dispatcher<C> dispatcher, RunAt<? extends C> runnable) {
    1918                if (dispatcher.isActive()) {
    20                         runnable.run();
     19                        runnable.runAt();
    2120                        return;
    2221                }
    2322                dispatcher.dispatch(runnable);
    24         }
    25 
    26         //TODO RunAt StateFunctor
    27         public static <C> void dispatchOk(Dispatcher<C> dispatcher, final StateFunctor stateFunctor) {
    28                 dispatcher.dispatch(new RunAt<C>() {
    29                         @Override
    30                         public void run() {
    31                                 stateFunctor.call();
    32                         }
    33                 });
    3423        }
    3524
    … …  
    4029
    4130        public static <P, C> void invokeDispatch(Dispatcher<P> dispatcher, final Dispatcher<C> finalDispatcher, final RunAt<C> runnable) {
    42                 dispatcher.dispatch(new RunAt<P>() {
     31                dispatcher.dispatch(new RunAt<P>(runnable) {
    4332                        @Override
    44                         public void run() {
     33                        protected void runAt() {
    4534                                finalDispatcher.dispatch(runnable);
    4635                        }
    … …  
    4938
    5039        public static void sleep(double seconds) {
     40                log.debug("sleeping");
    5141                try {
    5242                        java.lang.Thread.sleep((long) (seconds * 1000));
    … …  
    5444
    5545                }
     46                log.debug("slept");
    5647        }
    5748
    … …  
    6253                        return;
    6354                }
    64                 runnable.run();
     55                runnable.runAt();
    6556        }
    6657
    … …  
    9586
    9687        public static void childChangedState(final JoinableParent parent, final Joinable joinable, final JoinableState state) {
    97                 dispatcherGuardedInvoke(joinable, new RunAt<Object>() {
     88                dispatcherGuardedInvoke(joinable, new RunAt<Object>(ThrowExceptionHandler.getInstance()) {
    9889                        @Override
    99                         public void run() {
     90                        protected void runAt() {
    10091                                log.debug("joinable " + joinable + " is notifying parent " + parent + " about change to " + state);
    10192                                parent.childChangedState(joinable, state);
    … …  
    140131                 */
    141132                public QueryRunner(Query<T> query) {
     133                        //TODO TEH
     134                        super(ThrowExceptionHandler.getInstance());
    142135                        this.query = query;
    143136                }
    144137
    145138                @Override
    146                 public void run() {
     139                protected void runAt() {
    147140                        result = query.get();
    148141                        synchronized (this) {
    … …  
    206199        public static <C> void synchronize(Dispatcher<C> dispatcher, double seconds) {
    207200                final Waiter waiter = new Waiter(seconds);
    208                 dispatcher.dispatch(new RunAt<C>() {
     201                dispatcher.dispatch(new RunAt<C>(ThrowExceptionHandler.getInstance()) {
    209202                        @Override
    210                         public void run() {
     203                        protected void runAt() {
    211204                                waiter.pass();
    212205                        }

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

    r96 r97  
    77 */
    88public abstract class Future<T> implements ExceptionResultHandler {
    9 
    10         protected final ExceptionResultHandler handler;
    11 
    12         public Future(ExceptionResultHandler handler) {
    13                 this.handler = handler;
    14         }
    15 
    16         public Future() {
    17                 this.handler = null;
    18         }
    199
    2010        protected abstract void result(T result);
    … …  
    2818        }
    2919
    30         public static <T> void passOrHandle(Future<T> future, T value, FramsticksException e) {
    31                 if (e != null) {
    32                         future.handle(e);
    33                 } else {
    34                         future.pass(value);
    35                 }
    36         }
    3720
    38         @Override
    39         public void handle(FramsticksException exception) {
    40                 if (handler != null) {
    41                         handler.handle(exception);
    42                         return;
    43                 }
    44                 throw exception;
    45         }
    4621}

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

    r96 r97  
    11package com.framsticks.util.dispatching;
    22
     3import java.util.AbstractCollection;
     4import java.util.Collection;
    35import java.util.Collections;
    46import java.util.HashSet;
    … …  
    4244                if (this.state.equals(JoinableState.RUNNING)) {
    4345                        Dispatching.use(joinable, this);
     46                }
     47        }
     48
     49        public synchronized void remove(T joinable) {
     50                if (this.state.ordinal() > JoinableState.RUNNING.ordinal()) {
     51                        throw new FramsticksException().msg("failed to remote joinable - collection is passed running state").arg("joinable", joinable).arg("collection", this);
     52                }
     53                if (!joinables.contains(joinable)) {
     54                        throw new FramsticksException().msg("joinable is not observed").arg("joinable", joinable).arg("in", this);
     55                }
     56
     57                joinables.remove(joinable);
     58
     59                if (this.state.equals(JoinableState.RUNNING)) {
     60                        Dispatching.drop(joinable, this);
    4461                }
    4562        }
    … …  
    140157        }
    141158
     159        public Collection<T> asCollection() {
     160                return new AbstractCollection<T>() {
     161
     162                        @Override
     163                        public Iterator<T> iterator() {
     164                                return JoinableCollection.this.iterator();
     165                        }
     166
     167                        @Override
     168                        public int size() {
     169                                return JoinableCollection.this.size();
     170                        }
     171
     172                        @Override
     173                        public boolean add(T joinable) {
     174                                JoinableCollection.this.add(joinable);
     175                                return true;
     176                        }
     177
     178                        @SuppressWarnings("unchecked")
     179                        @Override
     180                        public boolean remove(Object joinable) {
     181                                JoinableCollection.this.remove((T) joinable);
     182                                return true;
     183                        }
     184                };
     185        }
     186
    142187}

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

    r90 r97  
    11package com.framsticks.util.dispatching;
    22
    3 public abstract class RunAt<C> implements java.lang.Runnable {
     3import com.framsticks.util.FramsticksException;
    44
    5         public RunAt() {
     5public abstract class RunAt<C> implements ExceptionResultHandler, Runnable {
     6
     7        protected final ExceptionResultHandler handler;
     8
     9        public RunAt(ExceptionResultHandler handler) {
     10                assert handler != null;
     11                this.handler = handler;
    612        }
    713
    8         public RunAt(Dispatcher<? super C> dispatcher) {
    9                 dispatcher.dispatch(this);
     14        protected abstract void runAt();
     15
     16        public final void run() {
     17                try {
     18                        runAt();
     19                } catch (FramsticksException e) {
     20                        handle(e);
     21                }
    1022        }
     23
     24
     25
     26        @Override
     27        public final void handle(FramsticksException exception) {
     28                handler.handle(exception);
     29        }
     30
    1131}

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

    r96 r97  
    88        protected final long moment;
    99
    10         public Task() {
     10        public Task(ExceptionResultHandler handler) {
     11                super(handler);
    1112                moment = System.currentTimeMillis();
    1213        }
    1314
    14         public Task(long moment) {
     15        public Task(ExceptionResultHandler handler, long moment) {
     16                super(handler);
    1517                this.moment = System.currentTimeMillis() + moment;
    1618        }

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

    r96 r97  
    1515public class Thread<C> extends AbstractJoinable implements Dispatcher<C> {
    1616
    17         private static final Logger log = Logger.getLogger(Thread.class.getName());
     17        private static final Logger log = Logger.getLogger(Thread.class);
    1818
    1919        protected final java.lang.Thread thread;
    … …  
    7373                        }
    7474                        try {
    75                                 task.run();
     75                                task.runAt();
    7676                        } catch (Exception e) {
    7777                                if (exceptionHandler != null) {
    … …  
    119119        public void dispatch(final RunAt<? extends C> runnable) {
    120120                if (!(runnable instanceof Task)) {
    121                         enqueueTask(new Task<C>() {
     121                        enqueueTask(new Task<C>(runnable) {
    122122                                @Override
    123                                 public void run() {
    124                                         runnable.run();
     123                                protected void runAt() {
     124                                        runnable.runAt();
    125125                                }
    126126                        });

  • java/main/src/main/java/com/framsticks/util/io/Encoding.java

    r85 r97  
    77        protected static final Charset defaultCharset = Charset.forName("UTF-8");
    88
    9         protected static final Charset framsticksCharset = Charset.forName("ISO-8859-1");
     9        protected static final Charset framsticksCharset = Charset.forName("UTF-8");
     10        //Charset.forName("ISO-8859-1");
    1011
    1112

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

    r96 r97  
    2626
    2727        public static String toStringNullProof(Object object) {
     28                return toStringNullProof(object, "");
     29        }
     30
     31        public static String toStringNullProof(Object object, String def) {
    2832                if (object == null) {
    29                         return "";
     33                        return def;
    3034                }
    3135                return object.toString();
    … …  
    5660                return input.substring(0, 1).toLowerCase() + input.substring(1);
    5761        }
     62
     63        public static String commonPrefix(String a, String b) {
     64                int length = Math.min(a.length(), b.length());
     65                int i = 0;
     66                while ((i < length) && (a.charAt(i) == b.charAt(i))) {
     67                        ++i;
     68                }
     69                return a.substring(0, i);
     70        }
     71
    5872}

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

    r96 r97  
    11<?xml version="1.0" encoding="UTF-8"?>
    22<Framsticks>
    3         <import class="com.framsticks.gui.Browser" />
    4         <import class="com.framsticks.remote.RemoteInstance" />
    5         <import class="com.framsticks.remote.SimulatorInstance" />
    6         <import class="com.framsticks.model.ModelPackage" />
    7         <import class="com.framsticks.model.ModelBuilder" />
    8         <import class="com.framsticks.model.f0.SchemaBuilder" />
    9         <import class="com.framsticks.core.ObjectInstance" />
    10         <import class="com.framsticks.hosting.Server" />
    11         <import class="com.framsticks.test.TestClass" />
    12         <Browser>
    13                 <SimulatorInstance name="localhost:9009" address="localhost:9009">
    14                         <ModelPackage />
    15                 </SimulatorInstance>
    16                 <ObjectInstance name="model">
    17                         <ModelBuilder resource="/examples/f0_example.txt" />
    18                 </ObjectInstance>
    19                 <ObjectInstance name="f0schema">
    20                         <SchemaBuilder />
    21                 </ObjectInstance>
    22                 <RemoteInstance name="remote" address="localhost:9007" />
    23         </Browser>
    24         <Server name="server" port="9007">
    25                 <ObjectInstance name="test">
    26                         <TestClass />
    27                 </ObjectInstance>
    28         </Server>
     3        <import class="com.framsticks.gui.console.ManagedConsole" />
     4        <import class="com.framsticks.remote.RemoteTree" />
     5        <ManagedConsole>
     6                <RemoteTree name="remote" address="localhost:9009" />
     7        </ManagedConsole>
     8
     9        <!-- <import class="com.framsticks.gui.console.DirectConsole" /> -->
     10        <!-- <import class="com.framsticks.communication.ClientSideRawConnection" /> -->
     11        <!-- <DirectConsole> -->
     12        <!--    <ClientSideRawConnection address="localhost:9009" /> -->
     13        <!-- </DirectConsole> -->
     14
     15        <!-- <import class="com.framsticks.gui.Browser" /> -->
     16        <!-- <import class="com.framsticks.remote.RemoteTree" /> -->
     17        <!-- <import class="com.framsticks.remote.SimulatorTree" /> -->
     18        <!-- <import class="com.framsticks.model.ModelPackage" /> -->
     19        <!-- <import class="com.framsticks.model.ModelBuilder" /> -->
     20        <!-- <import class="com.framsticks.model.f0.SchemaBuilder" /> -->
     21        <!-- <import class="com.framsticks.core.ObjectTree" /> -->
     22        <!-- <import class="com.framsticks.hosting.Server" /> -->
     23        <!-- <import class="com.framsticks.test.TestClass" /> -->
     24        <!-- <Browser> -->
     25        <!--    <SimulatorTree name="localhost:9009" address="localhost:9009"> -->
     26        <!--            <ModelPackage /> -->
     27        <!--    </SimulatorTree> -->
     28        <!--    <ObjectTree name="model"> -->
     29        <!--            <ModelBuilder resource="/examples/f0_example.txt" /> -->
     30        <!--    </ObjectTree> -->
     31        <!--    <ObjectTree name="f0schema"> -->
     32        <!--            <SchemaBuilder /> -->
     33        <!--    </ObjectTree> -->
     34        <!--    <RemoteTree name="remote" address="localhost:9007" /> -->
     35        <!-- </Browser> -->
     36        <!-- <Server name="server" port="9007"> -->
     37        <!--    <ObjectTree name="test"> -->
     38        <!--            <TestClass /> -->
     39        <!--    </ObjectTree> -->
     40        <!-- </Server> -->
    2941</Framsticks>

  • java/main/src/main/resources/configs/log4j.properties

    r96 r97  
    3131# log4j.logger.com.framsticks.core.Framsticks=DEBUG
    3232# log4j.logger.com.framsticks.gui.Frame=DEBUG
    33 # log4j.logger.com.framsticks.core.ObjectInstance=DEBUG
    34 # log4j.logger.com.framsticks.core.Instance=DEBUG
    3533# log4j.logger.com.framsticks.gui.controls.ProcedureControl=DEBUG
    3634# log4j.logger.com.framsticks.params.ReflectionAccess=TRACE
    … …  
    4947#log4j.logger.com.framsticks.gui.Browser=DEBUG
    5048#log4j.logger.com.framsticks.gui.EndpointAtFrame=DEBUG
    51 #log4j.logger.com.framsticks.remote.RemoteInstance=DEBUG
    5249#log4j.logger.com.framsticks.gui.TreeNode=DEBUG
    5350#log4j.logger.com.framsticks.gui.components.CheckBox=DEBUG

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

    r96 r97  
    1616                //                              public void result(Path result, Exception e) {
    1717                //                                      if (e != null) {
    18                 //                                              log.error("failed to load file instance " + FileInstance.this + ": " + e);
     18                //                                              log.error("failed to load file: " + e);
    1919                //                                              fireRun(e);
    2020                //                                              return;
    2121                //                                      }
    22                 //                                      log.info("loaded file instance " + FileInstance.this);
     22                //                                      log.info("loaded file");
    2323                //                                      fireRun(null);
    2424                //                              }

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

    r96 r97  
    44
    55import org.apache.log4j.Logger;
    6 import org.fest.swing.core.Robot;
    7 import org.fest.swing.edt.FailOnThreadViolationRepaintManager;
    86import org.fest.swing.edt.GuiQuery;
    97import org.fest.swing.fixture.FrameFixture;
    … …  
    119import org.testng.annotations.Test;
    1210
    13 import com.framsticks.test.MonitorBasedTest;
     11
     12import org.fest.swing.edt.GuiActionRunner;
     13
    1414import com.framsticks.util.dispatching.Joinable;
    1515
    16 import static org.fest.assertions.Assertions.assertThat;
    17 import static org.fest.swing.edt.GuiActionRunner.executeInEDT;
    18 import static org.fest.swing.core.BasicRobot.robotWithNewAwtHierarchy;
    19 import org.fest.swing.edt.GuiActionRunner;
    20 
    2116@Test
    22 public abstract class BrowserBaseTest extends MonitorBasedTest {
     17public abstract class BrowserBaseTest extends GuiTest {
    2318
    2419        private static final Logger log = Logger.getLogger(BrowserTest.class);
    2520
    2621        protected Browser browser;
    27         protected static Robot robot;
    2822        protected FrameFixture frame;
    2923        protected JTreeFixture tree;
    30 
    31         static {
    32                 FailOnThreadViolationRepaintManager.install();
    33                 assertThat(executeInEDT()).isTrue();
    34 
    35                 robot = robotWithNewAwtHierarchy();
    36         }
    3724
    3825        @Override
    … …  
    6451        }
    6552
    66         protected void waitForIdle() {
    67                 robot.waitForIdle();
    68         }
    6953
    7054}

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

    r96 r97  
    33import static org.fest.assertions.Assertions.assertThat;
    44import static org.fest.swing.edt.GuiActionRunner.execute;
     5
     6import java.awt.event.KeyEvent;
    57
    68
    … …  
    1012
    1113import com.framsticks.model.ModelPackage;
    12 import com.framsticks.remote.SimulatorInstance;
     14import com.framsticks.remote.SimulatorTree;
     15import com.framsticks.util.dispatching.Dispatching;
    1316
    1417public class BrowserTest extends BrowserBaseTest {
    … …  
    1619        private static final Logger log = Logger.getLogger(BrowserTest.class);
    1720
    18         SimulatorInstance localhost;
     21        SimulatorTree localhost;
    1922
    2023        @Override
    … …  
    2225                browser = new Browser();
    2326
    24                 localhost = new SimulatorInstance();
     27                localhost = new SimulatorTree();
    2528                localhost.setName("localhost");
    2629                localhost.setAddress("localhost:9009");
    2730                localhost.usePackage(new ModelPackage());
    2831
    29                 browser.addInstance(localhost);
     32                browser.addTree(localhost);
    3033
    3134        }
    3235
    33         @Test(timeOut = 10000)
     36        @Test(timeOut = 30000)
    3437        public void testShow() {
    3538                log.info("testing");
    3639                tree.clickRow(0).expandRow(0);
    3740                robot.waitForIdle();
     41
    3842                tree.clickRow(1).expandRow(1);
    3943                robot.waitForIdle();
    … …  
    4751                });
    4852
     53
    4954                clickAndExpandPath("localhost/simulator/genepools");
    5055                clickAndExpandPath("localhost/simulator/genepools/groups");
    5156                clickAndExpandPath("localhost/simulator/genepools/groups/Genotypes");
     57                clickAndExpandPath("localhost/simulator/genepools/groups/Genotypes/genotypes");
     58                Dispatching.sleep(2.0);
     59                clickAndExpandPath("localhost/simulator/genepools/groups/Genotypes/genotypes");
     60                robot.pressAndReleaseKey(KeyEvent.VK_J);
     61                waitForIdle();
     62                Dispatching.sleep(2.0);
     63
     64                frame.panel("Genotype").panel("name").textBox("value").enterText("-Żółw");
     65                clickButton(frame.panel("Genotype").button("apply"));
     66
     67                Dispatching.sleep(1.0);
    5268        }
    5369

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

    r96 r97  
    77import org.testng.annotations.Test;
    88
    9 import com.framsticks.core.Instance;
    10 import com.framsticks.core.ObjectInstance;
     9import com.framsticks.core.Tree;
     10import com.framsticks.core.ObjectTree;
    1111import com.framsticks.params.AccessInterface;
    1212import com.framsticks.params.FramsClass;
    … …  
    1515import com.framsticks.parsers.XmlLoader;
    1616import com.framsticks.test.TestClass;
     17// import com.framsticks.util.dispatching.Dispatching;
    1718import com.framsticks.util.dispatching.RunAt;
    18 import static com.framsticks.core.InstanceUtils.*;
     19import static com.framsticks.core.TreeOperations.*;
    1920
    2021@Test
    2122public class ProcedureBrowserTest extends BrowserBaseTest {
    2223
    23         ObjectInstance instance;
     24        ObjectTree tree;
    2425
    2526        @Override
    … …  
    2728                browser = new XmlLoader().load(Browser.class, getClass().getResourceAsStream("/configs/ProcedureBrowserTest.xml"));
    2829
    29                 assertThat(browser.getInstances().size()).isEqualTo(1);
    30                 assertThat(browser.getInstances().get("test")).isInstanceOf(ObjectInstance.class);
     30                assertThat(browser.getTrees().size()).isEqualTo(1);
     31                assertThat(browser.getTrees().get("test")).isInstanceOf(ObjectTree.class);
    3132
    32                 instance = (ObjectInstance) browser.getInstances().get("test");
     33                tree = (ObjectTree) browser.getTrees().get("test");
    3334        }
    3435
    3536        @Test(timeOut = 10000)
    3637        public void testShow() {
    37                 instance.dispatch(new RunAt<Instance>() {
     38                tree.dispatch(new RunAt<Tree>(failOnException) {
    3839                        @Override
    39                         public void run() {
    40                                 assertThat(instance.getRootObject()).isInstanceOf(TestClass.class);
     40                        protected void runAt() {
     41                                assertThat(tree.getRootObject()).isInstanceOf(TestClass.class);
    4142                        }
    4243                });
    … …  
    4445                clickAndExpandPath("test");
    4546
    46                 instance.dispatch(new RunAt<Instance>() {
     47                tree.dispatch(new RunAt<Tree>(failOnException) {
    4748                        @Override
    48                         public void run() {
    49                                 assertThat(bindAccess(instance, "/").getFramsClass().getParam("history")).isInstanceOf(StringParam.class);
     49                        protected void runAt() {
     50                                assertThat(bindAccess(tree, "/").getFramsClass().getParam("history")).isInstanceOf(StringParam.class);
    5051                        }
    5152                });
    … …  
    5354                // monitor.useFor(4.0);
    5455
    55                 instance.dispatch(new RunAt<Instance>() {
     56                tree.dispatch(new RunAt<Tree>(failOnException) {
    5657                        @Override
    57                         public void run() {
    58                                 AccessInterface access = bindAccess(instance, "/");
     58                        protected void runAt() {
     59                                AccessInterface access = bindAccess(tree, "/");
    5960                                assertThat(access).isInstanceOf(ReflectionAccess.class);
    6061                                FramsClass framsClass = access.getFramsClass();
    … …  
    6566                                assertThat(framsClass.getParam(3).getId()).isEqualTo("resetHistory");
    6667
    67                                 assertThat(access.get("history", String.class)).isEqualTo("");
     68                                assertThat(access.get("history", String.class)).isEqualTo("initial|");
    6869                        }
    6970                });
    7071
    7172                // frame.panel("TestClass");
    72                 JPanelFixture appendHistory = frame.panel("TestClass").panel("appendHistory");
    73                 appendHistory.panel("arg0").textBox("value").enterText("argument");
    74                 appendHistory.button("call").click();
     73                final JPanelFixture appendHistory = frame.panel("TestClass").panel("appendHistory");
     74                appendHistory.panel("arg0").textBox("value").enterText("Żółw");
     75                assertThat(appendHistory.panel("arg0").textBox("value").text()).isEqualTo("Żółw");
     76                clickButton(appendHistory.button("call"));
    7577                waitForIdle();
    7678
    77                 instance.dispatch(new RunAt<Instance>() {
     79
     80                tree.dispatch(new RunAt<Tree>(failOnException) {
    7881                        @Override
    79                         public void run() {
    80                                 assertThat(bindAccess(instance, "/").get("history", String.class)).isEqualTo("argument|");
     82                        protected void runAt() {
     83                                assertThat(bindAccess(tree, "/").get("history", String.class)).isEqualTo("initial|Żółw|");
    8184                        }
    8285                });
    8386
    84                 frame.panel("TestClass").panel("resetHistory").button("call").click();
     87                clickButton(frame.panel("TestClass").panel("resetHistory").button("call"));
    8588                waitForIdle();
    8689
    87                 instance.dispatch(new RunAt<Instance>() {
     90                tree.dispatch(new RunAt<Tree>(failOnException) {
    8891                        @Override
    89                         public void run() {
    90                                 assertThat(bindAccess(instance, "/").get("history", String.class)).isEqualTo("");
     92                        protected void runAt() {
     93                                assertThat(bindAccess(tree, "/").get("history", String.class)).isEqualTo("");
    9194                        }
    9295                });

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

    r96 r97  
    44import org.testng.annotations.Test;
    55
    6 import com.framsticks.core.ObjectInstance;
     6import com.framsticks.core.Mode;
     7import com.framsticks.core.ObjectTree;
    78import com.framsticks.core.Path;
    89import com.framsticks.core.XmlBasedTest;
    9 import com.framsticks.remote.RemoteInstance;
     10import com.framsticks.remote.RemoteTree;
    1011
    1112import com.framsticks.test.TestClass;
    12 import com.framsticks.core.Instance;
     13import com.framsticks.core.Tree;
    1314import com.framsticks.params.FramsClass;
    14 import com.framsticks.util.AbstractStateFunctor;
    1515import com.framsticks.util.dispatching.Dispatching;
    1616import com.framsticks.params.AccessInterface;
     17import com.framsticks.params.PrimitiveParam;
    1718import com.framsticks.params.PropertiesAccess;
    18 import com.framsticks.params.ValueParam;
    1919import com.framsticks.params.types.ProcedureParam;
    2020import com.framsticks.util.dispatching.Dispatching.Waiter;
    21 import com.framsticks.util.dispatching.Future;
     21import com.framsticks.util.dispatching.FutureHandler;
    2222import com.framsticks.util.dispatching.RunAt;
    2323
    24 import static com.framsticks.core.InstanceUtils.*;
     24import static com.framsticks.core.TreeOperations.*;
    2525
    2626import static org.fest.assertions.Assertions.*;
    … …  
    2929public class ServerTest extends XmlBasedTest {
    3030
    31         protected RemoteInstance remote;
     31        protected RemoteTree remote;
    3232        protected FramsClass remoteTestFramsClass;
    3333        protected Path remotePath;
    3434
    3535        protected Server server;
    36         protected ObjectInstance hosted;
     36        protected ObjectTree hosted;
    3737        protected TestClass hostedObject;
    3838
    … …  
    4646                assertThat(framsticks.size()).isEqualTo(2);
    4747                assertThat(framsticks.get("test")).isInstanceOf(Server.class);
    48                 assertThat(framsticks.get("remote")).isInstanceOf(RemoteInstance.class);
     48                assertThat(framsticks.get("remote")).isInstanceOf(RemoteTree.class);
    4949
    5050                server = (Server) framsticks.get("test");
    51                 remote = (RemoteInstance) framsticks.get("remote");
    52                 assertThat(server.getHosted()).isInstanceOf(ObjectInstance.class);
    53                 hosted = (ObjectInstance) server.getHosted();
     51                remote = (RemoteTree) framsticks.get("remote");
     52                assertThat(server.getHosted()).isInstanceOf(ObjectTree.class);
     53                hosted = (ObjectTree) server.getHosted();
    5454                assertThat(hosted.getRootObject()).isInstanceOf(TestClass.class);
    5555                hostedObject = hosted.getRootObject(TestClass.class);
    … …  
    5858        @Test(dependsOnMethods = "runServer")
    5959        public void fetchInfo() {
    60                 remote.dispatch(new RunAt<Instance>() {
     60                remote.dispatch(new RunAt<Tree>(failOnException) {
    6161                        @Override
    62                         public void run() {
    63                                 remote.fetchInfo(Path.to(remote, "/"), new Future<FramsClass>(failOnException()) {
     62                        protected void runAt() {
     63                                remote.info(Path.to(remote, "/"), new FutureHandler<FramsClass>(failOnException) {
    6464                                        @Override
    6565                                        protected void result(FramsClass result) {
    … …  
    7878                final Waiter waiter = produceWaiter(1.0);
    7979
    80                 remote.dispatch(new RunAt<Instance>() {
     80                remote.dispatch(new RunAt<Tree>(failOnException) {
    8181                        @Override
    82                         public void run() {
     82                        protected void runAt() {
    8383                                final Path path = Path.to(remote, "/");
    8484                                assertThat(path.isResolved()).isFalse();
    8585
    86                                 remote.resolve(path, new Future<Path>(failOnException()) {
     86                                remote.resolve(path, new FutureHandler<Path>(failOnException) {
    8787                                        @Override
    8888                                        protected void result(final Path result) {
    8989                                                assertThat(result.isResolved()).isTrue();
    9090                                                remotePath = result;
    91                                                 remote.fetchValues(result, new AbstractStateFunctor(failOnException()) {
     91                                                remote.get(result, Mode.FETCH, new FutureHandler<Object>(failOnException) {
    9292                                                        @Override
    93                                                         public void call() {
     93                                                        protected void result(Object object) {
    9494                                                                AccessInterface access = bindAccess(result);
    9595                                                                assertThat(access).isInstanceOf(PropertiesAccess.class);
    … …  
    108108                final Waiter waiter = produceWaiter(2.0);
    109109
    110                 storeValue(remotePath, remoteTestFramsClass.getParamEntry("name", ValueParam.class), "new name", new AbstractStateFunctor(failOnException()) {
     110                set(remotePath, remoteTestFramsClass.getParamEntry("name", PrimitiveParam.class), "new name", new FutureHandler<Integer>(failOnException) {
    111111                        @Override
    112                         public void call() {
     112                        protected void result(Integer flags) {
     113                                // assertThat(flags).isEqualTo(0);
    113114                                /** And now check directly whether it was really set. */
    114                                 hosted.dispatch(new RunAt<Instance>() {
     115                                hosted.dispatch(new RunAt<Tree>(failOnException) {
    115116                                        @Override
    116                                         public void run() {
     117                                        protected void runAt() {
    117118                                                assertThat(hostedObject.getName()).isEqualTo("new name");
    118119                                                waiter.pass();
    … …  
    128129                final Waiter waiter = produceWaiter(2.0);
    129130
    130                 call(remotePath, remoteTestFramsClass.getParamEntry("resetHistory", ProcedureParam.class), new Object[] {}, new Future<Object>(failOnException()) {
     131                call(remotePath, remoteTestFramsClass.getParamEntry("resetHistory", ProcedureParam.class), new Object[] {}, new FutureHandler<Object>(failOnException) {
    131132                        @Override
    132133                        protected void result(Object result) {
    … …  
    135136                });
    136137
    137                 call(remotePath, remoteTestFramsClass.getParamEntry("appendHistory", ProcedureParam.class), new Object[] {"next word"}, new Future<Object>(failOnException()) {
     138                call(remotePath, remoteTestFramsClass.getParamEntry("appendHistory", ProcedureParam.class), new Object[] {"next word"}, new FutureHandler<Object>(failOnException) {
    138139                        @Override
    139140                        protected void result(Object result) {
    140                                 hosted.dispatch(new RunAt<Instance>() {
     141                                hosted.dispatch(new RunAt<Tree>(failOnException) {
    141142                                        @Override
    142                                         public void run() {
     143                                        protected void runAt() {
    143144                                                assertThat(hostedObject.getHistory()).isEqualTo("next word|");
    144145                                                waiter.pass();

  • java/main/src/test/java/com/framsticks/model/f0/SchemaTest.java

    r90 r97  
    2020                assertThat(schema.getNeuroClasses().size()).isEqualTo(21);
    2121
     22                assertThat(schema.getFramsClass("m").getName()).isEqualTo("Model");
     23
    2224                assertThat(schema.getNeuroClass("|").getName()).isEqualTo("Bend muscle");
    2325                assertThat(schema.getNeuroClass("VEye").getParam("p")).isInstanceOf(FloatParam.class);

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

    r96 r97  
    8282                access.select(test);
    8383
    84                 assertThat(access.get("history", String.class)).isEqualTo("first|");
     84                assertThat(access.get("history", String.class)).isEqualTo("initial|first|");
    8585                Object result = access.call("appendHistory", new Object[] {"second"});
    8686
    8787                assertThat(result).isInstanceOf(Integer.class);
    88                 assertThat(result).isEqualTo(13);
    89                 assertThat(access.get("history", String.class)).isEqualTo("first|second|");
     88                assertThat(result).isEqualTo(21);
     89                assertThat(access.get("history", String.class)).isEqualTo("initial|first|second|");
    9090
    9191                result = access.call("resetHistory", null);

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

    r96 r97  
    8888        }
    8989
    90         public static ExceptionResultHandler failOnException() {
    91                 return new ExceptionResultHandler() {
    92                         @Override
    93                         public void handle(FramsticksException e) {
    94                                 assertThat(e).isNull();
    95                         }
    96                 };
    97 
    98         }
     90        public static final ExceptionResultHandler failOnException = new ExceptionResultHandler() {
     91                @Override
     92                public void handle(FramsticksException e) {
     93                        assertThat(e).isNull();
     94                }
     95        };
    9996}

  • java/main/src/test/resources/configs/FramsServerTest.xml

    r90 r97  
    22<Framsticks>
    33        <import class="com.framsticks.running.FramsServer" />
    4         <import class="com.framsticks.remote.RemoteInstance" />
     4        <import class="com.framsticks.remote.RemoteTree" />
    55        <import class="com.framsticks.running.LoggingOutputListener" />
    66        <FramsServer name="frams" port="9008">
    77                <LoggingOutputListener />
    88        </FramsServer>
    9         <!-- <RemoteInstance name="remote" address="localhost:9008" /> -->
     9        <!-- <RemoteTree name="remote" address="localhost:9008" /> -->
    1010</Framsticks>

  • java/main/src/test/resources/configs/ProcedureBrowserTest.xml

    r90 r97  
    11<?xml version="1.0" encoding="UTF-8"?>
    22<Browser>
    3         <import class="com.framsticks.core.ObjectInstance" />
     3        <import class="com.framsticks.core.ObjectTree" />
    44        <import class="com.framsticks.test.TestClass" />
    5         <ObjectInstance name="test">
     5        <ObjectTree name="test">
    66                <TestClass />
    7         </ObjectInstance>
     7        </ObjectTree>
    88</Browser>

  • java/main/src/test/resources/configs/ServerTest.xml

    r96 r97  
    22<Framsticks>
    33        <import class="com.framsticks.hosting.Server" />
    4         <import class="com.framsticks.remote.RemoteInstance" />
    5         <import class="com.framsticks.core.ObjectInstance" />
     4        <import class="com.framsticks.remote.RemoteTree" />
     5        <import class="com.framsticks.core.ObjectTree" />
    66        <import class="com.framsticks.test.TestClass" />
    77        <import class="com.framsticks.running.LoggingOutputListener" />
    88        <Server name="server" port="9007">
    9                 <ObjectInstance name="test">
     9                <ObjectTree name="test">
    1010                        <TestClass name="a test name" />
    11                 </ObjectInstance>
     11                </ObjectTree>
    1212        </Server>
    13         <RemoteInstance name="remote" address="localhost:9007" />
     13        <RemoteTree name="remote" address="localhost:9007" />
    1414</Framsticks>

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

    r96 r97  
    22<Framsticks>
    33        <import class="com.framsticks.gui.Browser" />
    4         <import class="com.framsticks.remote.SimulatorInstance" />
     4        <import class="com.framsticks.remote.SimulatorTree" />
    55        <Browser name="browser">
    6                 <SimulatorInstance name="localhost:9009" address="localhost:9009" />
     6                <SimulatorTree name="localhost:9009" address="localhost:9009" />
    77        </Browser>
    88</Framsticks>

  • java/main/src/test/resources/log4j.properties

    r96 r97  
    2626log4j.appender.STDOUT.layout.ConversionPattern=%d{ABSOLUTE} [%-5p] [%t] %c -- %m%n
    2727
    28 log4j.logger.com.framsticks=INFO
    29 # log4j.logger.com.framsticks.hosting.Server=DEBUG
     28log4j.logger.com.framsticks=WARN
     29log4j.logger.com.framsticks.test.TestConfiguration=INFO
     30# log4j.logger.com.framsticks.gui.console.TrackConsole=DEBUG
     31# log4j.logger.com.framsticks.gui.controls.ProcedureControl=DEBUG
     32# log4j.logger.com.framsticks.test.TestClass=DEBUG
    3033# log4j.logger.com.framsticks.communication.ServerConnection=TRACE
    31 # log4j.logger.com.framsticks.util.dispatching.AbstractJoinable=DEBUG
     34# log4j.logger.com.framsticks.util.dispatching.Dispatching=DEBUG
    3235# log4j.logger.com.framsticks.parsers.F0Writer=TRACE
    33 # log4j.logger.com.framsticks.core.ObjectInstance=DEBUG
    34 # log4j.logger.com.framsticks.core.Instance=DEBUG
    3536# log4j.logger.com.framsticks.running=DEBUG
    3637# log4j.logger.com.framsticks.parsers.XmlLoader=DEBUG
Note: See TracChangeset for help on using the changeset viewer.