EIC code displayed by LXR master/​include/​llvm/​ADT/​Sequence.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-05-10 08:43:07

 //===- Sequence.h - Utility for producing sequences of values ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
 /// Provides some synthesis utilities to produce sequences of values. The names
 /// are intentionally kept very short as they tend to occur in common and
 /// widely used contexts.
 ///
 /// The `seq(A, B)` function produces a sequence of values from `A` to up to
 /// (but not including) `B`, i.e., [`A`, `B`), that can be safely iterated over.
 /// `seq` supports both integral (e.g., `int`, `char`, `uint32_t`) and enum
 /// types. `seq_inclusive(A, B)` produces a sequence of values from `A` to `B`,
 /// including `B`.
 ///
 /// Examples with integral types:
 /// ```
 /// for (int x : seq(0, 3))
 ///   outs() << x << " ";
 /// ```
 ///
 /// Prints: `0 1 2 `.
 ///
 /// ```
 /// for (int x : seq_inclusive(0, 3))
 ///   outs() << x << " ";
 /// ```
 ///
 /// Prints: `0 1 2 3 `.
 ///
 /// Similar to `seq` and `seq_inclusive`, the `enum_seq` and
 /// `enum_seq_inclusive` functions produce sequences of enum values that can be
 /// iterated over.
 /// To enable iteration with enum types, you need to either mark enums as safe
 /// to iterate on by specializing `enum_iteration_traits`, or opt into
 /// potentially unsafe iteration at every callsite by passing
 /// `force_iteration_on_noniterable_enum`.
 ///
 /// Examples with enum types:
 /// ```
 /// namespace X {
 ///   enum class MyEnum : unsigned {A = 0, B, C};
 /// } // namespace X
 ///
 /// template <> struct enum_iteration_traits<X::MyEnum> {
 ///   static contexpr bool is_iterable = true;
 /// };
 ///
 /// class MyClass {
 /// public:
 ///   enum Safe { D = 3, E, F };
 ///   enum MaybeUnsafe { G = 1, H = 2, I = 4 };
 /// };
 ///
 /// template <> struct enum_iteration_traits<MyClass::Safe> {
 ///   static contexpr bool is_iterable = true;
 /// };
 /// ```
 ///
 /// ```
 ///   for (auto v : enum_seq(MyClass::Safe::D, MyClass::Safe::F))
 ///     outs() << int(v) << " ";
 /// ```
 ///
 /// Prints: `3 4 `.
 ///
 /// ```
 ///   for (auto v : enum_seq(MyClass::MaybeUnsafe::H, MyClass::MaybeUnsafe::I,
 ///                          force_iteration_on_noniterable_enum))
 ///     outs() << int(v) << " ";
 /// ```
 ///
 /// Prints: `2 3 `.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_SEQUENCE_H
 #define LLVM_ADT_SEQUENCE_H
 
 #include <cassert>     // assert
 #include <iterator>    // std::random_access_iterator_tag
 #include <limits>      // std::numeric_limits
 #include <type_traits> // std::is_integral, std::is_enum, std::underlying_type,
                        // std::enable_if
 
 #include "llvm/Support/MathExtras.h" // AddOverflow / SubOverflow
 
 namespace llvm {
 
 // Enum traits that marks enums as safe or unsafe to iterate over.
 // By default, enum types are *not* considered safe for iteration.
 // To allow iteration for your enum type, provide a specialization with
 // `is_iterable` set to `true` in the `llvm` namespace.
 // Alternatively, you can pass the `force_iteration_on_noniterable_enum` tag
 // to `enum_seq` or `enum_seq_inclusive`.
 template <typename EnumT> struct enum_iteration_traits {
   static constexpr bool is_iterable = false;
 };
 
 struct force_iteration_on_noniterable_enum_t {
   explicit force_iteration_on_noniterable_enum_t() = default;
 };
 
 inline constexpr force_iteration_on_noniterable_enum_t
     force_iteration_on_noniterable_enum;
 
 namespace detail {
 
 // Returns whether a value of type U can be represented with type T.
 template <typename T, typename U> bool canTypeFitValue(const U Value) {
   const intmax_t BotT = intmax_t(std::numeric_limits<T>::min());
   const intmax_t BotU = intmax_t(std::numeric_limits<U>::min());
   const uintmax_t TopT = uintmax_t(std::numeric_limits<T>::max());
   const uintmax_t TopU = uintmax_t(std::numeric_limits<U>::max());
   return !((BotT > BotU && Value < static_cast<U>(BotT)) ||
            (TopT < TopU && Value > static_cast<U>(TopT)));
 }
 
 // An integer type that asserts when:
 // - constructed from a value that doesn't fit into intmax_t,
 // - casted to a type that cannot hold the current value,
 // - its internal representation overflows.
 struct CheckedInt {
   // Integral constructor, asserts if Value cannot be represented as intmax_t.
   template <typename Integral,
             std::enable_if_t<std::is_integral<Integral>::value, bool> = 0>
   static CheckedInt from(Integral FromValue) {
     if (!canTypeFitValue<intmax_t>(FromValue))
       assertOutOfBounds();
     CheckedInt Result;
     Result.Value = static_cast<intmax_t>(FromValue);
     return Result;
   }
 
   // Enum constructor, asserts if Value cannot be represented as intmax_t.
   template <typename Enum,
             std::enable_if_t<std::is_enum<Enum>::value, bool> = 0>
   static CheckedInt from(Enum FromValue) {
     using type = std::underlying_type_t<Enum>;
     return from<type>(static_cast<type>(FromValue));
   }
 
   // Equality
   bool operator==(const CheckedInt &O) const { return Value == O.Value; }
   bool operator!=(const CheckedInt &O) const { return Value != O.Value; }
 
   CheckedInt operator+(intmax_t Offset) const {
     CheckedInt Result;
     if (AddOverflow(Value, Offset, Result.Value))
       assertOutOfBounds();
     return Result;
   }
 
   intmax_t operator-(CheckedInt Other) const {
     intmax_t Result;
     if (SubOverflow(Value, Other.Value, Result))
       assertOutOfBounds();
     return Result;
   }
 
   // Convert to integral, asserts if Value cannot be represented as Integral.
   template <typename Integral,
             std::enable_if_t<std::is_integral<Integral>::value, bool> = 0>
   Integral to() const {
     if (!canTypeFitValue<Integral>(Value))
       assertOutOfBounds();
     return static_cast<Integral>(Value);
   }
 
   // Convert to enum, asserts if Value cannot be represented as Enum's
   // underlying type.
   template <typename Enum,
             std::enable_if_t<std::is_enum<Enum>::value, bool> = 0>
   Enum to() const {
     using type = std::underlying_type_t<Enum>;
     return Enum(to<type>());
   }
 
 private:
   static void assertOutOfBounds() { assert(false && "Out of bounds"); }
 
   intmax_t Value;
 };
 
 template <typename T, bool IsReverse> struct SafeIntIterator {
   using iterator_category = std::random_access_iterator_tag;
   using value_type = T;
   using difference_type = intmax_t;
   using pointer = T *;
   using reference = value_type; // The iterator does not reference memory.
 
   // Construct from T.
   explicit SafeIntIterator(T Value) : SI(CheckedInt::from<T>(Value)) {}
   // Construct from other direction.
   SafeIntIterator(const SafeIntIterator<T, !IsReverse> &O) : SI(O.SI) {}
 
   // Dereference
   reference operator*() const { return SI.to<T>(); }
   // Indexing
   reference operator[](intmax_t Offset) const { return *(*this + Offset); }
 
   // Can be compared for equivalence using the equality/inequality operators.
   bool operator==(const SafeIntIterator &O) const { return SI == O.SI; }
   bool operator!=(const SafeIntIterator &O) const { return SI != O.SI; }
   // Comparison
   bool operator<(const SafeIntIterator &O) const { return (*this - O) < 0; }
   bool operator>(const SafeIntIterator &O) const { return (*this - O) > 0; }
   bool operator<=(const SafeIntIterator &O) const { return (*this - O) <= 0; }
   bool operator>=(const SafeIntIterator &O) const { return (*this - O) >= 0; }
 
   // Pre Increment/Decrement
   void operator++() { offset(1); }
   void operator--() { offset(-1); }
 
   // Post Increment/Decrement
   SafeIntIterator operator++(int) {
     const auto Copy = *this;
     ++*this;
     return Copy;
   }
   SafeIntIterator operator--(int) {
     const auto Copy = *this;
     --*this;
     return Copy;
   }
 
   // Compound assignment operators
   void operator+=(intmax_t Offset) { offset(Offset); }
   void operator-=(intmax_t Offset) { offset(-Offset); }
 
   // Arithmetic
   SafeIntIterator operator+(intmax_t Offset) const { return add(Offset); }
   SafeIntIterator operator-(intmax_t Offset) const { return add(-Offset); }
 
   // Difference
   intmax_t operator-(const SafeIntIterator &O) const {
     return IsReverse ? O.SI - SI : SI - O.SI;
   }
 
 private:
   SafeIntIterator(const CheckedInt &SI) : SI(SI) {}
 
   static intmax_t getOffset(intmax_t Offset) {
     return IsReverse ? -Offset : Offset;
   }
 
   CheckedInt add(intmax_t Offset) const { return SI + getOffset(Offset); }
 
   void offset(intmax_t Offset) { SI = SI + getOffset(Offset); }
 
   CheckedInt SI;
 
   // To allow construction from the other direction.
   template <typename, bool> friend struct SafeIntIterator;
 };
 
 } // namespace detail
 
 template <typename T> struct iota_range {
   using value_type = T;
   using reference = T &;
   using const_reference = const T &;
   using iterator = detail::SafeIntIterator<value_type, false>;
   using const_iterator = iterator;
   using reverse_iterator = detail::SafeIntIterator<value_type, true>;
   using const_reverse_iterator = reverse_iterator;
   using difference_type = intmax_t;
   using size_type = std::size_t;
 
   explicit iota_range(T Begin, T End, bool Inclusive)
       : BeginValue(Begin), PastEndValue(End) {
     assert(Begin <= End && "Begin must be less or equal to End.");
     if (Inclusive)
       ++PastEndValue;
   }
 
   size_t size() const { return PastEndValue - BeginValue; }
   bool empty() const { return BeginValue == PastEndValue; }
 
   auto begin() const { return const_iterator(BeginValue); }
   auto end() const { return const_iterator(PastEndValue); }
 
   auto rbegin() const { return const_reverse_iterator(PastEndValue - 1); }
   auto rend() const { return const_reverse_iterator(BeginValue - 1); }
 
 private:
   static_assert(std::is_integral<T>::value || std::is_enum<T>::value,
                 "T must be an integral or enum type");
   static_assert(std::is_same<T, std::remove_cv_t<T>>::value,
                 "T must not be const nor volatile");
 
   iterator BeginValue;
   iterator PastEndValue;
 };
 
 /// Iterate over an integral type from Begin up to - but not including - End.
 /// Note: Begin and End values have to be within [INTMAX_MIN, INTMAX_MAX] for
 /// forward iteration (resp. [INTMAX_MIN + 1, INTMAX_MAX] for reverse
 /// iteration).
 template <typename T, typename = std::enable_if_t<std::is_integral<T>::value &&
                                                   !std::is_enum<T>::value>>
 auto seq(T Begin, T End) {
   return iota_range<T>(Begin, End, false);
 }
 
 /// Iterate over an integral type from 0 up to - but not including - Size.
 /// Note: Size value has to be within [INTMAX_MIN, INTMAX_MAX - 1] for
 /// forward iteration (resp. [INTMAX_MIN + 1, INTMAX_MAX - 1] for reverse
 /// iteration).
 template <typename T, typename = std::enable_if_t<std::is_integral<T>::value &&
                                                   !std::is_enum<T>::value>>
 auto seq(T Size) {
   return seq<T>(0, Size);
 }
 
 /// Iterate over an integral type from Begin to End inclusive.
 /// Note: Begin and End values have to be within [INTMAX_MIN, INTMAX_MAX - 1]
 /// for forward iteration (resp. [INTMAX_MIN + 1, INTMAX_MAX - 1] for reverse
 /// iteration).
 template <typename T, typename = std::enable_if_t<std::is_integral<T>::value &&
                                                   !std::is_enum<T>::value>>
 auto seq_inclusive(T Begin, T End) {
   return iota_range<T>(Begin, End, true);
 }
 
 /// Iterate over an enum type from Begin up to - but not including - End.
 /// Note: `enum_seq` will generate each consecutive value, even if no
 /// enumerator with that value exists.
 /// Note: Begin and End values have to be within [INTMAX_MIN, INTMAX_MAX] for
 /// forward iteration (resp. [INTMAX_MIN + 1, INTMAX_MAX] for reverse
 /// iteration).
 template <typename EnumT,
           typename = std::enable_if_t<std::is_enum<EnumT>::value>>
 auto enum_seq(EnumT Begin, EnumT End) {
   static_assert(enum_iteration_traits<EnumT>::is_iterable,
                 "Enum type is not marked as iterable.");
   return iota_range<EnumT>(Begin, End, false);
 }
 
 /// Iterate over an enum type from Begin up to - but not including - End, even
 /// when `EnumT` is not marked as safely iterable by `enum_iteration_traits`.
 /// Note: `enum_seq` will generate each consecutive value, even if no
 /// enumerator with that value exists.
 /// Note: Begin and End values have to be within [INTMAX_MIN, INTMAX_MAX] for
 /// forward iteration (resp. [INTMAX_MIN + 1, INTMAX_MAX] for reverse
 /// iteration).
 template <typename EnumT,
           typename = std::enable_if_t<std::is_enum<EnumT>::value>>
 auto enum_seq(EnumT Begin, EnumT End, force_iteration_on_noniterable_enum_t) {
   return iota_range<EnumT>(Begin, End, false);
 }
 
 /// Iterate over an enum type from Begin to End inclusive.
 /// Note: `enum_seq_inclusive` will generate each consecutive value, even if no
 /// enumerator with that value exists.
 /// Note: Begin and End values have to be within [INTMAX_MIN, INTMAX_MAX - 1]
 /// for forward iteration (resp. [INTMAX_MIN + 1, INTMAX_MAX - 1] for reverse
 /// iteration).
 template <typename EnumT,
           typename = std::enable_if_t<std::is_enum<EnumT>::value>>
 auto enum_seq_inclusive(EnumT Begin, EnumT End) {
   static_assert(enum_iteration_traits<EnumT>::is_iterable,
                 "Enum type is not marked as iterable.");
   return iota_range<EnumT>(Begin, End, true);
 }
 
 /// Iterate over an enum type from Begin to End inclusive, even when `EnumT`
 /// is not marked as safely iterable by `enum_iteration_traits`.
 /// Note: `enum_seq_inclusive` will generate each consecutive value, even if no
 /// enumerator with that value exists.
 /// Note: Begin and End values have to be within [INTMAX_MIN, INTMAX_MAX - 1]
 /// for forward iteration (resp. [INTMAX_MIN + 1, INTMAX_MAX - 1] for reverse
 /// iteration).
 template <typename EnumT,
           typename = std::enable_if_t<std::is_enum<EnumT>::value>>
 auto enum_seq_inclusive(EnumT Begin, EnumT End,
                         force_iteration_on_noniterable_enum_t) {
   return iota_range<EnumT>(Begin, End, true);
 }
 
 } // end namespace llvm
 
 #endif // LLVM_ADT_SEQUENCE_H

This page was automatically generated by the 2.3.7 LXR engine. The LXR team