Some debug output slipped through.  Remove it to clean up stdout.

Add some extra tests to the TET table tests, to make sure things are being
read in correctly.

Also, fix up the Simulink Encoding parser tests to better check that everything
is working correctly, and all byte arrays are the same size.

Extract the common code for parsing the actual buffers into a common function,
to ensure MCOS data is properly parsed.  Also add a test exercising this
behaviour.

When out of bytes, don't return EOF.  Instead, return -1 as specified in the
InputStream contract.  Otherwise MatFileReader is unable to use the decoder,
as expected.

Due to a logic bug, the Simulink Decoder would throw RuntimeExceptions instead
of EOFExceptions after the first EOF.  Fix this by handling the state after
the first EOF explicitly.

Double check the size of the Data object, and make an instanceof test explicit,
instead of relying on a ClassCastException.

Support MCOS object arrays in MCOS object properties.  Also adds some tests
to the TET test to ensure that data was properly pulled out.

Since MLObject has been refactored to support this properly, now handle arrays
of MCOS.  Note that currently only 2d arrays are supported for MCOS objects
right now.

With the change to have MLObject properly store arrays of objects, and due
to the fact MLObject needs to handle the handle class, using MLStructure as
the data storage and array handler is about to get very messy.  Thus change
to the obvious data structure to manage everything.  The instance of a Map<>
is a specific instance of an MCOS.  That way handles are properly represented.

Sub objects are just random integers in a uint32 array.  Start handling single
objects.  Eventually, multiple object arrays need to be handled, but that
requires adjusting MLObject first.

 - Remove a redundant if check on the objectId in the third segment.  This
shouldn't happen anyways.
 - Remove an unused variable.
 - Correct a comment from a copy+paste error.
 - If properties are not found (not that there are none), then throw an exception.
 - Use the classname as found in the MCOS section, to make finding errors easier.
 - Even though it isn't used, store the segment 2 index for object properties,
   for the future.

In the third segment, it appeared that there was an object id, related back
to the object id given in a structure.  However, this is not true at all, as
MATLAB will randomly decide what values go here.  However, the index into this
segment seems to be the actual object id.  Thus switch to using that value.
The meaning of the other field is left for someone else to divine, it isn't
important here.

Simulink will encode its MAT file using a form of base64, using uuencode's
key.  SimulinkDecoder is a very simple stream based class to parse it.

Ensure handle classes have away to to compare for object equality.  Due to
the current design of MLArray, this cannot be done per object.  So instead
the same Objects share the same structure.  Eventually this should be fixed.

To support multiple objects with differing field values for the same class
type, it is now necessary to actually parse segment 4 and act accordingly.
Thus do that, and add a test to ensure the behaviour is correct.

Due to the way MATLAB stores field names for structures, individual items
in the structure don't have names.  Thus, one must use the field name.  Fix
the grab bag parsing to do this correctly, and add a test to verify correct
behaviour.

Don't mislead in the documentation.  When reading 24 bytes, 24 bytes are read.
Not 16.

Any class that has default attributes only is now fulled loaded and parsed.
Other attributes are currently skipped.  Also commit in a test for this
behaviour that uses a char array as a single parameter.

To avoid future surprises, make sure that the MCOS header bytes for an object
are correct.

For the future, the class name will need to be fetched before I know about
the placeholders.  Thus read in the class names and use that now.

For applications parsing the MAT file later, they may need to know the byte
order of the original file.  Thus store that information in the header.  Note
for writing it is possible to change the endian indicator without changing the
byte order returned.  This should eventually throw an exception.

Verify everything continues to work with multiple elements.

To match the new Group Id, switch the package name.  This also moves the
package name under a controlled domain, avoiding potential name collisions
later.

Fix some comment misspellings and formatting, and remove unused imports.

MCOS is handled completely separately through a weird format.  Thus, start
supporting it by reading in the necessary data.  Currently it isn't fully
parsed, as the first unit test doesn't require extra data.  Also include the
MATLAB class file used to generate the test.

Files produced by Simulink, along with embedded MAT files inside of MAT files
don't have the full header.  Thus enable parsing them as necessary.

Get this going for sanity checks.  Test against both JDK 6 and 7.

Even though most users won't run against this, in case multiple empty keys are
found, store them all under @? where ? is a 0-starting index.  Also include a
modified MATLAB file to test these conditions.  Note that MATLAB just ignores
all three inputs.

Also ignore the IntelliJ IDEA files.

Remove some old tests file that are not used, along with a pre-compiled jar
file that came from somewhere.

Fix up the pom file, preparing it to be used to deploy to Maven Central.
Also fix up some whitespace issues, and lock the versions of all used plugins,
since maven couldn't apparently figure out which versions to use.

Added an equivilant function to getIR() in MLSparse for columns. I thought getJC would do this but looking at the code it did something else. Therefore I added getIC (this is possibly named badly) which literally gives you the column index as an array whose i_th value is the column of the i_th entry in pr. I've also changed the pom.xml so that its version wasn't snapshot. This was so i could create the artifact and serve it off our nexus