JORTE: switch to direct ByteBuffer

JORTE: switch to direct ByteBuffer

This commit significantly changes the way new issues are sent and received
both on the Java side and on the C side.

In the past there was one Java instance of HeapByteBuffer in the
MessageData class. ByteBuffer is used to perform serialization and
deserialization of received and sent issues in Java. It is compatible with
the CORBA standard that is used in the main ORTE library.

The HeapByteBuffer has one significant drawback. It allocates memory
on the heap managed by Java VM's garbage collector and when accessing
the backing array from C it has to copy the entire array to new space
in memory outside the VM. Added to that the backing array wasn't accessed
as an array object from the C code, but rather every byte from the Java
buffer was copied to a C byte array or vice versa (publisher x subscriber
part). This adds a lot of overhead (calling JNI functions to obtain new
values).

Instead the DirectByteBuffer is now used which allocates memory directly
(outside of Java VM) through malloc() and stores the pointer in such a way,
that it is easily accesible from C code using GetDirectBufferAddress,
that returns (void *). The Java part behaves much the same as normal
(Heap) ByteBuffer. The allocated byte array could be used like any other
C array and the VM ensures that the memory region allocated by direct
ByteBuffer is contiguous. This is very useful, because normal Java arrays
are not guaranteed to be contiguous which makes them difficult to handle,
because JNI functions must be called that make copies of them in a
contiguous space and that adds another overhead.

As a bonus the C code for both publisher and subscriber Java wrappers
is much shorter and simpler than it used to be.