1 files changed, 195 insertions, 0 deletions
diff --git a/3rdparty/clucene/src/CLucene/store/RAMDirectory.h b/3rdparty/clucene/src/CLucene/store/RAMDirectory.h
new file mode 100644
index 000000000..af92e30b2
--- /dev/null
+++ b/3rdparty/clucene/src/CLucene/store/RAMDirectory.h
@@ -0,0 +1,195 @@
+/*
+ * 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_RAMDirectory_
+#define _lucene_store_RAMDirectory_
+
+#if defined(_LUCENE_PRAGMA_ONCE)
+#   pragma once
+#endif
+
+#include <QtCore/QString>
+#include <QtCore/QStringList>
+
+#include "Lock.h"
+#include "Directory.h"
+#include "CLucene/util/VoidMap.h"
+#include "CLucene/util/Arrays.h"
+
+CL_NS_DEF(store)
+
+class RAMFile : LUCENE_BASE
+{
+public:
+    CL_NS(util)::CLVector<uint8_t*, CL_NS(util)::Deletor::Array<uint8_t> > buffers;
+    int64_t length;
+    uint64_t lastModified;
+
+#ifdef _DEBUG
+    QString filename;
+#endif
+
+    RAMFile();
+    ~RAMFile();
+};
+
+class RAMIndexOutput : public BufferedIndexOutput
+{
+protected:
+    RAMFile* file;
+    int32_t pointer;
+    bool deleteFile;
+
+    // output methods: 
+    void flushBuffer(const uint8_t* src, const int32_t len);
+
+public:
+    RAMIndexOutput(RAMFile* f);
+    RAMIndexOutput();
+    /** Construct an empty output buffer. */
+    virtual ~RAMIndexOutput();
+
+    virtual void close();
+
+    // Random-at methods
+    virtual void seek(const int64_t pos);
+    int64_t length();
+    /** Resets this to an empty buffer. */
+    void reset();
+    /** Copy the current contents of this buffer to the named output. */
+    void writeTo(IndexOutput* output);
+};
+
+class RAMIndexInput : public BufferedIndexInput
+{
+private:
+    RAMFile* file;
+    int32_t pointer;
+    int64_t _length;
+
+protected:
+    /** IndexInput methods */
+    RAMIndexInput(const RAMIndexInput& clone);
+    void readInternal(uint8_t *dest, const int32_t len);
+
+    /** Random-at methods */
+    void seekInternal(const int64_t pos);
+
+public:
+    RAMIndexInput(RAMFile* f);
+    ~RAMIndexInput();
+    IndexInput* clone() const;
+
+    void close();
+    int64_t length();
+    QString getDirectoryType() const;
+};
+
+
+/**
+* A memory-resident {@link Directory} implementation.
+*/
+class RAMDirectory : public Directory
+{
+    class RAMLock : public LuceneLock
+    {
+    private:
+        RAMDirectory* directory;
+        QString fname;
+    public:
+        RAMLock(const QString& name, RAMDirectory* dir);
+        virtual ~RAMLock();
+        bool obtain();
+        void release();
+        bool isLocked();
+        virtual QString toString() const;
+    };
+
+    typedef CL_NS(util)::CLHashMap<QString, RAMFile*,
+        CL_NS(util)::Compare::Qstring, CL_NS(util)::Equals::Qstring,
+        CL_NS(util)::Deletor::DummyQString,
+        CL_NS(util)::Deletor::Object<RAMFile> > FileMap;
+
+protected:
+    /// Removes an existing file in the directory. 
+    virtual bool doDeleteFile(const QString& name);
+
+    /**
+    * Creates a new <code>RAMDirectory</code> instance from a different
+    * <code>Directory</code> implementation.  This can be used to load
+    * a disk-based index into memory.
+    * <P>
+    * This should be used only with indices that can fit into memory.
+    *
+    * @param dir a <code>Directory</code> value
+    * @exception IOException if an error occurs
+    */
+    void _copyFromDir(Directory* dir, bool closeDir);
+    FileMap files; // unlike the java Hashtable, FileMap is not synchronized, and all access must be protected by a lock
+
+public:
+#ifndef _CL_DISABLE_MULTITHREADING //do this so that the mutable keyword still works without mt enabled
+    mutable DEFINE_MUTEX(files_mutex) // mutable: const methods must also be able to synchronize properly
+#endif
+
+    // Returns a null terminated array of strings, one for each file in the directory. 
+    QStringList list() const;
+
+    /** Constructs an empty {@link Directory}. */
+    RAMDirectory();
+
+    // Destructor - only call this if you are sure the directory
+    // is not being used anymore. Otherwise use the ref-counting
+    // facilities of dir->close
+    virtual ~RAMDirectory();
+    RAMDirectory(Directory* dir);
+
+    /**
+    * Creates a new <code>RAMDirectory</code> instance from the {@link FSDirectory}.
+    *
+    * @param dir a <code>String</code> specifying the full index directory path
+    */
+    RAMDirectory(const QString& dir);
+
+    /// Returns true iff the named file exists in this directory. 
+    bool fileExists(const QString& name) const;
+
+    /// Returns the time the named file was last modified. 
+    int64_t fileModified(const QString& name) const;
+
+    /// Returns the length in bytes of a file in the directory. 
+    int64_t fileLength(const QString& name) const;
+
+    /// Removes an existing file in the directory. 
+    virtual 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. 
+    virtual IndexOutput* createOutput(const QString& name);
+
+    /// Construct a {@link Lock}.
+    /// @param name the name of the lock file
+    LuceneLock* makeLock(const QString& name);
+
+    /// Returns a stream reading an existing file. 
+    IndexInput* openInput(const QString& name);
+
+    virtual void close();
+
+    QString toString() const;
+
+    static QString DirectoryType() { return QLatin1String("RAM"); }
+    QString getDirectoryType() const { return DirectoryType(); }
+};
+
+CL_NS_END
+
+#endif