1 #ifndef _DEARRAYBUFFER_HPP 2 #define _DEARRAYBUFFER_HPP 3 /*------------------------------------------------------------------------- 4 * drawElements C++ Base Library 5 * ----------------------------- 6 * 7 * Copyright 2014 The Android Open Source Project 8 * 9 * Licensed under the Apache License, Version 2.0 (the "License"); 10 * you may not use this file except in compliance with the License. 11 * You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, software 16 * distributed under the License is distributed on an "AS IS" BASIS, 17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18 * See the License for the specific language governing permissions and 19 * limitations under the License. 20 * 21 *//*! 22 * \file 23 * \brief Array buffer 24 *//*--------------------------------------------------------------------*/ 25 26 #include "deDefs.hpp" 27 #include "deMemory.h" 28 29 #include <new> 30 31 namespace de 32 { 33 namespace detail 34 { 35 36 void* ArrayBuffer_AlignedMalloc (size_t numBytes, size_t alignment); 37 void ArrayBuffer_AlignedFree (void*); 38 39 } // detail 40 41 //! Array buffer self-test. 42 void ArrayBuffer_selfTest (void); 43 44 /*--------------------------------------------------------------------*//*! 45 * \brief Contiguous array that does not initialize its elements. 46 *//*--------------------------------------------------------------------*/ 47 template <typename T, size_t Alignment = (sizeof(T) > 4 ? 4 : sizeof(T)), size_t Stride = sizeof(T)> 48 class ArrayBuffer 49 { 50 public: 51 DE_STATIC_ASSERT(Stride >= sizeof(T)); 52 53 ArrayBuffer (void) throw(); 54 ArrayBuffer (size_t numElements); 55 ArrayBuffer (const T* ptr, size_t numElements); 56 ArrayBuffer (const ArrayBuffer& other); 57 ~ArrayBuffer (void) throw(); 58 ArrayBuffer& operator= (const ArrayBuffer& other); 59 60 void clear (void) throw(); 61 void setStorage (size_t numElements); // !< \note after a succesful call buffer contents are undefined 62 void swap (ArrayBuffer& other) throw(); 63 size_t size (void) const throw(); 64 bool empty (void) const throw(); 65 66 T* getElementPtr (size_t elementNdx) throw(); 67 const T* getElementPtr (size_t elementNdx) const throw(); 68 void* getPtr (void) throw(); 69 const void* getPtr (void) const throw(); 70 71 private: 72 void* m_ptr; 73 size_t m_cap; 74 } DE_WARN_UNUSED_TYPE; 75 76 template <typename T, size_t Alignment, size_t Stride> 77 ArrayBuffer<T,Alignment,Stride>::ArrayBuffer (void) throw() 78 : m_ptr (DE_NULL) 79 , m_cap (0) 80 { 81 } 82 83 template <typename T, size_t Alignment, size_t Stride> 84 ArrayBuffer<T,Alignment,Stride>::ArrayBuffer (size_t numElements) 85 : m_ptr (DE_NULL) 86 , m_cap (0) 87 { 88 if (numElements) 89 { 90 // \note no need to allocate stride for the last element, sizeof(T) is enough. Also handles cases where sizeof(T) > Stride 91 const size_t storageSize = (numElements - 1) * Stride + sizeof(T); 92 void* const ptr = detail::ArrayBuffer_AlignedMalloc(storageSize, Alignment); 93 94 if (!ptr) 95 throw std::bad_alloc(); 96 97 m_ptr = ptr; 98 m_cap = numElements; 99 } 100 } 101 102 template <typename T, size_t Alignment, size_t Stride> 103 ArrayBuffer<T,Alignment,Stride>::ArrayBuffer (const T* ptr, size_t numElements) 104 : m_ptr (DE_NULL) 105 , m_cap (0) 106 { 107 if (numElements) 108 { 109 // create new buffer of wanted size, copy to it, and swap to it 110 ArrayBuffer<T,Alignment,Stride> tmp(numElements); 111 112 if (Stride == sizeof(T)) 113 { 114 // tightly packed 115 const size_t storageSize = sizeof(T) * numElements; 116 deMemcpy(tmp.m_ptr, ptr, (int)storageSize); 117 } 118 else 119 { 120 // sparsely packed 121 for (size_t ndx = 0; ndx < numElements; ++ndx) 122 *tmp.getElementPtr(ndx) = ptr[ndx]; 123 } 124 125 swap(tmp); 126 } 127 } 128 129 template <typename T, size_t Alignment, size_t Stride> 130 ArrayBuffer<T,Alignment,Stride>::ArrayBuffer (const ArrayBuffer<T,Alignment,Stride>& other) 131 : m_ptr (DE_NULL) 132 , m_cap (0) 133 { 134 if (other.m_cap) 135 { 136 // copy to temporary and swap to it 137 138 const size_t storageSize = (other.m_cap - 1) * Stride + sizeof(T); 139 ArrayBuffer tmp (other.m_cap); 140 141 deMemcpy(tmp.m_ptr, other.m_ptr, (int)storageSize); 142 swap(tmp); 143 } 144 } 145 146 template <typename T, size_t Alignment, size_t Stride> 147 ArrayBuffer<T,Alignment,Stride>::~ArrayBuffer (void) throw() 148 { 149 clear(); 150 } 151 152 template <typename T, size_t Alignment, size_t Stride> 153 ArrayBuffer<T,Alignment,Stride>& ArrayBuffer<T,Alignment,Stride>::operator= (const ArrayBuffer& other) 154 { 155 ArrayBuffer copied(other); 156 swap(copied); 157 return *this; 158 } 159 160 template <typename T, size_t Alignment, size_t Stride> 161 void ArrayBuffer<T,Alignment,Stride>::clear (void) throw() 162 { 163 detail::ArrayBuffer_AlignedFree(m_ptr); 164 165 m_ptr = DE_NULL; 166 m_cap = 0; 167 } 168 169 template <typename T, size_t Alignment, size_t Stride> 170 void ArrayBuffer<T,Alignment,Stride>::setStorage (size_t numElements) 171 { 172 // create new buffer of the wanted size, swap to it 173 ArrayBuffer<T,Alignment,Stride> newBuffer(numElements); 174 swap(newBuffer); 175 } 176 177 template <typename T, size_t Alignment, size_t Stride> 178 void ArrayBuffer<T,Alignment,Stride>::swap (ArrayBuffer& other) throw() 179 { 180 void* const otherPtr = other.m_ptr; 181 const size_t otherCap = other.m_cap; 182 183 other.m_ptr = m_ptr; 184 other.m_cap = m_cap; 185 m_ptr = otherPtr; 186 m_cap = otherCap; 187 } 188 189 template <typename T, size_t Alignment, size_t Stride> 190 size_t ArrayBuffer<T,Alignment,Stride>::size (void) const throw() 191 { 192 return m_cap; 193 } 194 195 template <typename T, size_t Alignment, size_t Stride> 196 bool ArrayBuffer<T,Alignment,Stride>::empty (void) const throw() 197 { 198 return size() == 0; 199 } 200 201 template <typename T, size_t Alignment, size_t Stride> 202 T* ArrayBuffer<T,Alignment,Stride>::getElementPtr (size_t elementNdx) throw() 203 { 204 return (T*)(((deUint8*)m_ptr) + Stride * elementNdx); 205 } 206 207 template <typename T, size_t Alignment, size_t Stride> 208 const T* ArrayBuffer<T,Alignment,Stride>::getElementPtr (size_t elementNdx) const throw() 209 { 210 return (T*)(((deUint8*)m_ptr) + Stride * elementNdx); 211 } 212 213 template <typename T, size_t Alignment, size_t Stride> 214 void* ArrayBuffer<T,Alignment,Stride>::getPtr (void) throw() 215 { 216 return m_ptr; 217 } 218 219 template <typename T, size_t Alignment, size_t Stride> 220 const void* ArrayBuffer<T,Alignment,Stride>::getPtr (void) const throw() 221 { 222 return m_ptr; 223 } 224 225 } // de 226 227 #endif // _DEARRAYBUFFER_HPP 228
