org.apache.lucene.store

## Class RAMDirectory

- java.lang.Object
- - org.apache.lucene.store.Directory
  - - org.apache.lucene.store.RAMDirectory

- All Implemented Interfaces:
    Closeable, AutoCloseable

      public class RAMDirectory
      extends Directory

  A memory-resident `Directory` implementation. Locking implementation is by default the `SingleInstanceLockFactory` but can be changed with `Directory.setLockFactory(org.apache.lucene.store.LockFactory)`.

  Warning: This class is not intended to work with huge indexes. Everything beyond several hundred megabytes will waste resources (GC cycles), because it uses an internal buffer size of 1024 bytes, producing millions of `byte[1024]` arrays. This class is optimized for small memory-resident indexes. It also has bad concurrency on multithreaded environments.

  It is recommended to materialize large indexes on disk and use `MMapDirectory`, which is a high-performance directory implementation working directly on the file system cache of the operating system, so copying data to Java heap space is not useful.

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class org.apache.lucene.store.Directory

      `Directory.IndexInputSlicer`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected Map<String,RAMFile>` | `fileMap`
    `protected AtomicLong` | `sizeInBytes`

    - ### Fields inherited from class org.apache.lucene.store.Directory

      `isOpen, lockFactory`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `RAMDirectory()` Constructs an empty `Directory`.
    `RAMDirectory(Directory dir, IOContext context)` Creates a new `RAMDirectory` instance from a different `Directory` implementation.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `close()` Closes the store to future operations, releasing associated memory.
    `IndexOutput` | `createOutput(String name, IOContext context)` Creates a new, empty file in the directory with the given name.
    `void` | `deleteFile(String name)` Removes an existing file in the directory.
    `boolean` | `fileExists(String name)` Returns true iff the named file exists in this directory.
    `long` | `fileLength(String name)` Returns the length in bytes of a file in the directory.
    `String[]` | `listAll()` Returns an array of strings, one for each file in the directory.
    `protected RAMFile` | `newRAMFile()` Returns a new `RAMFile` for storing data.
    `IndexInput` | `openInput(String name, IOContext context)` Returns a stream reading an existing file.
    `long` | `sizeInBytes()` Return total size in bytes of all files in this directory.
    `void` | `sync(Collection<String> names)` Ensure that any writes to these files are moved to stable storage.

    - ### Methods inherited from class org.apache.lucene.store.Directory

      `clearLock, copy, createSlicer, ensureOpen, getLockFactory, getLockID, makeLock, setLockFactory, toString`

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

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

- - ### Field Detail

    - #### fileMap

          protected final Map<String,RAMFile> fileMap

    - #### sizeInBytes

          protected final AtomicLong sizeInBytes

  - ### Constructor Detail

    - #### RAMDirectory

          public RAMDirectory()

      Constructs an empty `Directory`.

    - #### RAMDirectory

          public RAMDirectory(Directory dir,
                      IOContext context)
                       throws IOException

      Creates a new `RAMDirectory` instance from a different `Directory` implementation. This can be used to load a disk-based index into memory.

      Warning: This class is not intended to work with huge indexes. Everything beyond several hundred megabytes will waste resources (GC cycles), because it uses an internal buffer size of 1024 bytes, producing millions of `byte[1024]` arrays. This class is optimized for small memory-resident indexes. It also has bad concurrency on multithreaded environments.

      For disk-based indexes it is recommended to use `MMapDirectory`, which is a high-performance directory implementation working directly on the file system cache of the operating system, so copying data to Java heap space is not useful.

      Note that the resulting `RAMDirectory` instance is fully independent from the original `Directory` (it is a complete copy). Any subsequent changes to the original `Directory` will not be visible in the `RAMDirectory` instance.

      Parameters:
        `dir` - a `Directory` value
      Throws:
        `IOException` - if an error occurs

  - ### Method Detail

    - #### listAll

          public final String[] listAll()

      Description copied from class: `Directory`
      Returns an array of strings, one for each file in the directory.
      Specified by:
        `listAll` in class `Directory`

    - #### fileExists

          public final boolean fileExists(String name)

      Returns true iff the named file exists in this directory.
      Specified by:
        `fileExists` in class `Directory`

    - #### fileLength

          public final long fileLength(String name)
                                throws IOException

      Returns the length in bytes of a file in the directory.
      Specified by:
        `fileLength` in class `Directory`
      Parameters:
        `name` - the name of the file for which to return the length.
      Throws:
        `IOException` - if the file does not exist

    - #### sizeInBytes

          public final long sizeInBytes()

      Return total size in bytes of all files in this directory. This is currently quantized to RAMOutputStream.BUFFER_SIZE.

    - #### deleteFile

          public void deleteFile(String name)
                          throws IOException

      Removes an existing file in the directory.
      Specified by:
        `deleteFile` in class `Directory`
      Throws:
        `IOException` - if the file does not exist

    - #### createOutput

          public IndexOutput createOutput(String name,
                                 IOContext context)
                                   throws IOException

      Creates a new, empty file in the directory with the given name. Returns a stream writing this file.
      Specified by:
        `createOutput` in class `Directory`
      Throws:
        `IOException`

    - #### newRAMFile

          protected RAMFile newRAMFile()

      Returns a new `RAMFile` for storing data. This method can be overridden to return different `RAMFile` impls, that e.g. override `RAMFile.newBuffer(int)`.

    - #### sync

          public void sync(Collection<String> names)
                    throws IOException

      Description copied from class: `Directory`
      Ensure that any writes to these files are moved to stable storage. Lucene uses this to properly commit changes to the index, to prevent a machine/OS crash from corrupting the index.
      NOTE: Clients may call this method for same files over and over again, so some impls might optimize for that. For other impls the operation can be a noop, for various reasons.
      Specified by:
        `sync` in class `Directory`
      Throws:
        `IOException`

    - #### openInput

          public IndexInput openInput(String name,
                             IOContext context)
                               throws IOException

      Returns a stream reading an existing file.
      Specified by:
        `openInput` in class `Directory`
      Throws:
        `IOException`

    - #### close

          public void close()

      Closes the store to future operations, releasing associated memory.
      Specified by:
        `close` in interface `Closeable`
      Specified by:
        `close` in interface `AutoCloseable`
      Specified by:
        `close` in class `Directory`

Copyright © 2000-2013 Apache Software Foundation. All Rights Reserved.