LCOV - code coverage report
Current view: top level - net - serialise.cc (source / functions) Hit Total Coverage
Test: Test Coverage for xapian-core 954b5873a738 Lines: 109 118 92.4 %
Date: 2019-06-30 05:20:33 Functions: 6 6 100.0 %
Branches: 113 196 57.7 %

           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 "pack.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                 :      31954 : serialise_stats(const Xapian::Weight::Internal &stats)
      43                 :            : {
      44         [ +  - ]:      31954 :     string result;
      45                 :            : 
      46         [ +  - ]:      31954 :     pack_uint(result, stats.total_length);
      47         [ +  - ]:      31954 :     pack_uint(result, stats.collection_size);
      48         [ +  - ]:      31954 :     pack_uint(result, stats.rset_size);
      49         [ +  - ]:      31954 :     pack_uint(result, stats.total_term_count);
      50         [ +  - ]:      31954 :     pack_bool(result, stats.have_max_part);
      51                 :            : 
      52         [ +  - ]:      31954 :     pack_uint(result, stats.termfreqs.size());
      53                 :      31954 :     map<string, TermFreqs>::const_iterator i;
      54         [ +  + ]:      55954 :     for (i = stats.termfreqs.begin(); i != stats.termfreqs.end(); ++i) {
      55         [ +  - ]:      24000 :         pack_string(result, i->first);
      56         [ +  - ]:      24000 :         pack_uint(result, i->second.termfreq);
      57         [ +  + ]:      24000 :         if (stats.rset_size != 0)
      58         [ +  - ]:        132 :             pack_uint(result, i->second.reltermfreq);
      59         [ +  - ]:      24000 :         pack_uint(result, i->second.collfreq);
      60         [ +  + ]:      24000 :         if (stats.have_max_part)
      61 [ +  - ][ +  - ]:       7674 :             result += serialise_double(i->second.max_part);
      62                 :            :     }
      63                 :            : 
      64                 :      31954 :     return result;
      65                 :            : }
      66                 :            : 
      67                 :            : void
      68                 :      31954 : unserialise_stats(const string &s, Xapian::Weight::Internal & stat)
      69                 :            : {
      70                 :      31954 :     const char * p = s.data();
      71                 :      31954 :     const char * p_end = p + s.size();
      72                 :            : 
      73                 :            :     size_t n;
      74 [ +  - ][ -  + ]:      95862 :     if (!unpack_uint(&p, p_end, &stat.total_length) ||
      75         [ +  - ]:      63908 :         !unpack_uint(&p, p_end, &stat.collection_size) ||
      76         [ +  - ]:      63908 :         !unpack_uint(&p, p_end, &stat.rset_size) ||
      77         [ +  - ]:      63908 :         !unpack_uint(&p, p_end, &stat.total_term_count) ||
      78 [ +  - ][ -  + ]:      95862 :         !unpack_bool(&p, p_end, &stat.have_max_part) ||
      79                 :      31954 :         !unpack_uint(&p, p_end, &n)) {
      80                 :          0 :         unpack_throw_serialisation_error(p);
      81                 :            :     }
      82                 :            : 
      83         [ +  - ]:      31954 :     string term;
      84         [ +  + ]:      55954 :     while (n--) {
      85                 :            :         Xapian::doccount termfreq;
      86                 :      24000 :         Xapian::doccount reltermfreq = 0;
      87                 :            :         Xapian::termcount collfreq;
      88   [ +  -  +  - ]:      72000 :         if (!unpack_string(&p, p_end, term) ||
                 [ -  + ]
      89         [ +  + ]:      48000 :             !unpack_uint(&p, p_end, &termfreq) ||
      90         [ +  - ]:      48132 :             (stat.rset_size != 0 && !unpack_uint(&p, p_end, &reltermfreq)) ||
           [ +  -  -  + ]
      91                 :      24000 :             !unpack_uint(&p, p_end, &collfreq)) {
      92                 :          0 :             unpack_throw_serialisation_error(p);
      93                 :            :         }
      94                 :      24000 :         double max_part = 0.0;
      95         [ +  + ]:      24000 :         if (stat.have_max_part)
      96         [ +  - ]:       7674 :             max_part = unserialise_double(&p, p_end);
      97                 :            :         stat.termfreqs.insert(make_pair(term,
      98                 :            :                                         TermFreqs(termfreq,
      99                 :            :                                                   reltermfreq,
     100                 :            :                                                   collfreq,
     101 [ +  - ][ +  - ]:      24000 :                                                   max_part)));
     102                 :      31954 :     }
     103                 :      31954 : }
     104                 :            : 
     105                 :            : string
     106                 :      10660 : serialise_rset(const Xapian::RSet &rset)
     107                 :            : {
     108                 :      10660 :     string result;
     109         [ +  + ]:      10660 :     if (rset.internal.get()) {
     110                 :         22 :         Xapian::docid lastdid = 0;
     111         [ +  + ]:         44 :         for (Xapian::docid did : rset.internal->docs) {
     112         [ +  - ]:         22 :             pack_uint(result, did - lastdid - 1);
     113                 :         22 :             lastdid = did;
     114                 :            :         }
     115                 :            :     }
     116                 :      10660 :     return result;
     117                 :            : }
     118                 :            : 
     119                 :            : Xapian::RSet
     120                 :      10658 : unserialise_rset(const string &s)
     121                 :            : {
     122         [ +  - ]:      10658 :     Xapian::RSet rset;
     123                 :            : 
     124                 :      10658 :     const char * p = s.data();
     125                 :      10658 :     const char * p_end = p + s.size();
     126                 :            : 
     127                 :      10658 :     Xapian::docid did = 0;
     128         [ +  + ]:      10680 :     while (p != p_end) {
     129                 :            :         Xapian::docid inc;
     130         [ -  + ]:         22 :         if (!unpack_uint(&p, p_end, &inc)) {
     131                 :          0 :             unpack_throw_serialisation_error(p);
     132                 :            :         }
     133                 :         22 :         did += inc + 1;
     134         [ +  - ]:         22 :         rset.add_document(did);
     135                 :            :     }
     136                 :            : 
     137                 :      10658 :     return rset;
     138                 :            : }
     139                 :            : 
     140                 :            : string
     141                 :      43615 : serialise_document(const Xapian::Document &doc)
     142                 :            : {
     143         [ +  - ]:      43615 :     string result;
     144                 :            : 
     145         [ +  - ]:      43615 :     size_t n = doc.values_count();
     146         [ +  - ]:      43615 :     pack_uint(result, n);
     147                 :      87230 :     Xapian::ValueIterator value;
     148 [ +  - ][ +  - ]:     179055 :     for (value = doc.values_begin(); value != doc.values_end(); ++value) {
         [ +  - ][ +  + ]
     149 [ +  - ][ +  - ]:     135440 :         pack_uint(result, value.get_valueno());
     150 [ +  - ][ +  - ]:     135440 :         pack_string(result, *value);
     151                 :     135440 :         --n;
     152                 :            :     }
     153                 :            :     Assert(n == 0);
     154                 :            : 
     155         [ +  - ]:      43615 :     n = doc.termlist_count();
     156         [ +  - ]:      43615 :     pack_uint(result, n);
     157                 :      87230 :     Xapian::TermIterator term;
     158 [ +  - ][ +  - ]:     565461 :     for (term = doc.termlist_begin(); term != doc.termlist_end(); ++term) {
         [ +  - ][ +  + ]
     159 [ +  - ][ +  - ]:     521846 :         pack_string(result, *term);
     160 [ +  - ][ +  - ]:     521846 :         pack_uint(result, term.get_wdf());
     161                 :            : 
     162         [ +  - ]:     521846 :         size_t x = term.positionlist_count();
     163         [ +  - ]:     521846 :         pack_uint(result, x);
     164                 :     521846 :         Xapian::PositionIterator pos;
     165                 :     521846 :         Xapian::termpos oldpos = 0;
     166 [ +  - ][ +  - ]:     970190 :         for (pos = term.positionlist_begin(); pos != term.positionlist_end(); ++pos) {
         [ +  - ][ +  + ]
     167 [ +  - ][ +  - ]:     448344 :             pack_uint(result, *pos - oldpos);
     168         [ +  - ]:     448344 :             oldpos = *pos;
     169                 :     448344 :             --x;
     170                 :            :         }
     171                 :            :         Assert(x == 0);
     172                 :     521846 :         --n;
     173                 :     521846 :     }
     174                 :            :     AssertEq(n, 0);
     175                 :            : 
     176 [ +  - ][ +  - ]:      43615 :     result += doc.get_data();
     177                 :      87230 :     return result;
     178                 :            : }
     179                 :            : 
     180                 :            : Xapian::Document
     181                 :      43607 : unserialise_document(const string &s)
     182                 :            : {
     183         [ +  - ]:      43607 :     Xapian::Document doc;
     184                 :      43607 :     const char * p = s.data();
     185                 :      43607 :     const char * p_end = p + s.size();
     186                 :            : 
     187                 :            :     size_t n_values;
     188         [ -  + ]:      43607 :     if (!unpack_uint(&p, p_end, &n_values)) {
     189                 :          0 :         unpack_throw_serialisation_error(p);
     190                 :            :     }
     191         [ +  - ]:      87214 :     string value;
     192         [ +  + ]:     179047 :     while (n_values--) {
     193                 :            :         Xapian::valueno slot;
     194 [ +  - ][ -  + ]:     270880 :         if (!unpack_uint(&p, p_end, &slot) ||
                 [ -  + ]
     195         [ +  - ]:     135440 :             !unpack_string(&p, p_end, value)) {
     196                 :          0 :             unpack_throw_serialisation_error(p);
     197                 :            :         }
     198         [ +  - ]:     135440 :         doc.add_value(slot, value);
     199                 :            :     }
     200                 :            : 
     201                 :            :     size_t n_terms;
     202         [ -  + ]:      43607 :     if (!unpack_uint(&p, p_end, &n_terms)) {
     203                 :          0 :         unpack_throw_serialisation_error(p);
     204                 :            :     }
     205         [ +  - ]:      87214 :     string term;
     206         [ +  + ]:     565453 :     while (n_terms--) {
     207                 :            :         Xapian::termcount wdf;
     208         [ +  - ]:    1043692 :         if (!unpack_string(&p, p_end, term) ||
           [ +  -  -  + ]
                 [ -  + ]
     209                 :     521846 :             !unpack_uint(&p, p_end, &wdf)) {
     210                 :          0 :             unpack_throw_serialisation_error(p);
     211                 :            :         }
     212                 :            :         // Set all the wdf using add_term, then pass wdf_inc 0 to add_posting.
     213         [ +  - ]:     521846 :         doc.add_term(term, wdf);
     214                 :            : 
     215                 :            :         size_t n_pos;
     216         [ -  + ]:     521846 :         if (!unpack_uint(&p, p_end, &n_pos)) {
     217                 :          0 :             unpack_throw_serialisation_error(p);
     218                 :            :         }
     219                 :     521846 :         Xapian::termpos pos = 0;
     220         [ +  + ]:     970190 :         while (n_pos--) {
     221                 :            :             Xapian::termpos inc;
     222         [ -  + ]:     448344 :             if (!unpack_uint(&p, p_end, &inc)) {
     223                 :          0 :                 unpack_throw_serialisation_error(p);
     224                 :            :             }
     225                 :     448344 :             pos += inc;
     226         [ +  - ]:     448344 :             doc.add_posting(term, pos, 0);
     227                 :            :         }
     228                 :            :     }
     229                 :            : 
     230 [ +  - ][ +  - ]:      43607 :     doc.set_data(string(p, p_end - p));
     231                 :      87214 :     return doc;
     232                 :            : }

Generated by: LCOV version 1.11