(file) Return to CIMBuffer.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/CIMBuffer.cpp between version 1.4 and 1.5

version 1.4, 2008/11/13 22:15:03 version 1.5, 2008/11/25 19:27:27
Line 5 
Line 5 
 #include "CIMInstanceRep.h" #include "CIMInstanceRep.h"
 #include "CIMClassRep.h" #include "CIMClassRep.h"
 #include "CIMQualifierRep.h" #include "CIMQualifierRep.h"
   #include "CIMQualifierDeclRep.h"
 #include "CIMParameterRep.h" #include "CIMParameterRep.h"
 #include "CIMMethodRep.h" #include "CIMMethodRep.h"
 #include "CIMPropertyList.h" #include "CIMPropertyList.h"
Line 14 
Line 15 
 #include "CIMPropertyListRep.h" #include "CIMPropertyListRep.h"
 #include "StringRep.h" #include "StringRep.h"
 #include "CIMValueRep.h" #include "CIMValueRep.h"
   #include "StringRep.h"
   #include "StringInline.h"
   #include "Buffer.h"
   #include "BinaryCodec.h"
  
 #define INSTANCE_MAGIC 0xD6EF2219 #define INSTANCE_MAGIC 0xD6EF2219
 #define CLASS_MAGIC 0xA8D7DE41 #define CLASS_MAGIC 0xA8D7DE41
Line 24 
Line 29 
 #define PRESENT_MAGIC 0xF55A7330 #define PRESENT_MAGIC 0xF55A7330
 #define ABSENT_MAGIC 0x77A0A639 #define ABSENT_MAGIC 0x77A0A639
  
   #define FLAG_IS_NULL             (1 << 0)
   #define FLAG_IS_ARRAY            (1 << 1)
   #define FLAG_IS_PROPAGATED       (1 << 2)
   #define FLAG_HAS_CLASS_ORIGIN    (1 << 3)
   #define FLAG_HAS_REFERENCE_CLASS (1 << 4)
   #define FLAG_HAS_QUALIFIERS      (1 << 5)
   
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 CIMBuffer::CIMBuffer(size_t size)  static bool _validString(const Uint16* p, size_t n)
   {
       const Uint16* start = p;
   
       while (n >= 8 && ((p[0]|p[1]|p[2]|p[3]|p[4]|p[5]|p[6]|p[7]) & 0xFF80) == 0)
       {
           p += 8;
           n -= 8;
       }
   
       while (n >= 4 && ((p[0]|p[1]|p[2]|p[3]) & 0xFF80) == 0)
       {
           p += 4;
           n -= 4;
       }
   
       while (n)
       {
           Uint16 c = *p;
   
           if (c >= 128)
           {
               if (c == 0xFFFE || c == 0xFFFF || (c >= 0xFDD0 && c <= 0xFDEF))
                   return false;
   
               if (c >= 0xD800 && c <= 0xDBFF)
               {
                   if (n == 1 || !(p[1] >= 0xDC00 && p[1] <= 0xDFFF))
                       return false;
               }
   
               if (c >= 0xDC00 && c <= 0xDFFF)
               {
                   if (p == start || !(p[-1] >= 0xD800  && p[-1] <= 0xDBFF))
                       return false;
               }
           }
   
           n--;
           p++;
       }
   
       return true;
   }
   
   static inline bool _validName(const String& str)
   {
       if (str.size() == 0)
           return true;
   
       return CIMName::legal(str);
   }
   
   static inline bool _validNamespaceName(const String& str)
   {
       if (str.size() == 0)
           return true;
   
       return CIMNamespaceName::legal(str);
   }
   
   void CIMBuffer::_create(size_t size)
 { {
     if (size < 1024)     if (size < 1024)
         size = 1024;         size = 1024;
  
 #if defined(PEGASUS_TEST_VALGRIND) #if defined(PEGASUS_TEST_VALGRIND)
     // Valgrind complains that we leave uninitialized bytes in this buffer so     // Valgrind complains that we leave uninitialized bytes in this buffer so
     // we clear all newly allocated memory when testing with Valgrind.  
     _data = (char*)calloc(1, size);     _data = (char*)calloc(1, size);
 #else #else
     _data = (char*)malloc(size);     _data = (char*)malloc(size);
 #endif #endif
  
   #if defined(PEGASUS_DEBUG)
       memset(_data, 0xAA, size);
   #endif
   
     if (!_data)     if (!_data)
     {     {
         throw PEGASUS_STD(bad_alloc)();         throw PEGASUS_STD(bad_alloc)();
Line 50 
Line 126 
     _ptr = _data;     _ptr = _data;
 } }
  
   CIMBuffer::CIMBuffer(size_t size) : _swap(0), _validate(0)
   {
       _create(size);
   }
   
   CIMBuffer::CIMBuffer() : _data(0), _end(0), _ptr(0), _swap(0), _validate(0)
   {
   }
   
 CIMBuffer::~CIMBuffer() CIMBuffer::~CIMBuffer()
 { {
     free(_data);     free(_data);
Line 61 
Line 146 
     size_t m = _ptr - _data;     size_t m = _ptr - _data;
     size_t cap = n * 2;     size_t cap = n * 2;
  
       if (cap <= 4096)
           cap = 4096;
   
     // Double the size of the buffer (n * 2). If size is greater than n, then     // Double the size of the buffer (n * 2). If size is greater than n, then
     // we will need yet more space so we increment cap by size.     // we will need yet more space so we increment cap by size.
  
Line 76 
Line 164 
  
     _end = _data + cap;     _end = _data + cap;
     _ptr = _data + m;     _ptr = _data + m;
 #if defined(PEGASUS_TEST_VALGRIND)  
   #if defined(PEGASUS_DEBUG)
       memset(_ptr, 0xAA, _end - _ptr);
   #elif defined(PEGASUS_TEST_VALGRIND)
     // Valgrind complains that we leave uninitialized bytes in this buffer so     // Valgrind complains that we leave uninitialized bytes in this buffer so
     // we clear all newly allocated memory when testing with Valgrind.     // we clear all newly allocated memory when testing with Valgrind.
     memset(_ptr, 0, _end - _ptr);     memset(_ptr, 0, _end - _ptr);
 #endif #endif
   
 } }
  
 bool CIMBuffer::getString(String& x) bool CIMBuffer::getString(String& x)
Line 95 
Line 187 
     if (_end - _ptr < ptrdiff_t(r))     if (_end - _ptr < ptrdiff_t(r))
         return false;         return false;
  
     if (n)      if (_swap)
     {     {
         x.assign((Char16*)_ptr, n);          _swapUint16Data((Uint16*)_ptr, n);
     }     }
  
       if (_validate)
       {
           if (!_validString((Uint16*)_ptr, n))
               return false;
       }
   
       if (n)
           x.assign((Char16*)_ptr, n);
   
     _ptr += r;     _ptr += r;
     return true;     return true;
 } }
  
   bool CIMBuffer::getName(CIMName& x)
   {
       String tmp;
   
       if (_validate)
       {
           // Get string without validation since we will validate name below.
   
           _validate = false;
   
           if (!getString(tmp))
               return false;
   
           _validate = true;
   
           if (!_validName(tmp))
               return false;
       }
       else
       {
           if (!getString(tmp))
               return false;
       }
   
       x = CIMNameCast(tmp);
       return true;
   }
   
   bool CIMBuffer::getNamespaceName(CIMNamespaceName& x)
   {
       String tmp;
   
       if (_validate)
       {
           // Get string without validation since we will validate namespace below.
   
           _validate = false;
   
           if (!getString(tmp))
               return false;
   
           _validate = true;
   
           if (!_validNamespaceName(tmp))
               return false;
       }
       else
       {
           if (!getString(tmp))
               return false;
       }
   
       x = CIMNamespaceNameCast(tmp);
       return true;
   }
   
 void CIMBuffer::putValue(const CIMValue& x) void CIMBuffer::putValue(const CIMValue& x)
 { {
 #if defined(PEGASUS_USE_EMBEDDED_VALUES)  
     CIMValueRep* rep = ((CIMValueRep*)&x);  
 #else  
     CIMValueRep* rep = *((CIMValueRep**)&x);     CIMValueRep* rep = *((CIMValueRep**)&x);
 #endif  
  
     _putMagic(VALUE_MAGIC);      // Resolve null flag:
     putUint32(rep->type);  
     putBoolean(rep->isArray);      bool isNull = rep->isNull;
  
     if (rep->type == CIMTYPE_INSTANCE && !rep->isArray)      if (!isNull && rep->type == CIMTYPE_INSTANCE && !rep->isArray)
     {     {
         const CIMInstance& ci = *((CIMInstance*)rep->u._instanceValue);         const CIMInstance& ci = *((CIMInstance*)rep->u._instanceValue);
  
         if (ci.isUninitialized())         if (ci.isUninitialized())
         {         {
             putBoolean(rep->isNull);              isNull = true;
             return;  
         }         }
     }     }
  
     putBoolean(rep->isNull);      // Magic:
       _putMagic(VALUE_MAGIC);
   
       // Put flags:
       {
           Uint32 flags = 0;
   
           if (isNull)
               flags |= FLAG_IS_NULL;
   
           if (rep->isArray)
               flags |= FLAG_IS_ARRAY;
  
     if (rep->isNull)          putUint32(flags);
       }
   
       // Type:
       putUint32(rep->type);
   
       if (isNull)
         return;         return;
  
       // Put value:
   
     if (rep->isArray)     if (rep->isArray)
     {     {
         switch (rep->type)         switch (rep->type)
Line 183 
Line 354 
                     *(reinterpret_cast<Array<CIMObjectPath>*>(&rep->u)));                     *(reinterpret_cast<Array<CIMObjectPath>*>(&rep->u)));
                 break;                 break;
             case CIMTYPE_INSTANCE:             case CIMTYPE_INSTANCE:
                 putInstanceA(*(reinterpret_cast<Array<CIMInstance>*>(&rep->u)));                  putInstanceA(*(reinterpret_cast<Array<CIMInstance>*>(&rep->u)),
                       false, false);
                 break;                 break;
             case CIMTYPE_OBJECT:             case CIMTYPE_OBJECT:
                 putObjectA(*(reinterpret_cast<Array<CIMObject>*>(&rep->u)));                  putObjectA(*(reinterpret_cast<Array<CIMObject>*>(&rep->u)),
                       false, false);
                 break;                 break;
             default:             default:
                 PEGASUS_ASSERT(0);                 PEGASUS_ASSERT(0);
Line 243 
Line 416 
                 putObjectPath(*((CIMObjectPath*)rep->u._referenceValue));                 putObjectPath(*((CIMObjectPath*)rep->u._referenceValue));
                 break;                 break;
             case CIMTYPE_INSTANCE:             case CIMTYPE_INSTANCE:
                 putInstance(*((CIMInstance*)rep->u._instanceValue));                  putInstance(*((CIMInstance*)rep->u._instanceValue),false,false);
                 break;                 break;
             case CIMTYPE_OBJECT:             case CIMTYPE_OBJECT:
                 putObject(*((CIMObject*)rep->u._instanceValue));                  putObject(*((CIMObject*)rep->u._instanceValue), false, false);
                 break;                 break;
             default:             default:
                 PEGASUS_ASSERT(0);                 PEGASUS_ASSERT(0);
Line 258 
Line 431 
 bool CIMBuffer::getValue(CIMValue& x) bool CIMBuffer::getValue(CIMValue& x)
 { {
     Uint32 type;     Uint32 type;
     Boolean isArray;  
     Boolean isNull;     Boolean isNull;
       Boolean isArray;
  
       // Magic:
     if (!_testMagic(VALUE_MAGIC))     if (!_testMagic(VALUE_MAGIC))
         return false;         return false;
  
     if (!getUint32(type) || !getBoolean(isArray) || !getBoolean(isNull))      // Flags:
       Uint32 flags;
   
       if (!getUint32(flags))
           return false;
   
       isNull = flags & FLAG_IS_NULL;
       isArray = flags & FLAG_IS_ARRAY;
   
       // Type:
       if (!getUint32(type))
         return false;         return false;
  
     if (isNull)     if (isNull)
Line 571 
Line 755 
 void CIMBuffer::putKeyBinding(const CIMKeyBinding& x) void CIMBuffer::putKeyBinding(const CIMKeyBinding& x)
 { {
     const CIMKeyBindingRep* kb = *(const CIMKeyBindingRep**)&x;     const CIMKeyBindingRep* kb = *(const CIMKeyBindingRep**)&x;
     putString(kb->_name.getString());      putName(kb->_name);
     putString(kb->_value);     putString(kb->_value);
     putUint32(kb->_type);     putUint32(kb->_type);
 } }
  
 bool CIMBuffer::getKeyBinding(CIMKeyBinding& x) bool CIMBuffer::getKeyBinding(CIMKeyBinding& x)
 { {
     String name;      CIMName name;
     String value;     String value;
     Uint32 type;     Uint32 type;
  
     if (!getString(name) || !getString(value) || !getUint32(type))      if (!getName(name) || !getString(value) || !getUint32(type))
         return false;         return false;
  
     x.~CIMKeyBinding();     x.~CIMKeyBinding();
     new(&x) CIMKeyBinding(CIMNameCast(name), value, CIMKeyBinding::Type(type));      new(&x) CIMKeyBinding(name, value, CIMKeyBinding::Type(type));
  
     return true;     return true;
 } }
  
 void CIMBuffer::putObjectPath(const CIMObjectPath& x)  void CIMBuffer::putObjectPath(
       const CIMObjectPath& x,
       bool includeHostAndNamespace,
       bool includeKeyBindings)
 { {
     const CIMObjectPathRep* rep = *((const CIMObjectPathRep**)&x);     const CIMObjectPathRep* rep = *((const CIMObjectPathRep**)&x);
  
Line 605 
Line 792 
     else     else
         putBoolean(true);         putBoolean(true);
  
   
       if (includeHostAndNamespace)
       {
     putString(rep->_host);     putString(rep->_host);
     putString(rep->_nameSpace.getString());          putNamespaceName(rep->_nameSpace);
     putString(rep->_className.getString());      }
       else
       {
           putString(String());
           putString(String());
       }
   
       putName(rep->_className);
   
       if (includeKeyBindings)
       {
     putUint32(rep->_keyBindings.size());     putUint32(rep->_keyBindings.size());
  
     for (Uint32 i = 0, n = rep->_keyBindings.size(); i < n; i++)     for (Uint32 i = 0, n = rep->_keyBindings.size(); i < n; i++)
Line 615 
Line 815 
         putKeyBinding(rep->_keyBindings[i]);         putKeyBinding(rep->_keyBindings[i]);
     }     }
 } }
       else
           putUint32(0);
   }
  
 bool CIMBuffer::getObjectPath(CIMObjectPath& x) bool CIMBuffer::getObjectPath(CIMObjectPath& x)
 { {
     String host;     String host;
     String nameSpace;      CIMNamespaceName nameSpace;
     String className;      CIMName className;
     Uint32 size;     Uint32 size;
     Array<CIMKeyBinding> kbs;     Array<CIMKeyBinding> kbs;
  
Line 638 
Line 841 
         return true;         return true;
     }     }
  
     if (!getString(host) || !getString(nameSpace) || !getString(className))      if (!getString(host) || !getNamespaceName(nameSpace) || !getName(className))
         return false;         return false;
  
     if (!getUint32(size))     if (!getUint32(size))
Line 657 
Line 860 
     x.set(     x.set(
         host,         host,
         *(reinterpret_cast<CIMNamespaceName*>(&nameSpace)),         *(reinterpret_cast<CIMNamespaceName*>(&nameSpace)),
         CIMNameCast(className),          className,
         kbs);         kbs);
  
     return true;     return true;
Line 667 
Line 870 
 { {
     const CIMQualifierRep* rep = *((const CIMQualifierRep**)&x);     const CIMQualifierRep* rep = *((const CIMQualifierRep**)&x);
  
     putString(rep->_name.getString());      putName(rep->_name);
     putValue(rep->_value);     putValue(rep->_value);
     putUint32(*((Uint32*)&rep->_flavor));     putUint32(*((Uint32*)&rep->_flavor));
     putBoolean(rep->_propagated);     putBoolean(rep->_propagated);
Line 675 
Line 878 
  
 bool CIMBuffer::getQualifier(CIMQualifier& x) bool CIMBuffer::getQualifier(CIMQualifier& x)
 { {
     String name;      CIMName name;
     CIMValue value;     CIMValue value;
     Uint32 flavor;     Uint32 flavor;
     Boolean propagated;     Boolean propagated;
  
     if (!getString(name))      if (!getName(name))
         return false;         return false;
  
     if (!getValue(value))     if (!getValue(value))
Line 695 
Line 898 
     x.~CIMQualifier();     x.~CIMQualifier();
  
     new(&x) CIMQualifier(     new(&x) CIMQualifier(
         CIMNameCast(name),          name,
         value,         value,
         *(reinterpret_cast<CIMFlavor*>(&flavor)),         *(reinterpret_cast<CIMFlavor*>(&flavor)),
         propagated);         propagated);
Line 732 
Line 935 
     return true;     return true;
 } }
  
   void CIMBuffer::putQualifierDecl(const CIMQualifierDecl& x)
   {
       const CIMQualifierDeclRep* rep = *((const CIMQualifierDeclRep**)&x);
   
       putName(rep->_name);
       putValue(rep->_value);
       putUint32(*((Uint32*)&rep->_scope));
       putUint32(*((Uint32*)&rep->_flavor));
       putUint32(rep->_arraySize);
   }
   
   bool CIMBuffer::getQualifierDecl(CIMQualifierDecl& x)
   {
       CIMName name;
       CIMValue value;
       Uint32 scope;
       Uint32 flavor;
       Uint32 arraySize;
   
       if (!getName(name))
           return false;
   
       if (!getValue(value))
           return false;
   
       if (!getUint32(scope))
           return false;
   
       if (!getUint32(flavor))
           return false;
   
       if (!getUint32(arraySize))
           return false;
   
       x.~CIMQualifierDecl();
   
       new(&x) CIMQualifierDecl(
           name,
           value,
           *(reinterpret_cast<CIMScope*>(&scope)),
           *(reinterpret_cast<CIMFlavor*>(&flavor)),
           arraySize);
   
       return true;
   }
   
 void CIMBuffer::putProperty(const CIMProperty& x) void CIMBuffer::putProperty(const CIMProperty& x)
 { {
     const CIMPropertyRep* rep = *((const CIMPropertyRep**)&x);     const CIMPropertyRep* rep = *((const CIMPropertyRep**)&x);
   
     // PROPERTY_MAGIC     // PROPERTY_MAGIC
     _putMagic(PROPERTY_MAGIC);     _putMagic(PROPERTY_MAGIC);
  
       // Flags
       Uint32 flags = 0;
       {
           // CIMProperty.arraySize
           if (rep->_arraySize)
           {
               flags |= FLAG_IS_ARRAY;
           }
   
           // CIMProperty.referenceClassName
           if (rep->_referenceClassName.getString().size())
           {
               flags |= FLAG_HAS_REFERENCE_CLASS;
           }
   
           // CIMProperty.classOrigin
           if (rep->_classOrigin.getString().size())
           {
               flags |= FLAG_HAS_CLASS_ORIGIN;
           }
   
           // CIMProperty.propagated
           if (rep->_propagated)
           {
               flags |= FLAG_IS_PROPAGATED;
           }
   
           // CIMProperty.qualifiers
           if (rep->_qualifiers.getCount())
           {
               flags |= FLAG_HAS_QUALIFIERS;
           }
   
           putUint32(flags);
       }
   
     // CIMProperty.name     // CIMProperty.name
     putString(rep->_name.getString());      putName(rep->_name);
  
     // CIMProperty.value     // CIMProperty.value
     putValue(rep->_value);     putValue(rep->_value);
  
     // CIMProperty.arraySize     // CIMProperty.arraySize
       if (flags & FLAG_IS_ARRAY)
       {
     putUint32(rep->_arraySize);     putUint32(rep->_arraySize);
       }
  
     // CIMProperty.referenceClassName     // CIMProperty.referenceClassName
     putString(rep->_referenceClassName.getString());      if (flags & FLAG_HAS_REFERENCE_CLASS)
       {
           putName(rep->_referenceClassName);
       }
  
     // CIMProperty.classOrigin     // CIMProperty.classOrigin
     putString(rep->_classOrigin.getString());      if (flags & FLAG_HAS_CLASS_ORIGIN)
       {
     // CIMProperty.propagated          putName(rep->_classOrigin);
     putBoolean(rep->_propagated);      }
  
     // CIMProperty.qualifiers     // CIMProperty.qualifiers
       if (flags & FLAG_HAS_QUALIFIERS)
       {
     putQualifierList(rep->_qualifiers);     putQualifierList(rep->_qualifiers);
           flags |= FLAG_HAS_QUALIFIERS;
       }
 } }
  
 bool CIMBuffer::getProperty(CIMProperty& x) bool CIMBuffer::getProperty(CIMProperty& x)
 { {
     String name;      CIMName name;
     CIMValue value;     CIMValue value;
     Uint32 arraySize;     Uint32 arraySize;
     String referenceClassName;      CIMName referenceClassName;
     String classOrigin;      CIMName classOrigin;
     Boolean propagated;     Boolean propagated;
  
     if (!_testMagic(PROPERTY_MAGIC))     if (!_testMagic(PROPERTY_MAGIC))
         return false;         return false;
  
       // Flags:
       Uint32 flags;
   
       if (!getUint32(flags))
           return false;
   
     // CIMProperty.name     // CIMProperty.name
     if (!getString(name))      if (!getName(name))
         return false;         return false;
  
     // CIMProperty.value     // CIMProperty.value
Line 782 
Line 1082 
         return false;         return false;
  
     // CIMProperty.arraySize     // CIMProperty.arraySize
   
       if (flags & FLAG_IS_ARRAY)
       {
     if (!getUint32(arraySize))     if (!getUint32(arraySize))
         return false;         return false;
       }
       else
           arraySize = 0;
  
     // CIMProperty.referenceClassName     // CIMProperty.referenceClassName
     if (!getString(referenceClassName))  
       if (flags & FLAG_HAS_REFERENCE_CLASS)
       {
           if (!getName(referenceClassName))
         return false;         return false;
       }
  
     // CIMProperty.classOrigin     // CIMProperty.classOrigin
     if (!getString(classOrigin))  
       if (flags & FLAG_HAS_CLASS_ORIGIN)
       {
           if (!getName(classOrigin))
         return false;         return false;
       }
  
     // CIMProperty.propagated     // CIMProperty.propagated
     if (!getBoolean(propagated))      propagated = flags & FLAG_IS_PROPAGATED;
         return false;  
       // Create property:
  
     x.~CIMProperty();     x.~CIMProperty();
  
     new(&x) CIMProperty(     new(&x) CIMProperty(
         CIMNameCast(name),          name,
         value,         value,
         arraySize,         arraySize,
         CIMNameCast(referenceClassName),          referenceClassName,
         CIMNameCast(classOrigin),          classOrigin,
         propagated);         propagated);
  
     CIMPropertyRep* rep = *((CIMPropertyRep**)&x);     CIMPropertyRep* rep = *((CIMPropertyRep**)&x);
  
     // CIMProperty.qualifiers     // CIMProperty.qualifiers
   
       if (flags & FLAG_HAS_QUALIFIERS)
       {
     if (!getQualifierList(rep->_qualifiers))     if (!getQualifierList(rep->_qualifiers))
         return false;         return false;
       }
  
     return true;     return true;
 } }
  
 void CIMBuffer::putInstance(const CIMInstance& x)  void CIMBuffer::putInstance(
       const CIMInstance& x,
       bool includeHostAndNamespace,
       bool includeKeyBindings)
 { {
     const CIMInstanceRep* rep = *((const CIMInstanceRep**)&x);     const CIMInstanceRep* rep = *((const CIMInstanceRep**)&x);
  
Line 834 
Line 1156 
         putBoolean(true);         putBoolean(true);
  
     // CIMInstance.reference:     // CIMInstance.reference:
     putObjectPath(rep->_reference);      putObjectPath(rep->_reference, includeHostAndNamespace, includeKeyBindings);
  
     // CIMInstance.qualifiers:     // CIMInstance.qualifiers:
     putQualifierList(rep->_qualifiers);     putQualifierList(rep->_qualifiers);
Line 937 
Line 1259 
     putObjectPath(rep->_reference);     putObjectPath(rep->_reference);
  
     // CIMClass.superClassName:     // CIMClass.superClassName:
     putString(rep->_superClassName.getString());      putName(rep->_superClassName);
  
     // CIMClass.qualifiers:     // CIMClass.qualifiers:
     putQualifierList(rep->_qualifiers);     putQualifierList(rep->_qualifiers);
Line 964 
Line 1286 
 bool CIMBuffer::getClass(CIMClass& x) bool CIMBuffer::getClass(CIMClass& x)
 { {
     CIMClassRep* rep;     CIMClassRep* rep;
     String className;      CIMName superClassName;
     String superClassName;  
  
     // CLASS_MAGIC:     // CLASS_MAGIC:
  
Line 994 
Line 1315 
  
     // CIMIntsance.superClassName:     // CIMIntsance.superClassName:
  
     if (!getString(superClassName))      if (!getName(superClassName))
         return false;         return false;
  
     rep = new CIMClassRep(reference.getClassName(),     rep = new CIMClassRep(reference.getClassName(),
         CIMNameCast(superClassName));          superClassName);
  
     rep->_reference = reference;     rep->_reference = reference;
  
Line 1059 
Line 1380 
     const CIMParameterRep* rep = *((const CIMParameterRep**)&x);     const CIMParameterRep* rep = *((const CIMParameterRep**)&x);
  
     // CIMParameter.name     // CIMParameter.name
     putString(rep->_name.getString());      putName(rep->_name);
  
     // CIMParameter.type     // CIMParameter.type
     putUint32(rep->_type);     putUint32(rep->_type);
Line 1071 
Line 1392 
     putUint32(rep->_arraySize);     putUint32(rep->_arraySize);
  
     // CIMParameter.referenceClassName     // CIMParameter.referenceClassName
     putString(rep->_referenceClassName.getString());      putName(rep->_referenceClassName);
  
     // CIMParameter.qualifiers     // CIMParameter.qualifiers
     putQualifierList(rep->_qualifiers);     putQualifierList(rep->_qualifiers);
Line 1079 
Line 1400 
  
 bool CIMBuffer::getParameter(CIMParameter& x) bool CIMBuffer::getParameter(CIMParameter& x)
 { {
     String name;      CIMName name;
     Uint32 type;     Uint32 type;
     Boolean isArray;     Boolean isArray;
     Uint32 arraySize;     Uint32 arraySize;
     String referenceClassName;      CIMName referenceClassName;
  
     // CIMParameter.name     // CIMParameter.name
     if (!getString(name))      if (!getName(name))
         return false;         return false;
  
     // CIMParameter.type     // CIMParameter.type
Line 1102 
Line 1423 
         return false;         return false;
  
     // CIMParameter.referenceClassName     // CIMParameter.referenceClassName
     if (!getString(referenceClassName))      if (!getName(referenceClassName))
         return false;         return false;
  
     x.~CIMParameter();     x.~CIMParameter();
  
     new(&x) CIMParameter(     new(&x) CIMParameter(
         CIMNameCast(name),          name,
         CIMType(type),         CIMType(type),
         isArray,         isArray,
         arraySize,         arraySize,
         CIMNameCast(referenceClassName));          referenceClassName);
  
     CIMParameterRep* rep = *((CIMParameterRep**)&x);     CIMParameterRep* rep = *((CIMParameterRep**)&x);
  
Line 1128 
Line 1449 
     const CIMMethodRep* rep = *((const CIMMethodRep**)&x);     const CIMMethodRep* rep = *((const CIMMethodRep**)&x);
  
     // CIMParameter.name     // CIMParameter.name
     putString(rep->_name.getString());      putName(rep->_name);
  
     // CIMParameter.type     // CIMParameter.type
     putUint32(rep->_type);     putUint32(rep->_type);
  
     // CIMProperty.classOrigin     // CIMProperty.classOrigin
     putString(rep->_classOrigin.getString());      putName(rep->_classOrigin);
  
     // CIMProperty.propagated     // CIMProperty.propagated
     putBoolean(rep->_propagated);     putBoolean(rep->_propagated);
Line 1155 
Line 1476 
 bool CIMBuffer::getMethod(CIMMethod& x) bool CIMBuffer::getMethod(CIMMethod& x)
 { {
     CIMMethodRep* rep;     CIMMethodRep* rep;
       CIMName name;
     String name;  
     Uint32 type;     Uint32 type;
     String classOrigin;      CIMName classOrigin;
     Boolean propagated;     Boolean propagated;
  
     // CIMMethod.name     // CIMMethod.name
     if (!getString(name))      if (!getName(name))
         return false;         return false;
  
     // CIMMethod.type     // CIMMethod.type
Line 1170 
Line 1490 
         return false;         return false;
  
     // CIMParameter.classOrigin     // CIMParameter.classOrigin
     if (!getString(classOrigin))      if (!getName(classOrigin))
         return false;         return false;
  
     // CIMParameter.propagated     // CIMParameter.propagated
     if (!getBoolean(propagated))     if (!getBoolean(propagated))
         return false;         return false;
  
     rep = new CIMMethodRep(name, CIMType(type), classOrigin, propagated);      rep = new CIMMethodRep(
           name, CIMType(type), classOrigin, propagated);
  
     // CIMMethod.qualifiers:     // CIMMethod.qualifiers:
     if (!getQualifierList(rep->_qualifiers))     if (!getQualifierList(rep->_qualifiers))
Line 1225 
Line 1546 
         putUint32(n);         putUint32(n);
  
         for (Uint32 i = 0; i < n; i++)         for (Uint32 i = 0; i < n; i++)
             putString(rep->propertyNames[i].getString());              putName(rep->propertyNames[i]);
     }     }
 } }
  
Line 1252 
Line 1573 
  
         for (Uint32 i = 0; i < n; i++)         for (Uint32 i = 0; i < n; i++)
         {         {
             String name;              CIMName name;
  
             if (!getString(name))              if (!getName(name))
                 return false;                 return false;
  
             names.append(CIMNameCast(name));              names.append(name);
         }         }
  
         x.~CIMPropertyList();         x.~CIMPropertyList();
Line 1267 
Line 1588 
     return true;     return true;
 } }
  
 void CIMBuffer::putObject(const CIMObject& x)  void CIMBuffer::putObject(
       const CIMObject& x,
       bool includeHostAndNamespace,
       bool includeKeyBindings)
 { {
     _putMagic(OBJECT_MAGIC);     _putMagic(OBJECT_MAGIC);
  
Line 1282 
Line 1606 
     if (x.isInstance())     if (x.isInstance())
     {     {
         putUint8('I');         putUint8('I');
         putInstance(CIMInstance(x));          putInstance(
               CIMInstance(x), includeHostAndNamespace, includeKeyBindings);
     }     }
     else     else
     {     {
Line 1405 
Line 1730 
     return false;     return false;
 } }
  
   void CIMBuffer::putInstanceA(
       const Array<CIMInstance>& x,
       bool includeHostAndNamespace,
       bool includeKeyBindings)
   {
       Uint32 n = x.size();
       putUint32(n);
   
       for (size_t i = 0; i < n; i++)
           putInstance(x[i], includeHostAndNamespace, includeKeyBindings);
   }
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.4  
changed lines
  Added in v.1.5
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2