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 keith.petley 1.15 #include <string>

 50 mike         1.8  #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                   {
 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 */