LTP GCOV extension - code coverage report
Current view: | directory - ept/debtags/maint - vocabularymerger.h
Test: | lcov.info
Date: | 2008-08-14 |  | Instrumented lines: | 13
Code covered: | 100.0 % |  | Executed lines: | 13

           1                 : /*
           2                 :  * Merge different vocabularies together and create the tag and facet indexes
           3                 :  *
           4                 :  * Copyright (C) 2003-2007  Enrico Zini <enrico@debian.org>
           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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
          19                 :  */
          20                 :
          21                 : #include <tagcoll/diskindex/mmap.h>
          22                 : #include <tagcoll/input/base.h>
          23                 : #include <string>
          24                 : #include <map>
          25                 : #include <set>
          26                 :
          27                 : #ifndef EPT_DEBTAGS_VOCABULARYMERGER_H
          28                 : #define EPT_DEBTAGS_VOCABULARYMERGER_H
          29                 :
          30                 : namespace ept {
          31                 : namespace debtags {
          32                 :
          33                 : class VocabularyMerger
          34               7 : {
          35                 : protected:
          36                 :         class FacetIndexer : public tagcoll::diskindex::MMapIndexer
          37                 :         {
          38                 :         protected:
          39                 :                 VocabularyMerger& vm;
          40                 :         public:
          41               7 :                 FacetIndexer(VocabularyMerger& vm) : vm(vm) {}
          42               7 :                 virtual ~FacetIndexer() {}
          43                 :                 virtual int encodedSize() const;
          44                 :                 virtual void encode(char* buf) const;
          45                 :         };
          46                 :         class TagIndexer : public tagcoll::diskindex::MMapIndexer
          47                 :         {
          48                 :         protected:
          49                 :                 VocabularyMerger& vm;
          50                 :         public:
          51               7 :                 TagIndexer(VocabularyMerger& vm) : vm(vm) {}
          52               7 :                 virtual ~TagIndexer() {}
          53                 :                 virtual int encodedSize() const;
          54                 :                 virtual void encode(char* buf) const;
          55                 :         };
          56                 :         class TagData : public std::map<std::string, std::string>
          57            8715 :         {
          58                 :         public:
          59                 :                 std::string name;
          60                 :                 // Offset in the last written file (used for indexing)
          61                 :                 long ofs;
          62                 :                 int len;
          63                 :                 int id;
          64                 :
          65            1245 :                 TagData() : ofs(0), len(0) {}
          66                 :         };
          67                 :         class FacetData : public std::map<std::string, std::string>
          68             434 :         {
          69                 :         public:
          70                 :                 std::string name;
          71                 :                 std::map<std::string, TagData> tags;
          72                 :                 // Offset in the last written file (used for indexing)
          73                 :                 long ofs;
          74                 :                 int len;
          75                 :                 int id;
          76                 :
          77              62 :                 FacetData() : ofs(0), len(0) {}
          78                 :
          79                 :                 TagData& obtainTag(const std::string& fullname);
          80                 :         };
          81                 :         std::map<std::string, FacetData> facets;
          82                 :         int tagCount;
          83                 :         FacetIndexer findexer;
          84                 :         TagIndexer tindexer;
          85                 :
          86                 :         FacetData& obtainFacet(const std::string& name);
          87                 :         TagData& obtainTag(const std::string& fullname);
          88                 :
          89                 : public:
          90               7 :         VocabularyMerger() : tagCount(0), findexer(*this), tindexer(*this) {}
          91                 :
          92                 :         /**
          93                 :          * Check if there is any data in the merged vocabulary
          94                 :          */
          95               3 :         bool empty() const { return facets.empty(); }
          96                 :
          97                 :         /**
          98                 :          * Parse and import the vocabulary from `input', merging the data with the
          99                 :          * previously imported ones
         100                 :          */
         101                 :         void read(tagcoll::input::Input& input);
         102                 :
         103                 :         /**
         104                 :          * Write the vocabulary data to the given file
         105                 :          */
         106                 :         void write(const std::string& fname);
         107                 :
         108                 :         /**
         109                 :          * Write the vocabulary data to the given output stream
         110                 :          */
         111                 :         void write(FILE* out);
         112                 :
         113                 :         /**
         114                 :          * Get the facet indexer.
         115                 :          *
         116                 :          * Note: the indexers will only be functional after one of the write
         117                 :          * methods have been invoked
         118                 :          */
         119               7 :         const tagcoll::diskindex::MMapIndexer& facetIndexer() const { return findexer; }
         120                 :
         121                 :         /**
         122                 :          * Get the tag indexer.
         123                 :          *
         124                 :          * Note: the indexers will only be functional after one of the write
         125                 :          * methods have been invoked
         126                 :          */
         127               7 :         const tagcoll::diskindex::MMapIndexer& tagIndexer() const { return tindexer; }
         128                 :
         129                 :         /**
         130                 :          * Check if the vocabulary contains the facet `name'
         131                 :          */
         132                 :         bool hasFacet(const std::string& name) const
         133                 :         {
         134                 :                 return facets.find(name) != facets.end();
         135                 :         }
         136                 :
         137                 :         /**
         138                 :          * Check if the vocabulary contains the tag `fullname'
         139                 :          */
         140                 :         bool hasTag(const std::string& fullname) const;
         141                 :
         142                 :         /**
         143                 :          * Return the ID for the given tag (or -1 if not found)
         144                 :          */
         145                 :         int tagID(const std::string& fullname) const;
         146                 :
         147                 :         /**
         148                 :          * Return a set with all tag names
         149                 :          */
         150                 :         std::set<std::string> tagNames() const;
         151                 : };
         152                 :
         153                 : }
         154                 : }
         155                 :
         156                 : // vim:set ts=4 sw=4:
         157                 : #endif

Generated by: LTP GCOV extension version 1.6