LCOV - code coverage report
Current view: top level - net - serialise.cc (source / functions) Hit Total Coverage
Test: Test Coverage for xapian-core 4ba52dacf4fb Lines: 119 119 100.0 %
Date: 2019-05-20 14:58:19 Functions: 6 6 100.0 %
Branches: 131 230 57.0 %

           Branch data     Line data    Source code
       1                 :            : /** @file serialise.cc
       2                 :            :  * @brief functions to convert Xapian objects to strings and back
       3                 :            :  */
       4                 :            : /* Copyright (C) 2006,2007,2008,2009,2010,2011,2014,2015,2017 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                 :            : #include <config.h>
      22                 :            : 
      23                 :            : #include <xapian/document.h>
      24                 :            : #include <xapian/positioniterator.h>
      25                 :            : #include <xapian/termiterator.h>
      26                 :            : #include <xapian/valueiterator.h>
      27                 :            : 
      28                 :            : #include "omassert.h"
      29                 :            : #include "api/rsetinternal.h"
      30                 :            : #include "length.h"
      31                 :            : #include "serialise.h"
      32                 :            : #include "serialise-double.h"
      33                 :            : #include "weight/weightinternal.h"
      34                 :            : 
      35                 :            : #include <memory>
      36                 :            : #include <set>
      37                 :            : #include <string>
      38                 :            : 
      39                 :            : using namespace std;
      40                 :            : 
      41                 :            : string
      42                 :      31222 : serialise_stats(const Xapian::Weight::Internal &stats)
      43                 :            : {
      44         [ +  - ]:      31222 :     string result;
      45                 :            : 
      46 [ +  - ][ +  - ]:      31222 :     result += encode_length(stats.total_length);
      47 [ +  - ][ +  - ]:      31222 :     result += encode_length(stats.collection_size);
      48 [ +  - ][ +  - ]:      31222 :     result += encode_length(stats.rset_size);
      49 [ +  - ][ +  - ]:      31222 :     result += encode_length(stats.total_term_count);
      50         [ +  - ]:      31222 :     result += static_cast<char>(stats.have_max_part);
      51                 :            : 
      52 [ +  - ][ +  - ]:      31222 :     result += encode_length(stats.termfreqs.size());
      53                 :      31222 :     map<string, TermFreqs>::const_iterator i;
      54         [ +  + ]:      53664 :     for (i = stats.termfreqs.begin(); i != stats.termfreqs.end(); ++i) {
      55 [ +  - ][ +  - ]:      22442 :         result += encode_length(i->first.size());
      56         [ +  - ]:      22442 :         result += i->first;
      57 [ +  - ][ +  - ]:      22442 :         result += encode_length(i->second.termfreq);
      58         [ +  + ]:      22442 :         if (stats.rset_size != 0)
      59 [ +  - ][ +  - ]:        132 :             result += encode_length(i->second.reltermfreq);
      60 [ +  - ][ +  - ]:      22442 :         result += encode_length(i->second.collfreq);
      61         [ +  + ]:      22442 :         if (stats.have_max_part)
      62 [ +  - ][ +  - ]:       7168 :             result += serialise_double(i->second.max_part);
      63                 :            :     }
      64                 :            : 
      65                 :      31222 :     return result;
      66                 :            : }
      67                 :            : 
      68                 :            : void
      69                 :      31222 : unserialise_stats(const string &s, Xapian::Weight::Internal & stat)
      70                 :            : {
      71                 :      31222 :     const char * p = s.data();
      72                 :      31222 :     const char * p_end = p + s.size();
      73                 :            : 
      74         [ +  - ]:      31222 :     decode_length(&p, p_end, stat.total_length);
      75         [ +  - ]:      31222 :     decode_length(&p, p_end, stat.collection_size);
      76         [ +  - ]:      31222 :     decode_length(&p, p_end, stat.rset_size);
      77         [ +  - ]:      31222 :     decode_length(&p, p_end, stat.total_term_count);
      78                 :            :     // If p == p_end, the next decode_length() will report it.
      79 [ +  - ][ +  + ]:      31222 :     stat.have_max_part = (p != p_end && *p++);
      80                 :            : 
      81                 :            :     size_t n;
      82         [ +  - ]:      31222 :     decode_length(&p, p_end, n);
      83         [ +  + ]:      53664 :     while (n--) {
      84                 :            :         size_t len;
      85         [ +  - ]:      22442 :         decode_length_and_check(&p, p_end, len);
      86         [ +  - ]:      22442 :         string term(p, len);
      87                 :      22442 :         p += len;
      88                 :            :         Xapian::doccount termfreq;
      89         [ +  - ]:      22442 :         decode_length(&p, p_end, termfreq);
      90                 :            :         Xapian::doccount reltermfreq;
      91         [ +  + ]:      22442 :         if (stat.rset_size == 0) {
      92                 :      22310 :             reltermfreq = 0;
      93                 :            :         } else {
      94         [ +  - ]:        132 :             decode_length(&p, p_end, reltermfreq);
      95                 :            :         }
      96                 :            :         Xapian::termcount collfreq;
      97         [ +  - ]:      22442 :         decode_length(&p, p_end, collfreq);
      98                 :      22442 :         double max_part = 0.0;
      99         [ +  + ]:      22442 :         if (stat.have_max_part)
     100         [ +  - ]:       7168 :             max_part = unserialise_double(&p, p_end);
     101                 :            :         stat.termfreqs.insert(make_pair(term,
     102                 :            :                                         TermFreqs(termfreq,
     103                 :            :                                                   reltermfreq,
     104                 :            :                                                   collfreq,
     105 [ +  - ][ +  - ]:      22442 :                                                   max_part)));
     106                 :      22442 :     }
     107                 :      31222 : }
     108                 :            : 
     109                 :            : string
     110                 :      10416 : serialise_rset(const Xapian::RSet &rset)
     111                 :            : {
     112                 :      10416 :     string result;
     113         [ +  + ]:      10416 :     if (rset.internal.get()) {
     114                 :         22 :         Xapian::docid lastdid = 0;
     115         [ +  + ]:         44 :         for (Xapian::docid did : rset.internal->docs) {
     116 [ +  - ][ +  - ]:         22 :             result += encode_length(did - lastdid - 1);
     117                 :         22 :             lastdid = did;
     118                 :            :         }
     119                 :            :     }
     120                 :      10416 :     return result;
     121                 :            : }
     122                 :            : 
     123                 :            : Xapian::RSet
     124                 :      10414 : unserialise_rset(const string &s)
     125                 :            : {
     126         [ +  - ]:      10414 :     Xapian::RSet rset;
     127                 :            : 
     128                 :      10414 :     const char * p = s.data();
     129                 :      10414 :     const char * p_end = p + s.size();
     130                 :            : 
     131                 :      10414 :     Xapian::docid did = 0;
     132         [ +  + ]:      10436 :     while (p != p_end) {
     133                 :            :         Xapian::docid inc;
     134         [ +  - ]:         22 :         decode_length(&p, p_end, inc);
     135                 :         22 :         did += inc + 1;
     136         [ +  - ]:         22 :         rset.add_document(did);
     137                 :            :     }
     138                 :            : 
     139                 :      10414 :     return rset;
     140                 :            : }
     141                 :            : 
     142                 :            : string
     143                 :      43613 : serialise_document(const Xapian::Document &doc)
     144                 :            : {
     145         [ +  - ]:      43613 :     string result;
     146                 :            : 
     147         [ +  - ]:      43613 :     size_t n = doc.values_count();
     148 [ +  - ][ +  - ]:      43613 :     result += encode_length(n);
     149                 :      87226 :     Xapian::ValueIterator value;
     150 [ +  - ][ +  - ]:     179053 :     for (value = doc.values_begin(); value != doc.values_end(); ++value) {
         [ +  - ][ +  + ]
     151 [ +  - ][ +  - ]:     135440 :         result += encode_length(value.get_valueno());
                 [ +  - ]
     152 [ +  - ][ +  - ]:     135440 :         result += encode_length((*value).size());
                 [ +  - ]
     153 [ +  - ][ +  - ]:     135440 :         result += *value;
     154                 :     135440 :         --n;
     155                 :            :     }
     156                 :            :     Assert(n == 0);
     157                 :            : 
     158         [ +  - ]:      43613 :     n = doc.termlist_count();
     159 [ +  - ][ +  - ]:      43613 :     result += encode_length(n);
     160                 :      87226 :     Xapian::TermIterator term;
     161 [ +  - ][ +  - ]:     565459 :     for (term = doc.termlist_begin(); term != doc.termlist_end(); ++term) {
         [ +  - ][ +  + ]
     162 [ +  - ][ +  - ]:     521846 :         result += encode_length((*term).size());
                 [ +  - ]
     163 [ +  - ][ +  - ]:     521846 :         result += *term;
     164 [ +  - ][ +  - ]:     521846 :         result += encode_length(term.get_wdf());
                 [ +  - ]
     165                 :            : 
     166         [ +  - ]:     521846 :         size_t x = term.positionlist_count();
     167 [ +  - ][ +  - ]:     521846 :         result += encode_length(x);
     168                 :     521846 :         Xapian::PositionIterator pos;
     169                 :     521846 :         Xapian::termpos oldpos = 0;
     170 [ +  - ][ +  - ]:     970190 :         for (pos = term.positionlist_begin(); pos != term.positionlist_end(); ++pos) {
         [ +  - ][ +  + ]
     171         [ +  - ]:     448344 :             Xapian::termpos diff = *pos - oldpos;
     172         [ +  - ]:     448344 :             string delta = encode_length(diff);
     173         [ +  - ]:     448344 :             result += delta;
     174         [ +  - ]:     448344 :             oldpos = *pos;
     175                 :     448344 :             --x;
     176                 :     448344 :         }
     177                 :            :         Assert(x == 0);
     178                 :     521846 :         --n;
     179                 :     521846 :     }
     180                 :            :     AssertEq(n, 0);
     181                 :            : 
     182 [ +  - ][ +  - ]:      43613 :     result += doc.get_data();
     183                 :      87226 :     return result;
     184                 :            : }
     185                 :            : 
     186                 :            : Xapian::Document
     187                 :      43605 : unserialise_document(const string &s)
     188                 :            : {
     189         [ +  - ]:      43605 :     Xapian::Document doc;
     190                 :      43605 :     const char * p = s.data();
     191                 :      43605 :     const char * p_end = p + s.size();
     192                 :            : 
     193                 :            :     size_t n_values;
     194         [ +  - ]:      43605 :     decode_length(&p, p_end, n_values);
     195         [ +  + ]:     179045 :     while (n_values--) {
     196                 :            :         Xapian::valueno slot;
     197         [ +  - ]:     135440 :         decode_length(&p, p_end, slot);
     198                 :            :         size_t len;
     199         [ +  - ]:     135440 :         decode_length_and_check(&p, p_end, len);
     200 [ +  - ][ +  - ]:     135440 :         doc.add_value(slot, string(p, len));
     201                 :     135440 :         p += len;
     202                 :            :     }
     203                 :            : 
     204                 :            :     size_t n_terms;
     205         [ +  - ]:      43605 :     decode_length(&p, p_end, n_terms);
     206         [ +  + ]:     565451 :     while (n_terms--) {
     207                 :            :         size_t len;
     208         [ +  - ]:     521846 :         decode_length_and_check(&p, p_end, len);
     209         [ +  - ]:     521846 :         string term(p, len);
     210                 :     521846 :         p += len;
     211                 :            : 
     212                 :            :         // Set all the wdf using add_term, then pass wdf_inc 0 to add_posting.
     213                 :            :         Xapian::termcount wdf;
     214         [ +  - ]:     521846 :         decode_length(&p, p_end, wdf);
     215         [ +  - ]:     521846 :         doc.add_term(term, wdf);
     216                 :            : 
     217                 :            :         size_t n_pos;
     218         [ +  - ]:     521846 :         decode_length(&p, p_end, n_pos);
     219                 :     521846 :         Xapian::termpos pos = 0;
     220         [ +  + ]:     970190 :         while (n_pos--) {
     221                 :            :             Xapian::termpos inc;
     222         [ +  - ]:     448344 :             decode_length(&p, p_end, inc);
     223                 :     448344 :             pos += inc;
     224         [ +  - ]:     448344 :             doc.add_posting(term, pos, 0);
     225                 :            :         }
     226                 :     521846 :     }
     227                 :            : 
     228 [ +  - ][ +  - ]:      43605 :     doc.set_data(string(p, p_end - p));
     229                 :      43605 :     return doc;
     230                 :            : }

Generated by: LCOV version 1.11