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 ArrayBuffer (void) throw();
52 ArrayBuffer (size_t numElements);
53 ArrayBuffer (const ArrayBuffer& other);
54 ~ArrayBuffer (void) throw();
55 ArrayBuffer& operator= (const ArrayBuffer& other);
56
57 void clear (void) throw();
58 void setStorage (size_t numElements); // !< \note after a succesful call buffer contents are undefined
59 void swap (ArrayBuffer& other) throw();
60 size_t size (void) const throw();
61 bool empty (void) const throw();
62
63 T* getElementPtr (size_t elementNdx) throw();
64 const T* getElementPtr (size_t elementNdx) const throw();
65 void* getPtr (void) throw();
66 const void* getPtr (void) const throw();
67
68 private:
69 void* m_ptr;
70 size_t m_cap;
71 } DE_WARN_UNUSED_TYPE;
72
73 template <typename T, size_t Alignment, size_t Stride>
ArrayBuffer(void)74 ArrayBuffer<T,Alignment,Stride>::ArrayBuffer (void) throw()
75 : m_ptr (DE_NULL)
76 , m_cap (0)
77 {
78 }
79
80 template <typename T, size_t Alignment, size_t Stride>
ArrayBuffer(size_t numElements)81 ArrayBuffer<T,Alignment,Stride>::ArrayBuffer (size_t numElements)
82 : m_ptr (DE_NULL)
83 , m_cap (0)
84 {
85 if (numElements)
86 {
87 // \note no need to allocate stride for the last element, sizeof(T) is enough. Also handles cases where sizeof(T) > Stride
88 const size_t storageSize = (numElements - 1) * Stride + sizeof(T);
89 void* const ptr = detail::ArrayBuffer_AlignedMalloc(storageSize, Alignment);
90
91 if (!ptr)
92 throw std::bad_alloc();
93
94 m_ptr = ptr;
95 m_cap = numElements;
96 }
97 }
98
99 template <typename T, size_t Alignment, size_t Stride>
ArrayBuffer(const ArrayBuffer<T,Alignment,Stride> & other)100 ArrayBuffer<T,Alignment,Stride>::ArrayBuffer (const ArrayBuffer<T,Alignment,Stride>& other)
101 : m_ptr (DE_NULL)
102 , m_cap (0)
103 {
104 if (other.m_cap)
105 {
106 // copy to temporary and swap to it
107
108 const size_t storageSize = (other.m_cap - 1) * Stride + sizeof(T);
109 ArrayBuffer tmp (other.m_cap);
110
111 deMemcpy(tmp.m_ptr, other.m_ptr, (int)storageSize);
112 swap(tmp);
113 }
114 }
115
116 template <typename T, size_t Alignment, size_t Stride>
~ArrayBuffer(void)117 ArrayBuffer<T,Alignment,Stride>::~ArrayBuffer (void) throw()
118 {
119 clear();
120 }
121
122 template <typename T, size_t Alignment, size_t Stride>
operator =(const ArrayBuffer & other)123 ArrayBuffer<T,Alignment,Stride>& ArrayBuffer<T,Alignment,Stride>::operator= (const ArrayBuffer& other)
124 {
125 ArrayBuffer copied(other);
126 swap(copied);
127 return *this;
128 }
129
130 template <typename T, size_t Alignment, size_t Stride>
clear(void)131 void ArrayBuffer<T,Alignment,Stride>::clear (void) throw()
132 {
133 detail::ArrayBuffer_AlignedFree(m_ptr);
134
135 m_ptr = DE_NULL;
136 m_cap = 0;
137 }
138
139 template <typename T, size_t Alignment, size_t Stride>
setStorage(size_t numElements)140 void ArrayBuffer<T,Alignment,Stride>::setStorage (size_t numElements)
141 {
142 // create new buffer of the wanted size, swap to it
143 ArrayBuffer<T,Alignment,Stride> newBuffer(numElements);
144 swap(newBuffer);
145 }
146
147 template <typename T, size_t Alignment, size_t Stride>
swap(ArrayBuffer & other)148 void ArrayBuffer<T,Alignment,Stride>::swap (ArrayBuffer& other) throw()
149 {
150 void* const otherPtr = other.m_ptr;
151 const size_t otherCap = other.m_cap;
152
153 other.m_ptr = m_ptr;
154 other.m_cap = m_cap;
155 m_ptr = otherPtr;
156 m_cap = otherCap;
157 }
158
159 template <typename T, size_t Alignment, size_t Stride>
size(void) const160 size_t ArrayBuffer<T,Alignment,Stride>::size (void) const throw()
161 {
162 return m_cap;
163 }
164
165 template <typename T, size_t Alignment, size_t Stride>
empty(void) const166 bool ArrayBuffer<T,Alignment,Stride>::empty (void) const throw()
167 {
168 return size() == 0;
169 }
170
171 template <typename T, size_t Alignment, size_t Stride>
getElementPtr(size_t elementNdx)172 T* ArrayBuffer<T,Alignment,Stride>::getElementPtr (size_t elementNdx) throw()
173 {
174 return (T*)(((deUint8*)m_ptr) + Stride * elementNdx);
175 }
176
177 template <typename T, size_t Alignment, size_t Stride>
getElementPtr(size_t elementNdx) const178 const T* ArrayBuffer<T,Alignment,Stride>::getElementPtr (size_t elementNdx) const throw()
179 {
180 return (T*)(((deUint8*)m_ptr) + Stride * elementNdx);
181 }
182
183 template <typename T, size_t Alignment, size_t Stride>
getPtr(void)184 void* ArrayBuffer<T,Alignment,Stride>::getPtr (void) throw()
185 {
186 return m_ptr;
187 }
188
189 template <typename T, size_t Alignment, size_t Stride>
getPtr(void) const190 const void* ArrayBuffer<T,Alignment,Stride>::getPtr (void) const throw()
191 {
192 return m_ptr;
193 }
194
195 } // de
196
197 #endif // _DEARRAYBUFFER_HPP
198