Logo Search packages:      
Sourcecode: qt4-x11 version File versions

FieldInfos.h

/*------------------------------------------------------------------------------
* 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_FieldInfos_
#define _lucene_index_FieldInfos_

#if defined(_LUCENE_PRAGMA_ONCE)
# pragma once
#endif

#include "CLucene/store/Directory.h"
#include "CLucene/document/Document.h"
#include "CLucene/document/Field.h"
#include "CLucene/util/VoidMap.h"
#include "CLucene/util/VoidList.h"

CL_NS_DEF(index)

class FieldInfo :LUCENE_BASE{
  public:
      //name of the field
      const TCHAR*     name;

    //Is field indexed? true = yes false = no
      bool        isIndexed;

      //field number
      const int32_t number;

      // true if term vector for this field should be stored
      bool storeTermVector;
      bool storeOffsetWithTermVector;
      bool storePositionWithTermVector;

      bool omitNorms; // omit norms associated with indexed fields

      //Func - Constructor
      //       Initialises FieldInfo.
      //       na holds the name of the field
      //       tk indicates whether this field is indexed or not
      //       nu indicates its number
      //Pre  - na != NULL and holds the name of the field
      //       tk is true or false
      //       number >= 0
      //Post - The FieldInfo instance has been created and initialized.
      //       name holds the duplicated string of na
      //       isIndexed = tk
      //       number = nu  
      FieldInfo(const TCHAR* fieldName, 
            const bool isIndexed, 
            const int32_t fieldNumber, 
            const bool storeTermVector,
            const bool storeOffsetWithTermVector,
            const bool storePositionWithTermVector,
            const bool omitNorms);

    //Func - Destructor
      //Pre  - true
      //Post - The instance has been destroyed
      ~FieldInfo();
};

/** Access to the Field Info file that describes document fields and whether or
*  not they are indexed. Each segment has a separate Field Info file. Objects
*  of this class are thread-safe for multiple readers, but only one thread can
*  be adding documents at a time, with no other reader or writer threads
*  accessing this object.
*/
00072 class FieldInfos :LUCENE_BASE{
private:
      //we now use internd field names, so we can use the voidCompare
      //to directly compare the strings
      typedef CL_NS(util)::CLHashMap<const TCHAR*,FieldInfo*,
          CL_NS(util)::Compare::TChar,CL_NS(util)::Equals::TChar > defByName;
      defByName byName;
            
            CL_NS(util)::CLArrayList<FieldInfo*,CL_NS(util)::Deletor::Object<FieldInfo> > byNumber;
            
public:
      enum{
            IS_INDEXED = 0x1,
            STORE_TERMVECTOR = 0x2,
            STORE_POSITIONS_WITH_TERMVECTOR = 0x4,
            STORE_OFFSET_WITH_TERMVECTOR = 0x8,
            OMIT_NORMS = 0x10
      };

      FieldInfos();
      ~FieldInfos();

      /**
      * Construct a FieldInfos object using the directory and the name of the file
      * IndexInput
      * @param d The directory to open the IndexInput from
      * @param name The name of the file to open the IndexInput from in the Directory
      * @throws IOException
   * 
   * @see #read
      */
      FieldInfos(CL_NS(store)::Directory* d, const char* name);

      int32_t fieldNumber(const TCHAR* fieldName)const;
      
      /**
      * Return the fieldinfo object referenced by the fieldNumber.
      * @param fieldNumber
      * @return the FieldInfo object or null when the given fieldNumber
      * doesn't exist.
      */ 
      FieldInfo* fieldInfo(const TCHAR* fieldName) const;
      
      /**
      * Return the fieldName identified by its number.
      * 
      * @param fieldNumber
      * @return the fieldName or an empty string when the field
      * with the given number doesn't exist.
      */  
      const TCHAR* fieldName(const int32_t fieldNumber)const;

      FieldInfo* fieldInfo(const int32_t fieldNumber) const;

      int32_t size()const;

      bool hasVectors() const;

      // Adds field info for a Document. 
      void add(const CL_NS(document)::Document* doc);

      // Merges in information from another FieldInfos. 
      void add(FieldInfos* other);
      
      
      /** If the field is not yet known, adds it. If it is known, checks to make
      *  sure that the isIndexed flag is the same as was given previously for this
      *  field. If not - marks it as being indexed.  Same goes for the TermVector
      * parameters.
      * 
      * @param name The name of the field
      * @param isIndexed true if the field is indexed
      * @param storeTermVector true if the term vector should be stored
      * @param storePositionWithTermVector true if the term vector with positions should be stored
      * @param storeOffsetWithTermVector true if the term vector with offsets should be stored
      */
      void add(const TCHAR* name, const bool isIndexed, const bool storeTermVector=false,
                bool storePositionWithTermVector=false, bool storeOffsetWithTermVector=false, bool omitNorms=false);
      
      /**
      * Assumes the fields are not storing term vectors 
      * @param names The names of the fields
      * @param isIndexed true if the field is indexed
      * @param storeTermVector true if the term vector should be stored
      * 
      * @see #add(String, boolean)
      */
      void add(const TCHAR** names, const bool isIndexed, const bool storeTermVector=false,
              bool storePositionWithTermVector=false, bool storeOffsetWithTermVector=false, bool omitNorms=false);

      void write(CL_NS(store)::Directory* d, const char* name) const;
      void write(CL_NS(store)::IndexOutput* output) const;

private:
      void read(CL_NS(store)::IndexInput* input);
      void addInternal( const TCHAR* name,const bool isIndexed, const bool storeTermVector,
            const bool storePositionWithTermVector, const bool storeOffsetWithTermVector, const bool omitNorms);

};
CL_NS_END
#endif

Generated by  Doxygen 1.6.0   Back to index