00001
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
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
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
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
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
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
00738 entity::Package p = c.packages().packageByName( "debtags" );
00739 ensure(p.valid());
00740
00741
00742 entity::Package p1 = psc("debtags");
00743 ensure(p1.valid());
00744
00745
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
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
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
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
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
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
00878 template<> template<>
00879 void to::test<5> ()
00880 {
00881 TagStringConverter& tsc = c.tagstringconverter();
00882 OpSet<entity::Tag> ts;
00883
00884
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
00914 template<> template<>
00915 void to::test<6> ()
00916 {
00917 TagStringConverter& tsc = c.tagstringconverter();
00918 OpSet<entity::Tag> ts;
00919
00920
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