1 mike  1.8 //%/////////////////////////////////////////////////////////////////////////////
  2           //
  3           // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM
  4           //
  5           // Permission is hereby granted, free of charge, to any person obtaining a copy
  6           // of this software and associated documentation files (the "Software"), to 
  7           // deal in the Software without restriction, including without limitation the 
  8           // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 
  9           // sell copies of the Software, and to permit persons to whom the Software is
 10           // furnished to do so, subject to the following conditions:
 11           // 
 12           // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN 
 13           // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
 14           // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 15           // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 
 16           // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 
 17           // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 
 18           // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 19           // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 20           //
 21           //==============================================================================
 22 mike  1.8 //
 23           // Author: Mike Brasher (mbrasher@bmc.com)
 24           //
 25           // Modified By:
 26           //
 27           //%/////////////////////////////////////////////////////////////////////////////
 28           
 29           ////////////////////////////////////////////////////////////////////////////////
 30           //
 31           // Memory.h
 32           //
 33           //	This file contains assorted memory-oriented routines:
 34           //
 35           //	    Zeros(): fills memory with zeros.
 36           //	    Destroy(): destructs multiple objects in contiguous memory.
 37           //	    CopyToRaw(): copies multiple objects to raw memory.
 38           //	    InitializeRaw(): default constructs mulitple object over raw memory.
 39           //
 40           //	Each of these is a template but specializations are provide for
 41           //	efficiency (which in some cases removes uncessary loops).
 42           //
 43 mike  1.8 ////////////////////////////////////////////////////////////////////////////////
 44           
 45           #ifndef Pegasus_Memory_h
 46           #define Pegasus_Memory_h
 47           
 48           #include <cstring>
 49           #include <Pegasus/Common/Config.h>
 50           #include <Pegasus/Common/CIMType.h>
 51           #include <Pegasus/Common/Char16.h>
 52           

 53 mike  1.10 

 54 mike  1.8  PEGASUS_NAMESPACE_BEGIN
 55            
 56            template<class T>
 57            inline void Zeros(T* items, Uint32 size)
 58            {
 59                memset(items, 0, sizeof(T) * size);
 60            }
 61            
 62            template<class T>
 63            inline void Destroy(T* items, Uint32 size)
 64            {
 65                while (size--)
 66            	items++->~T();
 67            }
 68            
 69            template<class T>
 70            inline void Destroy(T* ptr)
 71            {
 72                ptr->~T();
 73            }
 74            
 75 mike  1.8  template<class T, class U>
 76            inline void CopyToRaw(T* to, const U* from, Uint32 size)
 77            {
 78                while (size--)

 79 mike  1.9      {
 80            	// The following fails on TRU64:
 81            	//     new(to++) T(*from++);
 82            	// Probably a compiler error so I changed it to this:
 83            	// Mike Brasher
 84            
 85            	new(to) T(*from);
 86            	to++;
 87            	from++;
 88                }

 89 mike  1.8  }
 90            
 91            inline void CopyToRaw(Boolean* to, const Boolean* from, Uint32 size)
 92            {
 93                memcpy(to, from, sizeof(Boolean) * size);
 94            }
 95            
 96            inline void CopyToRaw(Uint8* to, const Uint8* from, Uint32 size)
 97            {
 98                memcpy(to, from, sizeof(Uint8) * size);
 99            }
100            
101            inline void CopyToRaw(Sint8* to, const Sint8* from, Uint32 size)
102            {
103                memcpy(to, from, sizeof(Sint8) * size);
104            }
105            
106            inline void CopyToRaw(Uint16* to, const Uint16* from, Uint32 size)
107            {
108                memcpy(to, from, sizeof(Uint16) * size);
109            }
110 mike  1.8  
111            inline void CopyToRaw(Sint16* to, const Sint16* from, Uint32 size)
112            {
113                memcpy(to, from, sizeof(Sint16) * size);
114            }
115            
116            inline void CopyToRaw(Uint32* to, const Uint32* from, Uint32 size)
117            {
118                memcpy(to, from, sizeof(Uint32) * size);
119            }
120            
121            inline void CopyToRaw(Sint32* to, const Sint32* from, Uint32 size)
122            {
123                memcpy(to, from, sizeof(Sint32) * size);
124            }
125            
126            inline void CopyToRaw(Uint64* to, const Uint64* from, Uint32 size)
127            {
128                memcpy(to, from, sizeof(Uint64) * size);
129            }
130            
131 mike  1.8  inline void CopyToRaw(Sint64* to, const Sint64* from, Uint32 size)
132            {
133                memcpy(to, from, sizeof(Sint64) * size);
134            }
135            
136            inline void CopyToRaw(Real32* to, const Real32* from, Uint32 size)
137            {
138                memcpy(to, from, sizeof(Real32) * size);
139            }
140            
141            inline void CopyToRaw(Real64* to, const Real64* from, Uint32 size)
142            {
143                memcpy(to, from, sizeof(Real64) * size);
144            }
145            
146            inline void CopyToRaw(Char16* to, const Char16* from, Uint32 size)
147            {
148                memcpy(to, from, sizeof(Char16) * size);
149            }
150            
151            template<class T>
152 mike  1.8  inline void InitializeRaw(T* items, Uint32 size)
153            {
154                while (size--)

155 kumpf 1.11     {
156            	new(items) T();
157            	items++;
158                }

159 mike  1.8  }
160            
161            #define PEGASUS_MEMORY_FUNCTIONS(T) \
162                inline void Destroy(T*, Uint32) { } \
163                inline void Destroy(T*) { } \
164                inline void InitializeRaw(T* items, Uint32 size) { Zeros(items, size); }
165            
166            PEGASUS_MEMORY_FUNCTIONS(char*)
167            PEGASUS_MEMORY_FUNCTIONS(const char*)
168            PEGASUS_MEMORY_FUNCTIONS(Boolean)
169            PEGASUS_MEMORY_FUNCTIONS(Uint8)
170            PEGASUS_MEMORY_FUNCTIONS(Sint8)
171            PEGASUS_MEMORY_FUNCTIONS(Uint16)
172            PEGASUS_MEMORY_FUNCTIONS(Sint16)
173            PEGASUS_MEMORY_FUNCTIONS(Uint32)
174            PEGASUS_MEMORY_FUNCTIONS(Sint32)
175            PEGASUS_MEMORY_FUNCTIONS(Uint64)
176            PEGASUS_MEMORY_FUNCTIONS(Sint64)
177            PEGASUS_MEMORY_FUNCTIONS(Real32)
178            PEGASUS_MEMORY_FUNCTIONS(Real64)
179            PEGASUS_MEMORY_FUNCTIONS(Char16)
180 mike  1.8  
181            PEGASUS_NAMESPACE_END
182            
183            #endif /* Pegasus_Memory_h */