ad6e25d00e085f532f95ecd36db9b7b1ba85f6b9
[lldb.git] / libc / utils / CPP / ArrayRef.h
1 //===----------------- Self contained ArrayRef type -------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "Array.h"
10
11 #include <stddef.h> // For size_t.
12
13 namespace __llvm_libc {
14 namespace cpp {
15
16 // The implementations of ArrayRef and MutualArrayRef in this file are based
17 // on the implementations of the types with the same names in
18 // llvm/ADT/ArrayRef.h. The implementations in this file are of a limited
19 // functionality, but can be extended in an as needed basis.
20
21 template <typename T> class ArrayRef {
22 public:
23   using iterator = const T *;
24
25 private:
26   const T *Data = nullptr;
27   size_t Length = 0;
28
29 public:
30   ArrayRef() = default;
31
32   // From Array.
33   template <size_t N>
34   ArrayRef(const Array<T, N> &Arr) : Data(Arr.Data), Length(N) {}
35
36   // Construct an ArrayRef from a single element.
37   explicit ArrayRef(const T &OneElt) : Data(&OneElt), Length(1) {}
38
39   // Construct an ArrayRef from a pointer and length.
40   ArrayRef(const T *data, size_t length) : Data(data), Length(length) {}
41
42   // Construct an ArrayRef from a range.
43   ArrayRef(const T *begin, const T *end) : Data(begin), Length(end - begin) {}
44
45   // Construct an ArrayRef from a C array.
46   template <size_t N>
47   constexpr ArrayRef(const T (&Arr)[N]) : Data(Arr), Length(N) {}
48
49   iterator begin() const { return Data; }
50   iterator end() const { return Data + Length; }
51
52   bool empty() const { return Length == 0; }
53
54   const T *data() const { return Data; }
55
56   size_t size() const { return Length; }
57
58   const T &operator[](size_t Index) const { return Data[Index]; }
59 };
60
61 template <typename T> class MutableArrayRef : public ArrayRef<T> {
62 public:
63   using iterator = T *;
64
65   // From Array.
66   template <size_t N> MutableArrayRef(Array<T, N> &Arr) : ArrayRef<T>(Arr) {}
67
68   // Construct from a single element.
69   explicit MutableArrayRef(T &OneElt) : ArrayRef<T>(OneElt) {}
70
71   // Construct from a pointer and length.
72   MutableArrayRef(T *data, size_t length) : ArrayRef<T>(data, length) {}
73
74   // Construct from a range.
75   MutableArrayRef(T *begin, T *end) : ArrayRef<T>(begin, end) {}
76
77   // Construct from a C array.
78   template <size_t N>
79   constexpr MutableArrayRef(T (&Arr)[N]) : ArrayRef<T>(Arr) {}
80
81   T *data() const { return const_cast<T *>(ArrayRef<T>::data()); }
82
83   iterator begin() const { return data(); }
84   iterator end() const { return data() + size(); }
85
86   T &operator[](size_t Index) const { return data()[Index]; }
87 };
88
89 } // namespace cpp
90 } // namespace __llvm_libc