Jpp - the software that should make you happy
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
JMultiMap.hh
Go to the documentation of this file.
1 #ifndef __JTOOLS__JMULTIMAP__
2 #define __JTOOLS__JMULTIMAP__
3 
5 #include "JLang/JEquals.hh"
7 
8 #include "JTools/JDistance.hh"
9 #include "JTools/JPair.hh"
10 #include "JTools/JMultiPair.hh"
11 #include "JTools/JMapList.hh"
13 #include "JTools/JMultiKey.hh"
14 #include "JMath/JMath.hh"
15 
16 
17 /**
18  * \file
19  *
20  * JMultiMap is a general purpose multidimensional map based on a type list of maps.
21  * \author mdejong
22  */
23 namespace JTOOLS {}
24 namespace JPP { using namespace JTOOLS; }
25 
26 namespace JTOOLS {
27 
28  using JMATH::JMath;
29  using JLANG::JEquals;
31 
32 
33  /**
34  * Multidimensional map.
35  *
36  * The first template parameter refers to the data type of the (multidimensional) key;
37  * the second to the data type of the overall mapped value;
38  * the third to the list of maps used; and
39  * the fourth to the distance operator.
40  *
41  * In addition to the standard STL iterators, there is a
42  * super_[const_[reverse_]]iterator for linear access to the multidimensional map.
43  * The access from the super_iterator to the actual elements in the multidimensional map
44  * is handeld via a the standard dereference and pointer operators yielding
45  * a multidimensional key (see JTOOLS::JMultiKey) or pair (see JTOOLS::JMultiPair), respectively.
46  */
47  template<class JAbscissa_t,
48  class JOrdinate_t,
49  class JMaplist_t,
50  class JDistance_t = JDistance<JAbscissa_t> >
51  class JMultiMap;
52 
53 
54  /**
55  * Template specialisation of JMultiMap for map list with at least one map.
56  */
57  template<class JAbscissa_t,
58  class JOrdinate_t,
59  template<class, class, class> class JHead_t,
60  class JTail_t,
61  class JDistance_t>
62  class JMultiMap<JAbscissa_t, JOrdinate_t, JMapList<JHead_t, JTail_t>, JDistance_t> :
63  public JHead_t<JAbscissa_t, JMultiMap<JAbscissa_t, JOrdinate_t, JTail_t, JDistance_t>, JDistance_t>,
64  public JMath< JMultiMap<JAbscissa_t, JOrdinate_t, JMapList<JHead_t, JTail_t>, JDistance_t> >
65  {
66  public:
67 
68  enum { NUMBER_OF_DIMENSIONS = JMapLength< JMapList<JHead_t, JTail_t> >::value };
69 
70  typedef JHead_t<JAbscissa_t,
72  JDistance_t> map_type;
73 
74  typedef JAbscissa_t abscissa_type;
75  typedef JOrdinate_t ordinate_type;
76 
77  typedef typename map_type::key_type key_type;
78  typedef typename map_type::mapped_type mapped_type;
79  typedef typename map_type::value_type value_type;
80 
81  typedef typename map_type::const_iterator const_iterator;
82  typedef typename map_type::const_reverse_iterator const_reverse_iterator;
83  typedef typename map_type::iterator iterator;
84  typedef typename map_type::reverse_iterator reverse_iterator;
85 
86  using map_type::insert;
87  using map_type::configure;
88  using map_type::get;
89 
90 
91  /**
92  * Default constructor.
93  */
95  {}
96 
97 
98  /**
99  * Add map.
100  *
101  * \param map multimap
102  * \return this multimap
103  */
105  {
106  static_cast<map_type&>(*this).add(static_cast<const map_type&>(map));
107 
108  return *this;
109  }
110 
111 
112  /**
113  * Subtract map.
114  *
115  * \param map multimap
116  * \return this multimap
117  */
119  {
120  static_cast<map_type&>(*this).sub(static_cast<const map_type&>(map));
121 
122  return *this;
123  }
124 
125 
126  /**
127  * Scale contents.
128  *
129  * \param value multiplication factor
130  * \return this multimap
131  */
132  JMultiMap& mul(const double value)
133  {
134  static_cast<map_type&>(*this).mul(value);
135 
136  return *this;
137  }
138 
139  /**
140  * Scale contents.
141  *
142  * \param value division factor
143  * \return this multimap
144  */
145  JMultiMap& div(const double value)
146  {
147  static_cast<map_type&>(*this).div(value);
148 
149  return *this;
150  }
151 
152 
153  /**
154  * Function application to each element of this multimap.
155  *
156  * \param function function
157  * \return function
158  */
159  template<class JFunction_t>
160  void for_each(const JFunction_t& function)
161  {
162  function(*this);
163 
164  for (iterator i = this->begin(); i != this->end(); ++i) {
165  i->getY().for_each(function);
166  }
167  }
168 
169 
170  /**
171  * Configure multidimensional map.
172  *
173  * \param bounds multidimensional bounds
174  */
176  {
177  this->configure(JMultiKey<0, abscissa_type>(), bounds);
178  }
179 
180 
181  /**
182  * Configure multidimensional map.
183  *
184  * \param key multidimensional key
185  * \param bounds multidimensional bounds
186  */
187  template<unsigned int N, unsigned int M>
189  {
190  this->configure(bounds(key));
191 
192  for (iterator i = this->begin(); i != this->end(); ++i) {
193  i->getY().configure(JMultiKey<M+1, abscissa_type>(key,i->getX()), bounds);
194  }
195  }
196 
197 
198  class super_const_iterator; // forward declaration
199 
200 
201  /**
202  * Multidimensional iterator.
203  */
204  class super_iterator :
205  public JEquals <super_iterator>,
206  public JForwardIterator<super_iterator>
207  {
208 
209  friend class JMultiMap;
210  friend class super_const_iterator;
211 
212  public:
213 
214  typedef int difference_type;
218  typedef std::forward_iterator_tag iterator_category;
220 
221  /**
222  * Default constructor.
223  */
225  {}
226 
227 
228  /**
229  * Smart pointer operator.
230  *
231  * \return pointer to pair of iterators
232  */
234  {
235  return pointer(new value_type(i->getX(), second));
236  }
237 
238 
239  /**
240  * Dereference operator.
241  *
242  * \return multidimensional pair
243  */
245  {
246  return reference(i->getX(), *second);
247  }
248 
249 
250  /**
251  * Equality of super iterator.
252  *
253  * \param cursor super iterator
254  * \return true if equal; else false
255  */
256  virtual bool equals(const super_iterator& cursor) const
257  {
258  return i == cursor.i && (i == range.second || second.equals(cursor.second));
259  }
260 
261 
262  /**
263  * Increment super_iterator.
264  *
265  * \return true if valid; else false
266  */
267  virtual bool increment() override
268  {
269  if (!second.increment()) {
270 
271  while (++i != range.second) {
272 
273  second = i->getY().super_begin();
274 
275  if (second != i->getY().super_end()) {
276  break;
277  }
278  }
279  }
280 
281  return i != range.second;
282  }
283 
284 
285  /**
286  * Get multi-dimensional key.
287  *
288  * \return key
289  */
291  {
292  return multikey_type(i->getX(), second.getKey());
293  }
294 
295 
296  /**
297  * Get value.
298  *
299  * \return value
300  */
301  JOrdinate_t& getValue()
302  {
303  return second.getValue();
304  }
305 
306 
307  private:
308  /**
309  * Constructor.
310  *
311  * \param __begin begin of data
312  * \param __end end of data
313  */
315  iterator __end) :
316  range(__begin, __end)
317  {
318  for (i = range.first; i != range.second; ++i) {
319 
320  second = i->getY().super_begin();
321 
322  if (second != i->getY().super_end()) {
323  break;
324  }
325  }
326  }
327 
328 
331  typename mapped_type::super_iterator second;
332  };
333 
334 
335  /**
336  * Multidimensional const_iterator.
337  */
338  class super_const_iterator :
339  public JEquals <super_const_iterator>,
340  public JForwardIterator<super_const_iterator>
341  {
342 
343  friend class JMultiMap;
344 
345  public:
346 
347  typedef int difference_type;
351  typedef std::forward_iterator_tag iterator_category;
353 
354 
355  /**
356  * Default constructor.
357  */
359  {}
360 
361 
362  /**
363  * Copy constructor.
364  *
365  * \param cursor super_iterator
366  */
367  super_const_iterator(super_iterator cursor) :
368  range (cursor.range),
369  i (cursor.i),
370  second(cursor.second)
371  {}
372 
373 
374  /**
375  * Smart pointer operator.
376  *
377  * \return pointer to pair of iterators
378  */
380  {
381  return pointer(new value_type(i->getX(), second));
382  }
383 
384 
385  /**
386  * Dereference operator.
387  *
388  * \return multidimensional pair
389  */
391  {
392  return reference(i->getX(), *second);
393  }
394 
395 
396  /**
397  * Equality of super iterator.
398  *
399  * \param cursor super iterator
400  * \return true if equal; else false
401  */
402  virtual bool equals(const super_const_iterator& cursor) const
403  {
404  return i == cursor.i && (i == range.second || second.equals(cursor.second));
405  }
406 
407 
408  /**
409  * Increment super_iterator.
410  *
411  * \return true if valid; else false
412  */
413  virtual bool increment() override
414  {
415  if (!second.increment()) {
416 
417  while (++i != range.second) {
418 
419  second = i->getY().super_begin();
420 
421  if (second != i->getY().super_end()) {
422  break;
423  }
424  }
425  }
426 
427  return i != range.second;
428  }
429 
430 
431  /**
432  * Get multi-dimensional key.
433  *
434  * \return key
435  */
437  {
438  return multikey_type(i->getX(), second.getKey());
439  }
440 
441 
442  /**
443  * Get value.
444  *
445  * \return value
446  */
447  const JOrdinate_t& getValue()
448  {
449  return second.getValue();
450  }
451 
452 
453  private:
454  /**
455  * Constructor.
456  *
457  * \param __begin begin of data
458  * \param __end end of data
459  */
461  const_iterator __end) :
462  range(__begin, __end)
463  {
464  for (i = range.first; i != range.second; ++i) {
465 
466  second = i->getY().super_begin();
467 
468  if (second != i->getY().super_end()) {
469  break;
470  }
471  }
472  }
473 
474 
477  typename mapped_type::super_const_iterator second;
478  };
479 
480 
481  class super_const_reverse_iterator; // forward declaration
482 
483 
484  /**
485  * Multidimensional reverse iterator.
486  */
487  class super_reverse_iterator :
488  public JEquals <super_reverse_iterator>,
489  public JForwardIterator<super_reverse_iterator>
490  {
491 
492  friend class JMultiMap;
493  friend class super_const_reverse_iterator;
494 
495  public:
496 
497  typedef int difference_type;
501  typedef std::forward_iterator_tag iterator_category;
503 
504 
505  /**
506  * Default constructor.
507  */
509  {}
510 
511 
512  /**
513  * Smart pointer operator.
514  *
515  * \return pointer to pair of iterators
516  */
518  {
519  return pointer(new value_type(i->getX(), second));
520  }
521 
522 
523  /**
524  * Dereference operator.
525  *
526  * \return multidimensional pair
527  */
529  {
530  return reference(i->getX(), *second);
531  }
532 
533 
534  /**
535  * Equality of super reverse iterator.
536  *
537  * \param cursor super reverse iterator
538  * \return true if equal; else false
539  */
540  virtual bool equals(const super_reverse_iterator& cursor) const
541  {
542  return i == cursor.i && (i == range.second || second.equals(cursor.second));
543  }
544 
545 
546  /**
547  * Increment super_iterator.
548  *
549  * \return true if valid; else false
550  */
551  virtual bool increment() override
552  {
553  if (!second.increment()) {
554 
555  while (++i != range.second) {
556 
557  second = i->getY().super_rbegin();
558 
559  if (!second.equals(i->getY().super_rend())) {
560  break;
561  }
562  }
563  }
564 
565  return i != range.second;
566  }
567 
568 
569  /**
570  * Get multi-dimensional key.
571  *
572  * \return key
573  */
575  {
576  return multikey_type(i->getX(), second.getKey());
577  }
578 
579 
580  /**
581  * Get value.
582  *
583  * \return value
584  */
585  JOrdinate_t& getValue()
586  {
587  return second.getValue();
588  }
589 
590 
591  private:
592  /**
593  * Constructor.
594  *
595  * \param __begin reverse begin of data
596  * \param __end reverse end of data
597  */
599  reverse_iterator __end) :
600  range(__begin, __end)
601  {
602  for (i = range.first; i != range.second; ++i) {
603 
604  second = i->getY().super_rbegin();
605 
606  if (!second.equals(i->getY().super_rend())) {
607  break;
608  }
609  }
610  }
611 
612 
615  typename mapped_type::super_reverse_iterator second;
616  };
617 
618 
619  /**
620  * Multidimensional const_reverse_iterator.
621  */
622  class super_const_reverse_iterator :
623  public JEquals <super_const_reverse_iterator>,
624  public JForwardIterator<super_const_reverse_iterator>
625  {
626 
627  friend class JMultiMap;
628 
629  public:
630 
631  typedef int difference_type;
635  typedef std::forward_iterator_tag iterator_category;
637 
638 
639  /**
640  * Default constructor.
641  */
643  {}
644 
645 
646  /**
647  * Copy constructor.
648  *
649  * \param cursor super_iterator
650  */
651  super_const_reverse_iterator(super_reverse_iterator cursor) :
652  range (cursor.range),
653  i (cursor.i),
654  second(cursor.second)
655  {}
656 
657 
658  /**
659  * Smart pointer operator.
660  *
661  * \return pointer to pair of iterators
662  */
664  {
665  return pointer(new value_type(i->getX(), second));
666  }
667 
668 
669  /**
670  * Dereference operator.
671  *
672  * \return multidimensional pair
673  */
675  {
676  return reference(i->getX(), *second);
677  }
678 
679 
680  /**
681  * Equality of super reverse iterator.
682  *
683  * \param cursor super reverse iterator
684  * \return true if equal; else false
685  */
686  virtual bool equals(const super_const_reverse_iterator& cursor) const
687  {
688  return i == cursor.i && (i == range.second || second.equals(cursor.second));
689  }
690 
691 
692  /**
693  * Increment super_iterator.
694  *
695  * \return true if valid; else false
696  */
697  virtual bool increment() override
698  {
699  if (!second.increment()) {
700 
701  while (++i != range.second) {
702 
703  second = i->getY().super_rbegin();
704 
705  if (second != i->getY().super_rend()) {
706  break;
707  }
708  }
709  }
710 
711  return i != range.second;
712  }
713 
714 
715  /**
716  * Get multi-dimensional key.
717  *
718  * \return key
719  */
721  {
722  return multikey_type(i->getX(), second.getKey());
723  }
724 
725 
726  /**
727  * Get value.
728  *
729  * \return value
730  */
731  const JOrdinate_t& getValue()
732  {
733  return second.getValue();
734  }
735 
736 
737  private:
738  /**
739  * Constructor.
740  *
741  * \param __begin begin of data
742  * \param __end end of data
743  */
745  const_reverse_iterator __end) :
746  range(__begin, __end)
747  {
748  for (i = range.first; i != range.second; ++i) {
749 
750  second = i->getY().super_rbegin();
751 
752  if (second != i->getY().super_rend()) {
753  break;
754  }
755  }
756  }
757 
758 
761  typename mapped_type::super_const_reverse_iterator second;
762  };
763 
764 
765  /**
766  * Get super_iterator to begin of data.
767  *
768  * \return super iterator
769  */
770  super_const_iterator super_begin() const
771  {
772  return super_const_iterator(this->begin(), this->end());
773  }
774 
775 
776  /**
777  * Get super_reverse_iterator to reverse begin of data
778  *
779  * \return super reverse iterator
780  */
781  super_const_reverse_iterator super_rbegin() const
782  {
783  return super_const_reverse_iterator(this->rbegin(), this->rend());
784  }
785 
786 
787  /**
788  * Get super_iterator to end of data.
789  *
790  * \return super iterator
791  */
792  super_const_iterator super_end() const
793  {
794  return super_const_iterator(this->end(), this->end());
795  }
796 
797 
798  /**
799  * Get super_reverse_iterator to end of data.
800  *
801  * \return super reverse iterator
802  */
803  super_const_reverse_iterator super_rend() const
804  {
805  return super_const_reverse_iterator(this->rend(), this->rend());
806  }
807 
808 
809  /**
810  * Get super_iterator to begin of data.
811  *
812  * \return super iterator
813  */
814  super_iterator super_begin()
815  {
816  return super_iterator(this->begin(), this->end());
817  }
818 
819 
820  /**
821  * Get super_reverse_iterator to begin of data.
822  *
823  * \return super iterator
824  */
825  super_reverse_iterator super_rbegin()
826  {
827  return super_reverse_iterator(this->rbegin(), this->rend());
828  }
829 
830 
831  /**
832  * Get super_iterator to end of data.
833  *
834  * \return super iterator
835  */
836  super_iterator super_end()
837  {
838  return super_iterator(this->end(), this->end());
839  }
840 
841 
842  /**
843  * Get super_reverse_iterator to end of data.
844  *
845  * \return super iterator
846  */
847  super_reverse_iterator super_rend()
848  {
849  return super_reverse_iterator(this->rend(), this->rend());
850  }
851 
852 
853  /**
854  * Get value.
855  *
856  * \param key multidimensional key
857  * \return value
858  */
860  {
861  return this->get(key.first).get(key.second);
862  }
863 
864 
865  /**
866  * Insert element.
867  *
868  * \param key multidimensional key
869  * \param value value
870  */
872  {
873  (*this)[key.first].insert(key.second, value);
874  }
875 
876 
877  /**
878  * Insert element.
879  *
880  * \param value multidimensional pair
881  */
883  {
884  (*this)[value.first].insert(value.second);
885  }
886 
887 
888  /**
889  * Insert element.
890  *
891  * \param value multidimensional iterator value
892  */
893  void insert(const typename super_iterator::reference& value)
894  {
895  (*this)[value.first].insert(value.second);
896  }
897 
898 
899  /**
900  * Insert element.
901  *
902  * \param value multidimensional iterator value
903  */
904  void insert(const typename super_const_iterator::reference& value)
905  {
906  (*this)[value.first].insert(value.second);
907  }
908  };
909 
910 
911  /**
912  * Terminator class of recursive JMultiMap class.
913  */
914  template<class JAbscissa_t,
915  class JOrdinate_t,
916  template<class, class, class> class JHead_t,
917  class JDistance_t>
918  class JMultiMap<JAbscissa_t, JOrdinate_t, JMapList<JHead_t, JLANG::JNullType>, JDistance_t> :
919  public JHead_t<JAbscissa_t, JOrdinate_t, JDistance_t>,
920  public JMath< JMultiMap<JAbscissa_t, JOrdinate_t, JMapList<JHead_t, JLANG::JNullType>, JDistance_t> >
921  {
922  public:
923 
924  enum { NUMBER_OF_DIMENSIONS = 1 };
925 
926  typedef JHead_t<JAbscissa_t, JOrdinate_t, JDistance_t> map_type;
927 
928  typedef JAbscissa_t abscissa_type;
929  typedef JOrdinate_t ordinate_type;
930 
931  typedef typename map_type::key_type key_type;
932  typedef typename map_type::mapped_type mapped_type;
933  typedef typename map_type::value_type value_type;
934 
935  typedef typename map_type::const_iterator const_iterator;
936  typedef typename map_type::const_reverse_iterator const_reverse_iterator;
937 
938  typedef typename map_type::iterator iterator;
939  typedef typename map_type::reverse_iterator reverse_iterator;
940 
941  using map_type::insert;
942  using map_type::configure;
943  using map_type::get;
944 
945 
946  /**
947  * Default constructor.
948  */
950  {}
951 
952 
953  /**
954  * Add map.
955  *
956  * \param map multimap
957  * \return this multimap
958  */
960  {
961  static_cast<map_type&>(*this).add(static_cast<const map_type&>(map));
962 
963  return *this;
964  }
965 
966 
967  /**
968  * Subtract map.
969  *
970  * \param map multimap
971  * \return this multimap
972  */
974  {
975  static_cast<map_type&>(*this).sub(static_cast<const map_type&>(map));
976 
977  return *this;
978  }
979 
980 
981  /**
982  * Scale contents.
983  *
984  * \param value multiplication factor
985  * \return this multimap
986  */
987  JMultiMap& mul(const double value)
988  {
989  static_cast<map_type&>(*this).mul(value);
990 
991  return *this;
992  }
993 
994  /**
995  * Scale contents.
996  *
997  * \param value division factor
998  * \return this multimap
999  */
1000  JMultiMap& div(const double value)
1001  {
1002  static_cast<map_type&>(*this).div(value);
1003 
1004  return *this;
1005  }
1006 
1007 
1008  /**
1009  * Termination of function application.
1010  *
1011  * \param function function
1012  * \return function
1013  */
1014  template<class JFunction_t>
1015  void for_each(const JFunction_t& function)
1016  {
1017  function(*this);
1018  }
1019 
1020 
1021  /**
1022  * Configure multidimensional map.
1023  *
1024  * \param bounds multidimensional bounds
1025  */
1027  {
1028  this->configure(JMultiKey<0, abscissa_type>(), bounds);
1029  }
1030 
1031 
1032  /**
1033  * Configure multidimensional map.
1034  *
1035  * \param key multidimensional key
1036  * \param bounds multidimensional bounds
1037  */
1038  template<unsigned int N, unsigned int M>
1040  {
1041  this->configure(bounds(key));
1042  }
1043 
1044 
1045  class super_const_iterator; // forward declaration
1046 
1047 
1048  /**
1049  * Terminator class of multidimensional iterator.
1050  */
1051  class super_iterator :
1052  public JEquals <super_iterator>,
1053  public JForwardIterator<super_iterator>
1054  {
1055 
1056  friend class JMultiMap;
1057  friend class super_const_iterator;
1058 
1059  public:
1060 
1061  typedef size_t difference_type;
1065  typedef std::forward_iterator_tag iterator_category;
1067 
1068 
1069  /**
1070  * Default constructor.
1071  */
1073  {}
1074 
1075 
1076  /**
1077  * Smart pointer operator.
1078  *
1079  * \return pointer to pair of iterators
1080  */
1082  {
1083  return pointer(new value_type(i->getX(), i->getY()));
1084  }
1085 
1086 
1087  /**
1088  * Dereference operator.
1089  *
1090  * \return multidimensional pair
1091  */
1093  {
1094  return reference(i->getX(), i->getY());
1095  }
1096 
1097 
1098  /**
1099  * Equality of super iterator.
1100  *
1101  * \param cursor super iterator
1102  * \return true if equal; else false
1103  */
1104  virtual bool equals(const super_iterator& cursor) const
1105  {
1106  return i == cursor.i;
1107  }
1108 
1109 
1110  /**
1111  * Increment super_iterator.
1112  *
1113  * \return true if valid; else false
1114  */
1115  virtual bool increment() override
1116  {
1117  return ++i != range.second;
1118  }
1119 
1120 
1121  /**
1122  * Get multi-dimensional key.
1123  *
1124  * \return key
1125  */
1127  {
1128  return multikey_type(i->getX());
1129  }
1130 
1131 
1132  /**
1133  * Get value.
1134  *
1135  * \return value
1136  */
1137  JOrdinate_t& getValue()
1138  {
1139  return i->getY();
1140  }
1141 
1142  private:
1143  /**
1144  * Constructor.
1145  *
1146  * \param __begin begin of data
1147  * \param __end end of data
1148  */
1150  iterator __end) :
1151  range(__begin, __end),
1152  i (__begin)
1153  {}
1154 
1155 
1158  };
1159 
1160 
1161  /**
1162  * Terminator class of multidimensional const_iterator.
1163  */
1164  class super_const_iterator :
1165  public JEquals <super_const_iterator>,
1166  public JForwardIterator<super_const_iterator>
1167  {
1168 
1169  friend class JMultiMap;
1170 
1171  public:
1172 
1173  typedef size_t difference_type;
1177  typedef std::forward_iterator_tag iterator_category;
1179 
1180 
1181  /**
1182  * Default constructor.
1183  */
1185  {}
1186 
1187 
1188  /**
1189  * Copy constructor.
1190  *
1191  * \param cursor super_iterator
1192  */
1193  super_const_iterator(super_iterator cursor) :
1194  range(cursor.range),
1195  i (cursor.i)
1196  {}
1197 
1198 
1199  /**
1200  * Smart pointer operator.
1201  *
1202  * \return pointer to pair of iterators
1203  */
1205  {
1206  return pointer(new value_type(i->getX(), i->getY()));
1207  }
1208 
1209 
1210  /**
1211  * Dereference operator.
1212  *
1213  * \return multidimensional pair
1214  */
1216  {
1217  return reference(i->getX(), i->getY());
1218  }
1219 
1220 
1221  /**
1222  * Equality of super iterator.
1223  *
1224  * \param cursor super iterator
1225  * \return true if equal; else false
1226  */
1227  virtual bool equals(const super_const_iterator& cursor) const
1228  {
1229  return i == cursor.i;
1230  }
1231 
1232 
1233  /**
1234  * Increment super_iterator.
1235  *
1236  * \return true if valid; else false
1237  */
1238  virtual bool increment() override
1239  {
1240  return ++i != range.second;
1241  }
1242 
1243 
1244  /**
1245  * Get multi-dimensional key.
1246  *
1247  * \return key
1248  */
1250  {
1251  return multikey_type(i->getX());
1252  }
1253 
1254 
1255  /**
1256  * Get value.
1257  *
1258  * \return value
1259  */
1260  const JOrdinate_t& getValue()
1261  {
1262  return i->getY();
1263  }
1264 
1265  private:
1266  /**
1267  * Constructor.
1268  *
1269  * \param __begin begin of data
1270  * \param __end end of data
1271  */
1273  const_iterator __end) :
1274  range(__begin, __end),
1275  i (__begin)
1276  {}
1277 
1278 
1281  };
1282 
1283 
1284  class super_const_reverse_iterator; // forward declaration
1285 
1286 
1287  /**
1288  * Terminator class of multidimensional reverse iterator.
1289  */
1290  class super_reverse_iterator :
1291  public JEquals <super_iterator>,
1292  public JForwardIterator<super_iterator>
1293  {
1294 
1295  friend class JMultiMap;
1296  friend class super_const_reverse_iterator;
1297 
1298  public:
1299 
1300  typedef size_t difference_type;
1304  typedef std::forward_iterator_tag iterator_category;
1306 
1307 
1308  /**
1309  * Default constructor.
1310  */
1312  {}
1313 
1314 
1315  /**
1316  * Smart pointer operator.
1317  *
1318  * \return pointer to pair of reverse iterators
1319  */
1321  {
1322  return pointer(new value_type(i->getX(), i->getY()));
1323  }
1324 
1325 
1326  /**
1327  * Dereference operator.
1328  *
1329  * \return multidimensional pair
1330  */
1332  {
1333  return reference(i->getX(), i->getY());
1334  }
1335 
1336 
1337  /**
1338  * Equality of super reverse iterator.
1339  *
1340  * \param cursor super reverse iterator
1341  * \return true if equal; else false
1342  */
1343  virtual bool equals(const super_reverse_iterator& cursor) const
1344  {
1345  return i == cursor.i;
1346  }
1347 
1348 
1349  /**
1350  * Increment super_reverse_iterator.
1351  *
1352  * \return true if valid; else false
1353  */
1354  virtual bool increment() override
1355  {
1356  return ++i != range.second;
1357  }
1358 
1359 
1360  /**
1361  * Get multi-dimensional key.
1362  *
1363  * \return key
1364  */
1366  {
1367  return multikey_type(i->getX());
1368  }
1369 
1370 
1371  /**
1372  * Get value.
1373  *
1374  * \return value
1375  */
1376  JOrdinate_t& getValue()
1377  {
1378  return i->getY();
1379  }
1380 
1381  private:
1382  /**
1383  * Constructor.
1384  *
1385  * \param __begin begin of data
1386  * \param __end end of data
1387  */
1389  reverse_iterator __end) :
1390  range(__begin, __end),
1391  i (__begin)
1392  {}
1393 
1394 
1397  };
1398 
1399 
1400  /**
1401  * Terminator class of multidimensional const_iterator.
1402  */
1403  class super_const_reverse_iterator :
1404  public JEquals <super_const_reverse_iterator>,
1405  public JForwardIterator<super_const_reverse_iterator>
1406  {
1407 
1408  friend class JMultiMap;
1409 
1410  public:
1411 
1412  typedef size_t difference_type;
1416  typedef std::forward_iterator_tag iterator_category;
1418 
1419 
1420  /**
1421  * Default constructor.
1422  */
1424  {}
1425 
1426 
1427  /**
1428  * Copy constructor.
1429  *
1430  * \param cursor super_iterator
1431  */
1432  super_const_reverse_iterator(super_reverse_iterator cursor) :
1433  range(cursor.range),
1434  i (cursor.i)
1435  {}
1436 
1437 
1438  /**
1439  * Smart pointer operator.
1440  *
1441  * \return pointer to pair of iterators
1442  */
1444  {
1445  return pointer(new value_type(i->getX(), i->getY()));
1446  }
1447 
1448 
1449  /**
1450  * Dereference operator.
1451  *
1452  * \return multidimensional pair
1453  */
1455  {
1456  return reference(i->getX(), i->getY());
1457  }
1458 
1459 
1460  /**
1461  * Equality of super reverse iterator.
1462  *
1463  * \param cursor super reverse iterator
1464  * \return true if equal; else false
1465  */
1466  virtual bool equals(const super_const_reverse_iterator& cursor) const
1467  {
1468  return i == cursor.i;
1469  }
1470 
1471 
1472  /**
1473  * Increment super_iterator.
1474  *
1475  * \return true if valid; else false
1476  */
1477  virtual bool increment() override
1478  {
1479  return ++i != range.second;
1480  }
1481 
1482 
1483  /**
1484  * Get multi-dimensional key.
1485  *
1486  * \return key
1487  */
1489  {
1490  return multikey_type(i->getX());
1491  }
1492 
1493 
1494  /**
1495  * Get value.
1496  *
1497  * \return value
1498  */
1499  const JOrdinate_t& getValue()
1500  {
1501  return i->getY();
1502  }
1503 
1504  private:
1505  /**
1506  * Constructor.
1507  *
1508  * \param __begin begin of data
1509  * \param __end end of data
1510  */
1512  const_reverse_iterator __end) :
1513  range(__begin, __end),
1514  i (__begin)
1515  {}
1516 
1517 
1520  };
1521 
1522 
1523  /**
1524  * Get super_iterator to begin of data.
1525  *
1526  * \return super_iterator
1527  */
1528  super_const_iterator super_begin() const
1529  {
1530  return super_const_iterator(this->begin(), this->end());
1531  }
1532 
1533 
1534  /**
1535  * Get super_reverse_iterator to reverse begin of data.
1536  *
1537  * \return super_reverse_iterator
1538  */
1539  super_const_reverse_iterator super_rbegin() const
1540  {
1541  return super_const_reverse_iterator(this->rbegin(), this->rend());
1542  }
1543 
1544 
1545  /**
1546  * Get super_iterator to end of data.
1547  *
1548  * \return super_iterator
1549  */
1550  super_const_iterator super_end() const
1551  {
1552  return super_const_iterator(this->end(), this->end());
1553  }
1554 
1555 
1556  /**
1557  * Get super_reverse_iterator to reverse end of data.
1558  *
1559  * \return super_reverse_iterator
1560  */
1561  super_const_reverse_iterator super_rend() const
1562  {
1563  return super_const_reverse_iterator(this->rend(), this->rend());
1564  }
1565 
1566 
1567  /**
1568  * Get super_iterator to begin of data.
1569  *
1570  * \return super_iterator
1571  */
1572  super_iterator super_begin()
1573  {
1574  return super_iterator(this->begin(), this->end());
1575  }
1576 
1577 
1578  /**
1579  * Get super_reverse_iterator to reverse begin of data.
1580  *
1581  * \return super_reverse_iterator
1582  */
1583  super_reverse_iterator super_rbegin()
1584  {
1585  return super_reverse_iterator(this->rbegin(), this->rend());
1586  }
1587 
1588 
1589  /**
1590  * Get super_iterator to end of data.
1591  *
1592  * \return super_iterator
1593  */
1594  super_iterator super_end()
1595  {
1596  return super_iterator(this->end(), this->end());
1597  }
1598 
1599 
1600  /**
1601  * Get super_reverse_iterator to end of data.
1602  *
1603  * \return super_reverse_iterator
1604  */
1605  super_reverse_iterator super_rend()
1606  {
1607  return super_reverse_iterator(this->rend(), this->rend());
1608  }
1609 
1610 
1611  /**
1612  * Get value.
1613  *
1614  * \param key multidimensional key
1615  * \return value
1616  */
1618  {
1619  return get(key.first);
1620  }
1621 
1622 
1623  /**
1624  * Insert element.
1625  *
1626  * \param key multidimensional key
1627  * \param value value
1628  */
1629  void insert(const JMultiKey<1, JAbscissa_t>& key, const JOrdinate_t& value)
1630  {
1631  insert(value_type(key.first, value));
1632  }
1633 
1634 
1635  /**
1636  * Insert element.
1637  *
1638  * \param value multidimensional pair
1639  */
1641  {
1642  insert(value_type(value.first, value.second));
1643  }
1644 
1645 
1646  /**
1647  * Insert element.
1648  *
1649  * \param value multidimensional iterator value
1650  */
1651  void insert(const typename super_iterator::reference& value)
1652  {
1653  insert(value_type(value.first, value.second));
1654  }
1655 
1656 
1657  /**
1658  * Insert element.
1659  *
1660  * \param value multidimensional iterator value
1661  */
1662  void insert(const typename super_const_iterator::reference& value)
1663  {
1664  insert(value_type(value.first, value.second));
1665  }
1666  };
1667 }
1668 
1669 #endif
super_const_iterator super_begin() const
Get super_iterator to begin of data.
Definition: JMultiMap.hh:770
super_const_reverse_iterator super_rend() const
Get super_reverse_iterator to reverse end of data.
Definition: JMultiMap.hh:1561
Template interface for method bool increment().
void for_each(const JFunction_t &function)
Termination of function application.
Definition: JMultiMap.hh:1015
super_reverse_iterator super_rend()
Get super_reverse_iterator to end of data.
Definition: JMultiMap.hh:1605
void insert(const typename super_iterator::reference &value)
Insert element.
Definition: JMultiMap.hh:1651
super_const_reverse_iterator super_rend() const
Get super_reverse_iterator to end of data.
Definition: JMultiMap.hh:803
mapped_type second
Definition: JMultiPair.hh:125
Auxiliary base class for aritmetic operations of derived class types.
Definition: JMath.hh:110
void insert(const JMultiPair< 1, JAbscissa_t, JOrdinate_t > &value)
Insert element.
Definition: JMultiMap.hh:1640
super_const_reverse_iterator(const_reverse_iterator __begin, const_reverse_iterator __end)
Constructor.
Definition: JMultiMap.hh:744
Template class for distance evaluation.
Definition: JDistance.hh:24
virtual bool equals(const super_reverse_iterator &cursor) const
Equality of super reverse iterator.
Definition: JMultiMap.hh:540
void configure(const JAbstractMultiMap< NUMBER_OF_DIMENSIONS, abscissa_type > &bounds)
Configure multidimensional map.
Definition: JMultiMap.hh:175
T get(const JHead &header)
Get object from header.
Length of map list.
Definition: JMapList.hh:45
JPair< const key_type &, typename mapped_type::super_const_reverse_iterator & > value_type
Definition: JMultiMap.hh:632
void insert(const JMultiKey< NUMBER_OF_DIMENSIONS, abscissa_type > &key, const ordinate_type &value)
Insert element.
Definition: JMultiMap.hh:871
void insert(const typename super_const_iterator::reference &value)
Insert element.
Definition: JMultiMap.hh:1662
JPair< const key_type &, typename mapped_type::super_const_iterator & > value_type
Definition: JMultiMap.hh:348
Abstract interface for abscissa values of a multidimensional map.
JMultiPair< NUMBER_OF_DIMENSIONS, const JAbscissa_t, JOrdinate_t & > reference
Definition: JMultiMap.hh:217
Multidimensional key.
Definition: JMultiKey.hh:34
The template JSinglePointer class can be used to hold a pointer to an object.
super_reverse_iterator super_rbegin()
Get super_reverse_iterator to begin of data.
Definition: JMultiMap.hh:825
Template specialisation for a pair of values.
Definition: JPair.hh:28
virtual bool equals(const super_const_iterator &cursor) const
Equality of super iterator.
Definition: JMultiMap.hh:1227
super_const_reverse_iterator super_rbegin() const
Get super_reverse_iterator to reverse begin of data.
Definition: JMultiMap.hh:1539
virtual bool equals(const super_iterator &cursor) const
Equality of super iterator.
Definition: JMultiMap.hh:256
Map list.
Definition: JMapList.hh:24
void insert(const typename super_const_iterator::reference &value)
Insert element.
Definition: JMultiMap.hh:904
Template definition of auxiliary base class for comparison of data structures.
Definition: JEquals.hh:24
virtual bool equals(const super_const_iterator &cursor) const
Equality of super iterator.
Definition: JMultiMap.hh:402
void configure(const JMultiKey< M, abscissa_type > &key, const JAbstractMultiMap< N, abscissa_type > &bounds)
Configure multidimensional map.
Definition: JMultiMap.hh:188
virtual bool equals(const super_reverse_iterator &cursor) const
Equality of super reverse iterator.
Definition: JMultiMap.hh:1343
Auxiliary class for no type definition.
Definition: JNullType.hh:19
super_const_iterator super_end() const
Get super_iterator to end of data.
Definition: JMultiMap.hh:1550
JPair< const key_type &, typename mapped_type::super_reverse_iterator & > value_type
Definition: JMultiMap.hh:498
void insert(const JMultiPair< NUMBER_OF_DIMENSIONS, abscissa_type, ordinate_type > &value)
Insert element.
Definition: JMultiMap.hh:882
super_reverse_iterator super_rend()
Get super_reverse_iterator to end of data.
Definition: JMultiMap.hh:847
void configure(const JMultiKey< M, abscissa_type > &key, const JAbstractMultiMap< N, abscissa_type > &bounds)
Configure multidimensional map.
Definition: JMultiMap.hh:1039
void insert(const JMultiKey< 1, JAbscissa_t > &key, const JOrdinate_t &value)
Insert element.
Definition: JMultiMap.hh:1629
virtual bool equals(const super_iterator &cursor) const
Equality of super iterator.
Definition: JMultiMap.hh:1104
z range($ZMAX-$ZMIN)< $MINIMAL_DZ." fi fi mv $WORKDIR/fit.root $MODULE_ROOT typeset -Z 4 STRING typeset -Z 2 FLOOR JPlot1D -f $
Definition: module-Z:fit.sh:84
super_const_iterator super_end() const
Get super_iterator to end of data.
Definition: JMultiMap.hh:792
JMultiPair< NUMBER_OF_DIMENSIONS, const JAbscissa_t, const JOrdinate_t & > reference
Definition: JMultiMap.hh:350
super_reverse_iterator super_rbegin()
Get super_reverse_iterator to reverse begin of data.
Definition: JMultiMap.hh:1583
void configure(const T &value, const JAbstractCollection< JAbscissa_t > &bounds, JBool< false > option)
Configuration of value.
virtual bool equals(const super_const_reverse_iterator &cursor) const
Equality of super reverse iterator.
Definition: JMultiMap.hh:1466
JHead_t< JAbscissa_t, JMultiMap< JAbscissa_t, JOrdinate_t, JTail_t, JDistance_t >, JDistance_t > map_type
Definition: JMultiMap.hh:72
Base class for data structures with artithmetic capabilities.
Multidimensional pair.
Definition: JMultiPair.hh:30
void for_each(const JFunction_t &function)
Function application to each element of this multimap.
Definition: JMultiMap.hh:160
void configure(const JAbstractMultiMap< NUMBER_OF_DIMENSIONS, abscissa_type > &bounds)
Configure multidimensional map.
Definition: JMultiMap.hh:1026
void insert(const typename super_iterator::reference &value)
Insert element.
Definition: JMultiMap.hh:893
virtual bool equals(const super_const_reverse_iterator &cursor) const
Equality of super reverse iterator.
Definition: JMultiMap.hh:686
const char * map
Definition: elog.cc:87
super_const_reverse_iterator super_rbegin() const
Get super_reverse_iterator to reverse begin of data.
Definition: JMultiMap.hh:781
JPair< const key_type &, typename mapped_type::super_iterator & > value_type
Definition: JMultiMap.hh:215
Multidimensional map.
Definition: JMultiMap.hh:51
super_const_iterator super_begin() const
Get super_iterator to begin of data.
Definition: JMultiMap.hh:1528