libept  0.5.25
serializer.h
Go to the documentation of this file.
1 // -*- mode: c++; tab-width: 4; indent-tabs-mode: t -*-
7 #ifndef EPT_DEBTAGS_SERIALIZER_H
8 #define EPT_DEBTAGS_SERIALIZER_H
9 
10 #include <ept/debtags/vocabulary.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  IntToPkg(PkgId& pkgid, Vocabulary& voc, const OUT& out)
28  : pkgid(pkgid), voc(voc), out(out) {}
29 
30  template<typename ITEMS, typename TAGS>
31  IntToPkg<OUT>& operator=(const std::pair<ITEMS, TAGS>& data)
32  {
33  std::set<std::string> ritems;
34  std::set<Tag> rtags;
35 
36  for (typename ITEMS::const_iterator i = data.first.begin();
37  i != data.first.end(); ++i)
38  {
39  std::string pkg = pkgid.byID(*i);
40  if (!pkg.empty())
41  ritems.insert(pkg);
42  }
43 
44  for (typename TAGS::const_iterator i = data.second.begin();
45  i != data.second.end(); ++i)
46  {
47  Tag t = voc.tagByID(*i);
48  if (t.valid())
49  rtags.insert(t);
50  }
51 
52  if (!ritems.empty() && !rtags.empty())
53  {
54  *out = make_pair(ritems, rtags);
55  ++out;
56  }
57  return *this;
58  }
59 };
60 
61 template<typename OUT>
62 IntToPkg<OUT> intToPkg(PkgId& pkgid, Vocabulary& voc, const OUT& out)
63 {
64  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  StringToInt(PkgId& pkgid, Vocabulary& voc, const OUT& out)
76  : pkgid(pkgid), voc(voc), out(out) {}
77 
78  template<typename ITEMS, typename TAGS>
79  StringToInt<OUT>& operator=(const std::pair<ITEMS, TAGS>& data)
80  {
81  std::set<int> ritems;
82  std::set<int> rtags;
83 
84  for (typename ITEMS::const_iterator i = data.first.begin();
85  i != data.first.end(); ++i)
86  {
87  int id = pkgid.byName(*i);
88  if (id != -1)
89  ritems.insert(id);
90  }
91 
92  for (typename TAGS::const_iterator i = data.second.begin();
93  i != data.second.end(); ++i)
94  {
95  Tag t = voc.tagByName(*i);
96  if (t.valid())
97  rtags.insert(t.id());
98  }
99 
100  if (!ritems.empty() && !rtags.empty())
101  {
102  *out = make_pair(ritems, rtags);
103  ++out;
104  }
105  return *this;
106  }
107 
108 };
109 
110 template<typename OUT>
111 StringToInt<OUT> stringToInt(PkgId& pkgid, Vocabulary& voc, const OUT& out)
112 {
113  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  PkgToString(const OUT& out) : out(out) {}
172 
173  template<typename ITEMS, typename TAGS>
174  PkgToString<OUT>& operator=(const std::pair<ITEMS, TAGS>& data)
175  {
176  std::set<std::string> stags;
177  for (typename TAGS::const_iterator i = data.second.begin();
178  i != data.second.end(); ++i)
179  if (i->valid())
180  stags.insert(i->fullname());
181  *out = make_pair(data.first, stags);
182  ++out;
183  return *this;
184  }
185 };
186 
187 template<typename OUT>
189 {
190  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  PatchStringToInt(PkgId& pkgid, Vocabulary& voc, const OUT& out)
202  : pkgid(pkgid), voc(voc), out(out) {}
203 
204  PatchStringToInt<OUT>& operator=(const tagcoll::Patch<std::string, std::string>& patch)
205  {
206  int id = pkgid.byName(patch.item);
207  if (id == -1)
208  return *this;
209 
210  tagcoll::Patch<int, int> res(id);
211  for (std::set<std::string>::const_iterator i = patch.added.begin();
212  i != patch.added.end(); ++i)
213  {
214  Tag tag = voc.tagByName(*i);
215  if (tag.valid())
216  res.add(tag.id());
217  }
218  for (std::set<std::string>::const_iterator i = patch.removed.begin();
219  i != patch.removed.end(); ++i)
220  {
221  Tag tag = voc.tagByName(*i);
222  if (tag.valid())
223  res.remove(tag.id());
224  }
225  *out = res;
226  ++out;
227  return *this;
228  }
229 };
230 
231 template<typename OUT>
233 {
234  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  PatchIntToString(PkgId& pkgid, Vocabulary& voc, const OUT& out)
246  : pkgid(pkgid), voc(voc), out(out) {}
247 
248  PatchIntToString<OUT>& operator=(const tagcoll::Patch<int, int>& patch)
249  {
250  std::string name = pkgid.byID(patch.item);
251  if (name.empty())
252  return *this;
253 
254  tagcoll::Patch<std::string, std::string> res(name);
255  for (std::set<int>::const_iterator i = patch.added.begin();
256  i != patch.added.end(); ++i)
257  {
258  Tag tag = voc.tagByID(*i);
259  if (tag.valid())
260  res.add(tag.fullname());
261  }
262  for (std::set<int>::const_iterator i = patch.removed.begin();
263  i != patch.removed.end(); ++i)
264  {
265  Tag tag = voc.tagByID(*i);
266  if (tag.valid())
267  res.remove(tag.fullname());
268  }
269  *out = res;
270  ++out;
271  return *this;
272  }
273 };
274 
275 template<typename OUT>
277 {
278  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 
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 
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 
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 
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 
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 {
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 
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 {
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 
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:
int byName(const std::string &name) const
Get the ID of a package given its name.
Definition: pkgid.cc:40
PkgToString< OUT > & operator=(const std::pair< ITEMS, TAGS > &data)
Definition: serializer.h:174
StringToPkg< OUT > stringToPkg(PkgId &pkgid, Vocabulary &voc, const OUT &out)
Definition: serializer.h:161
Definition: serializer.h:68
int id() const
Return the ID of this tag.
Definition: tag.h:242
StringToPkg(PkgId &pkgid, Vocabulary &voc, const OUT &out)
Definition: serializer.h:124
PatchStringToInt< OUT > patchStringToInt(PkgId &pkgid, Vocabulary &voc, const OUT &out)
Definition: serializer.h:232
Tag tagByID(int id) const
Return the tag with the given full name.
Definition: vocabulary.cc:164
StringToInt< OUT > & operator=(const std::pair< ITEMS, TAGS > &data)
Definition: serializer.h:79
PatchIntToString< OUT > patchIntToString(PkgId &pkgid, Vocabulary &voc, const OUT &out)
Definition: serializer.h:276
StringToPkg< OUT > & operator=(const std::pair< ITEMS, TAGS > &data)
Definition: serializer.h:128
PatchIntToString(PkgId &pkgid, Vocabulary &voc, const OUT &out)
Definition: serializer.h:245
PkgToString< OUT > pkgToString(const OUT &out)
Definition: serializer.h:188
Representation of a tag.
Definition: tag.h:163
std::string byID(int id) const
Get a package name given its ID.
Definition: pkgid.h:68
StringToInt< OUT > stringToInt(PkgId &pkgid, Vocabulary &voc, const OUT &out)
Definition: serializer.h:111
Maps Packages to IDs and vice-versa.
Definition: pkgid.h:40
std::string fullname() const
Return the name of the tag, with the facet:: prefix.
Definition: tag.cc:102
IntToPkg< OUT > & operator=(const std::pair< ITEMS, TAGS > &data)
Definition: serializer.h:31
Definition: vocabulary.h:37
Definition: serializer.h:167
Definition: serializer.h:238
PkgToString(const OUT &out)
Definition: serializer.h:171
std::ostream & operator<<(std::ostream &o, const Sources::Entry &e)
Definition: sources.h:193
PatchIntToString< OUT > & operator=(const tagcoll::Patch< int, int > &patch)
Definition: serializer.h:248
bool valid() const
Definition: tag.h:182
IntToPkg(PkgId &pkgid, Vocabulary &voc, const OUT &out)
Definition: serializer.h:27
IntToPkg< OUT > intToPkg(PkgId &pkgid, Vocabulary &voc, const OUT &out)
Definition: serializer.h:62
Definition: serializer.h:194
Tag tagByName(const std::string &fullname) const
Return the tag with the given full name.
Definition: vocabulary.h:203
StringToInt(PkgId &pkgid, Vocabulary &voc, const OUT &out)
Definition: serializer.h:75
PatchStringToInt(PkgId &pkgid, Vocabulary &voc, const OUT &out)
Definition: serializer.h:201
Definition: serializer.h:117
PatchStringToInt< OUT > & operator=(const tagcoll::Patch< std::string, std::string > &patch)
Definition: serializer.h:204
Definition: serializer.h:20
Definition: core/apt.h:359