kakoune

Fork of kakoune, an acceptable text editor
git clone git://git.laack.co/kakoune.git
Log | Files | Refs

array_view.hh (2968B)


      1 #ifndef array_view_hh_INCLUDED
      2 #define array_view_hh_INCLUDED
      3 
      4 #include <initializer_list>
      5 #include <iterator>
      6 
      7 namespace Kakoune
      8 {
      9 
     10 // An ArrayView provides a typed, non owning view of a memory
     11 // range with an interface similar to std::vector.
     12 template<typename T>
     13 class ArrayView
     14 {
     15 public:
     16     using size_t = std::size_t;
     17 
     18     constexpr ArrayView()
     19         : m_pointer(nullptr), m_size(0) {}
     20 
     21     constexpr ArrayView(T& oneval)
     22         : m_pointer(&oneval), m_size(1) {}
     23 
     24     constexpr ArrayView(T* pointer, size_t size)
     25         : m_pointer(pointer), m_size(size) {}
     26 
     27     constexpr ArrayView(T* begin, T* end)
     28         : m_pointer(begin), m_size(end - begin) {}
     29 
     30     template<typename It>
     31         requires std::contiguous_iterator<It> and std::is_same_v<std::iter_value_t<It>, T>
     32     constexpr ArrayView(It begin, It end)
     33         : m_pointer(&*begin), m_size(end - begin) {}
     34 
     35     template<size_t N>
     36     constexpr ArrayView(T(&array)[N]) : m_pointer(array), m_size(N) {}
     37 
     38     template<typename Container>
     39         requires (sizeof(decltype(*std::declval<Container>().data())) == sizeof(T))
     40     constexpr ArrayView(Container&& c)
     41         : m_pointer(c.data()), m_size(c.size()) {}
     42 
     43     constexpr ArrayView(const std::initializer_list<T>& v)
     44         : m_pointer(v.begin()), m_size(v.size()) {}
     45 
     46     constexpr T* pointer() const { return m_pointer; }
     47     constexpr size_t size() const { return m_size; }
     48 
     49     [[gnu::always_inline]]
     50     constexpr T& operator[](size_t n) const { return *(m_pointer + n); }
     51 
     52     constexpr T* begin() const { return m_pointer; }
     53     constexpr T* end()   const { return m_pointer+m_size; }
     54 
     55     using reverse_iterator = std::reverse_iterator<T*>;
     56     constexpr reverse_iterator rbegin() const { return reverse_iterator(m_pointer+m_size); }
     57     constexpr reverse_iterator rend()   const { return reverse_iterator(m_pointer); }
     58 
     59     constexpr T& front() const { return *m_pointer; }
     60     constexpr T& back()  const { return *(m_pointer + m_size - 1); }
     61 
     62     constexpr bool empty() const { return m_size == 0; }
     63 
     64     constexpr ArrayView subrange(size_t first, size_t count = -1) const
     65     {
     66         auto min = [](size_t a, size_t b) { return a < b ? a : b; };
     67         return ArrayView(m_pointer + min(first, m_size),
     68                          min(count, m_size - min(first, m_size)));
     69     }
     70 
     71 private:
     72     T* m_pointer;
     73     size_t m_size;
     74 };
     75 
     76 template<typename It>
     77     requires std::contiguous_iterator<It>
     78 ArrayView(It begin, It end) -> ArrayView<std::iter_value_t<It>>;
     79 
     80 template<typename Container>
     81 ArrayView(Container& c) -> ArrayView<std::remove_reference_t<decltype(*c.data())>>;
     82 
     83 template<typename T>
     84 using ConstArrayView = ArrayView<const T>;
     85 
     86 template<typename T>
     87 bool operator==(ArrayView<T> lhs, ArrayView<T> rhs)
     88 {
     89     if (lhs.size() != rhs.size())
     90         return false;
     91     for (int i = 0; i < lhs.size(); ++i)
     92     {
     93         if (lhs[i] != rhs[i])
     94             return false;
     95     }
     96     return true;
     97 }
     98 
     99 }
    100 
    101 #endif // array_view_hh_INCLUDED