LCOV - code coverage report
Current view: top level - api - postingsource.cc (source / functions) Hit Total Coverage
Test: Test Coverage for xapian-core 954b5873a738 Lines: 225 251 89.6 %
Date: 2019-06-30 05:20:33 Functions: 54 58 93.1 %
Branches: 143 266 53.8 %

           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,2019 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 "pack.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         [ -  + ]:      19666 : PostingSource::~PostingSource() { }
      48                 :            : 
      49                 :            : void
      50                 :       5268 : PostingSource::set_maxweight(double max_weight)
      51                 :            : {
      52                 :       5268 :     max_weight_ = max_weight;
      53         [ +  + ]:       5268 :     if (usual(matcher_)) {
      54                 :        367 :         PostListTree* pltree = static_cast<PostListTree*>(matcher_);
      55                 :        367 :         pltree->force_recalc();
      56                 :            :     }
      57                 :       5268 : }
      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                 :            : void
     112                 :        665 : PostingSource::reset(const Database& db, Xapian::doccount)
     113                 :            : {
     114                 :        665 :     init(db);
     115                 :        665 : }
     116                 :            : 
     117                 :            : void
     118                 :          0 : PostingSource::init(const Database&)
     119                 :            : {
     120                 :            :     const char* msg = "Either PostingSource::reset() or PostingSource::init() "
     121                 :          0 :                       "must be overridden";
     122 [ #  # ][ #  # ]:          0 :     throw Xapian::InvalidOperationError(msg);
                 [ #  # ]
     123                 :            : }
     124                 :            : 
     125                 :            : string
     126                 :          0 : PostingSource::get_description() const
     127                 :            : {
     128         [ #  # ]:          0 :     return "Xapian::PostingSource subclass";
     129                 :            : }
     130                 :            : 
     131                 :            : Xapian::doccount
     132                 :        136 : ValuePostingSource::get_termfreq_min() const
     133                 :            : {
     134                 :        136 :     return termfreq_min;
     135                 :            : }
     136                 :            : 
     137                 :            : Xapian::doccount
     138                 :        160 : ValuePostingSource::get_termfreq_est() const
     139                 :            : {
     140                 :        160 :     return termfreq_est;
     141                 :            : }
     142                 :            : 
     143                 :            : Xapian::doccount
     144                 :        136 : ValuePostingSource::get_termfreq_max() const
     145                 :            : {
     146                 :        136 :     return termfreq_max;
     147                 :            : }
     148                 :            : 
     149                 :            : void
     150                 :       1025 : ValuePostingSource::next(double min_wt)
     151                 :            : {
     152         [ +  + ]:       1025 :     if (!started) {
     153                 :        184 :         started = true;
     154         [ +  - ]:        184 :         value_it = db.valuestream_begin(slot);
     155                 :            :     } else {
     156                 :        841 :         ++value_it;
     157                 :            :     }
     158                 :            : 
     159         [ +  + ]:       1025 :     if (value_it == db.valuestream_end(slot)) return;
     160                 :            : 
     161         [ -  + ]:        855 :     if (min_wt > get_maxweight()) {
     162         [ #  # ]:          0 :         value_it = db.valuestream_end(slot);
     163                 :       1025 :         return;
     164                 :            :     }
     165                 :            : }
     166                 :            : 
     167                 :            : void
     168                 :         76 : ValuePostingSource::skip_to(Xapian::docid min_docid, double min_wt)
     169                 :            : {
     170         [ +  + ]:         76 :     if (!started) {
     171                 :         12 :         started = true;
     172         [ +  - ]:         12 :         value_it = db.valuestream_begin(slot);
     173                 :            : 
     174         [ +  + ]:         12 :         if (value_it == db.valuestream_end(slot)) return;
     175                 :            :     }
     176                 :            : 
     177         [ -  + ]:         70 :     if (min_wt > get_maxweight()) {
     178         [ #  # ]:          0 :         value_it = db.valuestream_end(slot);
     179                 :          0 :         return;
     180                 :            :     }
     181                 :         76 :     value_it.skip_to(min_docid);
     182                 :            : }
     183                 :            : 
     184                 :            : bool
     185                 :        224 : ValuePostingSource::check(Xapian::docid min_docid, double min_wt)
     186                 :            : {
     187         [ +  + ]:        224 :     if (!started) {
     188                 :         36 :         started = true;
     189         [ +  - ]:         36 :         value_it = db.valuestream_begin(slot);
     190                 :            : 
     191         [ +  + ]:         36 :         if (value_it == db.valuestream_end(slot)) return true;
     192                 :            :     }
     193                 :            : 
     194         [ -  + ]:        218 :     if (min_wt > get_maxweight()) {
     195         [ #  # ]:          0 :         value_it = db.valuestream_end(slot);
     196                 :          0 :         return true;
     197                 :            :     }
     198                 :        224 :     return value_it.check(min_docid);
     199                 :            : }
     200                 :            : 
     201                 :            : bool
     202                 :       1913 : ValuePostingSource::at_end() const
     203                 :            : {
     204 [ +  + ][ +  + ]:       1913 :     return started && value_it == db.valuestream_end(slot);
                 [ +  + ]
     205                 :            : }
     206                 :            : 
     207                 :            : Xapian::docid
     208                 :       1393 : ValuePostingSource::get_docid() const
     209                 :            : {
     210                 :       1393 :     return value_it.get_docid();
     211                 :            : }
     212                 :            : 
     213                 :            : void
     214                 :        250 : ValuePostingSource::init(const Database & db_)
     215                 :            : {
     216                 :        250 :     db = db_;
     217                 :        250 :     started = false;
     218                 :        250 :     set_maxweight(DBL_MAX);
     219                 :            :     try {
     220         [ +  - ]:        250 :         termfreq_max = db.get_value_freq(slot);
     221                 :        250 :         termfreq_est = termfreq_max;
     222                 :        250 :         termfreq_min = termfreq_max;
     223         [ #  # ]:          0 :     } catch (const Xapian::UnimplementedError &) {
     224         [ #  # ]:          0 :         termfreq_max = db.get_doccount();
     225                 :          0 :         termfreq_est = termfreq_max / 2;
     226                 :          0 :         termfreq_min = 0;
     227                 :            :     }
     228                 :        250 : }
     229                 :            : 
     230                 :            : string
     231                 :          1 : ValuePostingSource::get_description() const
     232                 :            : {
     233         [ +  - ]:          1 :     string desc("Xapian::ValuePostingSource(slot=");
     234 [ +  - ][ +  - ]:          1 :     desc += str(get_slot());
     235         [ +  - ]:          1 :     desc += ")";
     236                 :          1 :     return desc;
     237                 :            : }
     238                 :            : 
     239                 :            : 
     240                 :       3478 : ValueWeightPostingSource::ValueWeightPostingSource(Xapian::valueno slot_)
     241                 :       3478 :         : ValuePostingSource(slot_)
     242                 :            : {
     243                 :       3478 : }
     244                 :            : 
     245                 :            : double
     246                 :        722 : ValueWeightPostingSource::get_weight() const
     247                 :            : {
     248                 :            :     Assert(!at_end());
     249                 :            :     Assert(get_started());
     250                 :        722 :     return sortable_unserialise(get_value());
     251                 :            : }
     252                 :            : 
     253                 :            : ValueWeightPostingSource *
     254                 :         85 : ValueWeightPostingSource::clone() const
     255                 :            : {
     256         [ +  - ]:         85 :     return new ValueWeightPostingSource(get_slot());
     257                 :            : }
     258                 :            : 
     259                 :            : string
     260                 :       1567 : ValueWeightPostingSource::name() const
     261                 :            : {
     262         [ +  - ]:       1567 :     return string("Xapian::ValueWeightPostingSource");
     263                 :            : }
     264                 :            : 
     265                 :            : string
     266                 :          8 : ValueWeightPostingSource::serialise() const
     267                 :            : {
     268                 :          8 :     string result;
     269         [ +  - ]:          8 :     pack_uint_last(result, get_slot());
     270                 :          8 :     return result;
     271                 :            : }
     272                 :            : 
     273                 :            : ValueWeightPostingSource *
     274                 :          8 : ValueWeightPostingSource::unserialise(const string &s) const
     275                 :            : {
     276                 :          8 :     const char * p = s.data();
     277                 :          8 :     const char * end = p + s.size();
     278                 :            : 
     279                 :            :     Xapian::valueno new_slot;
     280         [ -  + ]:          8 :     if (!unpack_uint_last(&p, end, &new_slot)) {
     281                 :          0 :         unpack_throw_serialisation_error(p);
     282                 :            :     }
     283                 :            : 
     284 [ +  - ][ +  - ]:          8 :     return new ValueWeightPostingSource(new_slot);
     285                 :            : }
     286                 :            : 
     287                 :            : void
     288                 :        186 : ValueWeightPostingSource::init(const Database & db_)
     289                 :            : {
     290         [ +  - ]:        186 :     ValuePostingSource::init(db_);
     291                 :            : 
     292         [ +  - ]:        186 :     string upper_bound;
     293                 :            :     try {
     294 [ +  - ][ +  - ]:        186 :         upper_bound = get_database().get_value_upper_bound(get_slot());
         [ +  - ][ #  # ]
     295         [ #  # ]:          0 :     } catch (const Xapian::UnimplementedError &) {
     296                 :            :         // ValuePostingSource::init() set the maxweight to DBL_MAX.
     297                 :        186 :         return;
     298                 :            :     }
     299                 :            : 
     300         [ +  + ]:        186 :     if (upper_bound.empty()) {
     301                 :            :         // This should only happen if there are no entries, in which case the
     302                 :            :         // maxweight is 0.
     303         [ +  - ]:         15 :         set_maxweight(0.0);
     304                 :            :     } else {
     305 [ +  - ][ +  - ]:        186 :         set_maxweight(sortable_unserialise(upper_bound));
     306                 :        186 :     }
     307                 :            : }
     308                 :            : 
     309                 :            : string
     310                 :          7 : ValueWeightPostingSource::get_description() const
     311                 :            : {
     312         [ +  - ]:          7 :     string desc("Xapian::ValueWeightPostingSource(slot=");
     313 [ +  - ][ +  - ]:          7 :     desc += str(get_slot());
     314         [ +  - ]:          7 :     desc += ")";
     315                 :          7 :     return desc;
     316                 :            : }
     317                 :            : 
     318                 :            : 
     319                 :       1625 : ValueMapPostingSource::ValueMapPostingSource(Xapian::valueno slot_)
     320                 :            :         : ValuePostingSource(slot_),
     321                 :            :           default_weight(0.0),
     322         [ +  - ]:       1625 :           max_weight_in_map(0.0)
     323                 :            : {
     324                 :       1625 : }
     325                 :            : 
     326                 :            : void
     327                 :        240 : ValueMapPostingSource::add_mapping(const string & key, double wt)
     328                 :            : {
     329                 :        240 :     weight_map[key] = wt;
     330                 :        240 :     max_weight_in_map = max(wt, max_weight_in_map);
     331                 :        240 : }
     332                 :            : 
     333                 :            : void
     334                 :          7 : ValueMapPostingSource::clear_mappings()
     335                 :            : {
     336                 :          7 :     weight_map.clear();
     337                 :          7 :     max_weight_in_map = 0.0;
     338                 :          7 : }
     339                 :            : 
     340                 :            : void
     341                 :         47 : ValueMapPostingSource::set_default_weight(double wt)
     342                 :            : {
     343                 :         47 :     default_weight = wt;
     344                 :         47 : }
     345                 :            : 
     346                 :            : double
     347                 :        238 : ValueMapPostingSource::get_weight() const
     348                 :            : {
     349 [ +  - ][ +  - ]:        238 :     map<string, double>::const_iterator wit = weight_map.find(get_value());
     350         [ +  + ]:        238 :     if (wit == weight_map.end()) {
     351                 :        168 :         return default_weight;
     352                 :            :     }
     353                 :        238 :     return wit->second;
     354                 :            : }
     355                 :            : 
     356                 :            : ValueMapPostingSource *
     357                 :         32 : ValueMapPostingSource::clone() const
     358                 :            : {
     359                 :            :     unique_ptr<ValueMapPostingSource> res(
     360 [ +  - ][ +  - ]:         32 :             new ValueMapPostingSource(get_slot()));
     361                 :         32 :     map<string, double>::const_iterator i;
     362         [ +  + ]:        182 :     for (i = weight_map.begin(); i != weight_map.end(); ++i) {
     363         [ +  - ]:        150 :         res->add_mapping(i->first, i->second);
     364                 :            :     }
     365         [ +  - ]:         32 :     res->set_default_weight(default_weight);
     366                 :         32 :     return res.release();
     367                 :            : }
     368                 :            : 
     369                 :            : string
     370                 :       1565 : ValueMapPostingSource::name() const
     371                 :            : {
     372         [ +  - ]:       1565 :     return string("Xapian::ValueMapPostingSource");
     373                 :            : }
     374                 :            : 
     375                 :            : string
     376                 :          6 : ValueMapPostingSource::serialise() const
     377                 :            : {
     378         [ +  - ]:          6 :     string result;
     379         [ +  - ]:          6 :     pack_uint(result, get_slot());
     380 [ +  - ][ +  - ]:          6 :     result += serialise_double(default_weight);
     381                 :            : 
     382                 :          6 :     map<string, double>::const_iterator i;
     383         [ +  + ]:         26 :     for (i = weight_map.begin(); i != weight_map.end(); ++i) {
     384         [ +  - ]:         20 :         pack_string(result, i->first);
     385 [ +  - ][ +  - ]:         20 :         result.append(serialise_double(i->second));
     386                 :            :     }
     387                 :            : 
     388                 :          6 :     return result;
     389                 :            : }
     390                 :            : 
     391                 :            : ValueMapPostingSource *
     392                 :          6 : ValueMapPostingSource::unserialise(const string &s) const
     393                 :            : {
     394                 :          6 :     const char * p = s.data();
     395                 :          6 :     const char * end = p + s.size();
     396                 :            : 
     397                 :            :     Xapian::valueno new_slot;
     398         [ -  + ]:          6 :     if (!unpack_uint(&p, end, &new_slot)) {
     399                 :          0 :         unpack_throw_serialisation_error(p);
     400                 :            :     }
     401 [ +  - ][ +  - ]:          6 :     unique_ptr<ValueMapPostingSource> res(new ValueMapPostingSource(new_slot));
     402 [ +  - ][ +  - ]:          6 :     res->set_default_weight(unserialise_double(&p, end));
     403         [ +  + ]:         26 :     while (p != end) {
     404         [ +  - ]:         20 :         string key;
     405 [ +  - ][ -  + ]:         20 :         if (!unpack_string(&p, end, key)) {
     406                 :          0 :             unpack_throw_serialisation_error(p);
     407                 :            :         }
     408 [ +  - ][ +  - ]:         20 :         res->add_mapping(key, unserialise_double(&p, end));
     409                 :         20 :     }
     410                 :          6 :     return res.release();
     411                 :            : }
     412                 :            : 
     413                 :            : void
     414                 :         34 : ValueMapPostingSource::init(const Database & db_)
     415                 :            : {
     416                 :         34 :     ValuePostingSource::init(db_);
     417                 :         34 :     set_maxweight(max(max_weight_in_map, default_weight));
     418                 :         34 : }
     419                 :            : 
     420                 :            : string
     421                 :          7 : ValueMapPostingSource::get_description() const
     422                 :            : {
     423         [ +  - ]:          7 :     string desc("Xapian::ValueMapPostingSource(slot=");
     424 [ +  - ][ +  - ]:          7 :     desc += str(get_slot());
     425         [ +  - ]:          7 :     desc += ")";
     426                 :          7 :     return desc;
     427                 :            : }
     428                 :            : 
     429                 :       1637 : FixedWeightPostingSource::FixedWeightPostingSource(double wt)
     430         [ +  - ]:       1637 :     : started(false)
     431                 :            : {
     432                 :            :     // The weight is fixed at wt, so that's the maxweight too.  So just store wt
     433                 :            :     // as the maxweight and we can read it from there when we need it.
     434         [ +  - ]:       1637 :     set_maxweight(wt);
     435                 :       1637 : }
     436                 :            : 
     437                 :            : Xapian::doccount
     438                 :         16 : FixedWeightPostingSource::get_termfreq_min() const
     439                 :            : {
     440                 :         16 :     return termfreq;
     441                 :            : }
     442                 :            : 
     443                 :            : Xapian::doccount
     444                 :         24 : FixedWeightPostingSource::get_termfreq_est() const
     445                 :            : {
     446                 :         24 :     return termfreq;
     447                 :            : }
     448                 :            : 
     449                 :            : Xapian::doccount
     450                 :         16 : FixedWeightPostingSource::get_termfreq_max() const
     451                 :            : {
     452                 :         16 :     return termfreq;
     453                 :            : }
     454                 :            : 
     455                 :            : double
     456                 :        147 : FixedWeightPostingSource::get_weight() const
     457                 :            : {
     458                 :        147 :     return get_maxweight();
     459                 :            : }
     460                 :            : 
     461                 :            : void
     462                 :        156 : FixedWeightPostingSource::next(double min_wt)
     463                 :            : {
     464         [ +  + ]:        156 :     if (!started) {
     465                 :         23 :         started = true;
     466 [ +  - ][ +  - ]:         23 :         it = db.postlist_begin(string());
     467                 :            :     } else {
     468                 :        133 :         ++it;
     469                 :            :     }
     470                 :            : 
     471         [ +  + ]:        303 :     if (it == db.postlist_end(string())) return;
     472                 :            : 
     473         [ +  + ]:        147 :     if (check_docid) {
     474                 :          7 :         it.skip_to(check_docid + 1);
     475                 :          7 :         check_docid = 0;
     476                 :            :     }
     477                 :            : 
     478         [ +  + ]:        147 :     if (min_wt > get_maxweight()) {
     479         [ +  - ]:          7 :         it = db.postlist_end(string());
     480                 :            :     }
     481                 :            : }
     482                 :            : 
     483                 :            : void
     484                 :         22 : FixedWeightPostingSource::skip_to(Xapian::docid min_docid, double min_wt)
     485                 :            : {
     486         [ +  + ]:         22 :     if (!started) {
     487                 :          8 :         started = true;
     488 [ +  - ][ +  - ]:          8 :         it = db.postlist_begin(string());
     489                 :            : 
     490         [ +  + ]:          8 :         if (it == db.postlist_end(string())) return;
     491                 :            :     }
     492                 :            : 
     493         [ +  + ]:         21 :     if (check_docid) {
     494         [ -  + ]:          7 :         if (min_docid < check_docid)
     495                 :          0 :             min_docid = check_docid + 1;
     496                 :          7 :         check_docid = 0;
     497                 :            :     }
     498                 :            : 
     499         [ +  + ]:         21 :     if (min_wt > get_maxweight()) {
     500         [ +  - ]:          7 :         it = db.postlist_end(string());
     501                 :          7 :         return;
     502                 :            :     }
     503                 :         22 :     it.skip_to(min_docid);
     504                 :            : }
     505                 :            : 
     506                 :            : bool
     507                 :         42 : FixedWeightPostingSource::check(Xapian::docid min_docid, double)
     508                 :            : {
     509                 :            :     // We're guaranteed not to be called if the document doesn't
     510                 :            :     // exist, so just remember the docid passed, and return true.
     511                 :         42 :     check_docid = min_docid;
     512                 :         42 :     return true;
     513                 :            : }
     514                 :            : 
     515                 :            : bool
     516                 :        222 : FixedWeightPostingSource::at_end() const
     517                 :            : {
     518         [ +  + ]:        222 :     if (check_docid != 0) return false;
     519 [ +  + ][ +  - ]:        222 :     return started && it == db.postlist_end(string());
         [ +  + ][ +  + ]
                 [ +  + ]
           [ #  #  #  # ]
     520                 :            : }
     521                 :            : 
     522                 :            : Xapian::docid
     523                 :        196 : FixedWeightPostingSource::get_docid() const
     524                 :            : {
     525         [ +  + ]:        196 :     if (check_docid != 0) return check_docid;
     526                 :        154 :     return *it;
     527                 :            : }
     528                 :            : 
     529                 :            : FixedWeightPostingSource *
     530                 :         33 : FixedWeightPostingSource::clone() const
     531                 :            : {
     532         [ +  - ]:         33 :     return new FixedWeightPostingSource(get_maxweight());
     533                 :            : }
     534                 :            : 
     535                 :            : string
     536                 :       1563 : FixedWeightPostingSource::name() const
     537                 :            : {
     538         [ +  - ]:       1563 :     return string("Xapian::FixedWeightPostingSource");
     539                 :            : }
     540                 :            : 
     541                 :            : string
     542                 :          4 : FixedWeightPostingSource::serialise() const
     543                 :            : {
     544                 :          4 :     return serialise_double(get_maxweight());
     545                 :            : }
     546                 :            : 
     547                 :            : FixedWeightPostingSource *
     548                 :          4 : FixedWeightPostingSource::unserialise(const string &s) const
     549                 :            : {
     550                 :          4 :     const char * p = s.data();
     551                 :          4 :     const char * s_end = p + s.size();
     552         [ +  - ]:          4 :     double new_wt = unserialise_double(&p, s_end);
     553         [ -  + ]:          4 :     if (p != s_end) {
     554 [ #  # ][ #  # ]:          0 :         throw Xapian::NetworkError("Bad serialised FixedWeightPostingSource - junk at end");
                 [ #  # ]
     555                 :            :     }
     556 [ +  - ][ +  - ]:          4 :     return new FixedWeightPostingSource(new_wt);
     557                 :            : }
     558                 :            : 
     559                 :            : void
     560                 :         39 : FixedWeightPostingSource::init(const Xapian::Database & db_)
     561                 :            : {
     562                 :         39 :     db = db_;
     563                 :         39 :     termfreq = db_.get_doccount();
     564                 :         39 :     started = false;
     565                 :         39 :     check_docid = 0;
     566                 :         39 : }
     567                 :            : 
     568                 :            : string
     569                 :          7 : FixedWeightPostingSource::get_description() const
     570                 :            : {
     571         [ +  - ]:          7 :     string desc("Xapian::FixedWeightPostingSource(wt=");
     572 [ +  - ][ +  - ]:          7 :     desc += str(get_maxweight());
     573         [ +  - ]:          7 :     desc += ")";
     574                 :          7 :     return desc;
     575                 :            : }
     576                 :            : 
     577                 :            : }

Generated by: LCOV version 1.11