Adding new policies for stub/skeleton generation - second benchmark

Updating database with relations; Adding new SQL query config files

Updating database for the 4th benchmark

Removing unwanted stub and skeleton files

Preparing second and third benchmarks; backing up MySQL database

First benchmark working with capability-based RMI; adjustments in callbacks, etc.

Adjustments in stubs and skeletons for callback in callback; using different ports for each for now; still having problems with cross references in C++

Porting and compiling SmartLightsController

Integrating capability-based RMI on Sentinel for Java side

Preparing Makefiles, stub, skeleton, config files, etc. for porting LifxLightBulb and Lifxtest

Adding LifxLightBulb files and placeholders for benchmarks; preparing for porting

Adding last version of iotruntime and iotinstaller; preparing to extend IoTMaster for new RMI

Cleaning up

Adding example for a CPP that calls class skeleton

Adding example for a CPP that calls class skeleton

Tested on RPi, both RPi1 and RPi2; works fine and fast

1) Making Java socket read/write length in 4 bytes as well; 2) Fixing endianness issue when transferring message length between Java and C++

Fixing a bug in C++ socket server-client: message length was represented just in 1 byte - this is not enough for sending longer messages (just enough to represent up to ~126 bytes/8-bit representation) - now it's changed to 4 bytes (integer size)

Testing enum and callback combination

Combining enum, struct, and callback in one method; refactoring method body generations for callback and non-callback methods; fixing small bugs

Integrating enum and struct in one method call; fixing minor bugs

Testing complex callbacks invocation; fixing subtle bugs

Testing more complex struct and enum declarations; fixing subtle bugs

Fixing second bug (C++ skeleton cannot connect to Java's callback socket server); Instead of reporting connection failure after the first connection, we make the C++ wait for connection to occur (Java thread/socket server creation is a little slower)

Fixing problem with array/list of callbacks; Java static variables persist across multiple objects of the same type that are instantiated at the same instance - needed to make objectId non-static to mark different callback objects

Testing callbacks for Java and C++; fixing a few bugs; more bugs to tackle: 1) Need to retest C++ skeleton and Java stub, 2) Array of callbacks contains wrong references in Java

Testing struct for array and list (Java and C++); fixing bugs

Testing struct (single object); fixing small bugs, etc.

Fixing bugs: 1) Arrays.asList generates finaled List (need to feed it into an ArrayList constructor); 2) Generate setAllowed.insert() only when there is callback for C++

Testing and fixing bugs on enum data types

Adding permission insertion for struct (will be tested later)

Moving permission setting from stub to skeleton (mistakenly put stuff in stub and not skeleton)

Adding permission inclusion for callback helper function; some testcases on enum type

Cleaning up callback code generation; Fixing a few minor issues, e.g. indentation, etc.

Preparing for callback testing (creating new policy files); Adding error messsages that require callback policy files (with class definition) to be parsed first

Testing for list/vector data types

Fixing bugs on char translation; testing for arrays

Replacing throw error with exit statements for now to handle fatal errors when communication is taking place

Reverting type resolution in C++ to Java types, e.g. byte and char instead of just char

Adding new policy, Java, and Cpp files for testing/debugging

Fixing comments and cleaning up

Code refactoring for skeleton generation in C++ and Java, and a bit of clean-up

Completing compiler with C++ struct support; need to clean up code!

Fixing minor bugs in callback generation

Adding struct support for Java in compiler

Adding enum support in compiler

More refactoring for permission writing in Java constructor

Refactoring policy writing

Adding policy dynamic checks on skeleton and stub that has callback objects

Adding callback support for C++; still missing dynamic policy checks for both

Fixing minor bugs for callback-in-callback placeholders

Adding Java callback support in compiler

Adding feature for enum and struct generations

Moving struct and enum declaration into interface declaration

Adding skeleton generation for Java and C++; excluding specific features for now, e.g. callbacks, enum, struct, etc.

Adding permission check and error throw in C++

Adding permission checks for Java; fixing type translations for return and parameter types for C++ in IoTCompiler

Completing parser to parse generic/template return types; adding standard method bodies in stubs

Refactoring method signature generations for interfaces and classes

Initial cleaning up in compiler, fixing bugs

Adding package (path) and import statement for ParseNode

Extending parser for struct/enum (policy) definition files; Removing parser support for generics/template with 2 data types

Adding support to returning struct/list of struct objects

Testing for callbacks thread safety in C++

Sending int[] instead of a bunch of int for enum type transport; cleaning up method signatures on C++ side

Adding return value support for enumeration (both Java and C++

Adding enum support for method argument; need to emulate the same functionality for return value as well (together with struct)

Doing the same set of transformations for C++

Cleaning methodSignatures

Using methodId directly without method signature; placing sendReturnObj in individual methods (more modular)

Fixing bug for return value from callback in C++ (sendReturnObj is called twice); making skeleton more modular

Adding callback for C++ (still has bug for return values); adding struct as method argument; still missing struct as return value; clean up needed later

Adding object ID and tons of minor adjustments for callback support

Separating socket creation from callback method, so that this method can be called multiple times

Adding lock/synchronization to make sure that RMI calls are thread safe

Initial version that handles multiple callback objects through 1 socket

Adding #include<vector> declaration when array is translated as vector in C++

Using sorted integer as method Id instead of hash values

Removing IoTRMITypes.java from the outer directory

Translating array into vector in C++; supporting only List/ArrayList/list for Collections/STL

Moving IoTRMITypes class into Java directory

Making sure that sample stub and skeleton classes inherit from a common interface

Refactoring type size handler; using Java types as standard

Completing stub and skeleton sides' APIs; Adding tests for C++ side; Still need to refactor non-primitive data types handling

Adding array/vector feature on C++ side - vector is chosen here because C++ doesn't provide a straightforward way to get dimensions for traditional arrays

Adding premature C++ side; supporting only primitive types (including string) for now

Early version of RMI system for Java part; supports primitives, one-dimensional array, some of the Collection classes (but not recursively parsed), and callback mechanism

Abstracting IoTSocket and extend it for client and server sides

Adding early version of IoT RMI system; for now: 1) Connects Java to Java; 2) Translates only primitive/basic data types

Cleaning up; Adding new files

Fixing program structure; now accepting multiple policy files; cross-checking references in multiple policy files for USERDEFINED types to generate type-checked input parameters; better command line input

Refactoring policy parsing section; Preparing for parsing multiple policy files

Adding square brackets handling for arrays; Adding more policy files

Adding handling for primitives, non-primitives, and user-defined types; doesn't handle local vs. stub interface exchange for input parameters yet

Separating policy file into main policy and generated interfaces; fixing lexer, parser, parse-tree, etc.; non-generic data types haven't been handled

Perfecting parser, lexer, and parse-tree handling for policy files; Generating skeletons for stubs

First version of parser; Generates AST in XML and HTML format.