org.crosswire.jsword.book.sword

## Class NullBackend

- java.lang.Object
- - org.crosswire.jsword.book.sword.NullBackend

- All Implemented Interfaces:
    Backend

      public class NullBackend
      extends Object
      implements Backend

  A NullBackend is not attached to resources.
  Author:
    DM Smith
  See Also:
    `The GNU Lesser General Public License for details.`

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `NullBackend()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `contains(Key key)` Determine whether this Book contains the key in question
    `void` | `create()` Create the directory to hold the Book if it does not exist.
    `void` | `decipher(byte[] data)` Decipher the data in place, if it is enciphered and there is a key to unlock it.
    `void` | `encipher(byte[] data)` Encipher the data in place, if there is a key to unlock it.
    `SwordBookMetaData` | `getBookMetaData()`
    `Key` | `getGlobalKeyList()` Gets the fast global key list, and if this operation is not supported, throws a `UnsupportedOperationException`
    `String` | `getRawText(Key key)` Get the text as it is found in the Book for the given key
    `int` | `getRawTextLength(Key key)` Determine the size of the raw data for the key in question.
    `boolean` | `isSupported()` Returns whether this AbstractBackend is implemented.
    `boolean` | `isWritable()` A Backend is writable if the file system allows the underlying files to be opened for writing and if the backend has implemented writing.
    `Key` | `readIndex()` Initialize a AbstractBackend before use.
    `List` | `readToOsis(Key key, RawTextToXmlProcessor processor)` Get the text allotted for the given entry
    `void` | `setAliasKey(Key alias, Key source)`

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

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

- - ### Constructor Detail

    - #### NullBackend

          public NullBackend()

  - ### Method Detail

    - #### getBookMetaData

          public SwordBookMetaData getBookMetaData()

      Specified by:
        `getBookMetaData` in interface `Backend`
      Returns:
        Returns the Sword BookMetaData.

    - #### decipher

          public void decipher(byte[] data)

      Description copied from interface: `Backend`
      Decipher the data in place, if it is enciphered and there is a key to unlock it.
      Specified by:
        `decipher` in interface `Backend`
      Parameters:
        `data` - the data to unlock

    - #### encipher

          public void encipher(byte[] data)

      Description copied from interface: `Backend`
      Encipher the data in place, if there is a key to unlock it.
      Specified by:
        `encipher` in interface `Backend`

    - #### readIndex

          public Key readIndex()

      Description copied from interface: `Backend`
      Initialize a AbstractBackend before use. This method needs to call addKey() a number of times on GenBookBackend
      Specified by:
        `readIndex` in interface `Backend`
      Returns:
        the list of all keys for the book

    - #### contains

          public boolean contains(Key key)

      Description copied from interface: `Backend`
      Determine whether this Book contains the key in question
      Specified by:
        `contains` in interface `Backend`
      Parameters:
        `key` - The key whose presence is desired.
      Returns:
        true if the Book contains the key

    - #### getRawText

          public String getRawText(Key key)
                            throws BookException

      Description copied from interface: `Backend`
      Get the text as it is found in the Book for the given key
      Specified by:
        `getRawText` in interface `Backend`
      Parameters:
        `key` - the key for which the raw text is desired.
      Returns:
        the text from the module
      Throws:
        `BookException`

    - #### setAliasKey

          public void setAliasKey(Key alias,
                         Key source)
                           throws BookException

      Specified by:
        `setAliasKey` in interface `Backend`
      Throws:
        `BookException`

    - #### getRawTextLength

          public int getRawTextLength(Key key)

      Description copied from interface: `Backend`
      Determine the size of the raw data for the key in question. This method may not be faster than getting the raw text and getting its size.
      Specified by:
        `getRawTextLength` in interface `Backend`
      Parameters:
        `key` - The key whose raw data length is desired.
      Returns:
        The length of the raw data, 0 if not a valid key.

    - #### getGlobalKeyList

          public Key getGlobalKeyList()
                               throws BookException

      Description copied from interface: `Backend`
      Gets the fast global key list, and if this operation is not supported, throws a `UnsupportedOperationException`
      Specified by:
        `getGlobalKeyList` in interface `Backend`
      Returns:
        the fast global key list
      Throws:
        `BookException` - the book exception if for some reason the book failed to be read properly.

    - #### readToOsis

          public List readToOsis(Key key,
                        RawTextToXmlProcessor processor)
                          throws BookException

      Description copied from interface: `Backend`
      Get the text allotted for the given entry
      Specified by:
        `readToOsis` in interface `Backend`
      Parameters:
        `key` - The key to fetch
        `processor` - processor that executes before/after the content is read from disk or another kind of backend
      Returns:
        String The data for the verse in question
      Throws:
        `BookException` - If the data can not be read.

    - #### create

          public void create()
                      throws IOException,
                             BookException

      Description copied from interface: `Backend`
      Create the directory to hold the Book if it does not exist.
      Specified by:
        `create` in interface `Backend`
      Throws:
        `IOException`
        `BookException`

    - #### isSupported

          public boolean isSupported()

      Description copied from interface: `Backend`
      Returns whether this AbstractBackend is implemented.
      Specified by:
        `isSupported` in interface `Backend`
      Returns:
        true if this AbstractBackend is implemented.

    - #### isWritable

          public boolean isWritable()

      Description copied from interface: `Backend`
      A Backend is writable if the file system allows the underlying files to be opened for writing and if the backend has implemented writing. Ultimately, all drivers should allow writing. At this time writing is not supported by most backends, so abstract implementations should return false and let specific implementations return true otherwise.
      Specified by:
        `isWritable` in interface `Backend`
      Returns:
        true if the book is writable