LCOV - lcov.info - /usr/include/tagcoll-2.0.11/tagcoll/coll/simple.tcc

LTP GCOV extension - code coverage report
Current view: | directory - usr/include/tagcoll-2.0.11/tagcoll/coll - simple.tcc
Test: | lcov.info
Date: | 2008-08-14 |  | Instrumented lines: | 17
Code covered: | 82.4 % |  | Executed lines: | 14

           1                 : /*
           2                 :  * Merge tags of items appearing multiple times in a stream of tagged items
           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_COLL_SIMPLE_TCC
          22                 : #define TAGCOLL_COLL_SIMPLE_TCC
          23                 :
          24                 : #include <tagcoll/utils/set.h>
          25                 : #include <tagcoll/coll/simple.h>
          26                 : #include <tagcoll/patch.h>
          27                 :
          28                 : #include <wibble/operators.h>
          29                 :
          30                 : using namespace std;
          31                 : using namespace wibble::operators;
          32                 :
          33                 : namespace tagcoll {
          34                 : namespace coll {
          35                 :
          36                 :
          37                 : template<class ITEM, class TAG> template<typename ITEMS, typename TAGS>
          38           42293 : void Simple<ITEM, TAG>::insert(const ITEMS& items, const TAGS& tags)
          39                 : {
          40                 :         using namespace wibble::operators;
          41                 :
          42           42295 :         if (tags.empty())
          43               0 :                 return;
          44           84590 :         for (typename ITEMS::const_iterator i = items.begin();
          45                 :                         i != items.end(); ++i)
          46                 :         {
          47           42295 :                 typename std::map< ITEM, std::set<TAG> >::iterator iter = coll.find(*i);
          48           42295 :                 if (iter == coll.end())
          49           21149 :                         coll.insert(std::make_pair(*i, std::set<TAG>() | tags));
          50                 :                 else
          51           21146 :                         iter->second |= tags;
          52                 :         }
          53                 : }
          54                 :
          55                 : template<class ITEM, class TAG>
          56                 : std::set<TAG> Simple<ITEM, TAG>::getTagsOfItem(const ITEM& item) const
          57                 : {
          58               2 :         typename map< ITEM, std::set<TAG> >::const_iterator i = coll.find(item);
          59                 :
          60               2 :         if (i == coll.end())
          61               0 :                 return std::set<TAG>();
          62                 :         else
          63               2 :                 return i->second;
          64                 : }
          65                 :
          66                 : template<class ITEM, class TAG>
          67                 : std::set<ITEM> Simple<ITEM, TAG>::getItemsHavingTag(const TAG& tag) const
          68                 : {
          69                 :         std::set<ITEM> res;
          70                 :         for (typename map< ITEM, std::set<TAG> >::const_iterator i = coll.begin();
          71                 :                         i != coll.end(); i++)
          72                 :                 if (i->second.find(tag) != i->second.end())
          73                 :                         res |= i->first;
          74                 :         return res;
          75                 : }
          76                 :
          77                 : template<class ITEM, class TAG> template<typename TAGS>
          78                 : std::set<ITEM> Simple<ITEM, TAG>::getItemsHavingTags(const TAGS& tags) const
          79                 : {
          80                 :         std::set<ITEM> res;
          81                 :         for (typename map< ITEM, std::set<TAG> >::const_iterator i = coll.begin();
          82                 :                         i != coll.end(); i++)
          83                 :                 if (utils::set_contains(i->second, tags))
          84                 :                         res |= i->first;
          85                 :         return res;
          86                 : }
          87                 :
          88                 : #if 0
          89                 : template<class T, class Tag>
          90                 : void Simple<T, Tag>::outputReversed(Consumer<Tag, T>& consumer) const
          91                 : {
          92                 :         for (typename map< T, std::set<Tag> >::const_iterator i = coll.begin();
          93                 :                         i != coll.end(); i++)
          94                 :         {
          95                 :                 std::set<T> items;
          96                 :                 items |= i->first;
          97                 :                 consumer.consume(i->second, items);
          98                 :         }
          99                 : }
         100                 : #endif
         101                 :
         102                 : template<class ITEM, class TAG> template<typename TAGS, typename OUT>
         103                 : void Simple<ITEM, TAG>::outputHavingTags(const TAGS& ts, OUT out) const
         104                 : {
         105                 :         for (typename map< ITEM, std::set<TAG> >::const_iterator i = coll.begin();
         106                 :                         i != coll.end(); ++i)
         107                 :                 if (utils::set_contains(i->second, ts))
         108                 :                 {
         109                 :                         *out = *i;
         110                 :                         ++out;
         111                 :                 }
         112                 : }
         113                 :
         114                 :
         115                 :
         116                 : template<class T, class Tag>
         117                 : void Simple<T, Tag>::applyChange(const PatchList<T, Tag>& change)
         118                 : {
         119                 :         for (typename PatchList<T, Tag>::const_iterator i = change.begin(); i != change.end(); i++)
         120                 :         {
         121                 :                 typename map< T, std::set<Tag> >::iterator it = coll.find(i->first);
         122                 :                 if (it == coll.end())
         123                 :                 {
         124                 :                         // If the item doesn't exist, create it
         125                 :                         coll.insert(make_pair(i->first, i->second.added));
         126                 :                 } else {
         127                 :                         it->second = i->second.apply(it->second);
         128                 :                 }
         129                 :         }
         130                 : }
         131                 :
         132                 : template<typename ITEM, typename TAG>
         133                 : std::set<ITEM> Simple<ITEM, TAG>::getTaggedItems() const
         134                 : {
         135                 :         std::set<ITEM> res;
         136                 :         for (typename std::map< ITEM, std::set<TAG> >::const_iterator i = coll.begin();
         137                 :                         i != coll.end(); i++)
         138                 :                 res.insert(i->first);
         139                 :         return res;
         140                 : }
         141                 :
         142                 : template<class T, class Tag>
         143                 : std::set<Tag> Simple<T, Tag>::getAllTags() const
         144                 : {
         145               3 :         std::set<Tag> tags;
         146                 :
         147               6 :         for (typename map< T, std::set<Tag> >::const_iterator i = coll.begin();
         148                 :                         i != coll.end(); i++)
         149               3 :                 tags |= i->second;
         150                 :
         151               0 :         return tags;
         152                 : }
         153                 :
         154                 : template<class T, class Tag>
         155                 : std::set<Tag> Simple<T, Tag>::getCompanionTags(const std::set<Tag>& ts) const
         156                 : {
         157                 :         std::set<Tag> tags;
         158                 :
         159                 :         for (typename map< T, std::set<Tag> >::const_iterator i = coll.begin();
         160                 :                         i != coll.end(); i++)
         161                 :                 if (utils::set_contains(i->second, (ts)))
         162                 :                         tags |= i->second - ts;
         163                 :
         164                 :         return tags;
         165                 : }
         166                 :
         167                 : template<class T, class Tag>
         168                 : std::set<T> Simple<T, Tag>::getRelatedItems(const std::set<Tag>& tags, int maxdistance) const
         169                 : {
         170                 :         std::set<T> res;
         171                 :
         172                 :         for (typename map< T, std::set<Tag> >::const_iterator i = coll.begin();
         173                 :                         i != coll.end(); i++)
         174                 :         {
         175                 :                 int dist = utils::set_distance(tags, i->second);
         176                 :                 if (dist >= 0 && dist <= maxdistance)
         177                 :                         res |= i->first;
         178                 :         }
         179                 :
         180                 :         return res;
         181                 : }
         182                 :
         183                 : template<class T, class Tag>
         184                 : unsigned int Simple<T, Tag>::itemCount() const
         185                 : {
         186               5 :         return coll.size();
         187                 : }
         188                 :
         189                 : }
         190                 : }
         191                 :
         192                 : #include <tagcoll/coll/base.tcc>
         193                 :
         194                 : #endif
         195                 :
         196                 : // vim:set ts=4 sw=4:

Generated by: LTP GCOV extension version 1.6