First true message passing.

Experimenting with messages: a start method is added to processes and called after registering. It sends a broadcast Hello World message. Clock is still not working.
Dropping MessageCopy class and introducing a start mechanism.
Message queue is checked by a single dedicated thread.

Dropping scheduleDispatch method and the related sync complexity. The new solution is a simple worker thread who regularly wakes up and checks for waiting messages.
Minor .gitignore fix.
added message input to clients
Merge branch 'develop' of https://github.com/sassospicco/da25 into develop
Fixing worker thread launch.

Replacing run with start.
Merge branch 'develop' of https://github.com/sassospicco/da25 into develop
implemented algorithm
UI improvements and Sync fixed

The server now takes commands.
The actual algo is wrapped in synchronized blocks to avoid race conditions.
The concept of "locked" network is introduced.
Introducing test case 1.

In order to perform a test case from a single central location, processes now expose a sendMessage remote method and the user can interact with the network and manually forward messages, if needed.
Since user interacion is not needed, the parser thread in clients has been commented out.
Message class' toString method was improved.
Name reconciliation.

In the course slides, the act of moving a message out of the (per-process) incoming buffer  and handling it out for actual elaboration is called "deliver", whereas our code used the "dispatch" term. Now we use deliver as well.
Test cases 2, 3 and 4

Other test cases included: a chain of dependencies spanning multiple processes, a chain of dependencies inside a single one and a case without dependencies.
Abstracting Network and allowing for process spawning via console.

Network class is no longer async only (possibly with strange hacks to make it sync), but it is an abstract class. Two concrete subclasses (SyncNetwork and AsyncNetwork) can be instantiated, depending on needs.

Following the requirements in assignment 2, I introduced the "new" command to spawn new processes locally via the console (instead of creating a new, ideally remote, VM).
Moreover, the assignment 2 requires that IDs can be chosen; this motivated changes in the VectorClock class (now backed by a "sparse" HashMap instead of an array).

The new "local" processes also called for a better handling of clocks: now messages hold a copy of the clock, instead of relying on RMI automatic serialization.
Recovering test cases.

Test cases for assignment 1 were removed from the branch to get a common platform from which start with assignment2s branch. Now they can be re-introduced.
Abstracting Process.

In addition to splitting Network in sync and async subclasses, I am now splitting also the Process class. This way, we are able to choose at runtime what assignment to run and we have a single codebase.

BssProcess refers to Assignment 1 (Birman-Schiper-Stephenson); AgProcess to Assignment 2 (Afek-Gafni).
Further subclassing networks.

Separating the classes handling common operations (either sync or async) from the ones specifically related to an assignment. Currently this is a redundand operation, since we are working only on two assignments, but clarifies the code and helps getting ready for the third assignment.

Please note that this commit is not perfeclty working, since there is a half-baked change in SyncNetwork class pertaining to the future works in synchronous communications.
Polishing the framework.

Some little refactoring to reduce code duplication. Now the framework is fairly complete and powerful and we can start actually implementing AG algo.
Implementing AG algorithm.

The Afek-Gafni algorithm is implemented and working. There is maybe still room to devise a couple of interesting test cases.

Some constants were moved to da25.base package for an easier access.