LCOV - code coverage report
Current view: top level - api - postingsource.cc (source / functions) Hit Total Coverage
Test: Test Coverage for xapian-core c2b6f1024d3a Lines: 222 243 91.4 %
Date: 2019-05-16 09:13:18 Functions: 53 56 94.6 %
Branches: 136 250 54.4 %

           Branch data     Line data    Source code
       1                 :            : /** @file postingsource.cc
       2                 :            :  * @brief External sources of posting information
       3                 :            :  */
       4                 :            : /* Copyright (C) 2008,2009,2010,2011,2012,2015,2016,2017 Olly Betts
       5                 :            :  * Copyright (C) 2008,2009 Lemur Consulting Ltd
       6                 :            :  * Copyright (C) 2010 Richard Boulton
       7                 :            :  *
       8                 :            :  * This program is free software; you can redistribute it and/or
       9                 :            :  * modify it under the terms of the GNU General Public License as
      10                 :            :  * published by the Free Software Foundation; either version 2 of the
      11                 :            :  * License, or (at your option) any later version.
      12                 :            :  *
      13                 :            :  * This program is distributed in the hope that it will be useful,
      14                 :            :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      15                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      16                 :            :  * GNU General Public License for more details.
      17                 :            :  *
      18                 :            :  * You should have received a copy of the GNU General Public License
      19                 :            :  * along with this program; if not, write to the Free Software
      20                 :            :  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
      21                 :            :  */
      22                 :            : 
      23                 :            : #include <config.h>
      24                 :            : 
      25                 :            : #include "xapian/postingsource.h"
      26                 :            : 
      27                 :            : #include "backends/databaseinternal.h"
      28                 :            : #include "backends/documentinternal.h"
      29                 :            : #include "matcher/postlisttree.h"
      30                 :            : 
      31                 :            : #include "xapian/document.h"
      32                 :            : #include "xapian/error.h"
      33                 :            : #include "xapian/queryparser.h" // For sortable_unserialise().
      34                 :            : 
      35                 :            : #include "omassert.h"
      36                 :            : #include "net/length.h"
      37                 :            : #include "serialise-double.h"
      38                 :            : #include "str.h"
      39                 :            : 
      40                 :            : #include <cfloat>
      41                 :            : #include <memory>
      42                 :            : 
      43                 :            : using namespace std;
      44                 :            : 
      45                 :            : namespace Xapian {
      46                 :            : 
      47         [ -  + ]:      18514 : PostingSource::~PostingSource() { }
      48                 :            : 
      49                 :            : void
      50                 :       5018 : PostingSource::set_maxweight(double max_weight)
      51                 :            : {
      52                 :       5018 :     max_weight_ = max_weight;
      53         [ +  + ]:       5018 :     if (usual(matcher_)) {
      54                 :        363 :         PostListTree* pltree = static_cast<PostListTree*>(matcher_);
      55                 :        363 :         pltree->force_recalc();
      56                 :            :     }
      57                 :       5018 : }
      58                 :            : 
      59                 :            : double
      60                 :          0 : PostingSource::get_weight() const
      61                 :            : {
      62                 :          0 :     return 0;
      63                 :            : }
      64                 :            : 
      65                 :            : void
      66                 :          0 : PostingSource::skip_to(Xapian::docid did, double min_wt)
      67                 :            : {
      68 [ #  # ][ #  # ]:          0 :     while (!at_end() && get_docid() < did) {
                 [ #  # ]
      69                 :          0 :         next(min_wt);
      70                 :            :     }
      71                 :          0 : }
      72                 :            : 
      73                 :            : bool
      74                 :         55 : PostingSource::check(Xapian::docid did, double min_wt)
      75                 :            : {
      76                 :         55 :     skip_to(did, min_wt);
      77                 :         55 :     return true;
      78                 :            : }
      79                 :            : 
      80                 :            : PostingSource *
      81                 :         16 : PostingSource::clone() const
      82                 :            : {
      83                 :         16 :     return NULL;
      84                 :            : }
      85                 :            : 
      86                 :            : string
      87                 :          4 : PostingSource::name() const
      88                 :            : {
      89                 :          4 :     return string();
      90                 :            : }
      91                 :            : 
      92                 :            : string
      93                 :          5 : PostingSource::serialise() const
      94                 :            : {
      95 [ +  - ][ +  - ]:          5 :     throw Xapian::UnimplementedError("serialise() not supported for this PostingSource");
                 [ +  - ]
      96                 :            : }
      97                 :            : 
      98                 :            : PostingSource *
      99                 :          1 : PostingSource::unserialise(const string &) const
     100                 :            : {
     101 [ +  - ][ +  - ]:          1 :     throw Xapian::UnimplementedError("unserialise() not supported for this PostingSource");
                 [ +  - ]
     102                 :            : }
     103                 :            : 
     104                 :            : PostingSource *
     105                 :         41 : PostingSource::unserialise_with_registry(const std::string &s,
     106                 :            :                                          const Registry &) const
     107                 :            : {
     108                 :         41 :     return unserialise(s);
     109                 :            : }
     110                 :            : 
     111                 :            : string
     112                 :          0 : PostingSource::get_description() const
     113                 :            : {
     114         [ #  # ]:          0 :     return "Xapian::PostingSource subclass";
     115                 :            : }
     116                 :            : 
     117                 :            : Xapian::doccount
     118                 :        135 : ValuePostingSource::get_termfreq_min() const
     119                 :            : {
     120                 :        135 :     return termfreq_min;
     121                 :            : }
     122                 :            : 
     123                 :            : Xapian::doccount
     124                 :        159 : ValuePostingSource::get_termfreq_est() const
     125                 :            : {
     126                 :        159 :     return termfreq_est;
     127                 :            : }
     128                 :            : 
     129                 :            : Xapian::doccount
     130                 :        135 : ValuePostingSource::get_termfreq_max() const
     131                 :            : {
     132                 :        135 :     return termfreq_max;
     133                 :            : }
     134                 :            : 
     135                 :            : void
     136                 :        983 : ValuePostingSource::next(double min_wt)
     137                 :            : {
     138         [ +  + ]:        983 :     if (!started) {
     139                 :        173 :         started = true;
     140         [ +  - ]:        173 :         value_it = db.valuestream_begin(slot);
     141                 :            :     } else {
     142                 :        810 :         ++value_it;
     143                 :            :     }
     144                 :            : 
     145         [ +  + ]:        983 :     if (value_it == db.valuestream_end(slot)) return;
     146                 :            : 
     147         [ -  + ]:        823 :     if (min_wt > get_maxweight()) {
     148         [ #  # ]:          0 :         value_it = db.valuestream_end(slot);
     149                 :        983 :         return;
     150                 :            :     }
     151                 :            : }
     152                 :            : 
     153                 :            : void
     154                 :         76 : ValuePostingSource::skip_to(Xapian::docid min_docid, double min_wt)
     155                 :            : {
     156         [ +  + ]:         76 :     if (!started) {
     157                 :         12 :         started = true;
     158         [ +  - ]:         12 :         value_it = db.valuestream_begin(slot);
     159                 :            : 
     160         [ +  + ]:         12 :         if (value_it == db.valuestream_end(slot)) return;
     161                 :            :     }
     162                 :            : 
     163         [ -  + ]:         70 :     if (min_wt > get_maxweight()) {
     164         [ #  # ]:          0 :         value_it = db.valuestream_end(slot);
     165                 :          0 :         return;
     166                 :            :     }
     167                 :         76 :     value_it.skip_to(min_docid);
     168                 :            : }
     169                 :            : 
     170                 :            : bool
     171                 :        224 : ValuePostingSource::check(Xapian::docid min_docid, double min_wt)
     172                 :            : {
     173         [ +  + ]:        224 :     if (!started) {
     174                 :         36 :         started = true;
     175         [ +  - ]:         36 :         value_it = db.valuestream_begin(slot);
     176                 :            : 
     177         [ +  + ]:         36 :         if (value_it == db.valuestream_end(slot)) return true;
     178                 :            :     }
     179                 :            : 
     180         [ -  + ]:        218 :     if (min_wt > get_maxweight()) {
     181         [ #  # ]:          0 :         value_it = db.valuestream_end(slot);
     182                 :          0 :         return true;
     183                 :            :     }
     184                 :        224 :     return value_it.check(min_docid);
     185                 :            : }
     186                 :            : 
     187                 :            : bool
     188                 :       1837 : ValuePostingSource::at_end() const
     189                 :            : {
     190 [ +  + ][ +  + ]:       1837 :     return started && value_it == db.valuestream_end(slot);
                 [ +  + ]
     191                 :            : }
     192                 :            : 
     193                 :            : Xapian::docid
     194                 :       1375 : ValuePostingSource::get_docid() const
     195                 :            : {
     196                 :       1375 :     return value_it.get_docid();
     197                 :            : }
     198                 :            : 
     199                 :            : void
     200                 :        238 : ValuePostingSource::init(const Database & db_)
     201                 :            : {
     202                 :        238 :     db = db_;
     203                 :        238 :     started = false;
     204                 :        238 :     set_maxweight(DBL_MAX);
     205                 :            :     try {
     206         [ +  - ]:        238 :         termfreq_max = db.get_value_freq(slot);
     207                 :        238 :         termfreq_est = termfreq_max;
     208                 :        238 :         termfreq_min = termfreq_max;
     209         [ #  # ]:          0 :     } catch (const Xapian::UnimplementedError &) {
     210         [ #  # ]:          0 :         termfreq_max = db.get_doccount();
     211                 :          0 :         termfreq_est = termfreq_max / 2;
     212                 :          0 :         termfreq_min = 0;
     213                 :            :     }
     214                 :        238 : }
     215                 :            : 
     216                 :            : string
     217                 :          1 : ValuePostingSource::get_description() const
     218                 :            : {
     219         [ +  - ]:          1 :     string desc("Xapian::ValuePostingSource(slot=");
     220 [ +  - ][ +  - ]:          1 :     desc += str(get_slot());
     221         [ +  - ]:          1 :     desc += ")";
     222                 :          1 :     return desc;
     223                 :            : }
     224                 :            : 
     225                 :            : 
     226                 :       3251 : ValueWeightPostingSource::ValueWeightPostingSource(Xapian::valueno slot_)
     227                 :       3251 :         : ValuePostingSource(slot_)
     228                 :            : {
     229                 :       3251 : }
     230                 :            : 
     231                 :            : double
     232                 :        720 : ValueWeightPostingSource::get_weight() const
     233                 :            : {
     234                 :            :     Assert(!at_end());
     235                 :            :     Assert(get_started());
     236                 :        720 :     return sortable_unserialise(get_value());
     237                 :            : }
     238                 :            : 
     239                 :            : ValueWeightPostingSource *
     240                 :         85 : ValueWeightPostingSource::clone() const
     241                 :            : {
     242                 :         85 :     return new ValueWeightPostingSource(get_slot());
     243                 :            : }
     244                 :            : 
     245                 :            : string
     246                 :       1455 : ValueWeightPostingSource::name() const
     247                 :            : {
     248         [ +  - ]:       1455 :     return string("Xapian::ValueWeightPostingSource");
     249                 :            : }
     250                 :            : 
     251                 :            : string
     252                 :          8 : ValueWeightPostingSource::serialise() const
     253                 :            : {
     254                 :          8 :     return encode_length(get_slot());
     255                 :            : }
     256                 :            : 
     257                 :            : ValueWeightPostingSource *
     258                 :          8 : ValueWeightPostingSource::unserialise(const string &s) const
     259                 :            : {
     260                 :          8 :     const char * p = s.data();
     261                 :          8 :     const char * end = p + s.size();
     262                 :            : 
     263                 :            :     Xapian::valueno new_slot;
     264         [ +  - ]:          8 :     decode_length(&p, end, new_slot);
     265         [ -  + ]:          8 :     if (p != end) {
     266 [ #  # ][ #  # ]:          0 :         throw Xapian::NetworkError("Bad serialised ValueWeightPostingSource - junk at end");
                 [ #  # ]
     267                 :            :     }
     268                 :            : 
     269         [ +  - ]:          8 :     return new ValueWeightPostingSource(new_slot);
     270                 :            : }
     271                 :            : 
     272                 :            : void
     273                 :        184 : ValueWeightPostingSource::init(const Database & db_)
     274                 :            : {
     275         [ +  - ]:        184 :     ValuePostingSource::init(db_);
     276                 :            : 
     277         [ +  - ]:        184 :     string upper_bound;
     278                 :            :     try {
     279 [ +  - ][ +  - ]:        184 :         upper_bound = get_database().get_value_upper_bound(get_slot());
         [ +  - ][ #  # ]
     280                 :          0 :     } catch (const Xapian::UnimplementedError &) {
     281                 :            :         // ValuePostingSource::init() set the maxweight to DBL_MAX.
     282                 :        184 :         return;
     283                 :            :     }
     284                 :            : 
     285         [ +  + ]:        184 :     if (upper_bound.empty()) {
     286                 :            :         // This should only happen if there are no entries, in which case the
     287                 :            :         // maxweight is 0.
     288                 :         15 :         set_maxweight(0.0);
     289                 :            :     } else {
     290         [ +  - ]:        184 :         set_maxweight(sortable_unserialise(upper_bound));
     291                 :        184 :     }
     292                 :            : }
     293                 :            : 
     294                 :            : string
     295                 :          7 : ValueWeightPostingSource::get_description() const
     296                 :            : {
     297         [ +  - ]:          7 :     string desc("Xapian::ValueWeightPostingSource(slot=");
     298 [ +  - ][ +  - ]:          7 :     desc += str(get_slot());
     299         [ +  - ]:          7 :     desc += ")";
     300                 :          7 :     return desc;
     301                 :            : }
     302                 :            : 
     303                 :            : 
     304                 :       1513 : ValueMapPostingSource::ValueMapPostingSource(Xapian::valueno slot_)
     305                 :            :         : ValuePostingSource(slot_),
     306                 :            :           default_weight(0.0),
     307         [ +  - ]:       1513 :           max_weight_in_map(0.0)
     308                 :            : {
     309                 :       1513 : }
     310                 :            : 
     311                 :            : void
     312                 :        240 : ValueMapPostingSource::add_mapping(const string & key, double wt)
     313                 :            : {
     314                 :        240 :     weight_map[key] = wt;
     315                 :        240 :     max_weight_in_map = max(wt, max_weight_in_map);
     316                 :        240 : }
     317                 :            : 
     318                 :            : void
     319                 :          7 : ValueMapPostingSource::clear_mappings()
     320                 :            : {
     321                 :          7 :     weight_map.clear();
     322                 :          7 :     max_weight_in_map = 0.0;
     323                 :          7 : }
     324                 :            : 
     325                 :            : void
     326                 :         47 : ValueMapPostingSource::set_default_weight(double wt)
     327                 :            : {
     328                 :         47 :     default_weight = wt;
     329                 :         47 : }
     330                 :            : 
     331                 :            : double
     332                 :        238 : ValueMapPostingSource::get_weight() const
     333                 :            : {
     334 [ +  - ][ +  - ]:        238 :     map<string, double>::const_iterator wit = weight_map.find(get_value());
     335         [ +  + ]:        238 :     if (wit == weight_map.end()) {
     336                 :        168 :         return default_weight;
     337                 :            :     }
     338                 :        238 :     return wit->second;
     339                 :            : }
     340                 :            : 
     341                 :            : ValueMapPostingSource *
     342                 :         32 : ValueMapPostingSource::clone() const
     343                 :            : {
     344                 :            :     unique_ptr<ValueMapPostingSource> res(
     345 [ +  - ][ +  - ]:         32 :             new ValueMapPostingSource(get_slot()));
     346                 :         32 :     map<string, double>::const_iterator i;
     347         [ +  + ]:        182 :     for (i = weight_map.begin(); i != weight_map.end(); ++i) {
     348         [ +  - ]:        150 :         res->add_mapping(i->first, i->second);
     349                 :            :     }
     350                 :         32 :     res->set_default_weight(default_weight);
     351                 :         32 :     return res.release();
     352                 :            : }
     353                 :            : 
     354                 :            : string
     355                 :       1453 : ValueMapPostingSource::name() const
     356                 :            : {
     357         [ +  - ]:       1453 :     return string("Xapian::ValueMapPostingSource");
     358                 :            : }
     359                 :            : 
     360                 :            : string
     361                 :          6 : ValueMapPostingSource::serialise() const
     362                 :            : {
     363         [ +  - ]:          6 :     string result = encode_length(get_slot());
     364 [ +  - ][ +  - ]:          6 :     result += serialise_double(default_weight);
     365                 :            : 
     366                 :          6 :     map<string, double>::const_iterator i;
     367         [ +  + ]:         26 :     for (i = weight_map.begin(); i != weight_map.end(); ++i) {
     368 [ +  - ][ +  - ]:         20 :         result.append(encode_length(i->first.size()));
     369         [ +  - ]:         20 :         result.append(i->first);
     370 [ +  - ][ +  - ]:         20 :         result.append(serialise_double(i->second));
     371                 :            :     }
     372                 :            : 
     373                 :          6 :     return result;
     374                 :            : }
     375                 :            : 
     376                 :            : ValueMapPostingSource *
     377                 :          6 : ValueMapPostingSource::unserialise(const string &s) const
     378                 :            : {
     379                 :          6 :     const char * p = s.data();
     380                 :          6 :     const char * end = p + s.size();
     381                 :            : 
     382                 :            :     Xapian::valueno new_slot;
     383         [ +  - ]:          6 :     decode_length(&p, end, new_slot);
     384 [ +  - ][ +  - ]:          6 :     unique_ptr<ValueMapPostingSource> res(new ValueMapPostingSource(new_slot));
     385         [ +  - ]:          6 :     res->set_default_weight(unserialise_double(&p, end));
     386         [ +  + ]:         26 :     while (p != end) {
     387                 :            :         size_t keylen;
     388         [ +  - ]:         20 :         decode_length_and_check(&p, end, keylen);
     389         [ +  - ]:         20 :         string key(p, keylen);
     390                 :         20 :         p += keylen;
     391 [ +  - ][ +  - ]:         20 :         res->add_mapping(key, unserialise_double(&p, end));
     392                 :         20 :     }
     393                 :          6 :     return res.release();
     394                 :            : }
     395                 :            : 
     396                 :            : void
     397                 :         34 : ValueMapPostingSource::init(const Database & db_)
     398                 :            : {
     399                 :         34 :     ValuePostingSource::init(db_);
     400                 :         34 :     set_maxweight(max(max_weight_in_map, default_weight));
     401                 :         34 : }
     402                 :            : 
     403                 :            : string
     404                 :          7 : ValueMapPostingSource::get_description() const
     405                 :            : {
     406         [ +  - ]:          7 :     string desc("Xapian::ValueMapPostingSource(slot=");
     407 [ +  - ][ +  - ]:          7 :     desc += str(get_slot());
     408         [ +  - ]:          7 :     desc += ")";
     409                 :          7 :     return desc;
     410                 :            : }
     411                 :            : 
     412                 :       1525 : FixedWeightPostingSource::FixedWeightPostingSource(double wt)
     413         [ +  - ]:       1525 :     : started(false)
     414                 :            : {
     415                 :            :     // The weight is fixed at wt, so that's the maxweight too.  So just store wt
     416                 :            :     // as the maxweight and we can read it from there when we need it.
     417                 :       1525 :     set_maxweight(wt);
     418                 :       1525 : }
     419                 :            : 
     420                 :            : Xapian::doccount
     421                 :         16 : FixedWeightPostingSource::get_termfreq_min() const
     422                 :            : {
     423                 :         16 :     return termfreq;
     424                 :            : }
     425                 :            : 
     426                 :            : Xapian::doccount
     427                 :         24 : FixedWeightPostingSource::get_termfreq_est() const
     428                 :            : {
     429                 :         24 :     return termfreq;
     430                 :            : }
     431                 :            : 
     432                 :            : Xapian::doccount
     433                 :         16 : FixedWeightPostingSource::get_termfreq_max() const
     434                 :            : {
     435                 :         16 :     return termfreq;
     436                 :            : }
     437                 :            : 
     438                 :            : double
     439                 :        147 : FixedWeightPostingSource::get_weight() const
     440                 :            : {
     441                 :        147 :     return get_maxweight();
     442                 :            : }
     443                 :            : 
     444                 :            : void
     445                 :        156 : FixedWeightPostingSource::next(double min_wt)
     446                 :            : {
     447         [ +  + ]:        156 :     if (!started) {
     448                 :         23 :         started = true;
     449 [ +  - ][ +  - ]:         23 :         it = db.postlist_begin(string());
     450                 :            :     } else {
     451                 :        133 :         ++it;
     452                 :            :     }
     453                 :            : 
     454         [ +  + ]:        303 :     if (it == db.postlist_end(string())) return;
     455                 :            : 
     456         [ +  + ]:        147 :     if (check_docid) {
     457                 :          7 :         it.skip_to(check_docid + 1);
     458                 :          7 :         check_docid = 0;
     459                 :            :     }
     460                 :            : 
     461         [ +  + ]:        147 :     if (min_wt > get_maxweight()) {
     462         [ +  - ]:          7 :         it = db.postlist_end(string());
     463                 :            :     }
     464                 :            : }
     465                 :            : 
     466                 :            : void
     467                 :         22 : FixedWeightPostingSource::skip_to(Xapian::docid min_docid, double min_wt)
     468                 :            : {
     469         [ +  + ]:         22 :     if (!started) {
     470                 :          8 :         started = true;
     471 [ +  - ][ +  - ]:          8 :         it = db.postlist_begin(string());
     472                 :            : 
     473         [ +  + ]:          8 :         if (it == db.postlist_end(string())) return;
     474                 :            :     }
     475                 :            : 
     476         [ +  + ]:         21 :     if (check_docid) {
     477         [ -  + ]:          7 :         if (min_docid < check_docid)
     478                 :          0 :             min_docid = check_docid + 1;
     479                 :          7 :         check_docid = 0;
     480                 :            :     }
     481                 :            : 
     482         [ +  + ]:         21 :     if (min_wt > get_maxweight()) {
     483         [ +  - ]:          7 :         it = db.postlist_end(string());
     484                 :          7 :         return;
     485                 :            :     }
     486                 :         22 :     it.skip_to(min_docid);
     487                 :            : }
     488                 :            : 
     489                 :            : bool
     490                 :         42 : FixedWeightPostingSource::check(Xapian::docid min_docid, double)
     491                 :            : {
     492                 :            :     // We're guaranteed not to be called if the document doesn't
     493                 :            :     // exist, so just remember the docid passed, and return true.
     494                 :         42 :     check_docid = min_docid;
     495                 :         42 :     return true;
     496                 :            : }
     497                 :            : 
     498                 :            : bool
     499                 :        222 : FixedWeightPostingSource::at_end() const
     500                 :            : {
     501         [ +  + ]:        222 :     if (check_docid != 0) return false;
     502 [ +  + ][ +  - ]:        222 :     return started && it == db.postlist_end(string());
         [ +  + ][ +  + ]
                 [ +  + ]
           [ #  #  #  # ]
     503                 :            : }
     504                 :            : 
     505                 :            : Xapian::docid
     506                 :        196 : FixedWeightPostingSource::get_docid() const
     507                 :            : {
     508         [ +  + ]:        196 :     if (check_docid != 0) return check_docid;
     509                 :        154 :     return *it;
     510                 :            : }
     511                 :            : 
     512                 :            : FixedWeightPostingSource *
     513                 :         33 : FixedWeightPostingSource::clone() const
     514                 :            : {
     515         [ +  - ]:         33 :     return new FixedWeightPostingSource(get_maxweight());
     516                 :            : }
     517                 :            : 
     518                 :            : string
     519                 :       1451 : FixedWeightPostingSource::name() const
     520                 :            : {
     521         [ +  - ]:       1451 :     return string("Xapian::FixedWeightPostingSource");
     522                 :            : }
     523                 :            : 
     524                 :            : string
     525                 :          4 : FixedWeightPostingSource::serialise() const
     526                 :            : {
     527                 :          4 :     return serialise_double(get_maxweight());
     528                 :            : }
     529                 :            : 
     530                 :            : FixedWeightPostingSource *
     531                 :          4 : FixedWeightPostingSource::unserialise(const string &s) const
     532                 :            : {
     533                 :          4 :     const char * p = s.data();
     534                 :          4 :     const char * s_end = p + s.size();
     535         [ +  - ]:          4 :     double new_wt = unserialise_double(&p, s_end);
     536         [ -  + ]:          4 :     if (p != s_end) {
     537 [ #  # ][ #  # ]:          0 :         throw Xapian::NetworkError("Bad serialised FixedWeightPostingSource - junk at end");
                 [ #  # ]
     538                 :            :     }
     539 [ +  - ][ +  - ]:          4 :     return new FixedWeightPostingSource(new_wt);
     540                 :            : }
     541                 :            : 
     542                 :            : void
     543                 :         39 : FixedWeightPostingSource::init(const Xapian::Database & db_)
     544                 :            : {
     545                 :         39 :     db = db_;
     546                 :         39 :     termfreq = db_.get_doccount();
     547                 :         39 :     started = false;
     548                 :         39 :     check_docid = 0;
     549                 :         39 : }
     550                 :            : 
     551                 :            : string
     552                 :          7 : FixedWeightPostingSource::get_description() const
     553                 :            : {
     554         [ +  - ]:          7 :     string desc("Xapian::FixedWeightPostingSource(wt=");
     555 [ +  - ][ +  - ]:          7 :     desc += str(get_maxweight());
     556         [ +  - ]:          7 :     desc += ")";
     557                 :          7 :     return desc;
     558                 :            : }
     559                 :            : 
     560                 :            : }

Generated by: LCOV version 1.11