uk.ac.starlink.fits

## Class InputFactory

- java.lang.Object
- - uk.ac.starlink.fits.InputFactory

- All Implemented Interfaces:
    java.io.Closeable, java.lang.AutoCloseable

      public abstract class InputFactory
      extends java.lang.Object
      implements java.io.Closeable

  Represents a sequence of bytes, and can create BasicInput objects to read it.
  Since:
    2 Dec 2014

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `InputFactory()`

  - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static InputFactory` | `createByteStoreFactory(ByteStore byteStore)` Returns an input factory based on a populated bytestore.
    `static InputFactory` | `createFactory(DataSource datsrc, long offset, long leng)` Constructs an instance of this class to read a given data source.
    `static InputFactory` | `createFileFactory(java.io.File uncompressedFile, long offset, long leng)` Constructs an instance of this class to read a given uncompressed file.
    `abstract BasicInput` | `createInput(boolean isSeq)` Returns a BasicInput instance to read this object's byte stream.
    `static InputFactory` | `createRandomFactory(DataSource datsrc, long offset, long leng, StoragePolicy policy)` Returns an InputFactory for which random access is guaranteed.
    `static InputFactory` | `createSequentialFactory(DataSource datsrc, long offset, long leng)` Constructs an instance of this class to read a given data source viewed as a stream, not a file.
    `static BasicInput` | `createSequentialInput(java.io.DataInput in)` Returns a non-random-access BasicInput based on a supplied input stream.
    `abstract boolean` | `isRandom()` Indicates whether the BasicInput objects created by this factory will support random access.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface java.io.Closeable

      `close`

- - ### Constructor Detail

    - #### InputFactory

          public InputFactory()

  - ### Method Detail

    - #### isRandom

          public abstract boolean isRandom()

      Indicates whether the BasicInput objects created by this factory will support random access.
      Returns:
        true iff BasicInput.isRandom() will return true for created objects

    - #### createInput

          public abstract BasicInput createInput(boolean isSeq)
                                          throws java.io.IOException

      Returns a BasicInput instance to read this object's byte stream.
      Parameters:
        `isSeq` - if true, the returned object is expected to be used for sequential access only; this value is a hint which may or may not be used by the implementation
      Returns:
        new reader; if isSeq is false and isRandom returns true, it will be capable of random access
      Throws:
        `java.io.IOException`

    - #### createFactory

          public static InputFactory createFactory(DataSource datsrc,
                                                   long offset,
                                                   long leng)
                                            throws java.io.IOException

      Constructs an instance of this class to read a given data source.
      Parameters:
        `datsrc` - data source
        `offset` - offset into file of stream start
        `leng` - number of bytes in stream
      Returns:
        new instance
      Throws:
        `java.io.IOException`

    - #### createSequentialFactory

          public static InputFactory createSequentialFactory(DataSource datsrc,
                                                             long offset,
                                                             long leng)

      Constructs an instance of this class to read a given data source viewed as a stream, not a file.
      Parameters:
        `datsrc` - data source
        `offset` - offset into file of stream start
        `leng` - number of bytes in stream
      Returns:
        new instance

    - #### createFileFactory

          public static InputFactory createFileFactory(java.io.File uncompressedFile,
                                                       long offset,
                                                       long leng)
                                                throws java.io.IOException

      Constructs an instance of this class to read a given uncompressed file. It must be uncompressed for the random access to be able to locate the right part to read.
      Parameters:
        `uncompressedFile` - unencoded file
        `offset` - offset into file of stream start
        `leng` - number of bytes in stream
      Returns:
        new instance
      Throws:
        `java.io.IOException`

    - #### createRandomFactory

          public static InputFactory createRandomFactory(DataSource datsrc,
                                                         long offset,
                                                         long leng,
                                                         StoragePolicy policy)
                                                  throws java.io.IOException

      Returns an InputFactory for which random access is guaranteed. If necessary, the bytes from the data source will be cached using the supplied storage policy.
      Parameters:
        `datsrc` - data source
        `offset` - offset into file of stream start
        `leng` - number of bytes in stream
        `policy` - storage policy for caching if required, or null for default
      Returns:
        new instance
      Throws:
        `java.io.IOException`

    - #### createByteStoreFactory

          public static InputFactory createByteStoreFactory(ByteStore byteStore)
                                                     throws java.io.IOException

      Returns an input factory based on a populated bytestore.
      Parameters:
        `byteStore` - cache containing byte content
      Returns:
        new input factory
      Throws:
        `java.io.IOException`

    - #### createSequentialInput

          public static BasicInput createSequentialInput(java.io.DataInput in)

      Returns a non-random-access BasicInput based on a supplied input stream. The result is just an adapter wrapping the supplied DataInput.
      Parameters:
        `in` - input stream
      Returns:
        non-random BasicInput