1 mike  1.8 //%/////////////////////////////////////////////////////////////////////////////
  2           //

  3 kumpf 1.14 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
  4            // The Open Group, Tivoli Systems

  5 mike  1.8  //
  6            // Permission is hereby granted, free of charge, to any person obtaining a copy

  7 kumpf 1.14 // of this software and associated documentation files (the "Software"), to
  8            // deal in the Software without restriction, including without limitation the
  9            // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

 10 mike  1.8  // sell copies of the Software, and to permit persons to whom the Software is
 11            // furnished to do so, subject to the following conditions:
 12            // 

 13 kumpf 1.14 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

 14 mike  1.8  // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
 15            // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

 16 kumpf 1.14 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 17            // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 18            // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

 19 mike  1.8  // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 20            // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 21            //
 22            //==============================================================================
 23            //
 24            // Author: Mike Brasher (mbrasher@bmc.com)
 25            //
 26            // Modified By:
 27            //
 28            //%/////////////////////////////////////////////////////////////////////////////
 29            
 30            ////////////////////////////////////////////////////////////////////////////////
 31            //
 32            // Memory.h
 33            //

 34 kumpf 1.13 //      This file contains assorted memory-oriented routines:

 35 mike  1.8  //

 36 kumpf 1.13 //          Zeros(): fills memory with zeros.
 37            //          Destroy(): destructs multiple objects in contiguous memory.
 38            //          CopyToRaw(): copies multiple objects to raw memory.
 39            //          InitializeRaw(): default constructs mulitple object over raw memory.

 40 mike  1.8  //

 41 kumpf 1.13 //      Each of these is a template but specializations are provide for
 42            //      efficiency (which in some cases removes uncessary loops).

 43 mike  1.8  //
 44            ////////////////////////////////////////////////////////////////////////////////
 45            
 46            #ifndef Pegasus_Memory_h
 47            #define Pegasus_Memory_h
 48            
 49            #include <cstring>
 50            #include <Pegasus/Common/Config.h>
 51            #include <Pegasus/Common/CIMType.h>
 52            #include <Pegasus/Common/Char16.h>
 53            
 54            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 mike  1.8  {
 65                while (size--)

 66 kumpf 1.13         items++->~T();

 67 mike  1.8  }
 68            

 69 kumpf 1.13 template<class T>
 70            inline void CopyToRaw(T* to, const T* from, Uint32 size)

 71 mike  1.8  {
 72                while (size--)

 73 mike  1.9      {

 74 kumpf 1.13         // 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 mike  1.9      }

 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 kumpf 1.13         new(items) T();
151                    items++;

152 kumpf 1.11     }

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