LTP GCOV extension - code coverage report
Current view: | directory - usr/include/tagcoll-2.0.11/tagcoll - patch.h
Test: | lcov.info
Date: | 2008-08-14 |  | Instrumented lines: | 42
Code covered: | 100.0 % |  | Executed lines: | 42

           1                 : #ifndef TAGCOLL_PATCHES_H
           2                 : #define TAGCOLL_PATCHES_H
           3                 :
           4                 : /** \file
           5                 :  * Classes handling tag patches
           6                 :  */
           7                 :
           8                 : /*
           9                 :  * Copyright (C) 2003,2004,2005,2006  Enrico Zini <enrico@debian.org>
          10                 :  *
          11                 :  * This library is free software; you can redistribute it and/or
          12                 :  * modify it under the terms of the GNU Lesser General Public
          13                 :  * License as published by the Free Software Foundation; either
          14                 :  * version 2.1 of the License, or (at your option) any later version.
          15                 :  *
          16                 :  * This library is distributed in the hope that it will be useful,
          17                 :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
          18                 :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
          19                 :  * Lesser General Public License for more details.
          20                 :  *
          21                 :  * You should have received a copy of the GNU Lesser General Public
          22                 :  * License along with this library; if not, write to the Free Software
          23                 :  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
          24                 :  */
          25                 :
          26                 : #include <wibble/operators.h>
          27                 : #include <wibble/mixin.h>
          28                 : #include <map>
          29                 : #include <string>
          30                 :
          31                 : namespace tagcoll
          32                 : {
          33                 :
          34                 : /**
          35                 :  * Patch for the tagset of a specific item
          36                 :  */
          37                 : template <typename ITEM, typename TAG>
          38                 : struct Patch
          39                 : {
          40                 :         ITEM item;
          41                 :         std::set<TAG> added;
          42                 :         std::set<TAG> removed;
          43                 :
          44              55 :         Patch(const Patch<ITEM, TAG>& p) : item(p.item), added(p.added), removed(p.removed) {}
          45               5 :         Patch(const ITEM& item) : item(item) {}
          46               2 :         Patch(const ITEM& item, const std::set<TAG>& added, const std::set<TAG>& removed);
          47                 :         template<typename CONTA, typename CONTB>
          48               2 :         Patch(const ITEM& item, const CONTA& added, const CONTB& removed);
          49              66 :         ~Patch() {}
          50                 :
          51               5 :         void add(const TAG& tag)
          52                 :         {
          53                 :                 using namespace wibble::operators;
          54               5 :                 added |= tag; removed -= tag;
          55               5 :         }
          56               2 :         void add(const std::set<TAG>& tags)
          57                 :         {
          58                 :                 using namespace wibble::operators;
          59               2 :                 added |= tags; removed -= tags;
          60               2 :         }
          61               2 :         void remove(const TAG& tag)
          62                 :         {
          63                 :                 using namespace wibble::operators;
          64               2 :                 removed |= tag; added -= tag;
          65               2 :         }
          66               2 :         void remove(const std::set<TAG>& tags)
          67                 :         {
          68                 :                 using namespace wibble::operators;
          69               2 :                 removed |= tags; added -= tags;
          70               2 :         }
          71                 :
          72                 :         Patch<ITEM, TAG> getReverse() const
          73                 :         {
          74                 :                 return Patch<ITEM, TAG>(item, removed, added);
          75                 :         }
          76                 :
          77               2 :         void mergeWith(const Patch<ITEM, TAG>& patch)
          78                 :         {
          79               2 :                 add(patch.added);
          80               2 :                 remove(patch.removed);
          81               2 :         }
          82                 :
          83               1 :         std::set<TAG> apply(const std::set<TAG>& ts) const
          84                 :         {
          85                 :                 using namespace wibble::operators;
          86               1 :                 return (ts | added) - removed;
          87                 :         }
          88                 :
          89                 :         template<typename TAGS>
          90                 :         std::set<TAG> apply(const TAGS& tags) const
          91                 :         {
          92                 :                 using namespace wibble::operators;
          93                 :                 std::set<TAG> ts;
          94                 :                 for (typename TAGS::const_iterator i = tags.begin();
          95                 :                                 i != tags.end(); ++i)
          96                 :                         ts.insert(*i);
          97                 :                 return (ts | added) - removed;
          98                 :         }
          99                 :
         100               4 :         void removeRedundant(const std::set<TAG> ts)
         101                 :         {
         102                 :                 using namespace wibble::operators;
         103                 :                 // Don't add what already exists
         104               4 :                 added -= ts;
         105                 :                 // Don't remove what does not exist
         106               4 :                 removed -= (removed - ts);
         107               4 :         }
         108                 :
         109                 :         bool operator==(const Patch<ITEM, TAG>& p) const
         110                 :         {
         111                 :                 return p.item == item && p.added == added && p.removed == removed;
         112                 :         }
         113                 :         bool operator!=(const Patch<ITEM, TAG>& p) const
         114                 :         {
         115                 :                 return p.item != item || p.added != added || p.removed != removed;
         116                 :         }
         117                 : };
         118                 :
         119                 : /**
         120                 :  * List of patches that can be applied to a TaggedCollection
         121                 :  */
         122                 : template <class ITEM, class TAG>
         123                 : class PatchList : public std::map<ITEM, Patch<ITEM, TAG> >
         124              36 : {
         125                 : public:
         126              32 :         PatchList() {}
         127               3 :         PatchList(const PatchList& pl) : std::map<ITEM, Patch<ITEM, TAG> >(pl) {}
         128                 :
         129                 :         typedef typename std::map<ITEM, Patch<ITEM, TAG> >::const_iterator const_iterator;
         130                 :         typedef typename std::map<ITEM, Patch<ITEM, TAG> >::iterator iterator;
         131                 :
         132                 :         /**
         133                 :          * Add to this patchlist the patches needed to transform `im1' in `im2'
         134                 :          */
         135                 :         template<typename COLL1, typename COLL2>
         136                 :         void addPatch(const COLL1& im1, const COLL2& im2);
         137                 :
         138                 :         /**
         139                 :          * Add `patch' to this PatchList
         140                 :          */
         141              15 :         void addPatch(const Patch<ITEM, TAG>& patch);
         142                 :
         143                 :         /**
         144                 :          * Add `patches' to this PatchList
         145                 :          */
         146                 :         void addPatch(const PatchList<ITEM, TAG>& patches);
         147                 :
         148                 :         /**
         149                 :          * Add 'patch' to this PatchList, as tag: +/- package rather than package
         150                 :          * +/- tag
         151                 :          */
         152               2 :         void addPatchInverted(const Patch<TAG, ITEM>& patch);
         153                 :
         154                 :         /**
         155                 :          * Add 'patches' to this PatchList, as tag: +/- package rather than package
         156                 :          * +/- tag
         157                 :          */
         158               2 :         void addPatchInverted(const PatchList<TAG, ITEM>& patches);
         159                 :
         160                 :         /**
         161                 :          * If the PatchList contains the give item, invoke
         162                 :          * Patch::removeRedundant(tags) on its patch
         163                 :          */
         164               4 :         void removeRedundant(const ITEM& item, const std::set<TAG>& tags);
         165                 :
         166                 :         /**
         167                 :          * Patch a tagged item
         168                 :          *
         169                 :          * @return
         170                 :          *   The new (patched) set of tags
         171                 :          */
         172              14 :         std::set<TAG> patch(const ITEM& item, const std::set<TAG>& tagset) const;
         173                 :
         174                 :         // Output the patch list to a TagcollConsumer
         175                 :         template<typename OUT>
         176               3 :         void output(OUT out) const;
         177                 :
         178                 :         PatchList<ITEM, TAG> getReverse() const;
         179                 : };
         180                 :
         181                 : template<typename ITEM, typename TAG>
         182                 : class Inserter : public wibble::mixin::OutputIterator< Inserter<ITEM, TAG> >
         183                 : {
         184                 :         PatchList<ITEM, TAG>& patches;
         185                 : public:
         186               3 :         Inserter(PatchList<ITEM, TAG>& patches) : patches(patches) {}
         187                 :
         188               3 :         Inserter<ITEM, TAG>& operator=(const Patch<ITEM, TAG>& patch)
         189                 :         {
         190               3 :                 patches.addPatch(patch);
         191               3 :                 return *this;
         192                 :         }
         193                 : };
         194                 :
         195                 : template<typename ITEM, typename TAG>
         196               3 : Inserter<ITEM, TAG> inserter(PatchList<ITEM, TAG>& patches)
         197                 : {
         198               3 :         return Inserter<ITEM, TAG>(patches);
         199                 : }
         200                 :
         201                 : }
         202                 :
         203                 : // vim:set ts=4 sw=4:
         204                 : #endif

Generated by: LTP GCOV extension version 1.6