LIEF: Library to Instrument Executable Formats Version 2.0.0
Loading...
Searching...
No Matches
iterators.hpp
Go to the documentation of this file.
1/* Copyright 2017 - 2026 R. Thomas
2 * Copyright 2017 - 2021, NVIDIA CORPORATION. All rights reserved.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16#ifndef LIEF_ITERATORS_H
17#define LIEF_ITERATORS_H
18#include <type_traits>
19#include <algorithm>
20#include <cassert>
21#include <cstddef>
22#include <functional>
23#include <iterator>
24#include <memory>
25#include <vector>
26
28
29namespace LIEF {
30
31template<class T>
32using decay_t = std::decay_t<T>;
33
34template<class T>
35using add_const_t = std::add_const_t<T>;
36
37template<class T>
38using remove_const_t = std::remove_const_t<T>;
39
40template<class T>
41using add_lvalue_reference_t = std::add_lvalue_reference_t<T>;
42
43namespace details {
50template<class T, bool = std::is_reference_v<T>>
52 public:
53 using container_t = std::remove_reference_t<T>;
54 using arg_t = T;
55
56 container_storage() = default;
57 explicit container_storage(arg_t container) :
58 container_{std::addressof(container)} {}
59
61 container_t* get() const {
62 return container_;
63 }
64
65 private:
66 container_t* container_ = nullptr;
67};
68
69template<class T>
70class container_storage<T, false> {
71 public:
72 using container_t = std::remove_const_t<T>;
74
75 container_storage() = default;
76 explicit container_storage(arg_t container) :
77 container_(std::move(container)) {}
78
79 container_t* get() const {
80 return &container_;
81 }
82
83 private:
84 mutable container_t container_;
85};
86
87template<class T>
89
90template<class Ref, class U, class IT>
91Ref deref(const IT& it) {
92 if constexpr (std::is_pointer_v<U>) {
93 assert(*it && "integrity error: nullptr");
94 return static_cast<Ref>(**it);
95 } else {
96 return const_cast<Ref>(*it);
97 }
98}
99
100template<class T, class U, class Category>
102 std::conditional_t<std::is_reference_v<T> || std::is_pointer_v<U>, Category,
103 std::input_iterator_tag>;
104}
105
118template<class T, typename U = typename decay_t<T>::value_type,
119 class ITERATOR_T = typename decay_t<T>::iterator>
121 template<class, typename, class>
122 friend class ref_iterator;
123
124 public:
125 using iterator_category = std::bidirectional_iterator_tag;
128 using value_type = std::remove_cv_t<std::remove_pointer_t<decay_t<U>>>;
129 using difference_type = ptrdiff_t;
130 using pointer = std::remove_pointer_t<U>*;
131 using reference = std::remove_pointer_t<U>&;
132
133 using container_type = T; // e.g. std::vector<Section*>&
134 using DT_VAL = U; // e.g. Section*
135 using DT = decay_t<T>; // e.g. std::vector<Section>
138
139 ref_iterator() = default;
140
142 container_{other.container_},
143 it_{other.it_},
144 distance_{other.distance_} {
145 rebase();
146 }
147
148 ref_iterator(ref_iterator&& other) noexcept :
149 container_{std::move(other.container_)},
150 it_{other.it_},
151 distance_{other.distance_} {
152 rebase();
153 other.container_ = {};
154 other.it_ = {};
155 other.distance_ = 0;
156 }
157
159 ref_iterator copy{other};
160 swap(copy);
161 return *this;
162 }
163
165 swap(other);
166 return *this;
167 }
168
169 template<class T2, typename U2, class IT2,
170 typename = std::enable_if_t<
171 !std::is_same_v<ref_iterator, ref_iterator<T2, U2, IT2>> &&
172 std::is_same_v<decay_t<T>, decay_t<T2>>
173 >>
175 distance_{other.distance_} {
176 if (auto* container = other.container_.get(); container != nullptr) {
177 if constexpr (std::is_reference_v<T>) {
178 container_ = details::container_storage<T>{const_cast<T>(*container)};
179 } else {
180 container_ = details::container_storage<T>{*container};
181 }
182 it_ = std::next(std::begin(*container_.get()), distance_);
183 }
184 }
185
186 ~ref_iterator() = default;
187
188 // NOLINTNEXTLINE(performance-unnecessary-value-param)
190 container_{std::forward<details::container_arg_t<T>>(container)},
191 it_(std::begin(*container_.get())) {}
192
193 void swap(ref_iterator& other) noexcept {
194 std::swap(container_, other.container_);
195 std::swap(it_, other.it_);
196 std::swap(distance_, other.distance_);
197 rebase();
198 other.rebase();
199 }
200
201
203 it_ = std::next(it_);
204 distance_++;
205 return *this;
206 }
207
209 ref_iterator retval = *this;
210 ++(*this);
211 return retval;
212 }
213
215 if (it_ != std::begin(*container_.get())) {
216 it_ = std::prev(it_);
217 distance_--;
218 }
219 return *this;
220 }
221
223 ref_iterator retval = *this;
224 --(*this);
225 return retval;
226 }
227
228
230 const typename ref_iterator::difference_type& movement
232 std::advance(it_, movement);
233 distance_ += movement;
234 return *this;
235 }
236
237
239 const typename ref_iterator::difference_type& movement
241 return (*this) += -movement;
242 }
243
244
245 std::enable_if_t<!std::is_const_v<ref_t>, remove_const_t<ref_t>>
246 operator[](size_t n) {
247 return const_cast<remove_const_t<ref_t>>(
248 static_cast<const ref_iterator*>(this)->operator[](n)
249 );
250 }
251
252
254 assert(n < size() && "integrity error: out of bound");
255 return details::deref<ref_t, DT_VAL>(std::next(std::begin(*container_.get()),
256 difference_type(n)));
257 }
258
260 ref_iterator tmp = *this;
261 return tmp += n;
262 }
263
264
266 ref_iterator tmp = *this;
267 return tmp -= n;
268 }
269
270
272 return distance_ - rhs.distance_;
273 }
274
275 bool operator<(const ref_iterator& rhs) const {
276 return (rhs - *this) > 0;
277 }
278
279
280 bool operator>(const ref_iterator& rhs) const {
281 return rhs < *this;
282 }
283
284
285 bool operator>=(const ref_iterator& rhs) const {
286 return !(*this < rhs);
287 }
288
289
290 bool operator<=(const ref_iterator& rhs) const {
291 return !(*this > rhs);
292 }
293
295 if (container_.get() == nullptr) {
296 return {};
297 }
298 return ref_iterator{*container_.get()};
299 }
300
302 return begin();
303 }
304
306 ref_iterator it = begin();
307 if (auto* container = it.container_.get(); container != nullptr) {
308 it.it_ = std::end(*container);
309 it.distance_ = difference_type(container->size());
310 }
311 return it;
312 }
313
315 return end();
316 }
317
318 bool is_end() const {
319 return distance_ == difference_type(size());
320 }
321
322 bool operator==(const ref_iterator& other) const {
323 // If the current iterator borrows the container we assert the equality
324 // on the **address** of the container.
325 if constexpr (std::is_reference_v<T>) {
326 return container_.get() == other.container_.get() &&
327 distance_ == other.distance_;
328 } else {
329 return size() == other.size() && distance_ == other.distance_;
330 }
331 }
332
333 bool operator!=(const ref_iterator& other) const {
334 return !(*this == other);
335 }
336
337 size_t size() const {
338 const auto* container = container_.get();
339 return container != nullptr ? container->size() : 0;
340 }
341
342 bool empty() const {
343 const auto* container = container_.get();
344 return container == nullptr || container->empty();
345 }
346
347 std::enable_if_t<!std::is_const_v<ref_t>, remove_const_t<ref_t>> operator*() {
348 return const_cast<remove_const_t<ref_t>>(
349 static_cast<const ref_iterator*>(this)->operator*()
350 );
351 }
352
356
357 std::enable_if_t<!std::is_const_v<pointer_t>, pointer_t> operator->() {
358 return const_cast<remove_const_t<pointer_t>>(
359 static_cast<const ref_iterator*>(this)->operator->()
360 );
361 }
362
364 return const_cast<add_const_t<pointer_t>>(&(operator*()));
365 }
366
367 protected:
368 // If the container is owned by this iterator, make `it_` point in this
369 // container and not in the one it has been copied from
370 void rebase() {
371 if constexpr (!std::is_reference_v<T>) {
372 it_ = std::next(std::begin(*container_.get()), distance_);
373 }
374 }
375
376 details::container_storage<T> container_;
377 ITERATOR_T it_{};
378 typename ref_iterator::difference_type distance_{};
379};
380
381
383template<class T, typename U = typename decay_t<T>::value_type,
384 class CT = std::add_const_t<T>>
387
388
390template<class T, typename U = typename decay_t<T>::value_type,
391 class ITERATOR_T = typename decay_t<T>::iterator>
393
394 public:
395 using iterator_category = std::forward_iterator_tag;
398 using value_type = std::remove_cv_t<std::remove_pointer_t<decay_t<U>>>;
399 using difference_type = ptrdiff_t;
400 using pointer = std::remove_pointer_t<U>*;
401 using reference = std::remove_pointer_t<U>&;
402
403 using container_type = T;
404 using DT_VAL = U;
405 using DT = decay_t<T>;
408 using filter_t = std::function<bool(const typename DT::value_type&)>;
409
412 filter_iterator() = default;
413
415 size_c_{other.size_c_},
416 size_cached_{other.size_cached_},
417 container_{other.container_},
418 it_{other.it_},
419 filters_{other.filters_},
420 distance_{other.distance_} {
421 rebase();
422 }
423
425 size_c_{other.size_c_},
426 size_cached_{other.size_cached_},
427 container_{std::move(other.container_)},
428 it_{other.it_},
429 filters_{std::move(other.filters_)},
430 distance_{other.distance_} {
431 rebase();
432 other.size_c_ = 0;
433 other.size_cached_ = false;
434 other.container_ = {};
435 other.it_ = {};
436 other.distance_ = 0;
437 }
438
440 filter_iterator copy{other};
441 swap(copy);
442 return *this;
443 }
444
446 swap(other);
447 return *this;
448 }
449
450 ~filter_iterator() = default;
451
452 // NOLINTNEXTLINE(performance-unnecessary-value-param)
454 container_{std::forward<details::container_arg_t<T>>(container)},
455 it_(std::begin(*container_.get())),
456 filters_{} {
457 filters_.push_back(std::move(filter));
458
459 if (it_ != std::end(*container_.get()) && !match()) {
460 next();
461 }
462 }
463
464 // NOLINTNEXTLINE(performance-unnecessary-value-param)
466 const std::vector<filter_t>& filters) :
467 container_{std::forward<details::container_arg_t<T>>(container)},
468 it_(std::begin(*container_.get())),
469 filters_{filters} {
470 if (it_ != std::end(*container_.get()) && !match()) {
471 next();
472 }
473 }
474
475 // NOLINTNEXTLINE(performance-unnecessary-value-param)
477 container_{std::forward<details::container_arg_t<T>>(container)},
478 it_(std::begin(*container_.get())),
479 filters_{} {}
480
481 void swap(filter_iterator& other) noexcept {
482 std::swap(container_, other.container_);
483 std::swap(it_, other.it_);
484 std::swap(filters_, other.filters_);
485 std::swap(size_c_, other.size_c_);
486 std::swap(size_cached_, other.size_cached_);
487 std::swap(distance_, other.distance_);
488 rebase();
489 other.rebase();
490 }
491
492
494 filters_.push_back(func);
495 size_c_ = 0;
496 size_cached_ = false;
497 return *this;
498 }
499
501 next();
502 return *this;
503 }
504
506 filter_iterator retval = *this;
507 ++(*this);
508 return retval;
509 }
510
512 if (container_.get() == nullptr) {
513 return {};
514 }
515 return {*container_.get(), filters_};
516 }
517
519 return begin();
520 }
521
523 if (container_.get() == nullptr) {
524 return {};
525 }
526
527 // we don't need filter for the end iterator
528 filter_iterator it_end{*container_.get()};
529
530 it_end.it_ = std::end(*it_end.container_.get());
531 it_end.distance_ = difference_type(it_end.container_size());
532
533 return it_end;
534 }
535
537 return end();
538 }
539
540 bool is_end() const {
541 return distance_ == difference_type(container_size());
542 }
543
544 std::enable_if_t<!std::is_const_v<ref_t>, remove_const_t<ref_t>> operator*() {
545 return const_cast<remove_const_t<ref_t>>(
546 static_cast<const filter_iterator*>(this)->operator*()
547 );
548 }
549
553
554
555 std::enable_if_t<!std::is_const_v<ref_t>, remove_const_t<ref_t>>
556 operator[](size_t n) {
557 return const_cast<remove_const_t<ref_t>>(
558 static_cast<const filter_iterator*>(this)->operator[](n)
559 );
560 }
561
563 assert(n < size() && "integrity error: out of bound");
564
565 auto it = begin();
566 std::advance(it, n);
567
568 return details::deref<ref_t, DT_VAL>(std::next(std::begin(*container_.get()),
569 it.distance_));
570 }
571
572
573 std::enable_if_t<!std::is_const_v<pointer_t>, pointer_t> operator->() {
574 return const_cast<remove_const_t<pointer_t>>(
575 static_cast<const filter_iterator*>(this)->operator->()
576 );
577 }
578
580 return const_cast<add_const_t<pointer_t>>(&(operator*()));
581 }
582
583 size_t size() const {
584 if (filters_.empty()) {
585 return container_size();
586 }
587
588 if (size_cached_) {
589 return size_c_;
590 }
591 filter_iterator it = begin();
592 size_t size = 0;
593
594 auto end_iter = it.end();
595 for (; it != end_iter; ++it) {
596 ++size;
597 }
598 size_c_ = size;
599 size_cached_ = true;
600 return size_c_;
601 }
602
603
604 bool empty() const {
605 if (filters_.empty()) {
606 return container_size() == 0;
607 }
608
609 if (size_cached_) {
610 return size_c_ == 0;
611 }
612
613 return begin() == end();
614 }
615
616
617 bool operator==(const filter_iterator& other) const {
618 if constexpr (std::is_reference_v<T>) {
619 return container_.get() == other.container_.get() &&
620 distance_ == other.distance_;
621 } else {
622 return container_size() == other.container_size() &&
623 distance_ == other.distance_;
624 }
625 }
626
627 bool operator!=(const filter_iterator& other) const {
628 return !(*this == other);
629 }
630
631 protected:
632 size_t container_size() const {
633 const auto* container = container_.get();
634 return container != nullptr ? container->size() : 0;
635 }
636
637 bool match() const {
638 return std::all_of(std::begin(filters_), std::end(filters_),
639 [this](const filter_t& f) { return f(*it_); });
640 }
641
642 void next() {
643 if (it_ == std::end(*container_.get())) {
644 distance_ = difference_type(container_size());
645 return;
646 }
647
648 do {
649 it_ = std::next(it_);
650 distance_++;
651 } while (it_ != std::end(*container_.get()) && !match());
652 }
653
654 void rebase() {
655 if constexpr (!std::is_reference_v<T>) {
656 it_ = std::next(std::begin(*container_.get()), distance_);
657 }
658 }
659
660
661 mutable size_t size_c_ = 0;
662 mutable bool size_cached_ = false;
663 details::container_storage<T> container_;
664 ITERATOR_T it_{};
665 std::vector<filter_t> filters_;
666 typename filter_iterator::difference_type distance_ = 0;
667};
668
670template<class T, typename U = typename decay_t<T>::value_type,
671 class CT = std::add_const_t<T>>
674
675// ----------------------------------------------------------------------------
676// This part is taken from LLVM
677// ----------------------------------------------------------------------------
678
679template<typename IteratorT>
681 public:
682 using IteratorTy = IteratorT;
683 using IteratorDecayTy = std::decay_t<IteratorT>;
684
685 template<class T>
686 iterator_range(T&& it_begin, T&& it_end) :
687 begin_(std::forward<T>(it_begin)),
688 end_(std::forward<T>(it_end)) {}
689
690 IteratorT begin() const {
691 return begin_;
692 }
693
694 IteratorT end() const {
695 return end_;
696 }
697
698 bool empty() const {
699 return begin_ == end_;
700 }
701
702 class ReferenceProxy {
704
705 IteratorDecayTy it_;
706
707 explicit ReferenceProxy(IteratorDecayTy it) :
708 it_(std::move(it)) {}
709
710 public:
711 using reference = decltype(*std::declval<const IteratorDecayTy&>());
712
713 operator reference() const {
714 return *it_;
715 }
716
717 template<class It = IteratorDecayTy>
718 auto operator->() const -> decltype(&*std::declval<const It&>()) {
719 return &*it_;
720 }
721 };
722
723 ReferenceProxy at(typename IteratorDecayTy::difference_type pos) const {
724 static_assert(IsRandomAccess, "at() needs random access iterator");
725 auto it = begin_;
726 std::advance(it, pos);
727 return ReferenceProxy(std::move(it));
728 }
729
730 ReferenceProxy operator[](typename IteratorDecayTy::difference_type pos) const {
731 return at(pos);
732 }
733
734 std::ptrdiff_t size() const {
735 return std::distance(begin_, end_);
736 }
737
738 protected:
739 static constexpr bool IsRandomAccess =
740 std::is_base_of_v<std::random_access_iterator_tag,
741 typename IteratorDecayTy::iterator_category>;
742 static constexpr bool IsBidirectional =
743 std::is_base_of_v<std::bidirectional_iterator_tag,
744 typename IteratorDecayTy::iterator_category>;
745
746 private:
747 IteratorT begin_;
748 IteratorT end_;
749};
750
751template<class T>
753 return iterator_range<T>(std::forward<T>(x), std::forward<T>(y));
754}
755
756}
757
758#if LIEF_HAS_STD_RANGES
759template<typename IteratorT>
760inline constexpr bool
761 std::ranges::enable_borrowed_range<LIEF::iterator_range<IteratorT>> = true;
762
763// A {ref,filter}_iterator that borrows its container is cheap to
764// copy and can be used as a view.
765
766template<class T, typename U, class IT>
767inline constexpr bool std::ranges::enable_view<LIEF::ref_iterator<T, U, IT>> =
768 std::is_reference_v<T>;
769
770template<class T, typename U, class IT>
771inline constexpr bool std::ranges::enable_view<LIEF::filter_iterator<T, U, IT>> =
772 std::is_reference_v<T>;
773
774// The references returned by the iterators of a borrowed range must outlive
775// the range.
776
777template<class T, typename U, class IT>
778inline constexpr bool
779 std::ranges::enable_borrowed_range<LIEF::ref_iterator<T, U, IT>> =
780 std::is_reference_v<T> || std::is_pointer_v<U>;
781
782template<class T, typename U, class IT>
783inline constexpr bool
784 std::ranges::enable_borrowed_range<LIEF::filter_iterator<T, U, IT>> =
785 std::is_reference_v<T> || std::is_pointer_v<U>;
786#endif
787
788namespace LIEF {
789
790
848template<typename DerivedT, typename IteratorCategoryT, typename T,
849 typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T*,
850 typename ReferenceT = T&>
851class iterator_facade_base {
852 friend DerivedT;
853 iterator_facade_base() = default;
854
855 public:
856 using iterator_category = IteratorCategoryT;
857 using value_type = T;
858 using difference_type = DifferenceTypeT;
859 using pointer = PointerT;
860 using reference = ReferenceT;
861
862 protected:
863 static constexpr bool IsRandomAccess =
864 std::is_base_of_v<std::random_access_iterator_tag, IteratorCategoryT>;
865 static constexpr bool IsBidirectional =
866 std::is_base_of_v<std::bidirectional_iterator_tag, IteratorCategoryT>;
867
873 class ReferenceProxy {
874 friend iterator_facade_base;
875
876 DerivedT I;
877
878 ReferenceProxy(DerivedT I) :
879 I(std::move(I)) {}
880
881 public:
882 operator ReferenceT() const {
883 return *I;
884 }
885 };
886
891 class PointerProxy {
893
894 ReferenceT R;
895
896 template<typename RefT>
897 PointerProxy(RefT&& R) : // NOLINT(bugprone-forwarding-reference-overload)
898 R(std::forward<RefT>(R)) {}
899
900 public:
901 PointerT operator->() const {
902 return &R;
903 }
904 };
905
906 public:
907 DerivedT operator+(DifferenceTypeT n) const {
908 static_assert(std::is_base_of_v<iterator_facade_base, DerivedT>,
909 "Must pass the derived type to this template!");
910 static_assert(IsRandomAccess,
911 "The '+' operator is only defined for random access iterators.");
912 DerivedT tmp = *static_cast<const DerivedT*>(this);
913 tmp += n;
914 return tmp;
915 }
916
917 friend DerivedT operator+(DifferenceTypeT n, const DerivedT& i) {
918 static_assert(IsRandomAccess,
919 "The '+' operator is only defined for random access iterators.");
920 return i + n;
921 }
922
923 DerivedT operator-(DifferenceTypeT n) const {
924 static_assert(IsRandomAccess,
925 "The '-' operator is only defined for random access iterators.");
926 DerivedT tmp = *static_cast<const DerivedT*>(this);
927 tmp -= n;
928 return tmp;
929 }
930
932 static_assert(std::is_base_of_v<iterator_facade_base, DerivedT>,
933 "Must pass the derived type to this template!");
934 return static_cast<DerivedT*>(this)->operator+=(1);
935 }
936
938 DerivedT tmp = *static_cast<DerivedT*>(this);
939 ++*static_cast<DerivedT*>(this);
940 return tmp;
941 }
942
944 static_assert(
945 IsBidirectional,
946 "The decrement operator is only defined for bidirectional iterators."
947 );
948 return static_cast<DerivedT*>(this)->operator-=(1);
949 }
950
952 static_assert(
953 IsBidirectional,
954 "The decrement operator is only defined for bidirectional iterators."
955 );
956 DerivedT tmp = *static_cast<DerivedT*>(this);
957 --*static_cast<DerivedT*>(this);
958 return tmp;
959 }
960
961#ifndef __cpp_impl_three_way_comparison
962 bool operator!=(const DerivedT& RHS) const {
963 return !(static_cast<const DerivedT&>(*this) == RHS);
964 }
965#endif
966
967 bool operator>(const DerivedT& RHS) const {
968 static_assert(
969 IsRandomAccess,
970 "Relational operators are only defined for random access iterators."
971 );
972 return !(static_cast<const DerivedT&>(*this) < RHS) &&
973 !(static_cast<const DerivedT&>(*this) == RHS);
974 }
975
976 bool operator<=(const DerivedT& RHS) const {
977 static_assert(
978 IsRandomAccess,
979 "Relational operators are only defined for random access iterators."
980 );
981 return !(static_cast<const DerivedT&>(*this) > RHS);
982 }
983
984 bool operator>=(const DerivedT& RHS) const {
985 static_assert(
986 IsRandomAccess,
987 "Relational operators are only defined for random access iterators."
988 );
989 return !(static_cast<const DerivedT&>(*this) < RHS);
990 }
991
992 PointerProxy operator->() const {
993 return static_cast<const DerivedT*>(this)->operator*();
994 }
995
996 ReferenceProxy operator[](DifferenceTypeT n) const {
997 static_assert(IsRandomAccess,
998 "Subscripting is only defined for random access iterators.");
999 return static_cast<const DerivedT*>(this)->operator+(n);
1000 }
1001};
1002
1008template<typename DerivedT, typename WrappedIteratorT,
1009 typename IteratorCategoryT =
1010 typename std::iterator_traits<WrappedIteratorT>::iterator_category,
1011 typename T = typename std::iterator_traits<WrappedIteratorT>::value_type,
1012 typename DifferenceTypeT =
1013 typename std::iterator_traits<WrappedIteratorT>::difference_type,
1014 typename PointerT = std::conditional_t<
1015 std::is_same_v<T, typename std::iterator_traits<WrappedIteratorT>::
1016 value_type>,
1017 typename std::iterator_traits<WrappedIteratorT>::pointer, T*
1018 >,
1019 typename ReferenceT = std::conditional_t<
1020 std::is_same_v<T, typename std::iterator_traits<WrappedIteratorT>::
1021 value_type>,
1022 typename std::iterator_traits<WrappedIteratorT>::reference, T&
1023 >>
1024class iterator_adaptor_base
1025 : public iterator_facade_base<DerivedT, IteratorCategoryT, T, DifferenceTypeT,
1026 PointerT, ReferenceT> {
1027 using BaseT = typename iterator_adaptor_base::iterator_facade_base;
1028
1029 protected:
1030 WrappedIteratorT I;
1031
1032 iterator_adaptor_base() = default;
1033
1034 explicit iterator_adaptor_base(WrappedIteratorT u) :
1035 I(std::move(u)) {
1036 static_assert(std::is_base_of_v<iterator_adaptor_base, DerivedT>,
1037 "Must pass the derived type to this template!");
1038 }
1039
1040 const WrappedIteratorT& wrapped() const {
1041 return I;
1042 }
1043
1044 public:
1045 using difference_type = DifferenceTypeT;
1046
1048 static_assert(
1049 BaseT::IsRandomAccess,
1050 "The '+=' operator is only defined for random access iterators."
1051 );
1052 I += n;
1053 return *static_cast<DerivedT*>(this);
1054 }
1055
1057 static_assert(
1058 BaseT::IsRandomAccess,
1059 "The '-=' operator is only defined for random access iterators."
1060 );
1061 I -= n;
1062 return *static_cast<DerivedT*>(this);
1063 }
1064 using BaseT::operator-;
1066 static_assert(BaseT::IsRandomAccess,
1067 "The '-' operator is only defined for random access iterators.");
1068 return I - RHS.I;
1069 }
1070
1071 // We have to explicitly provide ++ and -- rather than letting the facade
1072 // forward to += because WrappedIteratorT might not support +=.
1073 using BaseT::operator++;
1075 ++I;
1076 return *static_cast<DerivedT*>(this);
1077 }
1078 using BaseT::operator--;
1080 static_assert(
1081 BaseT::IsBidirectional,
1082 "The decrement operator is only defined for bidirectional iterators."
1083 );
1084 --I;
1085 return *static_cast<DerivedT*>(this);
1086 }
1087
1088 friend bool operator==(const iterator_adaptor_base& LHS,
1089 const iterator_adaptor_base& RHS) {
1090 return LHS.I == RHS.I;
1091 }
1092
1093 friend bool operator<(const iterator_adaptor_base& LHS,
1094 const iterator_adaptor_base& RHS) {
1095 static_assert(
1096 BaseT::IsRandomAccess,
1097 "Relational operators are only defined for random access iterators."
1098 );
1099 return LHS.I < RHS.I;
1100 }
1101
1102 ReferenceT operator*() const {
1103 return *I;
1104 }
1105};
1106
1116template<typename WrappedIteratorT,
1117 typename T =
1118 std::remove_reference_t<decltype(**std::declval<WrappedIteratorT>())>>
1120 : iterator_adaptor_base<
1121 pointee_iterator<WrappedIteratorT, T>, WrappedIteratorT,
1122 typename std::iterator_traits<WrappedIteratorT>::iterator_category, T
1123 > {
1124 pointee_iterator() = default;
1125 template<typename U>
1126 pointee_iterator(U&& u) : // NOLINT(bugprone-forwarding-reference-overload)
1127 pointee_iterator::iterator_adaptor_base(std::forward<U>(u)) {}
1128
1129 T& operator*() const {
1130 return **this->I;
1131 }
1132};
1133
1134template<typename RangeT,
1135 typename WrappedIteratorT = decltype(std::begin(std::declval<RangeT>()))>
1136iterator_range<pointee_iterator<WrappedIteratorT>>
1137 make_pointee_range(RangeT&& Range) {
1138 using PointeeIteratorT = pointee_iterator<WrappedIteratorT>;
1139 return make_range(PointeeIteratorT(std::begin(std::forward<RangeT>(Range))),
1140 PointeeIteratorT(std::end(std::forward<RangeT>(Range))));
1141}
1142
1143template<typename WrappedIteratorT,
1144 typename T = decltype(&*std::declval<WrappedIteratorT>())>
1146 : public iterator_adaptor_base<
1147 pointer_iterator<WrappedIteratorT, T>, WrappedIteratorT,
1148 typename std::iterator_traits<WrappedIteratorT>::iterator_category, T
1149 > {
1150 mutable T Ptr;
1151
1152 public:
1153 pointer_iterator() = default;
1154
1155 explicit pointer_iterator(WrappedIteratorT u) :
1156 pointer_iterator::iterator_adaptor_base(std::move(u)) {}
1157
1158 T& operator*() const {
1159 return Ptr = &*this->I;
1160 }
1161};
1162
1163template<typename RangeT,
1164 typename WrappedIteratorT = decltype(std::begin(std::declval<RangeT>()))>
1165iterator_range<pointer_iterator<WrappedIteratorT>>
1166 make_pointer_range(RangeT&& Range) {
1167 using PointerIteratorT = pointer_iterator<WrappedIteratorT>;
1168 return make_range(PointerIteratorT(std::begin(std::forward<RangeT>(Range))),
1169 PointerIteratorT(std::end(std::forward<RangeT>(Range))));
1170}
1171
1172template<typename WrappedIteratorT,
1173 typename T1 =
1174 std::remove_reference_t<decltype(**std::declval<WrappedIteratorT>())>,
1175 typename T2 = std::add_pointer_t<T1>>
1178}
1179
1180#endif
container_t arg_t
Definition iterators.hpp:73
container_t * get() const
Definition iterators.hpp:79
std::remove_const_t< T > container_t
Definition iterators.hpp:72
container_storage(arg_t container)
Definition iterators.hpp:76
Storage of the container iterated by a ref_iterator or a filter_iterator.
Definition iterators.hpp:51
container_t * get() const
The container or a nullptr if the storage is default-constructed.
Definition iterators.hpp:61
T arg_t
Definition iterators.hpp:54
container_storage(arg_t container)
Definition iterators.hpp:57
std::remove_reference_t< T > container_t
Definition iterators.hpp:53
Iterator which returns a ref on container's values given predicates.
Definition iterators.hpp:392
std::enable_if_t<!std::is_const_v< pointer_t >, pointer_t > operator->()
Definition iterators.hpp:573
bool operator==(const filter_iterator &other) const
Definition iterators.hpp:617
add_const_t< ref_t > operator[](size_t n) const
Definition iterators.hpp:562
filter_iterator cend() const
Definition iterators.hpp:536
std::forward_iterator_tag iterator_category
Definition iterators.hpp:395
std::enable_if_t<!std::is_const_v< ref_t >, remove_const_t< ref_t > > operator*()
Definition iterators.hpp:544
filter_iterator & operator=(const filter_iterator &other)
Definition iterators.hpp:439
filter_iterator(details::container_arg_t< T > container, filter_t filter)
Definition iterators.hpp:453
add_const_t< ref_t > operator*() const
Definition iterators.hpp:550
void swap(filter_iterator &other) noexcept
Definition iterators.hpp:481
filter_iterator & operator++()
Definition iterators.hpp:500
filter_iterator(details::container_arg_t< T > container, const std::vector< filter_t > &filters)
Definition iterators.hpp:465
filter_iterator end() const
Definition iterators.hpp:522
typename filter_iterator::pointer pointer_t
Definition iterators.hpp:407
std::remove_pointer_t< Symbol * > * pointer
Definition iterators.hpp:400
typename filter_iterator::reference ref_t
Definition iterators.hpp:406
filter_iterator(const filter_iterator &other)
Definition iterators.hpp:414
bool is_end() const
Definition iterators.hpp:540
filter_iterator begin() const
Definition iterators.hpp:511
bool empty() const
Definition iterators.hpp:604
std::enable_if_t<!std::is_const_v< ref_t >, remove_const_t< ref_t > > operator[](size_t n)
Definition iterators.hpp:556
Symbol * DT_VAL
Definition iterators.hpp:404
ptrdiff_t difference_type
Definition iterators.hpp:399
~filter_iterator()=default
add_const_t< pointer_t > operator->() const
Definition iterators.hpp:579
std::remove_cv_t< std::remove_pointer_t< decay_t< Symbol * > > > value_type
Definition iterators.hpp:398
filter_iterator()=default
Create an iterator that is not associated with a container. It behaves as an empty range.
size_t size() const
Definition iterators.hpp:583
bool operator!=(const filter_iterator &other) const
Definition iterators.hpp:627
filter_iterator(details::container_arg_t< T > container)
Definition iterators.hpp:476
std::function< bool(const typename DT::value_type &)> filter_t
Definition iterators.hpp:408
std::remove_pointer_t< Symbol * > & reference
Definition iterators.hpp:401
details::iterator_concept_t< symbols_t &, Symbol *, std::forward_iterator_tag > iterator_concept
Definition iterators.hpp:396
filter_iterator(filter_iterator &&other) noexcept
Definition iterators.hpp:424
symbols_t & container_type
Definition iterators.hpp:403
filter_iterator operator++(int)
Definition iterators.hpp:505
decay_t< symbols_t & > DT
Definition iterators.hpp:405
filter_iterator cbegin() const
Definition iterators.hpp:518
filter_iterator & def(filter_t func)
Definition iterators.hpp:493
filter_iterator & operator=(filter_iterator &&other) noexcept
Definition iterators.hpp:445
DerivedT & operator++()
Definition iterators.hpp:1074
DerivedT & operator--()
Definition iterators.hpp:1079
DerivedT & operator-=(difference_type n)
Definition iterators.hpp:1056
ReferenceT operator*() const
Definition iterators.hpp:1102
friend bool operator<(const iterator_adaptor_base &LHS, const iterator_adaptor_base &RHS)
Definition iterators.hpp:1093
friend bool operator==(const iterator_adaptor_base &LHS, const iterator_adaptor_base &RHS)
Definition iterators.hpp:1088
DifferenceTypeT difference_type
Definition iterators.hpp:1045
DerivedT & operator+=(difference_type n)
Definition iterators.hpp:1047
difference_type operator-(const DerivedT &RHS) const
Definition iterators.hpp:1065
CRTP base class which implements the entire standard iterator facade in terms of a minimal subset of ...
Definition iterators.hpp:851
DifferenceTypeT difference_type
Definition iterators.hpp:858
PointerProxy operator->() const
Definition iterators.hpp:992
DerivedT & operator--()
Definition iterators.hpp:943
DerivedT operator++(int)
Definition iterators.hpp:937
T value_type
Definition iterators.hpp:857
friend DerivedT
Definition iterators.hpp:852
friend DerivedT operator+(DifferenceTypeT n, const DerivedT &i)
Definition iterators.hpp:917
bool operator>(const DerivedT &RHS) const
Definition iterators.hpp:967
ReferenceProxy operator[](DifferenceTypeT n) const
Definition iterators.hpp:996
ReferenceT reference
Definition iterators.hpp:860
bool operator>=(const DerivedT &RHS) const
Definition iterators.hpp:984
DerivedT operator-(DifferenceTypeT n) const
Definition iterators.hpp:923
DerivedT & operator++()
Definition iterators.hpp:931
PointerT pointer
Definition iterators.hpp:859
DerivedT operator--(int)
Definition iterators.hpp:951
IteratorCategoryT iterator_category
Definition iterators.hpp:856
DerivedT operator+(DifferenceTypeT n) const
Definition iterators.hpp:907
bool operator!=(const DerivedT &RHS) const
Definition iterators.hpp:962
bool operator<=(const DerivedT &RHS) const
Definition iterators.hpp:976
decltype(*std::declval< const IteratorDecayTy & >()) reference
Definition iterators.hpp:711
auto operator->() const -> decltype(&*std::declval< const It & >())
Definition iterators.hpp:718
friend iterator_range
Definition iterators.hpp:703
Definition iterators.hpp:680
IteratorT begin() const
Definition iterators.hpp:690
ReferenceProxy at(typename IteratorDecayTy::difference_type pos) const
Definition iterators.hpp:723
std::decay_t< assembly::Instruction::Iterator > IteratorDecayTy
Definition iterators.hpp:683
iterator_range(T &&it_begin, T &&it_end)
Definition iterators.hpp:686
IteratorT end() const
Definition iterators.hpp:694
bool empty() const
Definition iterators.hpp:698
ReferenceProxy operator[](typename IteratorDecayTy::difference_type pos) const
Definition iterators.hpp:730
assembly::Instruction::Iterator IteratorTy
Definition iterators.hpp:682
std::ptrdiff_t size() const
Definition iterators.hpp:734
Definition iterators.hpp:1149
T & operator*() const
Definition iterators.hpp:1158
pointer_iterator(WrappedIteratorT u)
Definition iterators.hpp:1155
Iterator which returns reference on container's values.
Definition iterators.hpp:120
bool operator<=(const ref_iterator &rhs) const
Definition iterators.hpp:290
ref_iterator & operator--()
Definition iterators.hpp:214
add_const_t< ref_t > operator*() const
Definition iterators.hpp:353
size_t size() const
Definition iterators.hpp:337
ref_iterator & operator++()
Definition iterators.hpp:202
void swap(ref_iterator &other) noexcept
Definition iterators.hpp:193
bool operator<(const ref_iterator &rhs) const
Definition iterators.hpp:275
ref_iterator operator-(typename ref_iterator::difference_type n) const
Definition iterators.hpp:265
ref_iterator operator++(int)
Definition iterators.hpp:208
ref_iterator begin() const
Definition iterators.hpp:294
sections_t container_type
Definition iterators.hpp:133
typename ref_iterator::reference ref_t
Definition iterators.hpp:136
ref_iterator operator--(int)
Definition iterators.hpp:222
ref_iterator cend() const
Definition iterators.hpp:314
ref_iterator(const ref_iterator &other)
Definition iterators.hpp:141
ref_iterator & operator+=(const typename ref_iterator::difference_type &movement)
Definition iterators.hpp:229
std::enable_if_t<!std::is_const_v< ref_t >, remove_const_t< ref_t > > operator[](size_t n)
Definition iterators.hpp:246
std::remove_pointer_t< typename decay_t< sections_t >::value_type > & reference
Definition iterators.hpp:131
std::bidirectional_iterator_tag iterator_category
Definition iterators.hpp:125
std::enable_if_t<!std::is_const_v< ref_t >, remove_const_t< ref_t > > operator*()
Definition iterators.hpp:347
ref_iterator(ref_iterator &&other) noexcept
Definition iterators.hpp:148
ptrdiff_t difference_type
Definition iterators.hpp:129
ref_iterator(details::container_arg_t< T > container)
Definition iterators.hpp:189
ref_iterator operator+(typename ref_iterator::difference_type n) const
Definition iterators.hpp:259
ref_iterator cbegin() const
Definition iterators.hpp:301
bool empty() const
Definition iterators.hpp:342
std::remove_cv_t< std::remove_pointer_t< decay_t< typename decay_t< sections_t >::value_type > > > value_type
Definition iterators.hpp:128
ref_iterator & operator=(ref_iterator &&other) noexcept
Definition iterators.hpp:164
bool operator!=(const ref_iterator &other) const
Definition iterators.hpp:333
ref_iterator()=default
bool operator>(const ref_iterator &rhs) const
Definition iterators.hpp:280
bool operator>=(const ref_iterator &rhs) const
Definition iterators.hpp:285
ref_iterator end() const
Definition iterators.hpp:305
ref_iterator & operator-=(const typename ref_iterator::difference_type &movement)
Definition iterators.hpp:238
ref_iterator(const ref_iterator< T2, U2, IT2 > &other)
Definition iterators.hpp:174
add_const_t< ref_t > operator[](size_t n) const
Definition iterators.hpp:253
std::remove_pointer_t< typename decay_t< sections_t >::value_type > * pointer
Definition iterators.hpp:130
std::enable_if_t<!std::is_const_v< pointer_t >, pointer_t > operator->()
Definition iterators.hpp:357
ref_iterator::difference_type operator-(const ref_iterator &rhs) const
Definition iterators.hpp:271
typename decay_t< sections_t >::value_type DT_VAL
Definition iterators.hpp:134
typename ref_iterator::pointer pointer_t
Definition iterators.hpp:137
details::iterator_concept_t< sections_t, typename decay_t< sections_t >::value_type, std::bidirectional_iterator_tag > iterator_concept
Definition iterators.hpp:126
friend class ref_iterator
Definition iterators.hpp:122
bool is_end() const
Definition iterators.hpp:318
~ref_iterator()=default
add_const_t< pointer_t > operator->() const
Definition iterators.hpp:363
ref_iterator & operator=(const ref_iterator &other)
Definition iterators.hpp:158
bool operator==(const ref_iterator &other) const
Definition iterators.hpp:322
decay_t< sections_t > DT
Definition iterators.hpp:135
#define LIEF_LIFETIMEBOUND
Definition compiler_attributes.hpp:72
@ T
Definition AcceleratorCodes.hpp:96
Definition Abstract/DebugInfo.hpp:27
Ref deref(const IT &it)
Definition iterators.hpp:91
typename container_storage< T >::arg_t container_arg_t
Definition iterators.hpp:88
std::conditional_t< std::is_reference_v< T >||std::is_pointer_v< U >, Category, std::input_iterator_tag > iterator_concept_t
Definition iterators.hpp:101
LIEF namespace.
Definition Abstract/Binary.hpp:41
filter_iterator< CT, U, typename decay_t< CT >::const_iterator > const_filter_iterator
Iterator which returns a const ref on container's values given predicates.
Definition iterators.hpp:672
iterator_range< pointee_iterator< WrappedIteratorT > > make_pointee_range(RangeT &&Range)
Definition iterators.hpp:1137
iterator_range< T > make_range(T &&x, T &&y)
Definition iterators.hpp:752
iterator_range< pointer_iterator< WrappedIteratorT > > make_pointer_range(RangeT &&Range)
Definition iterators.hpp:1166
std::remove_const_t< T > remove_const_t
Definition iterators.hpp:38
ref_iterator< CT, U, typename decay_t< CT >::const_iterator > const_ref_iterator
Iterator which returns a const ref on container's values.
Definition iterators.hpp:385
pointer_iterator< pointee_iterator< WrappedIteratorT, T1 >, T2 > raw_pointer_iterator
Definition iterators.hpp:1176
std::decay_t< T > decay_t
Definition iterators.hpp:32
std::add_const_t< T > add_const_t
Definition iterators.hpp:35
std::add_lvalue_reference_t< T > add_lvalue_reference_t
Definition iterators.hpp:41
An iterator type that allows iterating over the pointees via some other iterator.
Definition iterators.hpp:1123
T & operator*() const
Definition iterators.hpp:1129
pointee_iterator(U &&u)
Definition iterators.hpp:1126