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, class U>
 70            inline void CopyToRaw(T* to, const U* from, Uint32 size)
 71            {
 72                while (size--)

 73 mike  1.9      {
 74            	// The following fails on TRU64:
 75            	//     new(to++) T(*from++);
 76            	// Probably a compiler error so I changed it to this:
 77            	// Mike Brasher
 78            
 79            	new(to) T(*from);
 80            	to++;
 81            	from++;
 82                }

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

149 kumpf 1.11     {
150            	new(items) T();
151            	items++;
152                }

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