LCOV - lcov.info - ept/debtags/maint/serializer.h

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