Implemented SCIFIO FakeFormat

Translated the FakeReader for .fake files to SCIFIO components. In
addition to the standard components, this format includes a FakeHandle
class that can be used to construct RAIS objects (as these are the
underlying currency of SCIFIO) without forcing disk I/O.
Added protected zero-param RAIS constructor

Declared a protected zero-parameter RandomAccessInputStream constructor
allowing more freedom for subclassing.
Implemented RandomAccessInputStreamAdapter

Added a LegacyAdapter implementation for converting between legacy and
modern RandomAccessInputStream (RAIS) instances.

Because the existing legacy RAIS in loci.common already, essentially,
was a Wrapper of the modern RAIS, it was simply officially declared and
modified as such.
Updated auto-generated OME-XML classes

Used xsd-fu script to generate new ome-xml classes, from commit:
de62ebfd00823ef7518731fbda9cb1282f281fa6

Only non-model classes were generated (MetadataStore/Retrieve). Two
versions of each class were generated: a delegator and delegate in
loci.formats and ome.xml.meta respectively, to preserve backwards
compatibility.
Reworked AdapterTools mechanics

First, instead of maintaining a static function returning a queried
Adapter, a non-static class was created, and AdapterTools maintains a
static reference to a single instance of this helper class.

Second, instead of creating a list of adapters and only using what's on
it, if a queried adapter isn't found, a new instance is created and
mapped. This allows adapters to be defined downstream of AdapterTools
without any explicit discovery mechanism.
Converted SCIFIOReaderAdapter to a LegacyAdapter

SCIFIOReaderAdapter now follows the LegacyAdapter pattern. To facilitate
this, the old SCIFIOReaderAdapter logic was moved to the more
appropriately named SCIFIOReaderWrapper (as this class was wrapping an
IFormatReader).

SCIFIOReaderAdapter can now be used to freely interchange legacy
IFormatReaders with SCIFIO Readers.
Refactored FormatTools to use AdapterTools

As AdapterTools can now support IFormatReaders via the
SCIFIOReaderAdapter, FormatTools was updated to be fully backwards
compatibile via this adapter usage.
Updated MetadataTools to use AdapterUtils

MetadataTools now uses AdapterUtils to facilitate delegation between
legacy and modern classes, preserving backwards compatibility.
Refactored AWTImageTools to use AdapterTools

AWTImageTools now uses the AdapterTools pattern of maintaining backwards
compatibility, taking advantage of the SCIFIOReaderadapter class.
Implemented CoreMetadataAdapter

Created a CoreMetadataAdapter and CoreMetadataWrapper to follow the
LegacyAdapter pattern of maintaining backwards compatibility.

Currently only the Legacy to Modern direction of wrapping is supported.

The SCIFIOReaderWrapper was updated to take advantage of this new
adapter.
Refactored format name/suffixes to Format

Previously, the format file name and associated suffixes were being
tracked via a separate FormatHandler API, and included in several
components (e.g. Checkers, Writers) as needed.

This leads to repetition of code as each component is tracking the same
format. Instead it is logical that the actual Format interface be the
maintainer of format name and suffixes.

Thus all such references were migrated to the Format interface.

Static utility methods intended to operate on the format name and
suffixes were migrated to FormatTools.

All references and constructors were updated as appropriate.
Removed AbstractParser.metaClass

The AbstractParser class was keeping track of its Metadata class, to
avoid type erasure.

However, this information was not being used anywhere, and was private.
It is also unnecessary given that getFormat() can be used to find or
create a new, appropriate Metadata object.

Thus it was removed from the abstract and all implementating layers.
Removed getZCTCoords from Reader API

The getZCTCoords method is, in general, a convenience for the static
FormatTools.getZCTCoords method and it seems unnecessary to make it a
part of the Reader API when it is typically just delegating to a utility
class.

If a format requires specific behavior for such a method, it can
maintain it within its own utility class.
Refactored static-context to be Legacy only

The single, static context located in ome.scifio FormatTools was
removed. Context can be created as needed for SCIFIO code.

In the legacy layer, context creation is modeled after ImageReader - in
which a list of readers is parsed once and statically cached. Using this
philosophy, a LegacyContext class was added, with a get() method to get
the current context.

The LegacyContext context (SCIFIO object) is created once and statically
cached.
SCIFIO Formatting: removed unnecessary "this."

Removed superfluous "this." references from core SCIFIO classes, to
enhance readability of the code.
Converted FakeReader to a delegate

The loci.formats FakeReader has been marked deprecated and converted to
a delegate. It now passes all functionality through the ome.scifio
FakeFormat collection of components.
Improved Exception handling in ICS/APNGFormats

Updated the SCIFIO Formats that were imported from the legacy scifio
branch (APNG and ICS) with improved exception handling.

Both now properly use SLF4J logging in their exception handling.
Improved loci-legacy exception handling

Implemented better exception handling in loci-legacy component classes.
LegacyContext and AdapterHelper now use the SLF4J logger to print error
messages instead of just silently eating exceptions.
Moved ICS key, value parsing to Metadata class

Previously the ICS to OME-XML translator contained all the logic of
extracting information from the ICS key,value pairs - the
ICSFormat.Metadata class was simply a bag of these pairs.

However, there is nothing mandating that this logic be OME-XML specific.

This refactoring moves all the logic from the translator to
ICSFormat.Metadata via a series of getters. No values are actually
cached, but instead when a getter is invoked, the bag of key,value pairs
is interrogated as appropriate for the requested metadata value.

The ICS:OME-XML translator and ICS:CoreMetadata translator have been
appropriately updated to call these getters.
Added basic CoreMetadata modern->legacy support

The CoreMetadataAdapter originally did not support Modern->Legacy
conversion because of the legacy use of an array ( [] ) of CoreMetadata
objects. Without accessor methods to override there is no way to
dynamically generate information, and the only way to convert Modern
data to Legacy is pure conversion. Thus, if after conversion the Modern
CoreMetadata object is changed, the Legacy version will not reflect
those changes.

This limitation is still true, but adapter support was still added so
that extensions of SCIFIOFormatReader would have, at least, something
populated to return from the getCoreMetadata() method. But this is
hopefully just a temporary solution.

The reader accessor methods, which essentially alias to CoreMetadata
attributes, will stay synchronized as they are delegated to the SCIFIO
Reader.CoreMetadata. So they should be used whenever possible.