1 /* 2 * Copyright (C) 2016 The Android Open Source Project 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 17 #ifndef CHRE_UTIL_FIXED_SIZE_VECTOR_H_ 18 #define CHRE_UTIL_FIXED_SIZE_VECTOR_H_ 19 20 #include <type_traits> 21 22 #include "chre/util/non_copyable.h" 23 24 namespace chre { 25 26 template<typename ElementType, size_t kCapacity> 27 class FixedSizeVector : public NonCopyable { 28 public: 29 /** 30 * Destructs the objects 31 */ 32 ~FixedSizeVector(); 33 34 /** 35 * @return A reference to the last element in the vector 36 */ 37 ElementType& back(); 38 const ElementType& back() const; 39 40 /** 41 * @return A reference to the first element in the vector 42 */ 43 ElementType& front(); 44 const ElementType& front() const; 45 46 /** 47 * Obtains a pointer to the underlying storage for the vector. 48 * 49 * @return A pointer to the storage used for elements in this vector. 50 */ 51 ElementType *data(); 52 53 /** 54 * Obtains a const pointer to the underlying storage for the vector. 55 * 56 * @return A const pointer to the storage used for elements in this vector. 57 */ 58 const ElementType *data() const; 59 60 /** 61 * Obtains the number of elements currently stored in the static vector. 62 * 63 * @return The number of elements currently stored in the vector. 64 */ 65 size_t size() const; 66 67 /** 68 * Obtains the maximum number of elements that can be stored in the static 69 * vector. 70 * 71 * @return The maximum capacity of the vector as defined by the template 72 * argument. 73 */ 74 size_t capacity() const; 75 76 /** 77 * Determines whether the vector is empty or not. 78 * 79 * @return true if the vector is empty. 80 */ 81 bool empty() const; 82 83 /** 84 * Determines whether the vector is full or not. 85 * 86 * @return true if the vector is full. 87 */ 88 bool full() const; 89 90 /** 91 * Pushes an element onto the back of the vector. It is illegal to push an 92 * item onto a full vector. The user of the API must check the return of the 93 * full() function prior to pushing another element. All iterators and 94 * references are unaffected. 95 * 96 * @param The element to push onto the vector. 97 */ 98 void push_back(const ElementType& element); 99 100 /** 101 * Constructs an element onto the back of the vector. It is illegal to 102 * construct an item onto a full vector. The user of the API must check the 103 * return of the full() function prior to constructing another element. All 104 * iterators and references are unaffected. 105 * 106 * @param The arguments to the constructor 107 */ 108 template<typename... Args> 109 void emplace_back(Args&&... args); 110 111 /** 112 * Obtains an element of the vector given an index. It is illegal to index 113 * this vector out of bounds and the user of the API must check the size() 114 * function prior to indexing this vector to ensure that they will not read 115 * out of bounds. 116 * 117 * @param The index of the element. 118 * @return The element. 119 */ 120 ElementType& operator[](size_t index); 121 122 /** 123 * Obtains a const element of the vector given an index. It is illegal to 124 * index this vector out of bounds and the user of the API must check the 125 * size() function prior to indexing this vector to ensure that they will not 126 * read out of bounds. 127 * 128 * @param The index of the element. 129 * @return The element. 130 */ 131 const ElementType& operator[](size_t index) const; 132 133 /** 134 * Removes an element from the vector given an index. All elements after the 135 * indexed one are moved forward one position. The destructor is invoked on 136 * on the invalid item left at the end of the vector. The index passed in 137 * must be less than the size() of the vector. If the index is greater than or 138 * equal to the size no operation is performed. All iterators and references 139 * to elements before the indexed one are unaffected. 140 * 141 * @param index The index to remove an element at. 142 */ 143 void erase(size_t index); 144 145 /** 146 * Swaps the location of two elements stored in the vector. The indices 147 * passed in must be less than the size() of the vector. If the index is 148 * greater than or equal to the size, no operation is performed. All iterators 149 * and references to these two indexed elements are invalidated. 150 * 151 * @param index0 The index of the first element 152 * @param index1 The index of the second element 153 */ 154 void swap(size_t index0, size_t index1); 155 156 /** 157 * Resizes the fixed size vector by default-constructing from the current 158 * size() to the newly requested size. If the new size is smaller than the 159 * current size(), the elements from the new size to the current size() are 160 * destructed and the vector is shrunk. A resize operation cannot be performed 161 * that is greater than kCapacity. This will result in an assertion failure 162 * and a resize to kCapacity if assertions are disabled. All iterators and 163 * references to elements before newSize are unaffected. 164 * 165 * @param newSize The new size of the vector. 166 */ 167 void resize(size_t newSize); 168 169 /** 170 * Random-access iterator that points to some element in the container. 171 */ 172 typedef ElementType* iterator; 173 typedef const ElementType* const_iterator; 174 175 /** 176 * @return A random-access iterator to the beginning. 177 */ 178 typename FixedSizeVector<ElementType, kCapacity>::iterator begin(); 179 typename FixedSizeVector<ElementType, kCapacity>::const_iterator begin() const; 180 typename FixedSizeVector<ElementType, kCapacity>::const_iterator cbegin() const; 181 182 /** 183 * @return A random-access iterator to the end. 184 */ 185 typename FixedSizeVector<ElementType, kCapacity>::iterator end(); 186 typename FixedSizeVector<ElementType, kCapacity>::const_iterator end() const; 187 typename FixedSizeVector<ElementType, kCapacity>::const_iterator cend() const; 188 189 private: 190 //! Storage for vector elements. To avoid static initialization of members, 191 //! std::aligned_storage is used. 192 typename std::aligned_storage<sizeof(ElementType), 193 alignof(ElementType)>::type mData[kCapacity]; 194 195 //! The number of elements in the vector. This will never be more than 196 //! kCapacity. 197 size_t mSize = 0; 198 }; 199 200 } // namespace chre 201 202 #include "chre/util/fixed_size_vector_impl.h" 203 204 #endif // CHRE_UTIL_FIXED_SIZE_VECTOR_H_ 205