LTP GCOV extension - code coverage report
Current view: directory - usr/include/tagcoll-2.0.11/tagcoll - patch.tcc
Test: lcov.info
Date: 2008-08-14 Instrumented lines: 35
Code covered: 88.6 % Executed lines: 31

       1                 : /*
       2                 :  * Classes handling tag patches
       3                 :  *
       4                 :  * Copyright (C) 2003--2006  Enrico Zini <enrico@debian.org>
       5                 :  *
       6                 :  * This library is free software; you can redistribute it and/or
       7                 :  * modify it under the terms of the GNU Lesser General Public
       8                 :  * License as published by the Free Software Foundation; either
       9                 :  * version 2.1 of the License, or (at your option) any later version.
      10                 :  *
      11                 :  * This library 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 GNU
      14                 :  * Lesser General Public License for more details.
      15                 :  *
      16                 :  * You should have received a copy of the GNU Lesser General Public
      17                 :  * License along with this library; if not, write to the Free Software
      18                 :  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
      19                 :  */
      20                 : 
      21                 : #ifndef TAGCOLL_PATCHES_TCC
      22                 : #define TAGCOLL_PATCHES_TCC
      23                 : 
      24                 : #include <tagcoll/patch.h>
      25                 : #include <wibble/singleton.h>
      26                 : #include <wibble/empty.h>
      27                 : 
      28                 : using namespace std;
      29                 : using namespace wibble::operators;
      30                 : 
      31                 : namespace tagcoll {
      32                 : 
      33                 : template <typename ITEM, typename TAG>
      34                 : Patch<ITEM, TAG>::Patch(const ITEM& item, const std::set<TAG>& added, const std::set<TAG>& removed)
      35               2 :         : item(item), added(added-removed), removed(removed-added)
      36               0 : {
      37               2 : }
      38                 : 
      39                 : template <typename ITEM, typename TAG> template<typename CONTA, typename CONTB>
      40               2 : Patch<ITEM, TAG>::Patch(const ITEM& item, const CONTA& added, const CONTB& removed)
      41               4 :         : item(item)
      42                 : {
      43               4 :         std::copy(added.begin(), added.end(), inserter(this->added, this->added.begin()));
      44               4 :         std::copy(removed.begin(), removed.end(), inserter(this->removed, this->removed.begin()));
      45               4 : }
      46                 : 
      47                 : template <class ITEM, class TAG>
      48                 : void PatchList<ITEM, TAG>::addPatch(const Patch<ITEM, TAG>& patch)
      49                 : {
      50                 :         // Filter out empty patches
      51              15 :         if (patch.added.empty() && patch.removed.empty())
      52               0 :                 return;
      53                 : 
      54              15 :         iterator i = this->find(patch.item);
      55              15 :         if (i == this->end())
      56              13 :                 insert(make_pair<ITEM, Patch<ITEM, TAG> >(patch.item, patch));
      57                 :         else
      58               2 :                 i->second.mergeWith(patch);
      59                 : }
      60                 : 
      61                 : template <class ITEM, class TAG>
      62                 : void PatchList<ITEM, TAG>::addPatch(const PatchList<ITEM, TAG>& patches)
      63                 : {
      64                 :         for (typename PatchList<ITEM, TAG>::const_iterator i = patches.begin();
      65                 :                         i != patches.end(); i++)
      66                 :                 addPatch(i->second);
      67                 : }
      68                 : 
      69                 : template <class ITEM, class TAG>
      70                 : void PatchList<ITEM, TAG>::addPatchInverted(const Patch<TAG, ITEM>& patch)
      71                 : {
      72                 :         // Filter out empty patches
      73               2 :         if (patch.added.empty() && patch.removed.empty())
      74               0 :                 return;
      75                 : 
      76               8 :         for (typename std::set<ITEM>::const_iterator i = patch.added.begin();
      77                 :                         i != patch.added.end(); ++i)
      78               2 :                 addPatch(Patch<ITEM, TAG>(*i, wibble::singleton(patch.item), wibble::Empty<TAG>()));
      79               4 :         for (typename std::set<ITEM>::const_iterator i = patch.removed.begin();
      80                 :                         i != patch.removed.end(); ++i)
      81               0 :                 addPatch(Patch<ITEM, TAG>(*i, wibble::Empty<TAG>(), wibble::singleton(patch.item)));
      82                 : }
      83                 : 
      84                 : template <class ITEM, class TAG>
      85                 : void PatchList<ITEM, TAG>::addPatchInverted(const PatchList<TAG, ITEM>& patches)
      86                 : {
      87               4 :         for (typename PatchList<TAG, ITEM>::const_iterator i = patches.begin();
      88                 :                         i != patches.end(); i++)
      89               2 :                 addPatchInverted(i->second);
      90               2 : }
      91                 : 
      92                 : 
      93                 : template <class ITEM, class TAG> template<typename COLL1, typename COLL2>
      94                 : void PatchList<ITEM, TAG>::addPatch(const COLL1& im1, const COLL2& im2)
      95                 : {
      96                 :         // FIXME: if I could implement the guarantee that the collection iterators
      97                 :         // iterate in sorted item order, then I wouldn't need to extract all the
      98                 :         // items of im2
      99                 :         std::set<ITEM> im2items = im2.getTaggedItems();
     100                 :         for (typename COLL1::const_iterator i1 = im1.begin();
     101                 :                         i1 != im1.end(); ++i1)
     102                 :         {
     103                 :                 im2items.erase(i1->first);
     104                 :                 std::set<TAG> ts2 = im2.getTagsOfItem(i1->first);
     105                 :                 std::set<TAG> added = ts2 - i1->second;
     106                 :                 std::set<TAG> removed = i1->second - ts2;
     107                 :                 if (!added.empty() || !removed.empty())
     108                 :                         addPatch(Patch<ITEM, TAG>(i1->first, added, removed));
     109                 :         }
     110                 :         for (typename std::set<ITEM>::const_iterator i = im2items.begin();
     111                 :                         i != im2items.end(); ++i)
     112                 :         {
     113                 :                 addPatch(Patch<ITEM, TAG>(*i, im2.getTagsOfItem(*i), wibble::Empty<TAG>()));
     114                 :         }
     115                 : }
     116                 : 
     117                 : template <class ITEM, class TAG>
     118                 : void PatchList<ITEM, TAG>::removeRedundant(const ITEM& item, const std::set<TAG>& tags)
     119                 : {
     120               4 :         iterator i = this->find(item);
     121               4 :         if (i == this->end()) return;
     122               4 :         i->second.removeRedundant(tags);
     123                 : }
     124                 : 
     125                 : template <class ITEM, class TAG>
     126                 : std::set<TAG> PatchList<ITEM, TAG>::patch(const ITEM& item, const std::set<TAG>& tagset) const
     127                 : {
     128                 :         // Find the patch record for this item
     129              14 :         const_iterator p = this->find(item);
     130              14 :         if (p == this->end())
     131                 :                 // If there are no patches, return the tagset unchanged
     132              13 :                 return tagset;
     133                 : 
     134                 :         // There are patches: apply them:
     135               1 :         return p->second.apply(tagset);
     136                 : }
     137                 : 
     138                 : template <class ITEM, class TAG>
     139                 : PatchList<ITEM, TAG> PatchList<ITEM, TAG>::getReverse() const
     140                 : {
     141                 :         PatchList<ITEM, TAG> res;
     142                 :         for (typename PatchList<ITEM, TAG>::const_iterator i = this->begin();
     143                 :                         i != this->end(); i++)
     144                 :                 res.addPatch(i->second.getReverse());
     145                 :         return res;
     146                 : }
     147                 : 
     148                 : template<typename ITEM, typename TAG> template<typename OUT>
     149                 : void PatchList<ITEM, TAG>::output(OUT out) const
     150                 : {
     151               6 :         for (typename PatchList<ITEM, TAG>::const_iterator i = this->begin();
     152                 :                         i != this->end(); ++i)
     153                 :         {
     154               3 :                 *out = i->second;
     155               3 :                 ++out;
     156                 :         }
     157               3 : }
     158                 : 
     159                 : 
     160               6 : }
     161                 : 
     162                 : #endif
     163                 : 
     164                 : // vim:set ts=4 sw=4:

Generated by: LTP GCOV extension version 1.6