CLucene - a full-featured, c++ search engine
API Documentation

---

CompoundFile.h

Go to the documentation of this file.

/*------------------------------------------------------------------------------
* 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.
------------------------------------------------------------------------------*/
#ifndef _lucene_index_compoundfile_h
#define _lucene_index_compoundfile_h

#if defined(_LUCENE_PRAGMA_ONCE)
# pragma once
#endif

#include "CLucene/store/IndexInput.h"
#include "CLucene/store/IndexOutput.h"
#include "CLucene/store/Directory.h"
#include "CLucene/store/Lock.h"
#include "CLucene/util/VoidList.h"
#include "CLucene/util/VoidMap.h"


CL_NS_DEF(index)



class CompoundFileReader: public CL_NS(store)::Directory {
private:
    class CSIndexInput:public CL_NS(store)::BufferedIndexInput {
        private:
                CL_NS(store)::IndexInput* base;
                int64_t fileOffset;
                int64_t _length;
        protected:
                void readInternal(uint8_t* b, const int32_t len);
                void seekInternal(const int64_t pos)
                {
                }

        public:
                CSIndexInput(CL_NS(store)::IndexInput* base, const int64_t fileOffset, const int64_t length);
                CSIndexInput(const CSIndexInput& clone);
                ~CSIndexInput();

                void close();
                CL_NS(store)::IndexInput* clone() const;

                int64_t length(){ return _length; }
                
                const char* getDirectoryType() const{ return CompoundFileReader::DirectoryType(); }
        };

        class FileEntry:LUCENE_BASE {
        public:
                int64_t offset;
                int64_t length;
                FileEntry(){
                        offset=0;
                        length=0;
                }
                ~FileEntry(){
                }
        };

        // Base info
        CL_NS(store)::Directory* directory;
        char fileName[CL_MAX_PATH];

        CL_NS(store)::IndexInput* stream;

    typedef CL_NS(util)::CLHashMap<const char*,FileEntry*,
                CL_NS(util)::Compare::Char,
                CL_NS(util)::Equals::Char,
                CL_NS(util)::Deletor::acArray,
                CL_NS(util)::Deletor::Object<FileEntry> > EntriesType;
        EntriesType entries;
protected:
        bool doDeleteFile(const char* name);

public:
        CompoundFileReader(CL_NS(store)::Directory* dir, char* name);
        ~CompoundFileReader();
        CL_NS(store)::Directory* getDirectory();
        const char* getName() const;

        void close();
        CL_NS(store)::IndexInput* openInput(const char* id);

        void list(vector<string>* names) const;
        bool fileExists(const char* name) const;
        int64_t fileModified(const char* name) const;
        void touchFile(const char* name);
        void renameFile(const char* from, const char* to);
    int64_t fileLength(const char* name) const;
    CL_NS(store)::IndexOutput* createOutput(const char* name);
        CL_NS(store)::LuceneLock* makeLock(const char* name);

        TCHAR* toString() const;
        
        static const char* DirectoryType(){ return "CFS"; }
        const char* getDirectoryType() const{ return DirectoryType(); }
};


class CompoundFileWriter:LUCENE_BASE {
        class WriterFileEntry:LUCENE_BASE {
        public:
                WriterFileEntry(){
                        directoryOffset=0;
                        dataOffset=0;
                }
                ~WriterFileEntry(){
                }
                char file[CL_MAX_PATH];

                int64_t directoryOffset;

                int64_t dataOffset;

        };

        CL_NS(store)::Directory* directory;
        char fileName[CL_MAX_PATH];
        CL_NS(util)::CLHashSet<const char*,
                CL_NS(util)::Compare::Char,CL_NS(util)::Deletor::acArray> ids;
        CL_NS(util)::CLLinkedList<WriterFileEntry*,
                CL_NS(util)::Deletor::Object<WriterFileEntry> > entries;
        bool merged;
        void copyFile(WriterFileEntry* source, CL_NS(store)::IndexOutput* os, uint8_t* buffer, int32_t bufferLength);
public:
        CompoundFileWriter(CL_NS(store)::Directory* dir, const char* name);
        ~CompoundFileWriter();
        CL_NS(store)::Directory* getDirectory();
        const char* getName() const ;
        void addFile(const char* file);
        void close();
};

CL_NS_END
#endif

---

clucene.sourceforge.net