Cycles: svn merge -r41225:41232 ^/trunk/blender
[blender.git] / intern / cycles / util / util_vector.h
1 /*
2  * Copyright 2011, Blender Foundation.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  */
18
19 #ifndef __UTIL_VECTOR_H__
20 #define __UTIL_VECTOR_H__
21
22 /* Vector */
23
24 #include <string.h>
25 #include <vector>
26
27 CCL_NAMESPACE_BEGIN
28
29 using std::vector;
30
31 /* Array
32  *
33  * Simplified version of vector, serving two purposes:
34  * - somewhat faster in that it does not clear memory on resize/alloc,
35  *   this was actually showing up in profiles quite significantly
36  * - if this is used, we are not tempted to use inefficient operations */
37
38 template<typename T>
39 class array
40 {
41 public:
42         array()
43         {
44                 data = NULL;
45                 datasize = 0;
46         }
47
48         array(size_t newsize)
49         {
50                 if(newsize == 0) {
51                         data = NULL;
52                         datasize = 0;
53                 }
54                 else {
55                         data = new T[newsize];
56                         datasize = newsize;
57                 }
58         }
59
60         array(const array& from)
61         {
62                 *this = from;
63         }
64
65         array& operator=(const array& from)
66         {
67                 if(from.datasize == 0) {
68                         data = NULL;
69                         datasize = 0;
70                 }
71                 else {
72                         data = new T[from.datasize];
73                         memcpy(data, from.data, from.datasize*sizeof(T));
74                         datasize = from.datasize;
75                 }
76
77                 return *this;
78         }
79
80         array& operator=(const vector<T>& from)
81         {
82                 datasize = from.size();
83                 data = NULL;
84
85                 if(datasize > 0) {
86                         data = new T[datasize];
87                         memcpy(data, &from[0], datasize*sizeof(T));
88                 }
89
90                 return *this;
91         }
92
93         ~array()
94         {
95                 delete [] data;
96         }
97
98         void resize(size_t newsize)
99         {
100                 if(newsize == 0) {
101                         clear();
102                 }
103                 else {
104                         T *newdata = new T[newsize];
105                         memcpy(newdata, data, ((datasize < newsize)? datasize: newsize)*sizeof(T));
106                         delete [] data;
107
108                         data = newdata;
109                         datasize = newsize;
110                 }
111         }
112
113         void clear()
114         {
115                 delete [] data;
116                 data = NULL;
117                 datasize = 0;
118         }
119
120         size_t size() const
121         {
122                 return datasize;
123         }
124
125         T& operator[](size_t i) const
126         {
127                 return data[i];
128         }
129
130 protected:
131         T *data;
132         size_t datasize;
133 };
134
135 CCL_NAMESPACE_END
136
137 #endif /* __UTIL_VECTOR_H__ */
138