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