public  void clearLock(String name) throws IOException 
{
    if (lockFactory != null) {
      lockFactory.clearLock(name);
    }
}

Attempt to clear (forcefully unlock and remove) the specified lock. Only call this at a time when you are certain this lock is no longer in use.

 abstract public  void close() throws IOException
Closes the store.

 public static  void copy(Directory src,
    Directory dest,
    boolean closeDirSrc) throws IOException 
{
    final String[] files = src.listAll();
    IndexFileNameFilter filter = IndexFileNameFilter.getFilter();
    byte[] buf = new byte[BufferedIndexOutput.BUFFER_SIZE];
    for (int i = 0; i <  files.length; i++) {
      if (!filter.accept(null, files[i]))
        continue;
      IndexOutput os = null;
      IndexInput is = null;
      try {
        // create file in dest directory
        os = dest.createOutput(files[i]);
        // read current file
        is = src.openInput(files[i]);
        // and copy to dest directory
        long len = is.length();
        long readCount = 0;
        while (readCount <  len) {
          int toRead = readCount + BufferedIndexOutput.BUFFER_SIZE  > len ? (int)(len - readCount) : BufferedIndexOutput.BUFFER_SIZE;
          is.readBytes(buf, 0, toRead);
          os.writeBytes(buf, toRead);
          readCount += toRead;
        }
      } finally {
        // graceful cleanup
        try {
          if (os != null)
            os.close();
        } finally {
          if (is != null)
            is.close();
        }
      }
    }
    if(closeDirSrc)
      src.close();
}

Copy contents of a directory src to a directory dest. If a file in src already exists in dest then the one in dest will be blindly overwritten.

NOTE: the source directory cannot change while this method is running. Otherwise the results are undefined and you could easily hit a FileNotFoundException.

NOTE: this method only copies files that look like index files (ie, have extensions matching the known extensions of index files).

 abstract public IndexOutput createOutput(String name) throws IOException
Creates a new, empty file in the directory with the given name.
Returns a stream writing this file.

 abstract public  void deleteFile(String name) throws IOException
Removes an existing file in the directory.

 protected final  void ensureOpen() throws AlreadyClosedException 
{
    if (!isOpen)
      throw new AlreadyClosedException("this Directory is closed");
}

 abstract public boolean fileExists(String name) throws IOException
Returns true iff a file with the given name exists.

 abstract public long fileLength(String name) throws IOException
Returns the length of a file in the directory.

 abstract public long fileModified(String name) throws IOException
Returns the time the named file was last modified.

 public LockFactory getLockFactory() 
{
      return this.lockFactory;
}

Get the LockFactory that this Directory instance is using for its locking implementation. Note that this may be null for Directory implementations that provide their own locking implementation.

 public String getLockID() 
{
      return this.toString();
}

Return a string identifier that uniquely differentiates this Directory instance from other Directory instances. This ID should be the same if two Directory instances (even in different JVMs and/or on different machines) are considered "the same index". This is how locking "scopes" to the right index.

 abstract public String[] listAll() throws IOException
Returns an array of strings, one for each file in the
 directory.

 public Lock makeLock(String name) 
{
      return lockFactory.makeLock(name);
}

Construct a Lock .

 abstract public IndexInput openInput(String name) throws IOException
Returns a stream reading an existing file.

 public IndexInput openInput(String name,
    int bufferSize) throws IOException 
{
    return openInput(name);
}

Returns a stream reading an existing file, with the specified read buffer size. The particular Directory implementation may ignore the buffer size. Currently the only Directory implementations that respect this parameter are FSDirectory and org.apache.lucene.index.CompoundFileReader .

 public  void setLockFactory(LockFactory lockFactory) 
{
    assert lockFactory != null;
    this.lockFactory = lockFactory;
    lockFactory.setLockPrefix(this.getLockID());
}

Set the LockFactory that this Directory instance should use for its locking implementation. Each * instance of LockFactory should only be used for one directory (ie, do not share a single instance across multiple Directories).

 public  void sync(String name) throws IOException 
{

}

Ensure that any writes to this file 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.

 abstract public  void touchFile(String name) throws IOException
Set the modified time of an existing file to now.