• Main Page
  • Namespaces
  • Classes
  • Files
  • File List
  • File Members

serializer.h

Go to the documentation of this file.
00001 // -*- mode: c++; tab-width: 4; indent-tabs-mode: t -*-
00007 #ifndef EPT_DEBTAGS_SERIALIZER_H
00008 #define EPT_DEBTAGS_SERIALIZER_H
00009 
00010 #include <ept/debtags/vocabulary.h>
00011 #include <ept/debtags/maint/pkgid.h>
00012 #include <tagcoll/patch.h>
00013 #include <wibble/mixin.h>
00014 #include <string>
00015 
00016 namespace ept {
00017 namespace debtags {
00018 
00019 template<typename OUT>
00020 class IntToPkg : public wibble::mixin::OutputIterator< IntToPkg<OUT> >
00021 {
00022     PkgId& pkgid;
00023     Vocabulary& voc;
00024     OUT out;
00025 
00026 public:
00027     IntToPkg(PkgId& pkgid, Vocabulary& voc, const OUT& out)
00028         : pkgid(pkgid), voc(voc), out(out) {}
00029 
00030     template<typename ITEMS, typename TAGS>
00031     IntToPkg<OUT>& operator=(const std::pair<ITEMS, TAGS>& data)
00032     {
00033         std::set<std::string> ritems;
00034         std::set<Tag> rtags;
00035 
00036         for (typename ITEMS::const_iterator i = data.first.begin();
00037                 i != data.first.end(); ++i)
00038         {
00039             std::string pkg = pkgid.byID(*i);
00040             if (!pkg.empty())
00041                 ritems.insert(pkg);
00042         }
00043 
00044         for (typename TAGS::const_iterator i = data.second.begin();
00045                 i != data.second.end(); ++i)
00046         {
00047             Tag t = voc.tagByID(*i);
00048             if (t.valid())
00049                 rtags.insert(t);
00050         }
00051 
00052         if (!ritems.empty() && !rtags.empty())
00053         {
00054             *out = make_pair(ritems, rtags);
00055             ++out;
00056         }
00057         return *this;
00058     }
00059 };
00060 
00061 template<typename OUT>
00062 IntToPkg<OUT> intToPkg(PkgId& pkgid, Vocabulary& voc, const OUT& out)
00063 {
00064     return IntToPkg<OUT>(pkgid, voc, out);
00065 }
00066 
00067 template<typename OUT>
00068 class StringToInt : public wibble::mixin::OutputIterator< StringToInt<OUT> >
00069 {
00070     PkgId& pkgid;
00071     Vocabulary& voc;
00072     OUT out;
00073 
00074 public:
00075     StringToInt(PkgId& pkgid, Vocabulary& voc, const OUT& out)
00076         : pkgid(pkgid), voc(voc), out(out) {}
00077 
00078     template<typename ITEMS, typename TAGS>
00079     StringToInt<OUT>& operator=(const std::pair<ITEMS, TAGS>& data)
00080     {
00081         std::set<int> ritems;
00082         std::set<int> rtags;
00083 
00084         for (typename ITEMS::const_iterator i = data.first.begin();
00085                 i != data.first.end(); ++i)
00086         {
00087             int id = pkgid.byName(*i);
00088             if (id != -1)
00089                 ritems.insert(id);
00090         }
00091 
00092         for (typename TAGS::const_iterator i = data.second.begin();
00093                 i != data.second.end(); ++i)
00094         {
00095             Tag t = voc.tagByName(*i);
00096             if (t.valid())
00097                 rtags.insert(t.id());
00098         }
00099 
00100         if (!ritems.empty() && !rtags.empty())
00101         {
00102             *out = make_pair(ritems, rtags);
00103             ++out;
00104         }
00105         return *this;
00106     }
00107 
00108 };
00109 
00110 template<typename OUT>
00111 StringToInt<OUT> stringToInt(PkgId& pkgid, Vocabulary& voc, const OUT& out)
00112 {
00113     return StringToInt<OUT>(pkgid, voc, out);
00114 }
00115 
00116 template<typename OUT>
00117 class StringToPkg : public wibble::mixin::OutputIterator< StringToPkg<OUT> >
00118 {
00119     PkgId& pkgid;
00120     Vocabulary& voc;
00121     OUT out;
00122 
00123 public:
00124     StringToPkg(PkgId& pkgid, Vocabulary& voc, const OUT& out)
00125         : pkgid(pkgid), voc(voc), out(out) {}
00126 
00127     template<typename ITEMS, typename TAGS>
00128     StringToPkg<OUT>& operator=(const std::pair<ITEMS, TAGS>& data)
00129     {
00130         std::set<std::string> ritems;
00131         std::set<Tag> rtags;
00132 
00133         for (typename ITEMS::const_iterator i = data.first.begin();
00134                 i != data.first.end(); ++i)
00135         {
00136             // Ensure that the package exists in the pkgid database
00137             if (pkgid.byName(*i) == -1)
00138                 continue;
00139             ritems.insert(*i);
00140         }
00141 
00142         for (typename TAGS::const_iterator i = data.second.begin();
00143                 i != data.second.end(); ++i)
00144         {
00145             Tag t = voc.tagByName(*i);
00146             if (t.valid())
00147                 rtags.insert(t);
00148         }
00149 
00150         if (!ritems.empty() && !rtags.empty())
00151         {
00152             *out = make_pair(ritems, rtags);
00153             ++out;
00154         }
00155         return *this;
00156     }
00157 
00158 };
00159 
00160 template<typename OUT>
00161 StringToPkg<OUT> stringToPkg(PkgId& pkgid, Vocabulary& voc, const OUT& out)
00162 {
00163     return StringToPkg<OUT>(pkgid, voc, out);
00164 }
00165 
00166 template<typename OUT>
00167 class PkgToString : public wibble::mixin::OutputIterator< PkgToString<OUT> >
00168 {
00169     OUT out;
00170 public:
00171     PkgToString(const OUT& out) : out(out) {}
00172 
00173     template<typename ITEMS, typename TAGS>
00174     PkgToString<OUT>& operator=(const std::pair<ITEMS, TAGS>& data)
00175     {
00176         std::set<std::string> stags;
00177         for (typename TAGS::const_iterator i = data.second.begin();
00178                 i != data.second.end(); ++i)
00179             if (i->valid())
00180                 stags.insert(i->fullname());
00181         *out = make_pair(data.first, stags);
00182         ++out;
00183         return *this;
00184     }
00185 };
00186 
00187 template<typename OUT>
00188 PkgToString<OUT> pkgToString(const OUT& out)
00189 {
00190     return PkgToString<OUT>(out);
00191 }
00192 
00193 template<typename OUT>
00194 class PatchStringToInt : public wibble::mixin::OutputIterator< PatchStringToInt<OUT> >
00195 {
00196     PkgId& pkgid;
00197     Vocabulary& voc;
00198     OUT out;
00199 
00200 public:
00201     PatchStringToInt(PkgId& pkgid, Vocabulary& voc, const OUT& out)
00202         : pkgid(pkgid), voc(voc), out(out) {}
00203 
00204     PatchStringToInt<OUT>& operator=(const tagcoll::Patch<std::string, std::string>& patch)
00205     {
00206         int id = pkgid.byName(patch.item);
00207         if (id == -1)
00208             return *this;
00209 
00210         tagcoll::Patch<int, int> res(id);
00211         for (std::set<std::string>::const_iterator i = patch.added.begin();
00212                 i != patch.added.end(); ++i)
00213         {
00214             Tag tag = voc.tagByName(*i);
00215             if (tag.valid())
00216                 res.add(tag.id());
00217         }
00218         for (std::set<std::string>::const_iterator i = patch.removed.begin();
00219                 i != patch.removed.end(); ++i)
00220         {
00221             Tag tag = voc.tagByName(*i);
00222             if (tag.valid())
00223                 res.remove(tag.id());
00224         }
00225         *out = res;
00226         ++out;
00227         return *this;
00228     }
00229 };
00230 
00231 template<typename OUT>
00232 PatchStringToInt<OUT> patchStringToInt(PkgId& pkgid, Vocabulary& voc, const OUT& out)
00233 {
00234     return PatchStringToInt<OUT>(pkgid, voc, out);
00235 }
00236 
00237 template<typename OUT>
00238 class PatchIntToString : public wibble::mixin::OutputIterator< PatchIntToString<OUT> >
00239 {
00240     PkgId& pkgid;
00241     Vocabulary& voc;
00242     OUT out;
00243 
00244 public:
00245     PatchIntToString(PkgId& pkgid, Vocabulary& voc, const OUT& out)
00246         : pkgid(pkgid), voc(voc), out(out) {}
00247 
00248     PatchIntToString<OUT>& operator=(const tagcoll::Patch<int, int>& patch)
00249     {
00250         std::string name = pkgid.byID(patch.item);
00251         if (name.empty())
00252             return *this;
00253 
00254         tagcoll::Patch<std::string, std::string> res(name);
00255         for (std::set<int>::const_iterator i = patch.added.begin();
00256                 i != patch.added.end(); ++i)
00257         {
00258             Tag tag = voc.tagByID(*i);
00259             if (tag.valid())
00260                 res.add(tag.fullname());
00261         }
00262         for (std::set<int>::const_iterator i = patch.removed.begin();
00263                 i != patch.removed.end(); ++i)
00264         {
00265             Tag tag = voc.tagByID(*i);
00266             if (tag.valid())
00267                 res.remove(tag.fullname());
00268         }
00269         *out = res;
00270         ++out;
00271         return *this;
00272     }
00273 };
00274 
00275 template<typename OUT>
00276 PatchIntToString<OUT> patchIntToString(PkgId& pkgid, Vocabulary& voc, const OUT& out)
00277 {
00278     return PatchIntToString<OUT>(pkgid, voc, out);
00279 }
00280 
00281 #if 0
00282     GOOD STUFF
00283 
00284 template<typename OUT>
00285 class ToInt : public wibble::mixin::OutputIterator< ToInt<OUT> >
00286 {
00287     OUT out;
00288 public:
00289     ToInt(const OUT& out) : out(out) {}
00290 
00291     template<typename ITEMS, typename TAGS>
00292     ToInt<OUT>& operator=(const std::pair<ITEMS, TAGS>& data)
00293     {
00294         std::set<int> iitems;
00295         std::set<int> itags;
00296         for (typename ITEMS::const_iterator i = data.first.begin();
00297                 i != data.first.end(); ++i)
00298             if (i->valid())
00299                 iitems.insert(i->ondiskId());
00300         for (typename TAGS::const_iterator i = data.second.begin();
00301                 i != data.second.end(); ++i)
00302             if (i->valid())
00303                 itags.insert(i->id());
00304         *out = make_pair(iitems, itags);
00305         ++out;
00306         return *this;
00307     }
00308 };
00309 
00310 template<typename OUT>
00311 ToInt<OUT> toInt(const OUT& out)
00312 {
00313     return ToInt<OUT>(out);
00314 }
00315 
00316 template<typename ITEMCONV, typename TAGCONV, typename OUT>
00317 class Converter : public wibble::mixin::OutputIterator< Converter<ITEMCONV, TAGCONV, OUT> >
00318 {
00319     ITEMCONV itemconv;
00320     TAGCONV tagconv;
00321     OUT out;
00322 
00323 public:
00324     Converter(const ITEMCONV& itemconv, const TAGCONV& tagconv, const OUT& out)
00325         : itemconv(itemconv), tagconv(tagconv), out(out) {}
00326 
00327     template<typename ITEMS, typename TAGS>
00328     Converter<ITEMCONV, TAGCONV, OUT>& operator=(const std::pair<ITEMS, TAGS>& data)
00329     {
00330         *out = make_pair(itemconv(data.first), tagconv(data.second));
00331         ++out;
00332         return *this;
00333     }
00334 };
00335 
00336 template<typename ITEMCONV, typename TAGCONV, typename OUT>
00337 Converter<ITEMCONV, TAGCONV, OUT> converter(const ITEMCONV& itemconv, const TAGCONV& tagconv, const OUT& out)
00338 {
00339     return Converter<ITEMCONV, TAGCONV, OUT>(itemconv, tagconv, out);
00340 }
00341 
00342 
00343 template<typename OUT>
00344 class PatchToString : public wibble::mixin::OutputIterator< PatchToString<OUT> >
00345 {
00346     OUT out;
00347 
00348 public:
00349     PatchToString(const OUT& out) : out(out) {}
00350 
00351     template<typename PKG, typename TAG>
00352     PatchToString<OUT>& operator=(const tagcoll::Patch<PKG, TAG>& patch)
00353     {
00354         if (!patch.item.valid())
00355             return *this;
00356 
00357         tagcoll::Patch<std::string, std::string> res(patch.item.name());
00358         for (typename std::set<TAG>::const_iterator i = patch.added.begin();
00359                 i != patch.added.end(); ++i)
00360             if (i->valid())
00361                 res.add(i->fullname());
00362         for (typename std::set<TAG>::const_iterator i = patch.removed.begin();
00363                 i != patch.removed.end(); ++i)
00364             if (i->valid())
00365                 res.remove(i->fullname());
00366         *out = res;
00367         ++out;
00368         return *this;
00369     }
00370 };
00371 
00372 template<typename OUT>
00373 PatchToString<OUT> patchToString(const OUT& out)
00374 {
00375     return PatchToString<OUT>(out);
00376 }
00377 
00378 #endif
00379 
00380 }
00381 }
00382 
00383 #if 0
00384 
00385 namespace tagcoll {
00386 namespace coll {
00387 
00388 template<>
00389 struct coll_traits< ept::cache::debtags::DebtagsIndex >
00390 {
00391     typedef ept::cache::Package<> item_type;
00392     typedef ept::cache::debtags::Tag tag_type;
00393     typedef std::set< ept::cache::Package<> > itemset_type;
00394     typedef std::set<ept::cache::debtags::Tag> tagset_type;
00395 };
00396 
00397 }
00398 }
00399 
00400 namespace ept {
00401 namespace cache {
00402 namespace debtags {
00403 
00404 #if 0
00405 
00408 class FacetIntConverter : public Implementation<FacetIntConverter>,
00409     public Tagcoll::Converter<aptFront::cache::entity::Facet, int>,
00410     public Tagcoll::Converter<int, aptFront::cache::entity::Facet>
00411 {
00412     typedef aptFront::cache::entity::Facet Facet;
00413     typedef Tagcoll::OpSet<aptFront::cache::entity::Facet> FacetSet;
00414     typedef Tagcoll::OpSet<int> IntSet;
00415 public:
00416     virtual int operator()(const aptFront::cache::entity::Facet& item) const;
00417     virtual aptFront::cache::entity::Facet operator()(const int& item) const;
00418 
00419     virtual IntSet operator()(const FacetSet& item) const
00420         { return Tagcoll::Converter<Facet, int>::operator()(item); }
00421     virtual FacetSet operator()(const IntSet& item) const
00422         { return Tagcoll::Converter<int, Facet>::operator()(item); }
00423 
00424     static std::string componentName();
00425 };
00426 
00430 class FacetStringConverter : public Implementation<FacetStringConverter>,
00431     public Tagcoll::Converter<aptFront::cache::entity::Facet, std::string>,
00432     public Tagcoll::Converter<std::string, aptFront::cache::entity::Facet>
00433 {
00434     typedef aptFront::cache::entity::Facet Facet;
00435     typedef Tagcoll::OpSet<aptFront::cache::entity::Facet> FacetSet;
00436     typedef Tagcoll::OpSet<std::string> StringSet;
00437 public:
00438     virtual std::string operator()(const aptFront::cache::entity::Facet& item) const;
00439     virtual aptFront::cache::entity::Facet operator()(const std::string& item) const;
00440 
00441     virtual StringSet operator()(const FacetSet& item) const
00442         { return Tagcoll::Converter<Facet, std::string>::operator()(item); }
00443     virtual FacetSet operator()(const StringSet& item) const
00444         { return Tagcoll::Converter<std::string, Facet>::operator()(item); }
00445 
00446     static std::string componentName();
00447 };
00448 
00452 class TagIntConverter : public Implementation<TagIntConverter>,
00453     public Tagcoll::Converter<aptFront::cache::entity::Tag, int>,
00454     public Tagcoll::Converter<int, aptFront::cache::entity::Tag>
00455 {
00456     typedef aptFront::cache::entity::Tag Tag;
00457     typedef Tagcoll::OpSet<aptFront::cache::entity::Tag> TagSet;
00458     typedef Tagcoll::OpSet<int> IntSet;
00459 public:
00460     virtual int operator()(const aptFront::cache::entity::Tag& item) const;
00461     virtual aptFront::cache::entity::Tag operator()(const int& item) const;
00462 
00463     virtual IntSet operator()(const TagSet& item) const
00464         { return Tagcoll::Converter<Tag, int>::operator()(item); }
00465     virtual TagSet operator()(const IntSet& item) const
00466         { return Tagcoll::Converter<int, Tag>::operator()(item); }
00467 
00468     static std::string componentName();
00469 };
00470 
00474 class TagStringConverter : public Implementation<TagStringConverter>,
00475     public Tagcoll::Converter<aptFront::cache::entity::Tag, std::string>,
00476     public Tagcoll::Converter<std::string, aptFront::cache::entity::Tag>
00477 {
00478     typedef aptFront::cache::entity::Tag Tag;
00479     typedef Tagcoll::OpSet<aptFront::cache::entity::Tag> TagSet;
00480     typedef Tagcoll::OpSet<std::string> StringSet;
00481 public:
00482     virtual std::string operator()(const Tag& item) const;
00483     virtual Tag operator()(const std::string& item) const;
00484 
00485     virtual StringSet operator()(const TagSet& item) const
00486         { return Tagcoll::Converter<Tag, std::string>::operator()(item); }
00487     virtual TagSet operator()(const StringSet& item) const
00488         { return Tagcoll::Converter<std::string, Tag>::operator()(item); }
00489 
00490     TagSet parseTagList(const std::string& str) const;
00491 
00492     static std::string componentName();
00493 };
00494 
00498 class PackageIntConverter : public Implementation<PackageIntConverter>,
00499     public Tagcoll::Converter<aptFront::cache::entity::Package, int>,
00500     public Tagcoll::Converter<int, aptFront::cache::entity::Package>
00501 {
00502     typedef aptFront::cache::entity::Package Package;
00503     typedef Tagcoll::OpSet<aptFront::cache::entity::Package> PackageSet;
00504     typedef Tagcoll::OpSet<int> IntSet;
00505 public:
00506     virtual int operator()(const Package& item) const;
00507     virtual Package operator()(const int& item) const;
00508 
00509     virtual IntSet operator()(const PackageSet& item) const
00510         { return Tagcoll::Converter<Package, int>::operator()(item); }
00511     virtual PackageSet operator()(const IntSet& item) const
00512         { return Tagcoll::Converter<int, Package>::operator()(item); }
00513 
00514     static std::string componentName();
00515 };
00516 
00520 class PackageStringConverter : public Implementation<PackageStringConverter>,
00521     public Tagcoll::Converter<aptFront::cache::entity::Package, std::string>,
00522     public Tagcoll::Converter<std::string, aptFront::cache::entity::Package>
00523 {
00524     typedef aptFront::cache::entity::Package Package;
00525     typedef Tagcoll::OpSet<aptFront::cache::entity::Package> PackageSet;
00526     typedef Tagcoll::OpSet<std::string> StringSet;
00527 public:
00528     virtual std::string operator()(const Package& item) const;
00529     virtual Package operator()(const std::string& item) const;
00530 
00531     virtual StringSet operator()(const PackageSet& item) const
00532         { return Tagcoll::Converter<Package, std::string>::operator()(item); }
00533     virtual PackageSet operator()(const StringSet& item) const
00534         { return Tagcoll::Converter<std::string, Package>::operator()(item); }
00535 
00536     static std::string componentName();
00537 };
00538 
00539 #endif
00540 
00541 }
00542 }
00543 }
00544 
00545 #endif
00546 
00547 #endif
00548 // -*- mode: c++; tab-width: 4; indent-tabs-mode: t -*-
00549 
00550 #if 0
00551 
00556 #ifndef EPT_CACHE_DEBTAGS_SERIALIZER_TCC
00557 #define EPT_CACHE_DEBTAGS_SERIALIZER_TCC
00558 
00559 #include <ept/cache/debtags/serializer.h>
00560 #if 0
00561 #include <ept/cache/debtags/pkgidx.h>
00562 #include <ept/cache/debtags/vocabulary.h>
00563 #include <ept/cache/package.h>
00564 //#include <ept/cache/cache.h>
00565 #endif
00566 
00567 namespace ept {
00568 namespace t {
00569 namespace cache {
00570 namespace debtags {
00571 
00572 
00573 
00574 #if 0
00575 string FacetIntConverter::componentName() { return "FacetIntConverter"; }
00576 
00577 int FacetIntConverter::operator()(const aptFront::cache::entity::Facet& item) const
00578 {
00579     if (!item.valid()) return -1;
00580     return item.id();
00581 }
00582 aptFront::cache::entity::Facet FacetIntConverter::operator()(const int& item) const
00583 {
00584     return cache().tags().facetByID(item);
00585 }
00586 
00587 string FacetStringConverter::componentName() { return "FacetStringConverter"; }
00588 
00589 std::string FacetStringConverter::operator()(const aptFront::cache::entity::Facet& item) const
00590 {
00591     if (!item.valid()) return string();
00592     return item.name();
00593 }
00594 aptFront::cache::entity::Facet FacetStringConverter::operator()(const std::string& item) const
00595 {
00596     return cache().tags().facetByName(item);
00597 }
00598 
00599 string TagIntConverter::componentName() { return "TagIntConverter"; }
00600 
00601 int TagIntConverter::operator()(const aptFront::cache::entity::Tag& item) const
00602 {
00603     if (!item.valid()) return -1;
00604     return item.id();
00605 }
00606 aptFront::cache::entity::Tag TagIntConverter::operator()(const int& item) const
00607 {
00608     return cache().tags().tagByID(item);
00609 }
00610 
00611 string TagStringConverter::componentName() { return "TagStringConverter"; }
00612 
00613 std::string TagStringConverter::operator()(const aptFront::cache::entity::Tag& item) const
00614 {
00615     if (!item.valid()) return string();
00616     return item.fullname();
00617 }
00618 aptFront::cache::entity::Tag TagStringConverter::operator()(const std::string& item) const
00619 {
00620     return cache().tags().tagByName(item);
00621 }
00622 
00623 Tagcoll::OpSet<entity::Tag> TagStringConverter::parseTagList(const std::string& str) const
00624 {
00625     if (str.empty())
00626         return Tagcoll::OpSet<entity::Tag>();
00627 
00628     size_t i = str.find(", ");
00629     if (i == string::npos)
00630     {
00631         // Check if we need curly brace expansion
00632         if (str[str.size() - 1] == '}')
00633         {
00634             using namespace std;
00635             Tagcoll::OpSet<entity::Tag> res;
00636             size_t begin = str.find('{');
00637             if (begin == string::npos)
00638                 return res;
00639             string prefix(str, 0, begin);
00640             ++begin;
00641             size_t end;
00642             while ((end = str.find(',', begin)) != string::npos)
00643             {
00644                 res += (*this)(prefix + str.substr(begin, end-begin));
00645                 begin = end + 1;
00646             }
00647             res += (*this)(prefix + str.substr(begin, str.size() - 1 - begin));
00648             return res;
00649         } else {
00650             entity::Tag t = (*this)(str);
00651             if (t.valid())
00652                 return Tagcoll::OpSet<entity::Tag>() + t;
00653             else
00654                 return Tagcoll::OpSet<entity::Tag>();
00655         }
00656     } else {
00657         return parseTagList(string(str, 0, i)) + parseTagList(string(str, i+2));
00658     }
00659 }
00660 
00661 string PackageIntConverter::componentName() { return "PackageIntConverter"; }
00662 
00663 int PackageIntConverter::operator()(const aptFront::cache::entity::Package& item) const
00664 {
00665     if (!item.valid()) return -1;
00666     return item.id();
00667 }
00668 aptFront::cache::entity::Package PackageIntConverter::operator()(const int& item) const
00669 {
00670     PkgIdx& p = cache().pkgidx();
00671     return cache().packages().packageByName(string(p.name(item), p.size(item)));
00672 }
00673 
00674 string PackageStringConverter::componentName() { return "PackageStringConverter"; }
00675 
00676 std::string PackageStringConverter::operator()(const aptFront::cache::entity::Package& item) const
00677 {
00678     if (!item.valid()) return string();
00679     return item.name();
00680 }
00681 aptFront::cache::entity::Package PackageStringConverter::operator()(const std::string& item) const
00682 {
00683     return cache().packages().packageByName(item);
00684 }
00685 #endif
00686 
00687 }
00688 }
00689 
00690 #endif
00691 
00692 #if 0
00693 #ifdef COMPILE_TESTSUITE
00694 //#include <apt-front/cache/component/debtags/update.h>
00695 #include <iostream>
00696 #include "test-utils.h"
00697 
00698 namespace tut {
00699 using namespace aptFront::cache;
00700 using namespace component;
00701 using namespace debtags;
00702 using namespace std;
00703 
00704 struct cache_component_debtags_serializer_shar {
00705     cache_component_debtags_serializer_shar () {
00706         aptInit ();
00707         ok = true;
00708         debtags::fetchNewData();
00709         c.open( Cache::OpenDefault |
00710                 Cache::OpenReadOnly | Cache::OpenDebtags );
00711     }
00712     void check() {
00713         if (ok) return;
00714         ok = true;
00715         throw warning( "debtags init failed, cancelling" );
00716     }
00717     ~cache_component_debtags_serializer_shar() {
00718         check();
00719     }
00720     Cache c;
00721     bool ok;
00722 };
00723 
00724 TESTGRP( cache_component_debtags_serializer );
00725 
00726 using namespace Tagcoll;
00727 
00728 template<> template<>
00729 void to::test<1> ()
00730 {
00731     check();
00732 
00733     PackageStringConverter& psc = c.packagestringconverter();
00734 
00735     ensure(psc("Slartibartsfart") == entity::Package());
00736 
00737     /* Get the 'debtags' package */
00738     entity::Package p = c.packages().packageByName( "debtags" );
00739     ensure(p.valid());
00740 
00741     /* Get the 'debtags' package using the serializer */
00742     entity::Package p1 = psc("debtags");
00743     ensure(p1.valid());
00744 
00745     /* They must be the same */
00746     ensure(p == p1);
00747 
00748     ensure_equals(psc(p), "debtags");
00749     ensure_equals(psc(p1), "debtags");
00750     ensure_equals(psc(p), psc(p1));
00751 
00752     /* If there is an invalid package to serialize, it should be discarded */
00753     {
00754         Tagcoll::OpSet<entity::Package> pkgs;
00755         pkgs += c.packages().packageByName( "debtags" );
00756         pkgs += c.packages().packageByName( "tagcoll" );
00757         pkgs += entity::Package();
00758 
00759         ensure_equals (pkgs.size(), 3u);
00760         ensure_equals (psc(pkgs).size(), 2u);
00761         ensure (psc(pkgs).contains("debtags"));
00762         ensure (psc(pkgs).contains("tagcoll"));
00763     }
00764 
00765     /* If there is an invalid package to serialize, it should be discarded */
00766     {
00767         Tagcoll::OpSet<std::string> pkgs;
00768         pkgs += "debtags";
00769         pkgs += "tagcoll";
00770         pkgs += "Slartibartsfart";
00771 
00772         ensure_equals (pkgs.size(), 3u);
00773         ensure_equals (psc(pkgs).size(), 2u);
00774         ensure (psc(pkgs).contains(psc("debtags")));
00775         ensure (psc(pkgs).contains(psc("tagcoll")));
00776         ensure (!psc(pkgs).contains(entity::Package()));
00777     }
00778 }
00779 
00780 ostream& operator<<(ostream& out, const entity::Package& pkg)
00781 {
00782     if (pkg.valid())
00783         return out << pkg.name();
00784     else
00785         return out << "(invalid package)";
00786 }
00787 
00788 // Check that package conversions work two-way
00789 template<> template<>
00790 void to::test<2> ()
00791 {
00792     PackageStringConverter& psc = c.packagestringconverter();
00793     for (component::Aggregator::iterator i = c.packages().packagesBegin();
00794             i != c.packages().packagesEnd(); ++i)
00795     {
00796         try {
00797             ensure_equals(*i, psc(psc(*i)));
00798         } catch (...) {
00799             cerr << "Note: exception thrown during processing[string] of package " << i->name(string("(invalid package)")) << endl;
00800             throw;
00801         }
00802     }
00803 
00804     PackageIntConverter& pic = c.packageintconverter();
00805     for (component::Aggregator::iterator i = c.packages().packagesBegin();
00806             i != c.packages().packagesEnd(); ++i)
00807     {
00808         try {
00809             ensure_equals(*i, pic(pic(*i)));
00810         } catch (...) {
00811             cerr << "Note: exception thrown during processing[int] of package " << i->name(string("(invalid package)")) << endl;
00812             throw;
00813         }
00814     }
00815 }
00816 
00817 // Check that facet conversions work two-way
00818 template<> template<>
00819 void to::test<3> ()
00820 {
00821     typedef Tagcoll::OpSet<entity::Facet> FacetSet;
00822 
00823     FacetStringConverter& fsc = c.facetstringconverter();
00824     FacetSet allFacets(c.tags().facets());
00825     for (FacetSet::const_iterator i = allFacets.begin(); i != allFacets.end(); i++)
00826     {
00827         try {
00828             ensure_equals(*i, fsc(fsc(*i)));
00829         } catch (...) {
00830             cerr << "Note: exception thrown during processing[string] of facet " << i->name() << endl;
00831             throw;
00832         }
00833     }
00834 
00835     FacetIntConverter& fic = c.facetintconverter();
00836     for (FacetSet::const_iterator i = allFacets.begin(); i != allFacets.end(); i++)
00837     {
00838         try {
00839             ensure_equals(*i, fic(fic(*i)));
00840         } catch (...) {
00841             cerr << "Note: exception thrown during processing[int] of facet " << i->name() << endl;
00842             throw;
00843         }
00844     }
00845 }
00846 
00847 // Check that tag conversions work two-way
00848 template<> template<>
00849 void to::test<4> ()
00850 {
00851     typedef Tagcoll::OpSet<entity::Tag> TagSet;
00852 
00853     TagStringConverter& tsc = c.tagstringconverter();
00854     TagSet allTags(c.tags().tags());
00855     for (TagSet::const_iterator i = allTags.begin(); i != allTags.end(); i++)
00856     {
00857         try {
00858             ensure_equals(*i, tsc(tsc(*i)));
00859         } catch (...) {
00860             cerr << "Note: exception thrown during processing[string] of tag " << i->fullname() << endl;
00861             throw;
00862         }
00863     }
00864 
00865     TagIntConverter& tic = c.tagintconverter();
00866     for (TagSet::const_iterator i = allTags.begin(); i != allTags.end(); i++)
00867     {
00868         try {
00869             ensure_equals(*i, tic(tic(*i)));
00870         } catch (...) {
00871             cerr << "Note: exception thrown during processing[int] of tag " << i->fullname() << endl;
00872             throw;
00873         }
00874     }
00875 }
00876 
00877 // Check TagStringConverter::parseTagList
00878 template<> template<>
00879 void to::test<5> ()
00880 {
00881     TagStringConverter& tsc = c.tagstringconverter();
00882     OpSet<entity::Tag> ts;
00883 
00884     // First ensure that we're using existing tags as samples
00885     ensure(tsc("accessibility::TODO") != entity::Tag());
00886     ensure(tsc("role::sw:devel-lib") != entity::Tag());
00887     ensure(tsc("x11::xserver") != entity::Tag());
00888     ensure(tsc("antani") == entity::Tag());
00889     ensure(tsc("blinda") == entity::Tag());
00890     ensure(tsc("supercazzola") == entity::Tag());
00891 
00892     ts = tsc.parseTagList("role::sw:devel-lib");
00893     ensure_equals(ts.size(), 1u);
00894     ensure(ts.contains(tsc("role::sw:devel-lib")));
00895 
00896     ts = tsc.parseTagList("accessibility::TODO, x11::xserver, role::sw:devel-lib");
00897     ensure_equals(ts.size(), 3u);
00898     ensure(ts.contains(tsc("accessibility::TODO")));
00899     ensure(ts.contains(tsc("role::sw:devel-lib")));
00900     ensure(ts.contains(tsc("x11::xserver")));
00901 
00902     ts = tsc.parseTagList("antani");
00903     ensure_equals(ts.size(), 0u);
00904 
00905     ts = tsc.parseTagList("antani, blinda, supercazzola");
00906     ensure_equals(ts.size(), 0u);
00907 
00908     ts = tsc.parseTagList("antani, x11::xserver, blinda");
00909     ensure_equals(ts.size(), 1u);
00910     ensure(ts.contains(tsc("x11::xserver")));
00911 }
00912 
00913 // Check TagStringConverter::parseTagList's handling of curly brace expansion
00914 template<> template<>
00915 void to::test<6> ()
00916 {
00917     TagStringConverter& tsc = c.tagstringconverter();
00918     OpSet<entity::Tag> ts;
00919 
00920     // First ensure that we're using existing tags as samples
00921     ensure(tsc("role::TODO") != entity::Tag());
00922     ensure(tsc("role::sw:server") != entity::Tag());
00923     ensure(tsc("role::aux:dummy") != entity::Tag());
00924     ensure(tsc("role::sw:amusement") != entity::Tag());
00925     ensure(tsc("role::sw:server{}") == entity::Tag());
00926     ensure(tsc("role::{}") == entity::Tag());
00927     ensure(tsc("role::{") == entity::Tag());
00928     ensure(tsc("role::}") == entity::Tag());
00929 
00930     ts = tsc.parseTagList("role::{TODO,sw:server,aux:dummy,sw:amusement}");
00931     ensure_equals(ts.size(), 4u);
00932     ensure(ts.contains(tsc("role::TODO")));
00933     ensure(ts.contains(tsc("role::sw:server")));
00934     ensure(ts.contains(tsc("role::aux:dummy")));
00935     ensure(ts.contains(tsc("role::sw:amusement")));
00936 
00937     ts = tsc.parseTagList("role::{TODO,aux:dummy}, role::sw:{server,amusement}");
00938     ensure_equals(ts.size(), 4u);
00939     ensure(ts.contains(tsc("role::TODO")));
00940     ensure(ts.contains(tsc("role::sw:server")));
00941     ensure(ts.contains(tsc("role::aux:dummy")));
00942     ensure(ts.contains(tsc("role::sw:amusement")));
00943 }
00944 
00945 }
00946 #endif
00947 #endif
00948 #endif
00949 // vim:set ts=4 sw=4:

Generated on Fri Aug 19 2016 15:16:55 for libept by  doxygen 1.7.1