libept
0.5.25
|
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: