Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members

FXElement.h
1 /********************************************************************************
2 * *
3 * G e n e r i c E l e m e n t H a n d l i n g *
4 * *
5 *********************************************************************************
6 * Copyright (C) 1997,2017 by Jeroen van der Zijp. All Rights Reserved. *
7 *********************************************************************************
8 * This library is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU Lesser General Public License as published by *
10 * the Free Software Foundation; either version 3 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This library is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU Lesser General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU Lesser General Public License *
19 * along with this program. If not, see <http://www.gnu.org/licenses/> *
20 ********************************************************************************/
21 #ifndef FXELEMENT_H
22 #define FXELEMENT_H
23 
24 namespace FX {
25 
26 /**************************** D e f i n i t i o n ****************************/
27 
28 // Generic implementations for generic objects
29 
30 
31 // In-situ construct element at pointer
32 template<typename EType>
33 inline EType* construct(EType* ptr){
34  ::new ((void*)ptr) EType; return ptr;
35  }
36 
37 
38 // In-situ construct element at pointer, with argument
39 template<typename EType,typename Arg>
40 inline EType* construct(EType* ptr,Arg arg){
41  ::new ((void*)ptr) EType(arg); return ptr;
42  }
43 
44 
45 // In-situ destroy element at pointer
46 template<typename EType>
47 inline void destruct(EType* ptr){
48  ptr->~EType();
49  }
50 
51 
53 template<typename EType>
54 inline void constructElms(EType* ptr,FXuval n){
55  while(n--){ construct(ptr); ptr++; }
56  }
57 
58 
60 template<typename EType,typename Arg>
61 inline void constructElms(EType* ptr,Arg arg,FXuval n){
62  while(n--){ construct(ptr,arg); ptr++; }
63  }
64 
65 
67 template<typename EType>
68 inline void destructElms(EType* ptr,FXuval n){
69  while(n--){ destruct(ptr); ptr++; }
70  }
71 
72 
74 template<typename EType,typename OType>
75 inline void copyElms(EType* dst,const OType* src,FXuval n){
76  while(n--){ *dst++ = *src++; }
77  }
78 
79 
81 template<typename EType>
82 inline void moveElms(EType* dst,const EType* src,FXuval n){
83  if(src>dst){
84  while(n--){ *dst++ = *src++; }
85  }
86  else if(dst>src){
87  dst+=n;
88  src+=n;
89  while(n--){ *--dst = *--src; }
90  }
91  }
92 
93 
95 template<typename EType>
96 inline EType& swap(EType& dst,EType& src){
97  EType t=dst; dst=src; src=t;
98  return dst;
99  }
100 
101 
103 template<typename EType>
104 inline void swapElms(EType* dst,const EType* src,FXuval n){
105  while(n--){ swap(*dst++,*src++); }
106  }
107 
108 
110 template<typename EType>
111 inline FXbool equalElms(const EType* dst,const EType* src,FXuval n){
112  while(n--){ if(!(*dst++ == *src++)) return false; }
113  return true;
114  }
115 
116 
118 template<typename EType,typename OType>
119 inline void fillElms(EType* dst,const OType& src,FXuval n){
120  while(n--){ *dst++ = src; }
121  }
122 
123 
125 template<typename EType>
126 inline void clearElms(EType* dst,FXuval n){
127  memset((void*)dst,0,sizeof(EType)*n);
128  }
129 
130 
132 template<typename EType>
133 inline FXbool allocElms(EType*& ptr,FXuval n){
134  return fxmalloc((void**)&ptr,sizeof(EType)*n);
135  }
136 
137 
139 template<typename EType>
140 inline FXbool callocElms(EType*& ptr,FXuval n){
141  return fxcalloc((void**)&ptr,sizeof(EType)*n);
142  }
143 
144 
146 template<typename EType>
147 inline FXbool dupElms(EType*& ptr,const EType* src,FXuval n){
148  return fxmemdup((void**)&ptr,src,sizeof(EType)*n);
149  }
150 
151 
153 template<typename EType>
154 inline FXbool resizeElms(EType*& ptr,FXuval n){
155  return fxresize((void**)&ptr,sizeof(EType)*n);
156  }
157 
158 
160 template<typename EType>
161 inline void freeElms(EType*& ptr){
162  fxfree((void**)&ptr);
163  }
164 
165 
166 /********************** I m p l e m e n t a t i o n ************************/
167 
168 // Specific implementations for built-in types
169 
170 
171 // No-op constructors for array of basic type
172 inline void constructElms(FXuchar*,FXuval){ }
173 inline void constructElms(FXchar*,FXuval){ }
174 inline void constructElms(FXushort*,FXuval){ }
175 inline void constructElms(FXshort*,FXuval){ }
176 inline void constructElms(FXuint*,FXuval){ }
177 inline void constructElms(FXint*,FXuval){ }
178 inline void constructElms(FXulong*,FXuval){ }
179 inline void constructElms(FXlong*,FXuval){ }
180 inline void constructElms(FXfloat*,FXuval){ }
181 inline void constructElms(FXdouble*,FXuval){ }
182 
183 // No-op constructors for array of pointers to any type
184 template<typename EType> inline void constructElms(EType**,FXuval){ }
185 
186 
187 // No-op destructors for array of basic type
188 inline void destructElms(FXuchar*,FXuval){ }
189 inline void destructElms(FXchar*,FXuval){ }
190 inline void destructElms(FXushort*,FXuval){ }
191 inline void destructElms(FXshort*,FXuval){ }
192 inline void destructElms(FXuint*,FXuval){ }
193 inline void destructElms(FXint*,FXuval){ }
194 inline void destructElms(FXulong*,FXuval){ }
195 inline void destructElms(FXlong*,FXuval){ }
196 inline void destructElms(FXfloat*,FXuval){ }
197 inline void destructElms(FXdouble*,FXuval){ }
198 
199 // No-op destructors for array of pointers to any type
200 template<typename EType> inline void destructElms(EType**,FXuval){ }
201 
202 
203 // Simple bit-wise copy for array of basic type
204 inline void copyElms(FXuchar* dst,const FXuchar* src,FXuval n){ memcpy(dst,src,n); }
205 inline void copyElms(FXchar* dst,const FXchar* src,FXuval n){ memcpy(dst,src,n); }
206 inline void copyElms(FXushort* dst,const FXushort* src,FXuval n){ memcpy(dst,src,n<<1); }
207 inline void copyElms(FXshort* dst,const FXshort* src,FXuval n){ memcpy(dst,src,n<<1); }
208 inline void copyElms(FXuint* dst,const FXuint* src,FXuval n){ memcpy(dst,src,n<<2); }
209 inline void copyElms(FXint* dst,const FXint* src,FXuval n){ memcpy(dst,src,n<<2); }
210 inline void copyElms(FXulong* dst,const FXulong* src,FXuval n){ memcpy(dst,src,n<<3); }
211 inline void copyElms(FXlong* dst,const FXlong* src,FXuval n){ memcpy(dst,src,n<<3); }
212 inline void copyElms(FXfloat* dst,const FXfloat* src,FXuval n){ memcpy(dst,src,n<<2); }
213 inline void copyElms(FXdouble* dst,const FXdouble* src,FXuval n){ memcpy(dst,src,n<<3); }
214 
215 // Simple bit-wise copy for array of pointers to any type
216 template<typename EType> inline void copyElms(EType** dst,const EType** src,FXuval n){ memcpy(dst,src,n*sizeof(void*)); }
217 
218 
219 // Simple bit-wise move for array of basic type
220 inline void moveElms(FXuchar* dst,const FXuchar* src,FXuval n){ memmove(dst,src,n); }
221 inline void moveElms(FXchar* dst,const FXchar* src,FXuval n){ memmove(dst,src,n); }
222 inline void moveElms(FXushort* dst,const FXushort* src,FXuval n){ memmove(dst,src,n<<1); }
223 inline void moveElms(FXshort* dst,const FXshort* src,FXuval n){ memmove(dst,src,n<<1); }
224 inline void moveElms(FXuint* dst,const FXuint* src,FXuval n){ memmove(dst,src,n<<2); }
225 inline void moveElms(FXint* dst,const FXint* src,FXuval n){ memmove(dst,src,n<<2); }
226 inline void moveElms(FXulong* dst,const FXulong* src,FXuval n){ memmove(dst,src,n<<3); }
227 inline void moveElms(FXlong* dst,const FXlong* src,FXuval n){ memmove(dst,src,n<<3); }
228 inline void moveElms(FXfloat* dst,const FXfloat* src,FXuval n){ memmove(dst,src,n<<2); }
229 inline void moveElms(FXdouble* dst,const FXdouble* src,FXuval n){ memmove(dst,src,n<<3); }
230 
231 // Simple bit-wise move for array of pointers to any type
232 template<typename EType> inline void moveElms(EType** dst,const EType** src,FXuval n){ memmove(dst,src,n*sizeof(void*)); }
233 
234 
235 // Simple bit-wise swap for array of basic type
236 inline void swapElms(FXuchar* dst,FXuchar* src,FXuval n){ memswap(dst,src,n); }
237 inline void swapElms(FXchar* dst,FXchar* src,FXuval n){ memswap(dst,src,n); }
238 inline void swapElms(FXushort* dst,FXushort* src,FXuval n){ memswap(dst,src,n<<1); }
239 inline void swapElms(FXshort* dst,FXshort* src,FXuval n){ memswap(dst,src,n<<1); }
240 inline void swapElms(FXuint* dst,FXuint* src,FXuval n){ memswap(dst,src,n<<2); }
241 inline void swapElms(FXint* dst,FXint* src,FXuval n){ memswap(dst,src,n<<2); }
242 inline void swapElms(FXulong* dst,FXulong* src,FXuval n){ memswap(dst,src,n<<3); }
243 inline void swapElms(FXlong* dst,FXlong* src,FXuval n){ memswap(dst,src,n<<3); }
244 inline void swapElms(FXfloat* dst,FXfloat* src,FXuval n){ memswap(dst,src,n<<2); }
245 inline void swapElms(FXdouble* dst,FXdouble* src,FXuval n){ memswap(dst,src,n<<3); }
246 
247 // Simple bit-wise swap for array of pointers to any type
248 template<typename EType> inline void swapElms(EType** dst,EType** src,FXuval n){ memswap(dst,src,n*sizeof(void*)); }
249 
250 
251 // Simple bit-wise comparison for array of basic type
252 inline FXbool equalElms(const FXuchar* dst,const FXuchar* src,FXuval n){ return memcmp(dst,src,n)==0; }
253 inline FXbool equalElms(const FXchar* dst,const FXchar* src,FXuval n){ return memcmp(dst,src,n)==0; }
254 inline FXbool equalElms(const FXushort* dst,const FXushort* src,FXuval n){ return memcmp(dst,src,n<<1)==0; }
255 inline FXbool equalElms(const FXshort* dst,const FXshort* src,FXuval n){ return memcmp(dst,src,n<<1)==0; }
256 inline FXbool equalElms(const FXuint* dst,const FXuint* src,FXuval n){ return memcmp(dst,src,n<<2)==0; }
257 inline FXbool equalElms(const FXint* dst,const FXint* src,FXuval n){ return memcmp(dst,src,n<<2)==0; }
258 inline FXbool equalElms(const FXulong* dst,const FXulong* src,FXuval n){ return memcmp(dst,src,n<<3)==0; }
259 inline FXbool equalElms(const FXlong* dst,const FXlong* src,FXuval n){ return memcmp(dst,src,n<<3)==0; }
260 inline FXbool equalElms(const FXfloat* dst,const FXfloat* src,FXuval n){ return memcmp(dst,src,n<<2)==0; }
261 inline FXbool equalElms(const FXdouble* dst,const FXdouble* src,FXuval n){ return memcmp(dst,src,n<<3)==0; }
262 
263 // Simple bit-wise comparison for array of pointers to any type
264 template<typename EType> inline FXbool equalElms(EType** dst,const EType** src,FXuval n){ return memcmp(dst,src,n*sizeof(void*))==0; }
265 
266 
267 // Fill byte arrays with constant
268 inline void fillElms(FXuchar* dst,const FXuchar& src,FXuval n){ memset(dst,src,n); }
269 inline void fillElms(FXchar* dst,const FXchar& src,FXuval n){ memset(dst,src,n); }
270 
271 }
272 
273 #endif

Copyright © 1997-2016 Jeroen van der Zijp