summaryrefslogtreecommitdiffstats
path: root/3rdparty/clucene/src/CLucene/store/FSDirectory.h
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/clucene/src/CLucene/store/FSDirectory.h')
-rw-r--r--3rdparty/clucene/src/CLucene/store/FSDirectory.h216
1 files changed, 216 insertions, 0 deletions
diff --git a/3rdparty/clucene/src/CLucene/store/FSDirectory.h b/3rdparty/clucene/src/CLucene/store/FSDirectory.h
new file mode 100644
index 000000000..e967380e0
--- /dev/null
+++ b/3rdparty/clucene/src/CLucene/store/FSDirectory.h
@@ -0,0 +1,216 @@
+/*
+ * Copyright (C) 2003-2006 Ben van Klinken and the CLucene Team
+ *
+ * Distributable under the terms of either the Apache License (Version 2.0) or
+ * the GNU Lesser General Public License, as specified in the COPYING file.
+ *
+ * Changes are Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+*/
+#ifndef _lucene_store_FSDirectory_
+#define _lucene_store_FSDirectory_
+
+#if defined(_LUCENE_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#include <QtCore/QFile>
+#include <QtCore/QString>
+#include <QtCore/QStringList>
+
+#include "Directory.h"
+#include "Lock.h"
+#include "CLucene/util/VoidMap.h"
+#include "CLucene/util/StringBuffer.h"
+
+CL_NS_DEF(store)
+
+/**
+* Straightforward implementation of {@link Directory} as a directory of files.
+* <p>If the system property 'disableLuceneLocks' has the String value of
+* "true", lock creation will be disabled.
+*
+* @see Directory
+*/
+class FSDirectory : public Directory
+{
+public:
+ // Destructor - only call this if you are sure the directory
+ // is not being used anymore. Otherwise use the ref-counting
+ // facilities of _CLDECDELETE
+ ~FSDirectory();
+
+ // Get a list of strings, one for each file in the directory.
+ QStringList list() const;
+
+ // Returns true iff a file with the given name exists.
+ bool fileExists(const QString& name) const;
+
+ // Returns the text name of the directory
+ QString getDirName() const; ///<returns reference
+
+ /**
+ Returns the directory instance for the named location.
+
+ Do not delete this instance, only use close, otherwise other instances
+ will lose this instance.
+
+ <p>Directories are cached, so that, for a given canonical path, the same
+ FSDirectory instance will always be returned. This permits
+ synchronization on directories.
+
+ @param file the path to the directory.
+ @param create if true, create, or erase any existing contents.
+ @return the FSDirectory for the named file.
+ */
+ static FSDirectory* getDirectory(const QString& file, const bool create);
+
+ // Returns the time the named file was last modified.
+ int64_t fileModified(const QString& name) const;
+
+ //static
+ // Returns the time the named file was last modified.
+ static int64_t fileModified(const QString& dir, const QString& name);
+
+ // static
+ // Returns the length in bytes of a file in the directory.
+ int64_t fileLength(const QString& name) const;
+
+ // Returns a stream reading an existing file.
+ IndexInput* openInput(const QString& name);
+ IndexInput* openInput(const QString& name, int32_t bufferSize);
+
+ // Renames an existing file in the directory.
+ void renameFile(const QString& from, const QString& to);
+
+ // Set the modified time of an existing file to now.
+ void touchFile(const QString& name);
+
+ // Creates a new, empty file in the directory with the given name.
+ // Returns a stream writing this file.
+ IndexOutput* createOutput(const QString& name);
+
+ // Construct a {@link Lock}.
+ // @param name the name of the lock file
+ LuceneLock* makeLock(const QString& name);
+
+ // Decrease the ref-count to the directory by one. If the object is no
+ // longer needed, then the object is removed from the directory pool.
+ void close();
+
+ // If MMap is available, this can disable use of mmap reading.
+ void setUseMMap(bool value) { useMMap = value; }
+
+ // Gets whether the directory is using MMap for inputstreams.
+ bool getUseMMap() const { return useMMap; }
+
+ QString toString() const;
+
+ static QString DirectoryType() { return QLatin1String("FS"); }
+ QString getDirectoryType() const { return QLatin1String("FS"); }
+
+ // Set whether Lucene's use of lock files is disabled. By default,
+ // lock files are enabled. They should only be disabled if the index
+ // is on a read-only medium like a CD-ROM.
+ static void setDisableLocks(bool doDisableLocks)
+ { disableLocks = doDisableLocks; }
+
+ // Returns whether Lucene's use of lock files is disabled.
+ // @return true if locks are disabled, false if locks are enabled.
+ static bool getDisableLocks() { return disableLocks; }
+
+protected:
+ FSDirectory(const QString& path, const bool createDir);
+ // Removes an existing file in the directory.
+ bool doDeleteFile(const QString& name);
+
+private:
+ class FSLock : public LuceneLock {
+ public:
+ FSLock (const QString& lockDir, const QString& name);
+ ~FSLock();
+
+ bool obtain();
+ void release();
+ bool isLocked();
+ QString toString() const;
+
+ QString lockDir;
+ QString lockFile;
+ };
+ friend class FSDirectory::FSLock;
+
+ class FSIndexInput : public BufferedIndexInput {
+ public:
+ FSIndexInput(const QString& path, int32_t bufferSize =
+ CL_NS(store)::BufferedIndexOutput::BUFFER_SIZE);
+ ~FSIndexInput();
+
+ void close();
+ IndexInput* clone() const;
+
+ int64_t length()
+ { return handle->_length; }
+
+ QString getDirectoryType() const
+ { return FSDirectory::DirectoryType(); }
+
+ protected:
+ FSIndexInput(const FSIndexInput& clone);
+ // Random-access methods
+ void seekInternal(const int64_t position);
+ // IndexInput methods
+ void readInternal(uint8_t* b, const int32_t len);
+
+ private:
+ // We used a shared handle between all the fsindexinput clones.
+ // This reduces number of file handles we need, and it means
+ // we dont have to use file tell (which is slow) before doing a read.
+ class SharedHandle : LUCENE_REFBASE {
+ public:
+ SharedHandle();
+ ~SharedHandle();
+
+ int64_t _fpos;
+ int64_t _length;
+
+ QFile fhandle;
+ DEFINE_MUTEX(*THIS_LOCK)
+ };
+ SharedHandle* handle;
+ int64_t _pos;
+ };
+ friend class FSDirectory::FSIndexInput;
+
+ class FSIndexOutput : public BufferedIndexOutput {
+ public:
+ FSIndexOutput(const QString& path);
+ ~FSIndexOutput();
+
+ void close();
+ int64_t length();
+ void seek(const int64_t pos);
+
+ protected:
+ void flushBuffer(const uint8_t* b, const int32_t size);
+
+ private:
+ QFile fhandle;
+ };
+ friend class FSDirectory::FSIndexOutput;
+
+private:
+ QString directory;
+ int refCount;
+ void create();
+
+ QString lockDir;
+ QString getLockPrefix() const;
+ static bool disableLocks;
+
+ void priv_getFN(QString& buffer, const QString& name) const;
+ bool useMMap;
+};
+
+CL_NS_END
+
+#endif