LTP GCOV extension - code coverage report
Current view: directory - ept/debtags/maint - serializer.h
Test: lcov.info
Date: 2008-08-14 Instrumented lines: 89
Code covered: 97.8 % Executed lines: 87

       1                 : // -*- mode: c++; tab-width: 4; indent-tabs-mode: t -*-
       2                 : /**
       3                 :  * @file cache/component/debtags/serializer.h
       4                 :  * @author Enrico Zini (enrico) <enrico@enricozini.org>
       5                 :  */
       6                 : 
       7                 : #ifndef EPT_DEBTAGS_SERIALIZER_H
       8                 : #define EPT_DEBTAGS_SERIALIZER_H
       9                 : 
      10                 : #include <ept/debtags/vocabulary.h>
      11                 : #include <ept/debtags/maint/pkgid.h>
      12                 : #include <tagcoll/patch.h>
      13                 : #include <wibble/mixin.h>
      14                 : #include <string>
      15                 : 
      16                 : namespace ept {
      17                 : namespace debtags {
      18                 : 
      19                 : template<typename OUT>
      20                 : class IntToPkg : public wibble::mixin::OutputIterator< IntToPkg<OUT> >
      21                 : {
      22                 :         PkgId& pkgid;
      23                 :         Vocabulary& voc;
      24                 :         OUT out;
      25                 : 
      26                 : public:
      27               5 :         IntToPkg(PkgId& pkgid, Vocabulary& voc, const OUT& out)
      28               5 :                 : pkgid(pkgid), voc(voc), out(out) {}
      29                 : 
      30                 :         template<typename ITEMS, typename TAGS>
      31           42291 :         IntToPkg<OUT>& operator=(const std::pair<ITEMS, TAGS>& data)
      32                 :         {
      33           42291 :                 std::set<std::string> ritems;
      34           42291 :                 std::set<Tag> rtags;
      35                 : 
      36           84582 :                 for (typename ITEMS::const_iterator i = data.first.begin();
      37                 :                                 i != data.first.end(); ++i)
      38                 :                 {
      39           42291 :                         std::string pkg = pkgid.byID(*i);
      40           42291 :                         if (!pkg.empty())
      41           42291 :                                 ritems.insert(pkg);
      42                 :                 }
      43                 : 
      44          253489 :                 for (typename TAGS::const_iterator i = data.second.begin();
      45                 :                                 i != data.second.end(); ++i)
      46                 :                 {
      47          211198 :                         Tag t = voc.tagByID(*i);
      48          211198 :                         if (t.valid())
      49          211198 :                                 rtags.insert(t);
      50                 :                 }
      51                 : 
      52           42291 :                 if (!ritems.empty() && !rtags.empty())
      53                 :                 {
      54           42267 :                         *out = make_pair(ritems, rtags);
      55           42267 :                         ++out;
      56                 :                 }
      57           42291 :                 return *this;
      58                 :         }
      59                 : };
      60                 : 
      61                 : template<typename OUT>
      62               5 : IntToPkg<OUT> intToPkg(PkgId& pkgid, Vocabulary& voc, const OUT& out)
      63                 : {
      64               5 :         return IntToPkg<OUT>(pkgid, voc, out);
      65                 : }
      66                 : 
      67                 : template<typename OUT>
      68                 : class StringToInt : public wibble::mixin::OutputIterator< StringToInt<OUT> >
      69                 : {
      70                 :         PkgId& pkgid;
      71                 :         Vocabulary& voc;
      72                 :         OUT out;
      73                 : 
      74                 : public:
      75               2 :         StringToInt(PkgId& pkgid, Vocabulary& voc, const OUT& out)
      76               2 :                 : pkgid(pkgid), voc(voc), out(out) {}
      77                 : 
      78                 :         template<typename ITEMS, typename TAGS>
      79           21146 :         StringToInt<OUT>& operator=(const std::pair<ITEMS, TAGS>& data)
      80                 :         {
      81           21146 :                 std::set<int> ritems;
      82           21146 :                 std::set<int> rtags;
      83                 : 
      84           42292 :                 for (typename ITEMS::const_iterator i = data.first.begin();
      85                 :                                 i != data.first.end(); ++i)
      86                 :                 {
      87           21146 :                         int id = pkgid.byName(*i);
      88           21146 :                         if (id != -1)
      89           21146 :                                 ritems.insert(id);
      90                 :                 }
      91                 : 
      92          126874 :                 for (typename TAGS::const_iterator i = data.second.begin();
      93                 :                                 i != data.second.end(); ++i)
      94                 :                 {
      95          105728 :                         Tag t = voc.tagByName(*i);
      96          105728 :                         if (t.valid())
      97          105600 :                                 rtags.insert(t.id());
      98                 :                 }
      99                 : 
     100           21146 :                 if (!ritems.empty() && !rtags.empty())
     101                 :                 {
     102           21134 :                         *out = make_pair(ritems, rtags);
     103           21134 :                         ++out;
     104                 :                 }
     105           21146 :                 return *this;
     106                 :         }
     107                 : 
     108                 : };
     109                 : 
     110                 : template<typename OUT>
     111               2 : StringToInt<OUT> stringToInt(PkgId& pkgid, Vocabulary& voc, const OUT& out)
     112                 : {
     113               2 :         return StringToInt<OUT>(pkgid, voc, out);
     114                 : }
     115                 : 
     116                 : template<typename OUT>
     117                 : class StringToPkg : public wibble::mixin::OutputIterator< StringToPkg<OUT> >
     118                 : {
     119                 :         PkgId& pkgid;
     120                 :         Vocabulary& voc;
     121                 :         OUT out;
     122                 : 
     123                 : public:
     124                 :         StringToPkg(PkgId& pkgid, Vocabulary& voc, const OUT& out)
     125                 :                 : pkgid(pkgid), voc(voc), out(out) {}
     126                 : 
     127                 :         template<typename ITEMS, typename TAGS>
     128                 :         StringToPkg<OUT>& operator=(const std::pair<ITEMS, TAGS>& data)
     129                 :         {
     130                 :                 std::set<std::string> ritems;
     131                 :                 std::set<Tag> rtags;
     132                 : 
     133                 :                 for (typename ITEMS::const_iterator i = data.first.begin();
     134                 :                                 i != data.first.end(); ++i)
     135                 :                 {
     136                 :                         // Ensure that the package exists in the pkgid database
     137                 :                         if (pkgid.byName(*i) == -1)
     138                 :                                 continue;
     139                 :                         ritems.insert(*i);
     140                 :                 }
     141                 : 
     142                 :                 for (typename TAGS::const_iterator i = data.second.begin();
     143                 :                                 i != data.second.end(); ++i)
     144                 :                 {
     145                 :                         Tag t = voc.tagByName(*i);
     146                 :                         if (t.valid())
     147                 :                                 rtags.insert(t);
     148                 :                 }
     149                 : 
     150                 :                 if (!ritems.empty() && !rtags.empty())
     151                 :                 {
     152                 :                         *out = make_pair(ritems, rtags);
     153                 :                         ++out;
     154                 :                 }
     155                 :                 return *this;
     156                 :         }
     157                 : 
     158                 : };
     159                 : 
     160                 : template<typename OUT>
     161                 : StringToPkg<OUT> stringToPkg(PkgId& pkgid, Vocabulary& voc, const OUT& out)
     162                 : {
     163                 :         return StringToPkg<OUT>(pkgid, voc, out);
     164                 : }
     165                 : 
     166                 : template<typename OUT>
     167                 : class PkgToString : public wibble::mixin::OutputIterator< PkgToString<OUT> >
     168                 : {
     169                 :         OUT out;
     170                 : public:
     171               1 :         PkgToString(const OUT& out) : out(out) {}
     172                 : 
     173                 :         template<typename ITEMS, typename TAGS>
     174               1 :         PkgToString<OUT>& operator=(const std::pair<ITEMS, TAGS>& data)
     175                 :         {
     176               1 :                 std::set<std::string> stags;
     177               3 :                 for (typename TAGS::const_iterator i = data.second.begin();
     178                 :                                 i != data.second.end(); ++i)
     179               2 :                         if (i->valid())
     180               2 :                                 stags.insert(i->fullname());
     181               1 :                 *out = make_pair(data.first, stags);
     182               1 :                 ++out;
     183               1 :                 return *this;
     184                 :         }
     185                 : };
     186                 : 
     187                 : template<typename OUT>
     188               1 : PkgToString<OUT> pkgToString(const OUT& out)
     189                 : {
     190               1 :         return PkgToString<OUT>(out);
     191                 : }
     192                 : 
     193                 : template<typename OUT>
     194                 : class PatchStringToInt : public wibble::mixin::OutputIterator< PatchStringToInt<OUT> >
     195                 : {
     196                 :         PkgId& pkgid;
     197                 :         Vocabulary& voc;
     198                 :         OUT out;
     199                 : 
     200                 : public:
     201               1 :         PatchStringToInt(PkgId& pkgid, Vocabulary& voc, const OUT& out)
     202               1 :                 : pkgid(pkgid), voc(voc), out(out) {}
     203                 : 
     204               1 :         PatchStringToInt<OUT>& operator=(const tagcoll::Patch<std::string, std::string>& patch)
     205                 :         {
     206               1 :                 int id = pkgid.byName(patch.item);
     207               1 :                 if (id == -1)
     208               0 :                         return *this;
     209                 : 
     210               1 :                 tagcoll::Patch<int, int> res(id);
     211               2 :                 for (std::set<std::string>::const_iterator i = patch.added.begin();
     212                 :                                 i != patch.added.end(); ++i)
     213                 :                 {
     214               1 :                         Tag tag = voc.tagByName(*i);
     215               1 :                         if (tag.valid())
     216               1 :                                 res.add(tag.id());
     217                 :                 }
     218               2 :                 for (std::set<std::string>::const_iterator i = patch.removed.begin();
     219                 :                                 i != patch.removed.end(); ++i)
     220                 :                 {
     221               1 :                         Tag tag = voc.tagByName(*i);
     222               1 :                         if (tag.valid())
     223               1 :                                 res.remove(tag.id());
     224                 :                 }
     225               1 :                 *out = res;
     226               1 :                 ++out;
     227               1 :                 return *this;
     228                 :         }
     229                 : };
     230                 : 
     231                 : template<typename OUT>
     232               1 : PatchStringToInt<OUT> patchStringToInt(PkgId& pkgid, Vocabulary& voc, const OUT& out)
     233                 : {
     234               1 :         return PatchStringToInt<OUT>(pkgid, voc, out);
     235                 : }
     236                 : 
     237                 : template<typename OUT>
     238                 : class PatchIntToString : public wibble::mixin::OutputIterator< PatchIntToString<OUT> >
     239                 : {
     240                 :         PkgId& pkgid;
     241                 :         Vocabulary& voc;
     242                 :         OUT out;
     243                 : 
     244                 : public:
     245               2 :         PatchIntToString(PkgId& pkgid, Vocabulary& voc, const OUT& out)
     246               2 :                 : pkgid(pkgid), voc(voc), out(out) {}
     247                 : 
     248               2 :         PatchIntToString<OUT>& operator=(const tagcoll::Patch<int, int>& patch)
     249                 :         {
     250               2 :                 std::string name = pkgid.byID(patch.item);
     251               2 :                 if (name.empty())
     252               0 :                         return *this;
     253                 : 
     254               2 :                 tagcoll::Patch<std::string, std::string> res(name);
     255               4 :                 for (std::set<int>::const_iterator i = patch.added.begin();
     256                 :                                 i != patch.added.end(); ++i)
     257                 :                 {
     258               2 :                         Tag tag = voc.tagByID(*i);
     259               2 :                         if (tag.valid())
     260               2 :                                 res.add(tag.fullname());
     261                 :                 }
     262               3 :                 for (std::set<int>::const_iterator i = patch.removed.begin();
     263                 :                                 i != patch.removed.end(); ++i)
     264                 :                 {
     265               1 :                         Tag tag = voc.tagByID(*i);
     266               1 :                         if (tag.valid())
     267               1 :                                 res.remove(tag.fullname());
     268                 :                 }
     269               2 :                 *out = res;
     270               2 :                 ++out;
     271               2 :                 return *this;
     272                 :         }
     273                 : };
     274                 : 
     275                 : template<typename OUT>
     276               2 : PatchIntToString<OUT> patchIntToString(PkgId& pkgid, Vocabulary& voc, const OUT& out)
     277                 : {
     278               2 :         return PatchIntToString<OUT>(pkgid, voc, out);
     279                 : }
     280                 : 
     281                 : #if 0
     282                 :         GOOD STUFF
     283                 : 
     284                 : template<typename OUT>
     285                 : class ToInt : public wibble::mixin::OutputIterator< ToInt<OUT> >
     286                 : {
     287                 :         OUT out;
     288                 : public:
     289                 :         ToInt(const OUT& out) : out(out) {}
     290                 : 
     291                 :         template<typename ITEMS, typename TAGS>
     292                 :         ToInt<OUT>& operator=(const std::pair<ITEMS, TAGS>& data)
     293                 :         {
     294                 :                 std::set<int> iitems;
     295                 :                 std::set<int> itags;
     296                 :                 for (typename ITEMS::const_iterator i = data.first.begin();
     297                 :                                 i != data.first.end(); ++i)
     298                 :                         if (i->valid())
     299                 :                                 iitems.insert(i->ondiskId());
     300                 :                 for (typename TAGS::const_iterator i = data.second.begin();
     301                 :                                 i != data.second.end(); ++i)
     302                 :                         if (i->valid())
     303                 :                                 itags.insert(i->id());
     304                 :                 *out = make_pair(iitems, itags);
     305                 :                 ++out;
     306                 :                 return *this;
     307                 :         }
     308                 : };
     309                 : 
     310                 : template<typename OUT>
     311                 : ToInt<OUT> toInt(const OUT& out)
     312                 : {
     313                 :         return ToInt<OUT>(out);
     314                 : }
     315                 : 
     316                 : template<typename ITEMCONV, typename TAGCONV, typename OUT>
     317                 : class Converter : public wibble::mixin::OutputIterator< Converter<ITEMCONV, TAGCONV, OUT> >
     318                 : {
     319                 :         ITEMCONV itemconv;
     320                 :         TAGCONV tagconv;
     321                 :         OUT out;
     322                 : 
     323                 : public:
     324                 :         Converter(const ITEMCONV& itemconv, const TAGCONV& tagconv, const OUT& out)
     325                 :                 : itemconv(itemconv), tagconv(tagconv), out(out) {}
     326                 : 
     327                 :         template<typename ITEMS, typename TAGS>
     328                 :         Converter<ITEMCONV, TAGCONV, OUT>& operator=(const std::pair<ITEMS, TAGS>& data)
     329                 :         {
     330                 :                 *out = make_pair(itemconv(data.first), tagconv(data.second));
     331                 :                 ++out;
     332                 :                 return *this;
     333                 :         }
     334                 : };
     335                 : 
     336                 : template<typename ITEMCONV, typename TAGCONV, typename OUT>
     337                 : Converter<ITEMCONV, TAGCONV, OUT> converter(const ITEMCONV& itemconv, const TAGCONV& tagconv, const OUT& out)
     338                 : {
     339                 :         return Converter<ITEMCONV, TAGCONV, OUT>(itemconv, tagconv, out);
     340                 : }
     341                 : 
     342                 : 
     343                 : template<typename OUT>
     344                 : class PatchToString : public wibble::mixin::OutputIterator< PatchToString<OUT> >
     345                 : {
     346                 :         OUT out;
     347                 : 
     348                 : public:
     349                 :         PatchToString(const OUT& out) : out(out) {}
     350                 : 
     351                 :         template<typename PKG, typename TAG>
     352                 :         PatchToString<OUT>& operator=(const tagcoll::Patch<PKG, TAG>& patch)
     353                 :         {
     354                 :                 if (!patch.item.valid())
     355                 :                         return *this;
     356                 : 
     357                 :                 tagcoll::Patch<std::string, std::string> res(patch.item.name());
     358                 :                 for (typename std::set<TAG>::const_iterator i = patch.added.begin();
     359                 :                                 i != patch.added.end(); ++i)
     360                 :                         if (i->valid())
     361                 :                                 res.add(i->fullname());
     362                 :                 for (typename std::set<TAG>::const_iterator i = patch.removed.begin();
     363                 :                                 i != patch.removed.end(); ++i)
     364                 :                         if (i->valid())
     365                 :                                 res.remove(i->fullname());
     366                 :                 *out = res;
     367                 :                 ++out;
     368                 :                 return *this;
     369                 :         }
     370                 : };
     371                 : 
     372                 : template<typename OUT>
     373                 : PatchToString<OUT> patchToString(const OUT& out)
     374                 : {
     375                 :         return PatchToString<OUT>(out);
     376                 : }
     377                 : 
     378                 : #endif
     379                 : 
     380                 : }
     381                 : }
     382                 : 
     383                 : #if 0
     384                 : 
     385                 : namespace tagcoll {
     386                 : namespace coll {
     387                 : 
     388                 : template<>
     389                 : struct coll_traits< ept::cache::debtags::DebtagsIndex >
     390                 : {
     391                 :         typedef ept::cache::Package<> item_type;
     392                 :         typedef ept::cache::debtags::Tag tag_type;
     393                 :         typedef std::set< ept::cache::Package<> > itemset_type;
     394                 :         typedef std::set<ept::cache::debtags::Tag> tagset_type;
     395                 : };
     396                 : 
     397                 : }
     398                 : }
     399                 : 
     400                 : namespace ept {
     401                 : namespace cache {
     402                 : namespace debtags {
     403                 : 
     404                 : #if 0
     405                 : /**
     406                 :  * Convert Facets to ints
     407                 :  */
     408                 : class FacetIntConverter : public Implementation<FacetIntConverter>,
     409                 :         public Tagcoll::Converter<aptFront::cache::entity::Facet, int>,
     410                 :         public Tagcoll::Converter<int, aptFront::cache::entity::Facet>
     411                 : {
     412                 :         typedef aptFront::cache::entity::Facet Facet;
     413                 :         typedef Tagcoll::OpSet<aptFront::cache::entity::Facet> FacetSet;
     414                 :         typedef Tagcoll::OpSet<int> IntSet;
     415                 : public:
     416                 :         virtual int operator()(const aptFront::cache::entity::Facet& item) const;
     417                 :         virtual aptFront::cache::entity::Facet operator()(const int& item) const;
     418                 : 
     419                 :         virtual IntSet operator()(const FacetSet& item) const
     420                 :                 { return Tagcoll::Converter<Facet, int>::operator()(item); }
     421                 :         virtual FacetSet operator()(const IntSet& item) const
     422                 :                 { return Tagcoll::Converter<int, Facet>::operator()(item); }
     423                 : 
     424                 :         static std::string componentName();
     425                 : };
     426                 : 
     427                 : /**
     428                 :  * Convert Facets to strings
     429                 :  */
     430                 : class FacetStringConverter : public Implementation<FacetStringConverter>,
     431                 :         public Tagcoll::Converter<aptFront::cache::entity::Facet, std::string>,
     432                 :         public Tagcoll::Converter<std::string, aptFront::cache::entity::Facet>
     433                 : {
     434                 :         typedef aptFront::cache::entity::Facet Facet;
     435                 :         typedef Tagcoll::OpSet<aptFront::cache::entity::Facet> FacetSet;
     436                 :         typedef Tagcoll::OpSet<std::string> StringSet;
     437                 : public:
     438                 :         virtual std::string operator()(const aptFront::cache::entity::Facet& item) const;
     439                 :         virtual aptFront::cache::entity::Facet operator()(const std::string& item) const;
     440                 : 
     441                 :         virtual StringSet operator()(const FacetSet& item) const
     442                 :                 { return Tagcoll::Converter<Facet, std::string>::operator()(item); }
     443                 :         virtual FacetSet operator()(const StringSet& item) const
     444                 :                 { return Tagcoll::Converter<std::string, Facet>::operator()(item); }
     445                 : 
     446                 :         static std::string componentName();
     447                 : };
     448                 : 
     449                 : /**
     450                 :  * Convert Vocabulary to ints
     451                 :  */
     452                 : class TagIntConverter : public Implementation<TagIntConverter>,
     453                 :         public Tagcoll::Converter<aptFront::cache::entity::Tag, int>,
     454                 :         public Tagcoll::Converter<int, aptFront::cache::entity::Tag>
     455                 : {
     456                 :         typedef aptFront::cache::entity::Tag Tag;
     457                 :         typedef Tagcoll::OpSet<aptFront::cache::entity::Tag> TagSet;
     458                 :         typedef Tagcoll::OpSet<int> IntSet;
     459                 : public:
     460                 :         virtual int operator()(const aptFront::cache::entity::Tag& item) const;
     461                 :         virtual aptFront::cache::entity::Tag operator()(const int& item) const;
     462                 : 
     463                 :         virtual IntSet operator()(const TagSet& item) const
     464                 :                 { return Tagcoll::Converter<Tag, int>::operator()(item); }
     465                 :         virtual TagSet operator()(const IntSet& item) const
     466                 :                 { return Tagcoll::Converter<int, Tag>::operator()(item); }
     467                 : 
     468                 :         static std::string componentName();
     469                 : };
     470                 : 
     471                 : /**
     472                 :  * Convert Vocabulary to strings
     473                 :  */
     474                 : class TagStringConverter : public Implementation<TagStringConverter>,
     475                 :         public Tagcoll::Converter<aptFront::cache::entity::Tag, std::string>,
     476                 :         public Tagcoll::Converter<std::string, aptFront::cache::entity::Tag>
     477                 : {
     478                 :         typedef aptFront::cache::entity::Tag Tag;
     479                 :         typedef Tagcoll::OpSet<aptFront::cache::entity::Tag> TagSet;
     480                 :         typedef Tagcoll::OpSet<std::string> StringSet;
     481                 : public:
     482                 :         virtual std::string operator()(const Tag& item) const;
     483                 :         virtual Tag operator()(const std::string& item) const;
     484                 : 
     485                 :         virtual StringSet operator()(const TagSet& item) const
     486                 :                 { return Tagcoll::Converter<Tag, std::string>::operator()(item); }
     487                 :         virtual TagSet operator()(const StringSet& item) const
     488                 :                 { return Tagcoll::Converter<std::string, Tag>::operator()(item); }
     489                 : 
     490                 :         TagSet parseTagList(const std::string& str) const;
     491                 : 
     492                 :         static std::string componentName();
     493                 : };
     494                 : 
     495                 : /**
     496                 :  * Convert Aggregator to ints
     497                 :  */
     498                 : class PackageIntConverter : public Implementation<PackageIntConverter>,
     499                 :         public Tagcoll::Converter<aptFront::cache::entity::Package, int>,
     500                 :         public Tagcoll::Converter<int, aptFront::cache::entity::Package>
     501                 : {
     502                 :         typedef aptFront::cache::entity::Package Package;
     503                 :         typedef Tagcoll::OpSet<aptFront::cache::entity::Package> PackageSet;
     504                 :         typedef Tagcoll::OpSet<int> IntSet;
     505                 : public:
     506                 :         virtual int operator()(const Package& item) const;
     507                 :         virtual Package operator()(const int& item) const;
     508                 : 
     509                 :         virtual IntSet operator()(const PackageSet& item) const
     510                 :                 { return Tagcoll::Converter<Package, int>::operator()(item); }
     511                 :         virtual PackageSet operator()(const IntSet& item) const
     512                 :                 { return Tagcoll::Converter<int, Package>::operator()(item); }
     513                 : 
     514                 :         static std::string componentName();
     515                 : };
     516                 : 
     517                 : /**
     518                 :  * Convert Aggregator to strings
     519                 :  */
     520                 : class PackageStringConverter : public Implementation<PackageStringConverter>,
     521                 :         public Tagcoll::Converter<aptFront::cache::entity::Package, std::string>,
     522                 :         public Tagcoll::Converter<std::string, aptFront::cache::entity::Package>
     523                 : {
     524                 :         typedef aptFront::cache::entity::Package Package;
     525                 :         typedef Tagcoll::OpSet<aptFront::cache::entity::Package> PackageSet;
     526                 :         typedef Tagcoll::OpSet<std::string> StringSet;
     527                 : public:
     528                 :         virtual std::string operator()(const Package& item) const;
     529                 :         virtual Package operator()(const std::string& item) const;
     530                 : 
     531                 :         virtual StringSet operator()(const PackageSet& item) const
     532                 :                 { return Tagcoll::Converter<Package, std::string>::operator()(item); }
     533                 :         virtual PackageSet operator()(const StringSet& item) const
     534                 :                 { return Tagcoll::Converter<std::string, Package>::operator()(item); }
     535                 : 
     536                 :         static std::string componentName();
     537                 : };
     538                 : 
     539                 : #endif
     540                 : 
     541                 : }
     542                 : }
     543                 : }
     544                 : 
     545                 : #endif
     546                 : 
     547                 : #endif
     548                 : // -*- mode: c++; tab-width: 4; indent-tabs-mode: t -*-
     549                 : 
     550                 : #if 0
     551                 : /**
     552                 :  * @file cache/debtags/serializer.h
     553                 :  * @author Enrico Zini (enrico) <enrico@enricozini.org>
     554                 :  */
     555                 : 
     556                 : #ifndef EPT_CACHE_DEBTAGS_SERIALIZER_TCC
     557                 : #define EPT_CACHE_DEBTAGS_SERIALIZER_TCC
     558                 : 
     559                 : #include <ept/cache/debtags/serializer.h>
     560                 : #if 0
     561                 : #include <ept/cache/debtags/pkgidx.h>
     562                 : #include <ept/cache/debtags/vocabulary.h>
     563                 : #include <ept/cache/package.h>
     564                 : //#include <ept/cache/cache.h>
     565                 : #endif
     566                 : 
     567                 : namespace ept {
     568                 : namespace t {
     569                 : namespace cache {
     570                 : namespace debtags {
     571                 : 
     572                 : 
     573                 : 
     574                 : #if 0
     575                 : string FacetIntConverter::componentName() { return "FacetIntConverter"; }
     576                 : 
     577                 : int FacetIntConverter::operator()(const aptFront::cache::entity::Facet& item) const
     578                 : {
     579                 :         if (!item.valid()) return -1;
     580                 :         return item.id();
     581                 : }
     582                 : aptFront::cache::entity::Facet FacetIntConverter::operator()(const int& item) const
     583                 : {
     584                 :         return cache().tags().facetByID(item);
     585                 : }
     586                 : 
     587                 : string FacetStringConverter::componentName() { return "FacetStringConverter"; }
     588                 : 
     589                 : std::string FacetStringConverter::operator()(const aptFront::cache::entity::Facet& item) const
     590                 : {
     591                 :         if (!item.valid()) return string();
     592                 :         return item.name();
     593                 : }
     594                 : aptFront::cache::entity::Facet FacetStringConverter::operator()(const std::string& item) const
     595                 : {
     596                 :         return cache().tags().facetByName(item);
     597                 : }
     598                 : 
     599                 : string TagIntConverter::componentName() { return "TagIntConverter"; }
     600                 : 
     601                 : int TagIntConverter::operator()(const aptFront::cache::entity::Tag& item) const
     602                 : {
     603                 :         if (!item.valid()) return -1;
     604                 :         return item.id();
     605                 : }
     606                 : aptFront::cache::entity::Tag TagIntConverter::operator()(const int& item) const
     607                 : {
     608                 :         return cache().tags().tagByID(item);
     609                 : }
     610                 : 
     611                 : string TagStringConverter::componentName() { return "TagStringConverter"; }
     612                 : 
     613                 : std::string TagStringConverter::operator()(const aptFront::cache::entity::Tag& item) const
     614                 : {
     615                 :         if (!item.valid()) return string();
     616                 :         return item.fullname();
     617                 : }
     618                 : aptFront::cache::entity::Tag TagStringConverter::operator()(const std::string& item) const
     619                 : {
     620                 :         return cache().tags().tagByName(item);
     621                 : }
     622                 : 
     623                 : Tagcoll::OpSet<entity::Tag> TagStringConverter::parseTagList(const std::string& str) const
     624                 : {
     625                 :         if (str.empty())
     626                 :                 return Tagcoll::OpSet<entity::Tag>();
     627                 : 
     628                 :         size_t i = str.find(", ");
     629                 :         if (i == string::npos)
     630                 :         {
     631                 :                 // Check if we need curly brace expansion
     632                 :                 if (str[str.size() - 1] == '}')
     633                 :                 {
     634                 :                         using namespace std;
     635                 :                         Tagcoll::OpSet<entity::Tag> res;
     636                 :                         size_t begin = str.find('{');
     637                 :                         if (begin == string::npos)
     638                 :                                 return res;
     639                 :                         string prefix(str, 0, begin);
     640                 :                         ++begin;
     641                 :                         size_t end;
     642                 :                         while ((end = str.find(',', begin)) != string::npos)
     643                 :                         {
     644                 :                                 res += (*this)(prefix + str.substr(begin, end-begin));
     645                 :                                 begin = end + 1;
     646                 :                         }
     647                 :                         res += (*this)(prefix + str.substr(begin, str.size() - 1 - begin));
     648                 :                         return res;
     649                 :                 } else {
     650                 :                         entity::Tag t = (*this)(str);
     651                 :                         if (t.valid())
     652                 :                                 return Tagcoll::OpSet<entity::Tag>() + t;
     653                 :                         else
     654                 :                                 return Tagcoll::OpSet<entity::Tag>();
     655                 :                 }
     656                 :         } else {
     657                 :                 return parseTagList(string(str, 0, i)) + parseTagList(string(str, i+2));
     658                 :         }
     659                 : }
     660                 : 
     661                 : string PackageIntConverter::componentName() { return "PackageIntConverter"; }
     662                 : 
     663                 : int PackageIntConverter::operator()(const aptFront::cache::entity::Package& item) const
     664                 : {
     665                 :         if (!item.valid()) return -1;
     666                 :         return item.id();
     667                 : }
     668                 : aptFront::cache::entity::Package PackageIntConverter::operator()(const int& item) const
     669                 : {
     670                 :         PkgIdx& p = cache().pkgidx();
     671                 :         return cache().packages().packageByName(string(p.name(item), p.size(item)));
     672                 : }
     673                 : 
     674                 : string PackageStringConverter::componentName() { return "PackageStringConverter"; }
     675                 : 
     676                 : std::string PackageStringConverter::operator()(const aptFront::cache::entity::Package& item) const
     677                 : {
     678                 :         if (!item.valid()) return string();
     679                 :         return item.name();
     680                 : }
     681                 : aptFront::cache::entity::Package PackageStringConverter::operator()(const std::string& item) const
     682                 : {
     683                 :         return cache().packages().packageByName(item);
     684                 : }
     685                 : #endif
     686                 : 
     687                 : }
     688                 : }
     689                 : 
     690                 : #endif
     691                 : 
     692                 : #if 0
     693                 : #ifdef COMPILE_TESTSUITE
     694                 : //#include <apt-front/cache/component/debtags/update.h>
     695                 : #include <iostream>
     696                 : #include "test-utils.h"
     697                 : 
     698                 : namespace tut {
     699                 : using namespace aptFront::cache;
     700                 : using namespace component;
     701                 : using namespace debtags;
     702                 : using namespace std;
     703                 : 
     704                 : struct cache_component_debtags_serializer_shar {
     705                 :     cache_component_debtags_serializer_shar () {
     706                 :         aptInit ();
     707                 :         ok = true;
     708                 :         debtags::fetchNewData();
     709                 :         c.open( Cache::OpenDefault |
     710                 :                 Cache::OpenReadOnly | Cache::OpenDebtags );
     711                 :     }
     712                 :     void check() {
     713                 :         if (ok) return;
     714                 :         ok = true;
     715                 :         throw warning( "debtags init failed, cancelling" );
     716                 :     }
     717                 :     ~cache_component_debtags_serializer_shar() {
     718                 :         check();
     719                 :     }
     720                 :     Cache c;
     721                 :     bool ok;
     722                 : };
     723                 : 
     724                 : TESTGRP( cache_component_debtags_serializer );
     725                 : 
     726                 : using namespace Tagcoll;
     727                 : 
     728                 : template<> template<>
     729                 : void to::test<1> ()
     730                 : {
     731                 :     check();
     732                 : 
     733                 :         PackageStringConverter& psc = c.packagestringconverter();
     734                 : 
     735                 :         ensure(psc("Slartibartsfart") == entity::Package());
     736                 : 
     737                 :     /* Get the 'debtags' package */
     738                 :     entity::Package p = c.packages().packageByName( "debtags" );
     739                 :     ensure(p.valid());
     740                 : 
     741                 :         /* Get the 'debtags' package using the serializer */
     742                 :         entity::Package p1 = psc("debtags");
     743                 :         ensure(p1.valid());
     744                 : 
     745                 :         /* They must be the same */
     746                 :         ensure(p == p1);
     747                 : 
     748                 :         ensure_equals(psc(p), "debtags");
     749                 :         ensure_equals(psc(p1), "debtags");
     750                 :         ensure_equals(psc(p), psc(p1));
     751                 : 
     752                 :         /* If there is an invalid package to serialize, it should be discarded */
     753                 :         {
     754                 :                 Tagcoll::OpSet<entity::Package> pkgs;
     755                 :                 pkgs += c.packages().packageByName( "debtags" );
     756                 :                 pkgs += c.packages().packageByName( "tagcoll" );
     757                 :                 pkgs += entity::Package();
     758                 : 
     759                 :                 ensure_equals (pkgs.size(), 3u);
     760                 :                 ensure_equals (psc(pkgs).size(), 2u);
     761                 :                 ensure (psc(pkgs).contains("debtags"));
     762                 :                 ensure (psc(pkgs).contains("tagcoll"));
     763                 :         }
     764                 : 
     765                 :         /* If there is an invalid package to serialize, it should be discarded */
     766                 :         {
     767                 :                 Tagcoll::OpSet<std::string> pkgs;
     768                 :                 pkgs += "debtags";
     769                 :                 pkgs += "tagcoll";
     770                 :                 pkgs += "Slartibartsfart";
     771                 : 
     772                 :                 ensure_equals (pkgs.size(), 3u);
     773                 :                 ensure_equals (psc(pkgs).size(), 2u);
     774                 :                 ensure (psc(pkgs).contains(psc("debtags")));
     775                 :                 ensure (psc(pkgs).contains(psc("tagcoll")));
     776                 :                 ensure (!psc(pkgs).contains(entity::Package()));
     777                 :         }
     778                 : }
     779                 : 
     780                 : ostream& operator<<(ostream& out, const entity::Package& pkg)
     781                 : {
     782                 :         if (pkg.valid())
     783                 :                 return out << pkg.name();
     784                 :         else
     785                 :                 return out << "(invalid package)";
     786                 : }
     787                 : 
     788                 : // Check that package conversions work two-way
     789                 : template<> template<>
     790                 : void to::test<2> ()
     791                 : {
     792                 :         PackageStringConverter& psc = c.packagestringconverter();
     793                 :         for (component::Aggregator::iterator i = c.packages().packagesBegin();
     794                 :                         i != c.packages().packagesEnd(); ++i)
     795                 :         {
     796                 :                 try {
     797                 :                         ensure_equals(*i, psc(psc(*i)));
     798                 :                 } catch (...) {
     799                 :                         cerr << "Note: exception thrown during processing[string] of package " << i->name(string("(invalid package)")) << endl;
     800                 :                         throw;
     801                 :                 }
     802                 :         }
     803                 : 
     804                 :         PackageIntConverter& pic = c.packageintconverter();
     805                 :         for (component::Aggregator::iterator i = c.packages().packagesBegin();
     806                 :                         i != c.packages().packagesEnd(); ++i)
     807                 :         {
     808                 :                 try {
     809                 :                         ensure_equals(*i, pic(pic(*i)));
     810                 :                 } catch (...) {
     811                 :                         cerr << "Note: exception thrown during processing[int] of package " << i->name(string("(invalid package)")) << endl;
     812                 :                         throw;
     813                 :                 }
     814                 :         }
     815                 : }
     816                 : 
     817                 : // Check that facet conversions work two-way
     818                 : template<> template<>
     819                 : void to::test<3> ()
     820                 : {
     821                 :         typedef Tagcoll::OpSet<entity::Facet> FacetSet;
     822                 : 
     823                 :         FacetStringConverter& fsc = c.facetstringconverter();
     824                 :         FacetSet allFacets(c.tags().facets());
     825                 :         for (FacetSet::const_iterator i = allFacets.begin(); i != allFacets.end(); i++)
     826                 :         {
     827                 :                 try {
     828                 :                         ensure_equals(*i, fsc(fsc(*i)));
     829                 :                 } catch (...) {
     830                 :                         cerr << "Note: exception thrown during processing[string] of facet " << i->name() << endl;
     831                 :                         throw;
     832                 :                 }
     833                 :         }
     834                 : 
     835                 :         FacetIntConverter& fic = c.facetintconverter();
     836                 :         for (FacetSet::const_iterator i = allFacets.begin(); i != allFacets.end(); i++)
     837                 :         {
     838                 :                 try {
     839                 :                         ensure_equals(*i, fic(fic(*i)));
     840                 :                 } catch (...) {
     841                 :                         cerr << "Note: exception thrown during processing[int] of facet " << i->name() << endl;
     842                 :                         throw;
     843                 :                 }
     844                 :         }
     845                 : }
     846                 : 
     847                 : // Check that tag conversions work two-way
     848                 : template<> template<>
     849                 : void to::test<4> ()
     850                 : {
     851                 :         typedef Tagcoll::OpSet<entity::Tag> TagSet;
     852                 : 
     853                 :         TagStringConverter& tsc = c.tagstringconverter();
     854                 :         TagSet allTags(c.tags().tags());
     855                 :         for (TagSet::const_iterator i = allTags.begin(); i != allTags.end(); i++)
     856                 :         {
     857                 :                 try {
     858                 :                         ensure_equals(*i, tsc(tsc(*i)));
     859                 :                 } catch (...) {
     860                 :                         cerr << "Note: exception thrown during processing[string] of tag " << i->fullname() << endl;
     861                 :                         throw;
     862                 :                 }
     863                 :         }
     864                 : 
     865                 :         TagIntConverter& tic = c.tagintconverter();
     866                 :         for (TagSet::const_iterator i = allTags.begin(); i != allTags.end(); i++)
     867                 :         {
     868                 :                 try {
     869                 :                         ensure_equals(*i, tic(tic(*i)));
     870                 :                 } catch (...) {
     871                 :                         cerr << "Note: exception thrown during processing[int] of tag " << i->fullname() << endl;
     872                 :                         throw;
     873                 :                 }
     874                 :         }
     875                 : }
     876                 : 
     877                 : // Check TagStringConverter::parseTagList
     878                 : template<> template<>
     879                 : void to::test<5> ()
     880                 : {
     881                 :         TagStringConverter& tsc = c.tagstringconverter();
     882                 :         OpSet<entity::Tag> ts;
     883                 : 
     884                 :         // First ensure that we're using existing tags as samples
     885                 :         ensure(tsc("accessibility::TODO") != entity::Tag());
     886                 :         ensure(tsc("role::sw:devel-lib") != entity::Tag());
     887                 :         ensure(tsc("x11::xserver") != entity::Tag());
     888                 :         ensure(tsc("antani") == entity::Tag());
     889                 :         ensure(tsc("blinda") == entity::Tag());
     890                 :         ensure(tsc("supercazzola") == entity::Tag());
     891                 : 
     892                 :         ts = tsc.parseTagList("role::sw:devel-lib");
     893                 :         ensure_equals(ts.size(), 1u);
     894                 :         ensure(ts.contains(tsc("role::sw:devel-lib")));
     895                 : 
     896                 :         ts = tsc.parseTagList("accessibility::TODO, x11::xserver, role::sw:devel-lib");
     897                 :         ensure_equals(ts.size(), 3u);
     898                 :         ensure(ts.contains(tsc("accessibility::TODO")));
     899                 :         ensure(ts.contains(tsc("role::sw:devel-lib")));
     900                 :         ensure(ts.contains(tsc("x11::xserver")));
     901                 : 
     902                 :         ts = tsc.parseTagList("antani");
     903                 :         ensure_equals(ts.size(), 0u);
     904                 : 
     905                 :         ts = tsc.parseTagList("antani, blinda, supercazzola");
     906                 :         ensure_equals(ts.size(), 0u);
     907                 : 
     908                 :         ts = tsc.parseTagList("antani, x11::xserver, blinda");
     909                 :         ensure_equals(ts.size(), 1u);
     910                 :         ensure(ts.contains(tsc("x11::xserver")));
     911                 : }
     912                 : 
     913                 : // Check TagStringConverter::parseTagList's handling of curly brace expansion
     914                 : template<> template<>
     915                 : void to::test<6> ()
     916                 : {
     917                 :         TagStringConverter& tsc = c.tagstringconverter();
     918                 :         OpSet<entity::Tag> ts;
     919                 : 
     920                 :         // First ensure that we're using existing tags as samples
     921                 :         ensure(tsc("role::TODO") != entity::Tag());
     922                 :         ensure(tsc("role::sw:server") != entity::Tag());
     923                 :         ensure(tsc("role::aux:dummy") != entity::Tag());
     924                 :         ensure(tsc("role::sw:amusement") != entity::Tag());
     925                 :         ensure(tsc("role::sw:server{}") == entity::Tag());
     926                 :         ensure(tsc("role::{}") == entity::Tag());
     927                 :         ensure(tsc("role::{") == entity::Tag());
     928                 :         ensure(tsc("role::}") == entity::Tag());
     929                 : 
     930                 :         ts = tsc.parseTagList("role::{TODO,sw:server,aux:dummy,sw:amusement}");
     931                 :         ensure_equals(ts.size(), 4u);
     932                 :         ensure(ts.contains(tsc("role::TODO")));
     933                 :         ensure(ts.contains(tsc("role::sw:server")));
     934                 :         ensure(ts.contains(tsc("role::aux:dummy")));
     935                 :         ensure(ts.contains(tsc("role::sw:amusement")));
     936                 : 
     937                 :         ts = tsc.parseTagList("role::{TODO,aux:dummy}, role::sw:{server,amusement}");
     938                 :         ensure_equals(ts.size(), 4u);
     939                 :         ensure(ts.contains(tsc("role::TODO")));
     940                 :         ensure(ts.contains(tsc("role::sw:server")));
     941                 :         ensure(ts.contains(tsc("role::aux:dummy")));
     942                 :         ensure(ts.contains(tsc("role::sw:amusement")));
     943                 : }
     944                 : 
     945                 : }
     946                 : #endif
     947                 : #endif
     948                 : #endif
     949                 : // vim:set ts=4 sw=4:

Generated by: LTP GCOV extension version 1.6