1//===- llvm/ADT/EnumeratedArray.h - Enumerated Array-------------*- 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/// \file 10/// This file defines an array type that can be indexed using scoped enum 11/// values. 12/// 13//===----------------------------------------------------------------------===// 14 15#ifndef LLVM_ADT_ENUMERATEDARRAY_H 16#define LLVM_ADT_ENUMERATEDARRAY_H 17 18#include <cassert> 19#include <iterator> 20 21namespace llvm { 22 23template <typename ValueType, typename Enumeration, 24 Enumeration LargestEnum = Enumeration::Last, typename IndexType = int, 25 IndexType Size = 1 + static_cast<IndexType>(LargestEnum)> 26class EnumeratedArray { 27public: 28 using iterator = ValueType *; 29 using const_iterator = const ValueType *; 30 31 using const_reverse_iterator = std::reverse_iterator<const_iterator>; 32 using reverse_iterator = std::reverse_iterator<iterator>; 33 34 using value_type = ValueType; 35 using reference = ValueType &; 36 using const_reference = const ValueType &; 37 using pointer = ValueType *; 38 using const_pointer = const ValueType *; 39 40 EnumeratedArray() = default; 41 EnumeratedArray(ValueType V) { 42 for (IndexType IX = 0; IX < Size; ++IX) { 43 Underlying[IX] = V; 44 } 45 } 46 EnumeratedArray(std::initializer_list<ValueType> Init) { 47 assert(Init.size() == Size && "Incorrect initializer size"); 48 for (IndexType IX = 0; IX < Size; ++IX) { 49 Underlying[IX] = *(Init.begin() + IX); 50 } 51 } 52 53 const ValueType &operator[](Enumeration Index) const { 54 auto IX = static_cast<IndexType>(Index); 55 assert(IX >= 0 && IX < Size && "Index is out of bounds."); 56 return Underlying[IX]; 57 } 58 ValueType &operator[](Enumeration Index) { 59 return const_cast<ValueType &>( 60 static_cast<const EnumeratedArray<ValueType, Enumeration, LargestEnum, 61 IndexType, Size> &>(*this)[Index]); 62 } 63 IndexType size() const { return Size; } 64 bool empty() const { return size() == 0; } 65 66 iterator begin() { return Underlying; } 67 const_iterator begin() const { return Underlying; } 68 69 iterator end() { return begin() + size(); } 70 const_iterator end() const { return begin() + size(); } 71 72 reverse_iterator rbegin() { return reverse_iterator(end()); } 73 const_reverse_iterator rbegin() const { 74 return const_reverse_iterator(end()); 75 } 76 reverse_iterator rend() { return reverse_iterator(begin()); } 77 const_reverse_iterator rend() const { 78 return const_reverse_iterator(begin()); 79 } 80 81private: 82 ValueType Underlying[Size]; 83}; 84 85} // namespace llvm 86 87#endif // LLVM_ADT_ENUMERATEDARRAY_H 88