Previous Releases

Version 0.4

What's new?

Deferred calls, a.k.a. "futures" (see demo deferred);
ORB shutdown operation (see demo selfcall);
CORBA request interception (see demo interceptors);
CORBA's _is_equivalent operation;
Customizable component-based architecture (see section Internal Architecture from the User Manual);
IDL large numbers: long long, unsigned long long, long double (see file config);
NOTE: Lua must be changed so lua_Number is long double.

What changed?

Library API

Note: To use the old API, require oil.compat instead of oil.

New auxiliary funtions in module oil.

oil.VERSION to check OiL's version.
oil.tasks instead of scheduler.
oil.sleep(time) instead of scheduler.sleep(time).
oil.pcall(func, ...) instead of scheduler.pcall(func, ...).
oil.time() as an alternative to socket.gettime().
oil.main(func) instead of scheduler.new(func, ...); scheduler.run().
oil.newthread(func, ...) instead of scheduler.start(func, ...).
oil.writeto(file, text) replaces the similar to oil.writeIOR(obj, file).
oil.readfrom(file) instead of oil.readIOR(file).

Operations related to the ORB are provided by the broker object, such as:

broker.types as an improved alternative to oil.getLIR().
broker:loadidl(idlspec) instead of oil.loadidl(idlspec).
broker:loadidlfile(idlfile) instead of oil.loadidlfile(idlfile).
broker:setIR(irprx) instead of oil.getIR(irprx).
broker:getIR() instead of oil.getIR().
broker:getLIR() instead of oil.getLIR().
broker:narrow(proxy [, interface]) instead of oil.narrow(proxy [, interface]).
broker:newproxy(strref [, interface]) instead of oil.newproxy(impl [, interface]).
broker:newservant(impl [, key, interface]) instead of oil.newservant(impl [, interface, key]).
broker:tostring(object) instead of obj:_ior().
broker:deactivate(obj|key|impl) improved alternative to obj:_deactivate().
broker:newencoder() to create a CDR encoder.
broker:newdecoder(string) to create a CDR decoder.
broker:newexcept(body) as an alternative to oil.Exception(body).
broker:setexcatch(func, type) to set exception handlers.
broker:run() instead of oil.run().
broker:pending() instead of oil.pending().
broker:step() instead of oil.step().
broker:shutdown() to shutdown the ORB.
broker:setinterceptor(iceptor, side) to set interceptors.

Integrated CORBA's IR

Ability to change IR definitions;
Ability to load module parts using different oil.loadidl* calls;
Consistent storage of all IDL definitions, not only interfaces;
Standard CORBA exceptions are loaded by default;
Ability to import any definition from the remote delegated IR (oil.setIR);

CORBA's GIOP implementation

Support for marshaling of typecode null and anys containing values of type null;
nil values used as any are automatically coded as null;
Any's now provide the field _anytype to identify the IDL type of the value;
Sequences with nil values can have field n to define its size;
Automatic reconnections when connection is closed.
WARN: Operation invocation may be issued many times if no reply is sent (no at-most-once guarantees);

Object Proxies

oil.narrow and proxy:_narrow now accepts any valid interface specification, i.e. repID, absoulute name, IDL descriptor, or remote IR object;
The function used to handle exceptions can be defined for all proxies of a given interface by function oil.setexcatch(handler [, interface]). If no interface is provided then the handler is set for all proxies. Previously, this handler could only be set for individual proxies by field __exceptions;
Now, if the exception handler function returns (i.e. not raise a Lua error) then the exception is ignored and the values returned are used as the results of the invocation that raised in the original exception;
Addition of oil.deactivate( [, interface]) that removes an object from the ORB;

Servant Objects

Automatically generated object keys start with '\0' to provide a way for the application to avoid collisions with defined keys;
A single Lua object can be used as implementation of different CORBA objects created with automatic keys as long as they implement different interfaces because object keys now contains the interface descriptor hash-code.
WARN: Each time a Lua object is used as an object with a different interface a new CORBA object is created for each interface, which will be the actual (i.e. most specific) interface of the new CORBA object. To avoid implicit creation of different CORBA objects with different interfaces for a single Lua object, set the __type field of the objet meta-table (i.e. its class) to the interface (repID, absolute name, IDL descriptor, or remote IR object) that should be used;
The interface of an implicitly created CORBA object can also be defined by field __type of the object implementation itself (in older versions, only the __type field of the metatable could be used);

Verbose Support

Prints parameter values and objects;
New level distribution:
1. Operation invocation and dispatching;
2. GIOP request and reply processing;
3. Mutual exclusion channel access (concurrent mode);
4. GIOP message creation and handling (i.e. requests and replies);
5. Socket channels creation and handling (i.e. connection and transport);
6. Value (un)marshaling;
7. Hexadecimal view of marshaled streams;
8. Creation of IDL descriptors and internal IR operation;

Development Support

Utility script to create Lua scripts that feed the internal IR with descriptions described in IDL files;
New demo about exception handling;
Unix shell scripts for execution of demos;

Version 0.3.4

What's new?

Bug fixes

Correction of bugs reported from previous versions.

Incorrect parsing of IDL defintions.

Version 0.3.3

What changed?

Minor changes for compatibility with new Lua version.: Changes in the package for conformance with Lua 5.1 and LuaSocket 2.0.

Version 0.3.2

What changed?

Fragmented socket stream bug fix (concurrent mode only).: Correction of bug on handling of stream data received in chunks due to large messages or small network bandwith.

Version 0.3.1

What's new?

Naming Service: An implementation of a Naming Service in Lua using the OiL ORB.
Support for IDL pre-processor directives: LuaIDL now provides native support for pre-processor directives. It used to depend on a command-line C pre-processor.

What changed?

Field _anyval for values of type any.: Values of type any are mapped to a table that stores at field _anyval the actual value of the any.

Version 0.3

What's new?

Cooperative Concurrency: Support for concurrent request handling and method invocation by the use of coroutines implemented by Lua. See demo 'concurrency' for more details.
Customization: Better module organization enabling the use of reduced versions of OiL. See demo 'minimal' for more details.
Dynamic Adaptaion: Support for ORB adaptation due to changes on interface definitions. See demo 'adapt' for more details.
Remote Interface Repository: Support for retrieving interface definitions from a remote IR. Use the operations oil.setIR(ir) and oil.getIR() to define the remote IR to be used.
Integrated Interface Repository: All definitions handled by OiL are accessible though the IR interfaces of CORBA. Use operation oil.getLIR() to get a reference for the integrated IR
Interface Probing Operations: Objects exported by OiL implement the operations _is_a and _interface for probing object interface definitions.
Absolute Name Support: Support for the use of interface absolute name on oil.newproxy, oil.newobject and oil.narrow operations.
Explicit ORB Initialization: OiL Main ORB can be explicitly initialized by the operation oil.init(config). However, it is still implicitly initialized at invocation of oil.newproxy or oil.newobject operations.
Pre-Compiled Libraries: Makefiles can create a library with all Lua scripts precompiled, so it can be embedded into applications or dynamically loaded using the package model of Lua 5.1.
IOR File Operations: Addition of operations for reading and writing IOR stored in files.
Lua 5.1 alpha: Conformance to Lua 5.1 alpha

What changed?

Operation _get_ior: Changed to _ior to avoid name conflict with a possible attribute named 'ior'.
Get stringfied IOR: Should be oil.ior.encode(objref) instead of oil.ior.encode(objref._ior).

Version 0.2

What's new?

Bug fixes

Correction of bugs reported from previous versions.

Alignment of double values

Corbaloc references

Support for object references in the corbaloc format.

Existency Probing Operation

Both OiL proxies and objects implement the _non_existent operation (as well as its alias _not_existent).

IDL from Strings

Support for loading IDL definitions from strings by operation oil.loadidl(idlcode).

Lua 5.1 work6

Conformance to Lua 5.1 work6

What changed?

Loading IDL Operations: Operation oil.loadidl(filepath) changed to oil.loadidlfile(filepath). The operation oil.loadidl(idlcode) is used to load IDL definitions from strings

Version 0.1

What's new?

Installation Package: Makefiles for compilation of the bit manipulation library and installation of Lua files, both in Unix and Windows systems.
Verbose Feature: Debugging messages over different aspects of the ORB.
Lua Packages: Implementation in conformance with the new package model for Lua 5.1.

What changed?

Project Name: Project changes name to OiL. Used to be called O2 and Orbinho.
Major Review: Implementation completely revisited. Correction of problems and performance improvement. Gains measure up to 20%.
Main API: Major changes on the OiL API. Particularly, all operations are stored in proper namespace tables.
Type Mapping: The mapping of CORBA constructed types changed completely to improve marshalling performance.