fox-toolkit.org - Documentation

00001 /********************************************************************************
00002 *                                                                               *
00003 *                           Generic Element Handling                            *
00004 *                                                                               *
00005 *********************************************************************************
00006 * Copyright (C) 1997,2004 by Jeroen van der Zijp.   All Rights Reserved.        *
00007 *********************************************************************************
00008 * This library is free software; you can redistribute it and/or                 *
00009 * modify it under the terms of the GNU Lesser General Public                    *
00010 * License as published by the Free Software Foundation; either                  *
00011 * version 2.1 of the License, or (at your option) any later version.            *
00012 *                                                                               *
00013 * This library is distributed in the hope that it will be useful,               *
00014 * but WITHOUT ANY WARRANTY; without even the implied warranty of                *
00015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
00016 * Lesser General Public License for more details.                               *
00017 *                                                                               *
00018 * You should have received a copy of the GNU Lesser General Public              *
00019 * License along with this library; if not, write to the Free Software           *
00020 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
00021 *********************************************************************************
00022 * $Id: FXElement.h,v 1.13 2004/02/08 17:17:33 fox Exp $                         *
00023 ********************************************************************************/
00024 #ifndef FXELEMENT_H
00025 #define FXELEMENT_H
00026 
00027 namespace FX {
00028 
00029 /****************************  D e f i n i t i o n  ****************************/
00030 
00031 // Generic implementations for generic objects
00032 
00033 
00034 // Construct some elements at a location
00035 template<class TYPE>
00036 inline void constructElms(TYPE* ptr,unsigned long n){
00037   while(n--){ ::new ((void*)ptr) TYPE; ptr++; }
00038   }
00039 
00040 
00041 // Destruct some elements at a location
00042 template<class TYPE>
00043 inline void destructElms(TYPE* ptr,unsigned long n){
00044   while(n--){ ptr->~TYPE(); ptr++; }
00045   }
00046 
00047 
00048 // Copy some elements from one place to another
00049 template<class TYPE>
00050 inline void copyElms(TYPE* dst,const TYPE* src,unsigned long n){
00051   while(n--){ *dst++ = *src++; }
00052   }
00053 
00054 
00055 // Move some elements from overlapping place to another
00056 template<class TYPE>
00057 inline void moveElms(TYPE* dst,const TYPE* src,unsigned long n){
00058   if(src>dst){
00059     while(n--){ *dst++ = *src++; }
00060     }
00061   else if(dst>src){
00062     dst+=n;
00063     src+=n;
00064     while(n--){ *--dst = *--src; }
00065     }
00066   }
00067 
00068 
00069 // Save some elements to persistent store
00070 template<class TYPE>
00071 inline void saveElms(FXStream& store,const TYPE* ptr,unsigned long n){
00072   while(n--){ store << *ptr; ptr++; }
00073   }
00074 
00075 
00076 // Load some elements from persistent store
00077 template<class TYPE>
00078 inline void loadElms(FXStream& store,TYPE* ptr,unsigned long n){
00079   while(n--){ store >> *ptr; ptr++; }
00080   }
00081 
00082 
00083 // Allocate array of elements, uninitialized
00084 template<class TYPE>
00085 inline void allocElms(TYPE*& ptr,unsigned long n){
00086   fxmalloc((void**)&ptr,sizeof(TYPE)*n);
00087   }
00088 
00089 
00090 // Allocate array of elements, initialized with zero
00091 template<class TYPE>
00092 inline void callocElms(TYPE*& ptr,unsigned long n){
00093   fxcalloc((void**)&ptr,sizeof(TYPE)*n);
00094   }
00095 
00096 
00097 // Allocate array of elements, initialized with bit-wise copy of src array
00098 template<class TYPE>
00099 inline void dupElms(TYPE*& ptr,const TYPE* src,unsigned long n){
00100   fxmemdup((void**)&ptr,src,sizeof(TYPE)*n);
00101   }
00102 
00103 
00104 // Resize array of elements, without constructor or destructor
00105 template<class TYPE>
00106 inline void resizeElms(TYPE*& ptr,unsigned long n){
00107   fxresize((void**)&ptr,sizeof(TYPE)*n);
00108   }
00109 
00110 
00111 // Free array of elements, without destruction
00112 template<class TYPE>
00113 inline void freeElms(TYPE*& ptr){
00114   fxfree((void**)&ptr);
00115   }
00116 
00117 
00118 /**********************  I m p l e m e n t a t i o n  ************************/
00119 
00120 // Specific implementations for built-in types
00121 
00122 
00123 // No-op constructors for array of basic type
00124 inline void constructElms(FXuchar*,unsigned long){ }
00125 inline void constructElms(FXchar*,unsigned long){ }
00126 inline void constructElms(FXushort*,unsigned long){ }
00127 inline void constructElms(FXshort*,unsigned long){ }
00128 inline void constructElms(FXuint*,unsigned long){ }
00129 inline void constructElms(FXint*,unsigned long){ }
00130 inline void constructElms(FXfloat*,unsigned long){ }
00131 inline void constructElms(FXdouble*,unsigned long){ }
00132 
00133 // No-op destructors for array of basic type
00134 inline void destructElms(FXuchar*,unsigned long){ }
00135 inline void destructElms(FXchar*,unsigned long){ }
00136 inline void destructElms(FXushort*,unsigned long){ }
00137 inline void destructElms(FXshort*,unsigned long){ }
00138 inline void destructElms(FXuint*,unsigned long){ }
00139 inline void destructElms(FXint*,unsigned long){ }
00140 inline void destructElms(FXfloat*,unsigned long){ }
00141 inline void destructElms(FXdouble*,unsigned long){ }
00142 
00143 // Simple bit-wise copy for array of basic type
00144 inline void copyElms(FXuchar* dst,const FXuchar* src,unsigned long n){ memcpy(dst,src,n); }
00145 inline void copyElms(FXchar* dst,const FXchar* src,unsigned long n){ memcpy(dst,src,n); }
00146 inline void copyElms(FXushort* dst,const FXushort* src,unsigned long n){ memcpy(dst,src,n<<1); }
00147 inline void copyElms(FXshort* dst,const FXshort* src,unsigned long n){ memcpy(dst,src,n<<1); }
00148 inline void copyElms(FXuint* dst,const FXuint* src,unsigned long n){ memcpy(dst,src,n<<2); }
00149 inline void copyElms(FXint* dst,const FXint* src,unsigned long n){ memcpy(dst,src,n<<2); }
00150 inline void copyElms(FXfloat* dst,const FXfloat* src,unsigned long n){ memcpy(dst,src,n<<2); }
00151 inline void copyElms(FXdouble* dst,const FXdouble* src,unsigned long n){ memcpy(dst,src,n<<3); }
00152 
00153 // Simple bit-wise copy for array of pointers to any type
00154 template<class TYPE> inline void copyElms(TYPE** dst,const TYPE** src,unsigned long n){ memcpy(dst,src,n*sizeof(void*)); }
00155 
00156 // Simple bit-wise move for array of basic type
00157 inline void moveElms(FXuchar* dst,const FXuchar* src,unsigned long n){ memmove(dst,src,n); }
00158 inline void moveElms(FXchar* dst,const FXchar* src,unsigned long n){ memmove(dst,src,n); }
00159 inline void moveElms(FXushort* dst,const FXushort* src,unsigned long n){ memmove(dst,src,n<<1); }
00160 inline void moveElms(FXshort* dst,const FXshort* src,unsigned long n){ memmove(dst,src,n<<1); }
00161 inline void moveElms(FXuint* dst,const FXuint* src,unsigned long n){ memmove(dst,src,n<<2); }
00162 inline void moveElms(FXint* dst,const FXint* src,unsigned long n){ memmove(dst,src,n<<2); }
00163 inline void moveElms(FXfloat* dst,const FXfloat* src,unsigned long n){ memmove(dst,src,n<<2); }
00164 inline void moveElms(FXdouble* dst,const FXdouble* src,unsigned long n){ memmove(dst,src,n<<3); }
00165 
00166 // Simple bit-wise move for array of pointers to any type
00167 template<class TYPE> inline void moveElms(TYPE** dst,const TYPE** src,unsigned long n){ memmove(dst,src,n*sizeof(void*)); }
00168 
00169 // Type-safe save for basic types
00170 inline void saveElms(FXStream& store,const FXuchar* ptr,unsigned long n){ store.save(ptr,n); }
00171 inline void saveElms(FXStream& store,const FXchar* ptr,unsigned long n){ store.save(ptr,n); }
00172 inline void saveElms(FXStream& store,const FXushort* ptr,unsigned long n){ store.save(ptr,n); }
00173 inline void saveElms(FXStream& store,const FXshort* ptr,unsigned long n){ store.save(ptr,n); }
00174 inline void saveElms(FXStream& store,const FXuint* ptr,unsigned long n){ store.save(ptr,n); }
00175 inline void saveElms(FXStream& store,const FXint* ptr,unsigned long n){ store.save(ptr,n); }
00176 inline void saveElms(FXStream& store,const FXfloat* ptr,unsigned long n){ store.save(ptr,n); }
00177 inline void saveElms(FXStream& store,const FXdouble* ptr,unsigned long n){ store.save(ptr,n); }
00178 
00179 // Type-safe load for basic types
00180 inline void loadElms(FXStream& store,FXuchar* ptr,unsigned long n){ store.load(ptr,n); }
00181 inline void loadElms(FXStream& store,FXchar* ptr,unsigned long n){ store.load(ptr,n); }
00182 inline void loadElms(FXStream& store,FXushort* ptr,unsigned long n){ store.load(ptr,n); }
00183 inline void loadElms(FXStream& store,FXshort* ptr,unsigned long n){ store.load(ptr,n); }
00184 inline void loadElms(FXStream& store,FXuint* ptr,unsigned long n){ store.load(ptr,n); }
00185 inline void loadElms(FXStream& store,FXint* ptr,unsigned long n){ store.load(ptr,n); }
00186 inline void loadElms(FXStream& store,FXfloat* ptr,unsigned long n){ store.load(ptr,n); }
00187 inline void loadElms(FXStream& store,FXdouble* ptr,unsigned long n){ store.load(ptr,n); }
00188 
00189 }
00190 
00191 #endif