Class Directory

    • Field Detail

      • isOpen

        protected volatile boolean isOpen
      • lockFactory

        protected LockFactory lockFactory
        Holds the LockFactory instance (implements locking for this Directory instance).
    • Constructor Detail

      • Directory

        public Directory()
    • Method Detail

      • fileExists

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

        @Deprecated
        public abstract void touchFile​(String name)
                                throws IOException
        Deprecated.
        Lucene never uses this API; it will be removed in 4.0.
        Set the modified time of an existing file to now.
        Throws:
        IOException
      • deleteFile

        public abstract void deleteFile​(String name)
                                 throws IOException
        Removes an existing file in the directory.
        Throws:
        IOException
      • fileLength

        public abstract long fileLength​(String name)
                                 throws IOException
        Returns the length of a file in the directory. This method follows the following contract:
        • Throws FileNotFoundException if the file does not exist
        • Returns a value ≥0 if the file exists, which specifies its length.
        Parameters:
        name - the name of the file for which to return the length.
        Throws:
        FileNotFoundException - if the file does not exist.
        IOException - if there was an IO error while retrieving the file's length.
      • createOutput

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

        @Deprecated
        public void sync​(String name)
                  throws IOException
        Deprecated.
        use sync(Collection) instead. For easy migration you can change your code to call sync(Collections.singleton(name))
        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.
        Throws:
        IOException
      • sync

        public void sync​(Collection<String> names)
                  throws IOException
        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.
        Throws:
        IOException
      • openInput

        public IndexInput openInput​(String name,
                                    int bufferSize)
                             throws IOException
        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 CompoundFileReader.
        Throws:
        IOException
      • makeLock

        public Lock makeLock​(String name)
        Construct a Lock.
        Parameters:
        name - the name of the lock file
      • clearLock

        public void clearLock​(String name)
                       throws IOException
        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.
        Parameters:
        name - name of the lock to be cleared.
        Throws:
        IOException
      • setLockFactory

        public void setLockFactory​(LockFactory lockFactory)
                            throws IOException
        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).
        Parameters:
        lockFactory - instance of LockFactory.
        Throws:
        IOException
      • getLockFactory

        public LockFactory getLockFactory()
        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.
      • getLockID

        public String getLockID()
        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.
      • copy

        public void copy​(Directory to,
                         String src,
                         String dest)
                  throws IOException
        Copies the file src to Directory to under the new file name dest.

        If you want to copy the entire source directory to the destination one, you can do so like this:

         Directory to; // the directory to copy to
         for (String file : dir.listAll()) {
           dir.copy(to, file, newFile); // newFile can be either file, or a new name
         }
         

        NOTE: this method does not check whether dest exist and will overwrite it if it does.

        Throws:
        IOException
      • copy

        @Deprecated
        public static void copy​(Directory src,
                                Directory dest,
                                boolean closeDirSrc)
                         throws IOException
        Deprecated.
        should be replaced with calls to copy(Directory, String, String) for every file that needs copying. You can use the following code:
         IndexFileNameFilter filter = IndexFileNameFilter.getFilter();
         for (String file : src.listAll()) {
           if (filter.accept(null, file)) {
             src.copy(dest, file, file);
           }
         }
         
        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).

        Parameters:
        src - source directory
        dest - destination directory
        closeDirSrc - if true, call close() method on source directory
        Throws:
        IOException