LCOV - lcov.info - /usr/include/xapian/termgenerator.h

LTP GCOV extension - code coverage report
Current view: | directory - usr/include/xapian - termgenerator.h
Test: | lcov.info
Date: | 2008-08-14 |  | Instrumented lines: | 2
Code covered: | 100.0 % |  | Executed lines: | 2

           1                 : /** @file termgenerator.h
           2                 :  * @brief parse free text and generate terms
           3                 :  */
           4                 : /* Copyright (C) 2007 Olly Betts
           5                 :  *
           6                 :  * This program is free software; you can redistribute it and/or modify
           7                 :  * it under the terms of the GNU General Public License as published by
           8                 :  * the Free Software Foundation; either version 2 of the License, or
           9                 :  * (at your option) any later version.
          10                 :  *
          11                 :  * This program is distributed in the hope that it will be useful,
          12                 :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
          13                 :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
          14                 :  * GNU General Public License for more details.
          15                 :  *
          16                 :  * You should have received a copy of the GNU General Public License
          17                 :  * along with this program; if not, write to the Free Software
          18                 :  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
          19                 :  */
          20                 :
          21                 : #ifndef XAPIAN_INCLUDED_TERMGENERATOR_H
          22                 : #define XAPIAN_INCLUDED_TERMGENERATOR_H
          23                 :
          24                 : #include <xapian/base.h>
          25                 : #include <xapian/types.h>
          26                 : #include <xapian/unicode.h>
          27                 : #include <xapian/visibility.h>
          28                 :
          29                 : #include <string>
          30                 :
          31                 : namespace Xapian {
          32                 :
          33                 : class Document;
          34                 : class Stem;
          35                 : class Stopper;
          36                 : class WritableDatabase;
          37                 :
          38                 : /** Parses a piece of text and generate terms.
          39                 :  *
          40                 :  * This module takes a piece of text and parses it to produce words which are
          41                 :  * then used to generate suitable terms for indexing.  The terms generated are
          42                 :  * suitable for use with Query objects produced by the QueryParser class.
          43                 :  */
          44                 : class XAPIAN_VISIBILITY_DEFAULT TermGenerator {
          45                 :   public:
          46                 :     /// @private @internal Class representing the TermGenerator internals.
          47                 :     class Internal;
          48                 :     /// @private @internal Reference counted internals.
          49                 :     Xapian::Internal::RefCntPtr<Internal> internal;
          50                 :
          51                 :     /// Copy constructor.
          52                 :     TermGenerator(const TermGenerator & o);
          53                 :
          54                 :     /// Assignment.
          55                 :     TermGenerator & operator=(const TermGenerator & o);
          56                 :
          57                 :     /// Default constructor.
          58                 :     TermGenerator();
          59                 :
          60                 :     /// Destructor.
          61                 :     ~TermGenerator();
          62                 :
          63                 :     /// Set the Xapian::Stem object to be used for generating stemmed terms.
          64                 :     void set_stemmer(const Xapian::Stem & stemmer);
          65                 :
          66                 :     /// Set the Xapian::Stopper object to be used for identifying stopwords.
          67                 :     void set_stopper(const Xapian::Stopper *stop = NULL);
          68                 :
          69                 :     /// Set the current document.
          70                 :     void set_document(const Xapian::Document & doc);
          71                 :
          72                 :     /// Get the current document.
          73                 :     const Xapian::Document & get_document() const;
          74                 :
          75                 :     /// Set the database to index spelling data to.
          76                 :     void set_database(const Xapian::WritableDatabase &db);
          77                 :
          78                 :     /// Flags to OR together and pass to TermGenerator::set_flags().
          79                 :     enum flags {
          80                 :         /// Index data required for spelling correction.
          81                 :         FLAG_SPELLING = 128 // Value matches QueryParser flag.
          82                 :     };
          83                 :
          84                 :     /** Set flags.
          85                 :      *
          86                 :      *  The new value of flags is: (flags & mask) ^ toggle
          87                 :      *
          88                 :      *  To just set the flags, pass the new flags in toggle and the
          89                 :      *  default value for mask.
          90                 :      *
          91                 :      *  @param toggle   Flags to XOR.
          92                 :      *  @param mask     Flags to AND with first.
          93                 :      *
          94                 :      *  @return         The old flags setting.
          95                 :      */
          96                 :     flags set_flags(flags toggle, flags mask = flags(0));
          97                 :
          98                 :     /** Index some text.
          99                 :      *
         100                 :      * @param weight    The wdf increment (default 1).
         101                 :      * @param prefix    The term prefix to use (default is no prefix).
         102                 :      */
         103                 :     void index_text(const Xapian::Utf8Iterator & itor,
         104                 :                     Xapian::termcount weight = 1,
         105                 :                     const std::string & prefix = "");
         106                 :
         107                 :     /** Index some text in a std::string.
         108                 :      *
         109                 :      * @param weight    The wdf increment (default 1).
         110                 :      * @param prefix    The term prefix to use (default is no prefix).
         111                 :      */
         112                 :     void index_text(const std::string & text,
         113                 :                     Xapian::termcount weight = 1,
         114                 :                     const std::string & prefix = "") {
         115                 :         return index_text(Utf8Iterator(text), weight, prefix);
         116                 :     }
         117                 :
         118                 :     /** Index some text without positional information.
         119                 :      *
         120                 :      * Just like index_text, but no positional information is generated.  This
         121                 :      * means that the database will be significantly smaller, but that phrase
         122                 :      * searching and NEAR won't be supported.
         123                 :      */
         124                 :     void index_text_without_positions(const Xapian::Utf8Iterator & itor,
         125                 :                                       Xapian::termcount weight = 1,
         126                 :                                       const std::string & prefix = "");
         127                 :
         128                 :     /** Index some text in a std::string without positional information.
         129                 :      *
         130                 :      * Just like index_text, but no positional information is generated.  This
         131                 :      * means that the database will be significantly smaller, but that phrase
         132                 :      * searching and NEAR won't be supported.
         133                 :      */
         134                 :     void index_text_without_positions(const std::string & text,
         135                 :                                       Xapian::termcount weight = 1,
         136            5208 :                                       const std::string & prefix = "") {
         137            5208 :         return index_text_without_positions(Utf8Iterator(text), weight, prefix);
         138                 :     }
         139                 :
         140                 :     /** Increase the termpos used by index_text by @a delta.
         141                 :      *
         142                 :      *  This can be used to prevent phrase searches from spanning two
         143                 :      *  unconnected blocks of text (e.g. the title and body text).
         144                 :      */
         145                 :     void increase_termpos(Xapian::termcount delta = 100);
         146                 :
         147                 :     /// Get the current term position.
         148                 :     Xapian::termcount get_termpos() const;
         149                 :
         150                 :     /// Set the current term position.
         151                 :     void set_termpos(Xapian::termcount termpos);
         152                 :
         153                 :     /// Return a string describing this object.
         154                 :     std::string get_description() const;
         155                 : };
         156                 :
         157                 : }
         158                 :
         159                 : #endif // XAPIAN_INCLUDED_TERMGENERATOR_H

Generated by: LTP GCOV extension version 1.6