YSTest  PreAlpha_b500_20140530
The YSLib Test Project
 全部  命名空间 文件 函数 变量 类型定义 枚举 枚举值 友元 宏定义  
iterator.hpp
浏览该文件的文档.
1 /*
2  © 2011-2014 FrankHB.
3 
4  This file is part of the YSLib project, and may only be used,
5  modified, and distributed under the terms of the YSLib project
6  license, LICENSE.TXT. By continuing to use, modify, or distribute
7  this file you indicate that you have read the license and
8  understand and accept it fully.
9 */
10 
28 #ifndef YB_INC_ystdex_iterator_hpp_
29 #define YB_INC_ystdex_iterator_hpp_ 1
30 
31 #include "type_op.hpp" // for ystdex::remove_reference_t, ystdex::*_tag;
32 #include "cassert.h"
33 #include <iterator> // for std::make_move_iterator, std::iterator,
34 // std::iterator_traits;
35 #include <utility> // for std::make_pair;
36 #include <memory> // for std::addressof;
37 
38 namespace ystdex
39 {
40 
57 template<typename _tParam, typename = yimpl(std::pair<
58  decltype(*std::declval<_tParam&>()), decltype(++std::declval<_tParam&>())>)>
60  is_same<decltype(++std::declval<_tParam&>()), _tParam&>::value, int>;
61 
62 
69 
77 template<typename _tIterator>
78 yconstfn bool
79 is_undereferenceable(const _tIterator&) ynothrow
80 {
81  return false;
82 }
83 template<typename _type>
84 yconstfn bool
86 {
87  return !bool(p);
88 }
90 
97 template<typename _tIn, typename _fPred>
98 _tIn
99 next_if(_tIn i, _fPred f,
100  typename std::iterator_traits<_tIn>::difference_type n = 1)
101 {
103  return f(*i) ? std::next(i, n) : i;
104 }
105 template<typename _tIn, typename _type>
106 _tIn
107 next_if_eq(_tIn i, const _type& val,
108  typename std::iterator_traits<_tIn>::difference_type n = 1)
109 {
111  return *i == val ? std::next(i, n) : i;
112 }
114 
120 template<typename _tBi, typename _fPred>
121 _tBi
122 prev_if(_tBi i, _fPred f,
123  typename std::iterator_traits<_tBi>::difference_type n = 1)
124 {
125  return f(*i) ? std::prev(i, n) : i;
126 }
127 template<typename _tBi, typename _type>
128 _tBi
129 prev_if_eq(_tBi i, const _type& val,
130  typename std::iterator_traits<_tBi>::difference_type n = 1)
131 {
132  return *i == val ? std::prev(i, n) : i;
133 }
135 
137 
138 
144 template<typename _tIterator1, typename _tIterator2>
145 inline auto
146 make_move_iterator_pair(_tIterator1 it1, _tIterator2 it2) -> decltype(
147  std::make_pair(std::make_move_iterator(it1), std::make_move_iterator(it2)))
148 {
149  return std::make_pair(std::make_move_iterator(it1),
150  std::make_move_iterator(it2));
151 }
158 template<typename _tRange>
159 inline auto
161  -> decltype(ystdex::make_move_iterator_pair(begin(c), end(c)))
162 {
163  return ystdex::make_move_iterator_pair(begin(c), end(c));
164 }
165 
166 
177 template<typename _type>
179 {
180 public:
181  using iterator_type = _type*;
182  using iterator_category
183  = typename std::iterator_traits<iterator_type>::iterator_category;
184  using value_type = typename std::iterator_traits<iterator_type>::value_type;
185  using difference_type
186  = typename std::iterator_traits<iterator_type>::difference_type;
187  using pointer = typename std::iterator_traits<iterator_type>::pointer;
188  using reference = typename std::iterator_traits<iterator_type>::reference;
189 
190 protected:
193 
194 public:
195  yconstfn
197  : raw()
198  {}
200  template<typename _tPointer>
201  explicit yconstfn
202  pointer_iterator(_tPointer&& ptr)
203  : raw(yforward(ptr))
204  {}
205  inline
206  pointer_iterator(const pointer_iterator&) = default;
207 
211  {
212  yconstraint(raw);
213  raw += n;
214  return *this;
215  }
216 
220  {
221  yconstraint(raw);
222  raw -= n;
223  return *this;
224  }
225 
227  reference
229  {
230  yconstraint(raw);
231  return *raw;
232  }
233 
235  operator->() const
236  {
237  return raw;
238  }
239 
240  inline pointer_iterator&
242  {
243  yconstraint(raw);
244  ++raw;
245  return *this;
246  }
250  {
251  return raw++;
252  }
253 
254  inline pointer_iterator&
256  {
257  --raw;
258  return *this;
259  }
263  {
264  return raw--;
265  }
266 
268  reference
270  {
271  yconstraint(raw);
272 
273  return raw[n];
274  }
275 
279  {
280  return pointer_iterator(raw + n);
281  }
282 
286  {
287  return pointer_iterator(raw - n);
288  }
289 
290  yconstfn
291  operator pointer() const
292  {
293  return raw;
294  }
295 };
296 
302 template<typename _type>
303 inline bool
305 {
306  using pointer = typename pointer_iterator<_type>::pointer;
307 
308  return pointer(x) == pointer(y);
309 }
310 
311 template<typename _type>
312 inline bool
314 {
315  return !(x == y);
316 }
318 
319 
328 template<typename _type>
330 {
331  using type = _type;
332 };
333 
334 template<typename _type>
335 struct pointer_classify<_type*>
336 {
338 };
340 
341 
349 template<typename _type, typename _tIterator = _type*,
350  typename _tTraits = std::iterator_traits<_tIterator>>
352 {
353 public:
354  using iterator_type = _tIterator;
356  using traits_type = _tTraits;
357  using iterator_category = typename traits_type::iterator_category;
358  using value_type = typename traits_type::value_type;
359  using difference_type = typename traits_type::difference_type;
360  using pointer = typename traits_type::pointer;
361  using reference = typename traits_type::reference;
362 
364 
365  yconstfn
367  : value()
368  {}
369  explicit yconstfn
371  : value(v)
372  {}
373  yconstfn
374  pseudo_iterator(const pseudo_iterator&) = default;
375  yconstfn
376 #if YB_IMPL_MSCPP
379  : value(std::move(i.value))
380  {}
381 #else
382  pseudo_iterator(pseudo_iterator&&) = default;
383 #endif
384 
386  operator=(const pseudo_iterator&) = default;
388 #if YB_IMPL_MSCPP
391  {
392  value = std::move(i.value);
393  return *this;
394  }
395 #else
396  operator=(pseudo_iterator&&) = default;
397 #endif
398 
402  {
403  return *this;
404  }
405 
409  {
410  return *this;
411  }
412 
414 
416  operator*() const
417  {
418  return value;
419  }
420 
422  operator->() const
423  {
424  return this;
425  }
426 
429  {
430  return *this;
431  }
434  {
435  return *this;
436  }
438 
440 
442  operator--() const
443  {
444  return *this;
445  }
447  operator--(int) const
448  {
449  return *this;
450  }
452 
460  {
461  return this[n];
462  }
463 
466  {
467  return *this;
468  }
469 
472  {
473  return *this;
474  }
476 };
477 
484 template<typename _type, typename _tIterator, typename _tTraits>
485 inline bool
488 {
489  return x.value == y.value;
490 }
491 
492 template<typename _type, typename _tIterator, typename _tTraits>
493 inline bool
496 {
497  return !(x == y);
498 }
500 
501 
513 template<typename _tIterator, typename _fTransformer>
514 class transformed_iterator : public pointer_classify<_tIterator>::type
515 {
516 public:
521  using iterator_type = typename
527  using difference_type
530  using reference = decltype(std::declval<transformed_type>());
531 
532 protected:
535 
536 public:
538  transformed_iterator() = default;
540  template<typename _tIter, typename _tTran,
542  explicit yconstfn
543  transformed_iterator(_tIter&& i, _tTran f = {})
545  {}
547 
548  transformed_iterator(const transformed_iterator&) = default;
551 
553  inline reference
554  operator*() const
555  {
556  return yforward(transformer(get()));
557  }
558 
560  template<typename _tDiff>
561  enable_if_t<is_convertible<decltype(
562  std::declval<iterator_type&>()[_tDiff()]), reference>::value, reference>
563  operator[](_tDiff n)
564  {
565  return get()[difference_type(n)];
566  }
567 
572  inline
573  operator iterator_type&()
574  {
575  return *this;
576  }
577 
582  yconstfn
583  operator const iterator_type&() const
584  {
585  return *this;
586  }
587 
592  inline iterator_type&
593  get()
594  {
595  return *this;
596  }
597 
602  yconstfn const iterator_type&
603  get() const
604  {
605  return *this;
606  }
607 
609 
612  {
613  return transformer;
614  }
617  {
618  return transformer;
619  }
621 };
622 
629 template<typename _type, typename _fTransformer>
630 inline bool
633 {
634  return x.get() == y.get();
635 }
636 
637 template<typename _type, typename _fTransformer>
638 inline bool
641 {
642  return !(x == y);
643 }
645 
652 template<typename _type, typename _fTransformer>
653 inline transformed_iterator<_type, _fTransformer>&
656 {
657  i.get() += n;
658  return i;
659 }
660 
661 template<typename _type, typename _fTransformer>
665 {
666  i.get() -= n;
667  return i;
668 }
669 
670 template<typename _type, typename _fTransformer>
671 transformed_iterator<_type, _fTransformer>
672 operator+(const transformed_iterator<_type, _fTransformer>& i,
673  typename transformed_iterator<_type, _fTransformer>::difference_type n)
674 {
675  auto it(i);
676 
677  it += n;
678  return it;
679 }
680 
681 template<typename _type, typename _fTransformer>
682 transformed_iterator<_type, _fTransformer>
683 operator-(const transformed_iterator<_type, _fTransformer>& i,
684  typename transformed_iterator<_type, _fTransformer>::difference_type n)
685 {
686  auto it(i);
687 
688  it -= n;
689  return it;
690 }
691 template<typename _type, typename _fTransformer>
692 typename transformed_iterator<_type, _fTransformer>::difference_type
693 operator-(const transformed_iterator<_type, _fTransformer>& x,
694  const transformed_iterator<_type, _fTransformer>& y)
695 {
696  return x.get() - y.get();
697 }
698 
699 template<typename _type, typename _fTransformer>
700 inline bool
701 operator<(const transformed_iterator<_type, _fTransformer>& x,
702  const transformed_iterator<_type, _fTransformer>& y)
703 {
704  return bool(x.get() < y.get());
705 }
706 
707 template<typename _type, typename _fTransformer>
708 inline bool
709 operator<=(const transformed_iterator<_type, _fTransformer>& x,
710  const transformed_iterator<_type, _fTransformer>& y)
711 {
712  return !(y < x);
713 }
714 
715 template<typename _type, typename _fTransformer>
716 inline bool
717 operator>(const transformed_iterator<_type, _fTransformer>& x,
718  const transformed_iterator<_type, _fTransformer>& y)
719 {
720  return y < x;
721 }
722 
723 template<typename _type, typename _fTransformer>
724 inline bool
725 operator>=(const transformed_iterator<_type, _fTransformer>& x,
726  const transformed_iterator<_type, _fTransformer>& y)
727 {
728  return !(x < y);
729 }
731 
732 
739 template<typename _tIterator, typename _fTransformer>
740 inline transformed_iterator<typename array_ref_decay<_tIterator>::type,
741  _fTransformer>
742 make_transform(_tIterator&& i, _fTransformer f)
743 {
745  _fTransformer>(yforward(i), f);
746 }
747 
748 
753 namespace iterator_transformation
754 {
756 
757  template<typename _tIterator>
758  static yconstfn auto
759  first(const _tIterator& i) -> decltype((i->first))
760  {
761  return i->first;
762  }
763  template<typename _tIterator>
764  static yconstfn auto
765  second(const _tIterator& i) -> decltype((i->second))
766  {
767  return i->second;
768  }
769  template<typename _tIterator>
770  static yconstfn auto
771  indirect(const _tIterator& i) -> decltype((**i))
772  {
773  return **i;
774  }
776 } // namespace iterator_transformation;
777 
778 
789 
790 
795 template<typename _tIterator>
796 inline auto
797 operator|(_tIterator&& i, first_tag)
798  -> decltype(make_transform(yforward(i), iterator_transformation::first<
800 {
801  return make_transform(yforward(i), iterator_transformation::first<
803 }
804 template<typename _tIterator>
805 inline auto
806 operator|(_tIterator&& i, second_tag)
807  -> decltype(make_transform(yforward(i), iterator_transformation::second<
809 {
810  return make_transform(yforward(i), iterator_transformation::second<
812 }
814 template<typename _tIterator>
815 inline auto
816 operator|(_tIterator&& i, indirect_tag)
817  -> decltype(make_transform(yforward(i), iterator_transformation::indirect<
819 {
820  return make_transform(yforward(i), iterator_transformation::indirect<
822 }
823 
824 
833 template<typename _tMaster, typename _tSlave,
834  class _tTraits = std::iterator_traits<_tMaster>>
835 class pair_iterator : private std::pair<_tMaster, _tSlave>
836 {
837 public:
838  using pair_type = std::pair<_tMaster, _tSlave>;
839  using iterator_type = _tMaster;
841  using traits_type = _tTraits;
842  using iterator_category = typename traits_type::iterator_category;
843  using value_type = typename traits_type::value_type;
844  using difference_type = typename traits_type::difference_type;
845  using pointer = typename traits_type::pointer;
846  using reference = typename traits_type::reference;
847 
848  yconstfn
850  : std::pair<_tMaster, _tSlave>(_tMaster(), _tSlave())
851  {}
852  explicit yconstfn
853  pair_iterator(const _tMaster& _i)
854  : std::pair<_tMaster, _tSlave>(_i, _tSlave())
855  {}
856  yconstfn
857  pair_iterator(const _tMaster& _i, const _tSlave& _s)
858  : std::pair<_tMaster, _tSlave>(_i, _s)
859  {}
860  yconstfn
861  pair_iterator(const pair_iterator&) = default;
862  yconstfn
864  : std::pair<_tMaster, _tSlave>(std::move(_r))
865  {}
866 
867  inline pair_iterator&
868  operator=(const pair_iterator&) = default;
869  inline pair_iterator&
870 #if YB_IMPL_MSCPP
873  {
874  static_cast<std::pair<_tMaster, _tSlave>&>(*this)
875  = static_cast<std::pair<_tMaster, _tSlave>&&>(i);
876  return *this;
877  }
878 #else
879  operator=(pair_iterator&&) = default;
880 #endif
881 
885  {
886  yunseq(this->first += n, this->second += n);
887  return *this;
888  }
889 
893  {
894  yunseq(this->first -= n, this->second -= n);
895  return *this;
896  }
897 
899 
901  operator*() const
902  {
903  return *this->first;
904  }
905 
907  operator->() const
908  {
909  return this->first;
910  }
911 
914  {
915  yunseq(++this->first, ++this->second);
916  return *this;
917  }
920  {
921  auto i(*this);
922 
923  ++*this;
924  return i;
925  }
927 
929 
932  {
933  yunseq(--this->first, --this->second);
934  return *this;
935  }
938  {
939  auto i(*this);
940 
941  --*this;
942  return i;
943  }
945 
953  {
954  return this->first[n];
955  }
956 
959  {
960  auto i(*this);
961 
962  yunseq(i.first += n, i.second += n);
963  return i;
964  }
965 
968  {
969  auto i(*this);
970 
971  yunseq(i.first -= n, i.second -= n);
972  return i;
973  }
975 
977  template<typename _tFirst, typename _tSecond,
979  && is_convertible<_tSlave, _tSecond>::value, int>>
980  operator std::pair<_tFirst, _tSecond>()
981  {
982  return std::pair<_tFirst, _tSecond>(this->first, this->second);
983  }
984 
985  yconstfn const pair_type&
986  base() const
987  {
988  return *this;
989  }
990 };
991 
997 template<typename _tMaster, typename _tSlave>
998 bool
1001 {
1002  return x.base().first == y.base().first
1003  && x.base().second == y.base().second();
1004 }
1005 
1006 template<typename _tMaster, typename _tSlave>
1007 inline bool
1010 {
1011  return !(x == y);
1012 }
1014 
1015 
1022 template<typename _tIterator>
1024 {
1025 public:
1026  using iterator_type = _tIterator;
1027  using iterator_category = std::input_iterator_tag;
1028  using value_type = typename std::iterator_traits<iterator_type>::value_type;
1029  using difference_type
1030  = typename std::iterator_traits<iterator_type>::difference_type;
1031  using pointer = typename std::iterator_traits<iterator_type>::pointer;
1032  using reference = typename std::iterator_traits<iterator_type>::reference;
1033 
1034 private:
1036 
1037 public:
1039  : iter()
1040  {}
1042  : iter(i)
1043  {
1044  ++*this;
1045  }
1049  : iter()
1050  {
1051  using std::swap;
1052 
1053  swap(iter, i.iter);
1054  }
1055 
1057  operator=(const indirect_input_iterator&) = default;
1059 #if YB_IMPL_MSCPP
1062  {
1063  iter = std::move(i.iter);
1064  return *this;
1065  }
1066 #else
1067  operator=(indirect_input_iterator&&) = default;
1068 #endif
1069 
1070  pointer
1071  operator->() const
1072  {
1073  return (*iter).operator->();
1074  }
1075 
1077  template<typename = enable_if_t<is_constructible<bool,
1078  decltype(*std::declval<iterator_type&>())>::value, int>>
1079  explicit
1080  operator bool() const
1081 // operator bool() const ynoexcept((!is_undereferenceable(std::declval<
1082 // iterator_type&>()) && bool(*std::declval<iterator_type&>())))
1083  {
1084  return !is_undereferenceable(iter) && bool(*iter);
1085  }
1086 
1092  reference
1093  operator*() const
1094  {
1096  return **iter;
1097  }
1098 
1105  {
1107  ++*iter;
1108  return *this;
1109  }
1112  {
1113  const auto i(*this);
1114 
1115  ++*this;
1116  return i;
1117  }
1118 
1119  friend bool
1121  {
1122  return (!bool(x) && !bool(y)) || x.iter == y.iter;
1123  }
1124 
1125  iterator_type&
1126  get() ynothrow
1127  {
1128  return iter;
1129  }
1130  const iterator_type&
1131  get() const ynothrow
1132  {
1133  return iter;
1134  }
1135 };
1136 
1141 template<typename _tIterator>
1142 inline bool
1145 {
1146  return !(x == y);
1147 }
1148 
1149 
1161 #if YB_IMPL_MSCPP || YB_IMPL_CLANGPP
1163 template<unsigned char _vN, bool _bEndian = false>
1164 #else
1165 template<unsigned char _vN, bool _bEndian = {}>
1166 #endif
1167 class bitseg_iterator : public std::iterator<std::random_access_iterator_tag,
1168  byte, ptrdiff_t, byte*, byte&>
1169 {
1170  static_assert(_vN != 0, "A bit segment should contain at least one bit.");
1171  static_assert(_vN != CHAR_BIT, "A bit segment should not be a byte.");
1172  static_assert(CHAR_BIT % _vN == 0,
1173  "A byte should be divided by number of segments without padding.");
1174 
1175 public:
1176  using difference_type = ptrdiff_t;
1177  using pointer = byte*;
1178  using reference = byte&;
1179 
1180  static yconstexpr unsigned char seg_n = CHAR_BIT / _vN;
1181  static yconstexpr unsigned char seg_size = 1 << _vN;
1182  static yconstexpr unsigned char seg_width = _vN;
1183 
1184 protected:
1186  unsigned char shift;
1187  mutable byte value;
1188 
1189 public:
1191 
1192 
1197  bitseg_iterator(byte* p = {}, unsigned char n = 0) ynothrow
1198  : base(p), shift(n)
1199  {
1200  yassume(shift < seg_n);
1201  }
1202 
1205  {
1206  yconstraint(base);
1207  yassume(shift < seg_n);
1208 
1209  const size_t new_shift(shift + n);
1210 
1211  yunseq(base += new_shift / seg_n, shift = new_shift % seg_n);
1212  return *this;
1213  }
1214 
1217  {
1218  base += -n;
1219  return *this;
1220  }
1221 
1222  reference
1224  {
1225  yconstraint(base);
1226  return value = *base >> seg_width * (_bEndian ? seg_n - 1 - shift
1227  : seg_width) & seg_width;
1228  }
1229 
1232  {
1233  return &**this;
1234  }
1235 
1236  inline bitseg_iterator&
1238  {
1239  yconstraint(base);
1240  yassume(shift < seg_n);
1241  if(++shift == seg_n)
1242  yunseq(shift = 0, ++base);
1243  return *this;
1244  }
1248  {
1249  auto i(*this);
1250 
1251  ++*this;
1252  return i;
1253  }
1254 
1255  inline bitseg_iterator&
1257  {
1258  yconstraint(base);
1259  yassume(shift < seg_n);
1260  if(shift == 0)
1261  yunseq(--base, shift = seg_n - 1);
1262  else
1263  --shift;
1264  return *this;
1265  }
1269  {
1270  auto i(*this);
1271 
1272  --*this;
1273  return i;
1274  }
1275 
1276  reference
1278  {
1279  const auto i(*this);
1280 
1281  i += n;
1282  return *i.operator->();
1283  }
1284 
1287  {
1288  return bitseg_iterator(base + n);
1289  }
1290 
1293  {
1294  return bitseg_iterator(base - n);
1295  }
1296 
1297  yconstfn explicit
1298  operator pointer() const ynothrow
1299  {
1300  return base;
1301  }
1302 
1303  yconstfn size_t
1305  {
1306  return shift;
1307  }
1309 };
1310 
1316 template<size_t _vN, bool _bEndian>
1317 inline bool
1320 {
1322 
1323  return pointer(x) == pointer(y) && x.get_shift() == y.get_shift();
1324 }
1325 
1326 template<size_t _vN, bool _bEndian>
1327 inline bool
1330 {
1331  return !(x == y);
1332 }
1333 
1334 template<size_t _vN, bool _bEndian>
1335 inline bool
1336 operator<(const bitseg_iterator<_vN, _bEndian>& x,
1337  const bitseg_iterator<_vN, _bEndian>& y)
1338 {
1339  using pointer = typename bitseg_iterator<_vN, _bEndian>::pointer;
1340 
1341  return pointer(x) < pointer(y)
1342  || (pointer(x) == pointer(y) && x.get_shift() < y.get_shift());
1343 }
1344 
1345 template<size_t _vN, bool _bEndian>
1346 bool
1347 operator<=(const bitseg_iterator<_vN, _bEndian>& x,
1348  const bitseg_iterator<_vN, _bEndian>& y)
1349 {
1350  return !(y < x);
1351 }
1352 
1353 template<size_t _vN, bool _bEndian>
1354 bool
1355 operator>(const bitseg_iterator<_vN, _bEndian>& x,
1356  const bitseg_iterator<_vN, _bEndian>& y)
1357 {
1358  return y < x;
1359 }
1360 
1361 template<size_t _vN, bool _bEndian>
1362 bool
1363 operator>=(const bitseg_iterator<_vN, _bEndian>& x,
1364  const bitseg_iterator<_vN, _bEndian>& y)
1365 {
1366  return !(x < y);
1367 }
1369 
1370 
1379 template<class _tCon, typename _type>
1381 {
1382 public:
1383  using container_type = _tCon;
1384  using iterator_category = std::random_access_iterator_tag;
1385  using value_type = _type;
1386  using difference_type = ptrdiff_t;
1387  using pointer = _type*;
1388  using reference = _type&;
1389 
1390 protected:
1392  _tCon* con_ptr;
1393  size_t idx;
1394 
1395 public:
1396  yconstfn
1397  subscriptive_iterator(_tCon& c, size_t i)
1398  : con_ptr(std::addressof(c)), idx(i)
1399  {}
1400 
1403  {
1404  idx += n;
1405  return *this;
1406  }
1407 
1410  {
1411  yassume(!(idx < n));
1412  idx -= n;
1413  return *this;
1414  }
1415 
1417 
1418  reference
1419  operator*() const
1420  {
1421  return (*con_ptr)[idx];
1422  }
1423 
1424  pointer
1425  operator->() const
1426  {
1427  return std::addressof(**this);
1428  }
1429 
1432  {
1433  ++idx;
1434  return *this;
1435  }
1438  {
1439  auto i(*this);
1440 
1441  ++*this;
1442  return i;
1443  }
1444 
1447  {
1448  --idx;
1449  return *this;
1450  }
1453  {
1454  auto i(*this);
1455 
1456  --*this;
1457  return i;
1458  }
1460 
1461  reference
1463  {
1464  yassume(!(idx + n < 0));
1465  return (*con_ptr)[idx + n];
1466  }
1467 
1470  {
1471  yassume(!(idx + n < 0));
1472  return subscriptive_iterator(*con_ptr, idx + n);
1473  }
1474 
1477  {
1478  yassume(!(idx + n < 0));
1479  return subscriptive_iterator(*con_ptr, idx - n);
1480  }
1481 
1483  _tCon*
1485  {
1486  return con_ptr;
1487  }
1488 
1490  bool
1492  {
1493  return con_ptr == i.con_ptr && idx == i.idx;
1494  }
1495 
1497  size_t
1498  index() const ynothrow
1499  {
1500  return idx;
1501  }
1502 };
1503 
1509 template<class _tCon, typename _type>
1511 bool
1514 {
1515  return x.equals(y);
1516 }
1517 
1519 template<class _tCon, typename _type>
1520 bool
1523 {
1524  return !(x == y);
1525 }
1527 
1528 } // namespace ystdex;
1529 
1530 #endif
1531 
const transformer_type & get_transformer() const
Definition: iterator.hpp:616
typename traits_type::value_type value_type
Definition: iterator.hpp:843
bool operator>=(const path< _tSeqCon, _tNorm > &x, const path< _tSeqCon, _tNorm > &y)
Definition: path.hpp:400
pair_iterator & operator=(const pair_iterator &)=default
typename traits_type::iterator_category iterator_category
Definition: iterator.hpp:357
bitseg_iterator & operator+=(difference_type n)
Definition: iterator.hpp:1204
pseudo_iterator operator--(int) const
Definition: iterator.hpp:447
typename traits_type::pointer pointer
Definition: iterator.hpp:845
pointer_iterator(_tPointer &&ptr)
Definition: iterator.hpp:202
pointer operator->() const
Definition: iterator.hpp:1231
reference operator[](difference_type n) const
Definition: iterator.hpp:1277
间接输入迭代器。
Definition: iterator.hpp:1023
bitseg_iterator operator+(difference_type n) const
Definition: iterator.hpp:1286
pair_iterator & operator++()
Definition: iterator.hpp:913
pointer_iterator & operator+=(difference_type n)
Definition: iterator.hpp:210
#define ynothrowv
YSLib 无异常抛出保证验证:有条件地使用无异常抛出规范。
Definition: ydef.h:494
指针迭代器。
Definition: iterator.hpp:178
bool operator==(const bitseg_iterator< _vN, _bEndian > &x, const bitseg_iterator< _vN, _bEndian > &y)
Definition: iterator.hpp:1318
static auto first(const _tIterator &i) -> decltype((i->first))
Definition: iterator.hpp:759
typename traits_type::reference reference
Definition: iterator.hpp:361
reference operator*() const
Definition: iterator.hpp:1419
转换迭代器。
Definition: iterator.hpp:514
typename std::iterator_traits< iterator_type >::pointer pointer
Definition: iterator.hpp:1031
bool operator!=(nullptr_t lhs, const _type &rhs)
Definition: ydef.h:638
decltype(std::declval< transformed_type >()) reference
Definition: iterator.hpp:530
pointer_iterator operator-(difference_type n) const
Definition: iterator.hpp:285
pseudo_iterator(value_type v)
Definition: iterator.hpp:370
bitseg_iterator(byte *p={}, unsigned char n=0)
构造:使用基指针和偏移位。
Definition: iterator.hpp:1197
auto make_move_iterator_pair(_tIterator1 it1, _tIterator2 it2) -> decltype(std::make_pair(std::make_move_iterator(it1), std::make_move_iterator(it2)))
取转移迭代器对。
Definition: iterator.hpp:146
typename result_of< _type >::type result_of_t
Definition: type_op.hpp:286
bitseg_iterator operator--(int)
Definition: iterator.hpp:1268
pointer_iterator & operator--()
Definition: iterator.hpp:255
indirect_input_iterator & operator++()
迭代:向后遍历。
Definition: iterator.hpp:1104
typename std::iterator_traits< iterator_type >::value_type value_type
Definition: iterator.hpp:1028
pointer operator->() const
Definition: iterator.hpp:907
typename traits_type::pointer pointer
Definition: iterator.hpp:360
_tBi prev_if_eq(_tBi i, const _type &val, typename std::iterator_traits< _tBi >::difference_type n=1)
Definition: iterator.hpp:129
成员下标迭代器。
Definition: iterator.hpp:1380
pointer operator->() const
Definition: iterator.hpp:235
unsigned char byte
字节类型。
Definition: ydef.h:555
pair_iterator operator++(int)
Definition: iterator.hpp:919
ISO C 断言/调试跟踪扩展。
typename std::iterator_traits< iterator_type >::value_type value_type
Definition: iterator.hpp:184
std::pair< _tMaster, _tSlave > pair_type
Definition: iterator.hpp:838
bool operator==(const pointer_iterator< _type > &x, const pointer_iterator< _type > &y)
Definition: iterator.hpp:304
subscriptive_iterator operator+(difference_type n) const
Definition: iterator.hpp:1469
indirect_input_iterator & operator=(const indirect_input_iterator &)=default
decay_t< _fTransformer > transformer_type
Definition: iterator.hpp:523
bool operator!=(const indirect_input_iterator< _tIterator > &x, const indirect_input_iterator< _tIterator > &y)
Definition: iterator.hpp:1143
pointer operator->() const
Definition: iterator.hpp:422
indirect_input_iterator operator++(int)
Definition: iterator.hpp:1111
typename decay< _type >::type decay_t
Definition: type_op.hpp:271
const first_tag get_first
操纵子。
Definition: iterator.hpp:784
size_t get_shift() const
Definition: iterator.hpp:1304
pseudo_iterator & operator--() const
满足双向迭代器要求。
Definition: iterator.hpp:442
typename std::iterator_traits< iterator_type >::iterator_category iterator_category
Definition: iterator.hpp:183
bitseg_iterator & operator-=(difference_type n)
Definition: iterator.hpp:1216
pointer_iterator operator--(int)
Definition: iterator.hpp:262
subscriptive_iterator & operator++()
Definition: iterator.hpp:1431
#define yforward(_expr)
根据参数类型使用 std::forward 传递对应参数。
Definition: ydef.h:722
reference operator[](difference_type n) const
满足随机访问迭代器要求。
Definition: iterator.hpp:459
pair_iterator & operator--()
满足双向迭代器要求。
Definition: iterator.hpp:931
bool operator==(const transformed_iterator< _type, _fTransformer > &x, const transformed_iterator< _type, _fTransformer > &y)
满足输入迭代器要求。
Definition: iterator.hpp:631
const struct ystdex::indirect_tag get_indirect
#define yimpl(...)
实现标签。
Definition: ydef.h:177
bitseg_iterator operator++(int)
Definition: iterator.hpp:1247
subscriptive_iterator & operator-=(difference_type n)
Definition: iterator.hpp:1409
subscriptive_iterator operator--(int)
Definition: iterator.hpp:1452
bool operator>(const path< _tSeqCon, _tNorm > &x, const path< _tSeqCon, _tNorm > &y)
Definition: path.hpp:393
pair_iterator(const _tMaster &_i, const _tSlave &_s)
Definition: iterator.hpp:857
transformer_type transformer
Definition: iterator.hpp:534
typename traits_type::difference_type difference_type
Definition: iterator.hpp:359
bool operator==(const pair_iterator< _tMaster, _tSlave > &x, const pair_iterator< _tMaster, _tSlave > &y)
Definition: iterator.hpp:999
pointer_iterator & operator++()
Definition: iterator.hpp:241
typename pointer_classify< _tIterator >::type::difference_type difference_type
Definition: iterator.hpp:528
void swap(any &x, any &y)
交换对象。
Definition: any.h:729
pseudo_iterator & operator=(const pseudo_iterator &)=default
indirect_input_iterator(indirect_input_iterator &&i)
Definition: iterator.hpp:1048
const second_tag get_value
Definition: iterator.hpp:785
bitseg_iterator operator-(difference_type n) const
Definition: iterator.hpp:1292
pseudo_iterator & operator+=(difference_type)
Definition: iterator.hpp:401
pseudo_iterator operator-(difference_type) const
Definition: iterator.hpp:471
subscriptive_iterator operator-(difference_type n) const
Definition: iterator.hpp:1476
pointer_iterator operator+(difference_type n) const
Definition: iterator.hpp:278
#define yunseq
无序列依赖表达式组求值。
Definition: ydef.h:748
pair_iterator & operator+=(difference_type n)
Definition: iterator.hpp:884
pair_iterator operator-(difference_type n) const
Definition: iterator.hpp:967
pseudo_iterator operator+(difference_type) const
Definition: iterator.hpp:465
#define yassume
假定:环境语义。
Definition: cassert.h:58
typename std::iterator_traits< iterator_type >::pointer pointer
Definition: iterator.hpp:187
iterator_type & get()
取原迭代器引用。
Definition: iterator.hpp:593
pair_iterator & operator-=(difference_type n)
Definition: iterator.hpp:892
static const unsigned char seg_size
Definition: iterator.hpp:1181
pair_iterator operator+(difference_type n) const
Definition: iterator.hpp:958
static auto indirect(const _tIterator &i) -> decltype((**i))
Definition: iterator.hpp:771
static const unsigned char seg_n
Definition: iterator.hpp:1180
#define ynothrow
YSLib 无异常抛出保证:若支持 noexcept 关键字, 指定特定的 noexcept 异常规范。
Definition: ydef.h:514
typename traits_type::difference_type difference_type
Definition: iterator.hpp:844
空指针类。
Definition: ydef.h:583
pseudo_iterator & operator-=(difference_type)
Definition: iterator.hpp:408
_tIterator iterator_type
Definition: iterator.hpp:354
yconstfn GBinaryGroup< _type > operator+(const GBinaryGroup< _type > &a, const GBinaryGroup< _type > &b) ynothrow
加法:屏幕二元组。
Definition: ygdibase.h:203
reference operator*() const
Definition: iterator.hpp:228
std::random_access_iterator_tag iterator_category
Definition: iterator.hpp:1384
reference operator*() const
间接操作。
Definition: iterator.hpp:1093
#define yconstraint
约束:接口语义。
Definition: cassert.h:47
typename array_decay< _type >::type type
Definition: type_op.hpp:739
typename traits_type::reference reference
Definition: iterator.hpp:846
bool operator==(const pseudo_iterator< _type, _tIterator, _tTraits > &x, const pseudo_iterator< _type, _tIterator, _tTraits > &y)
满足输入迭代器要求。
Definition: iterator.hpp:486
pointer_iterator(nullptr_t={})
Definition: iterator.hpp:196
reference operator[](difference_type n) const
Definition: iterator.hpp:1462
typename std::iterator_traits< iterator_type >::reference reference
Definition: iterator.hpp:188
subscriptive_iterator & operator+=(difference_type n)
Definition: iterator.hpp:1402
typename traits_type::value_type value_type
Definition: iterator.hpp:358
#define yconstfn
指定编译时常量函数。
Definition: ydef.h:463
_tWidget _fCallable && f
Definition: ywgtevt.h:597
subscriptive_iterator operator--()
Definition: iterator.hpp:1446
enable_if_t<!is_same< _tClass &, remove_rcv_t< _tParam > & >::value, _type > exclude_self_ctor_t
移除选择类类型的特定重载避免构造模板和复制/转移构造函数冲突。
Definition: type_op.hpp:766
typename std::iterator_traits< iterator_type >::difference_type difference_type
Definition: iterator.hpp:1030
reference operator*() const
Definition: iterator.hpp:1223
pair_iterator(const _tMaster &_i)
Definition: iterator.hpp:853
static const unsigned char seg_width
Definition: iterator.hpp:1182
reference operator[](difference_type n) const
满足随机访问迭代器要求。
Definition: iterator.hpp:952
pointer operator->() const
Definition: iterator.hpp:1425
enable_if_t< is_convertible< decltype(std::declval< iterator_type & >)[_tDiff()]), reference >::value, reference > operator[](_tDiff n)
Definition: iterator.hpp:563
bool operator!=(const subscriptive_iterator< _tCon, _type > &x, const subscriptive_iterator< _tCon, _type > &y)
比较成员下标迭代器的不等性。
Definition: iterator.hpp:1521
transformed_iterator(_tIter &&i, _tTran f={})
Definition: iterator.hpp:543
const pair_type & base() const
Definition: iterator.hpp:986
subscriptive_iterator operator++(int)
Definition: iterator.hpp:1437
pointer_iterator & operator-=(difference_type n)
Definition: iterator.hpp:219
reference operator[](difference_type n) const
Definition: iterator.hpp:269
typename std::iterator_traits< iterator_type >::reference reference
Definition: iterator.hpp:1032
#define yconstexpr
指定编译时常量表达式。
Definition: ydef.h:462
bool is_undereferenceable(const any_input_iterator< _type, _tDifference, _tPointer, _tReference > &i)
enable_if_t< is_same< decltype(++std::declval< _tParam & >()), _tParam & >::value, int > enable_for_iterator_t
选择迭代器类型的特定重载避免和其它类型冲突。
Definition: iterator.hpp:60
伪迭代器。
Definition: iterator.hpp:351
pseudo_iterator & operator++()
Definition: iterator.hpp:428
reference operator*() const
满足前向迭代器要求。
Definition: iterator.hpp:901
typename traits_type::iterator_category iterator_category
Definition: iterator.hpp:842
C++ 类型操作。
pseudo_iterator operator++(int)
Definition: iterator.hpp:433
bitseg_iterator & operator--()
Definition: iterator.hpp:1256
typename pointer_classify< remove_reference_t< _tIterator >>::type iterator_type
原迭代器类型。
Definition: iterator.hpp:522
result_of_t< _fTransformer &(_tIterator &)> transformed_type
Definition: iterator.hpp:525
friend bool operator==(const indirect_input_iterator &x, const indirect_input_iterator &y)
Definition: iterator.hpp:1120
indirect_input_iterator(iterator_type i)
Definition: iterator.hpp:1041
pair_iterator(pair_iterator &&_r)
Definition: iterator.hpp:863
pair_iterator operator--(int)
Definition: iterator.hpp:937
auto operator|(_tIterator &&i, first_tag) -> decltype(make_transform(std::forward< decltype(i)>(i), iterator_transformation::first< typename array_ref_decay< _tIterator >::type >))
管道匹配操作符。
Definition: iterator.hpp:797
std::input_iterator_tag iterator_category
Definition: iterator.hpp:1027
transformed_iterator< _type, _fTransformer > & operator+=(transformed_iterator< _type, _fTransformer > &i, typename transformed_iterator< _type, _fTransformer >::difference_type n)
满足随机迭代器要求。
Definition: iterator.hpp:654
指针包装为类类型迭代器。
Definition: iterator.hpp:329
transformed_iterator< typename array_ref_decay< _tIterator >::type, _fTransformer > make_transform(_tIterator &&i, _fTransformer f)
创建转换迭代器。
Definition: iterator.hpp:742
_tIn next_if(_tIn i, _fPred f, typename std::iterator_traits< _tIn >::difference_type n=1)
迭代器指向的值满足条件时取邻接迭代器,否则取原值。
Definition: iterator.hpp:99
bitseg_iterator & operator++()
Definition: iterator.hpp:1237
bool equals(const subscriptive_iterator< _tCon, _type > &i) const
Definition: iterator.hpp:1491
const first_tag get_key
Definition: iterator.hpp:784
static auto second(const _tIterator &i) -> decltype((i->second))
Definition: iterator.hpp:765
bool operator==(const subscriptive_iterator< _tCon, _type > &x, const subscriptive_iterator< _tCon, _type > &y)
比较成员下标迭代器的相等性。
Definition: iterator.hpp:1512
reference operator*() const
Definition: iterator.hpp:554
_tIn next_if_eq(_tIn i, const _type &val, typename std::iterator_traits< _tIn >::difference_type n=1)
Definition: iterator.hpp:107
transformer_type & get_transformer()
Definition: iterator.hpp:611
yconstfn GBinaryGroup< _type > operator-(const GBinaryGroup< _type > &a, const GBinaryGroup< _type > &b) ynothrow
减法:屏幕二元组。
Definition: ygdibase.h:214
自然数标记。
Definition: type_op.hpp:782
reference operator*() const
满足前向迭代器要求。
Definition: iterator.hpp:416
byte v
typename enable_if< _bCond, _type >::type enable_if_t
Definition: type_op.hpp:274
pointer_iterator operator++(int)
Definition: iterator.hpp:249
位段迭代器。
Definition: iterator.hpp:1167
_tCon * container() const
Definition: iterator.hpp:1484
成对迭代器。
Definition: iterator.hpp:835
subscriptive_iterator(_tCon &c, size_t i)
Definition: iterator.hpp:1397
_tBi prev_if(_tBi i, _fPred f, typename std::iterator_traits< _tBi >::difference_type n=1)
迭代器指向的值满足条件时取反向邻接迭代器,否则取原值。
Definition: iterator.hpp:122
const second_tag get_second
Definition: iterator.hpp:785
typename std::iterator_traits< iterator_type >::difference_type difference_type
Definition: iterator.hpp:186