(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.3 and 1.10

version 1.3, 2008/11/13 19:39:17 version 1.10, 2011/01/07 02:17:20
Line 1 
Line 1 
   //%LICENSE////////////////////////////////////////////////////////////////
   //
   // Licensed to The Open Group (TOG) under one or more contributor license
   // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
   // this work for additional information regarding copyright ownership.
   // Each contributor licenses this file to you under the OpenPegasus Open
   // Source License; you may not use this file except in compliance with the
   // License.
   //
   // Permission is hereby granted, free of charge, to any person obtaining a
   // copy of this software and associated documentation files (the "Software"),
   // to deal in the Software without restriction, including without limitation
   // the rights to use, copy, modify, merge, publish, distribute, sublicense,
   // and/or sell copies of the Software, and to permit persons to whom the
   // Software is furnished to do so, subject to the following conditions:
   //
   // The above copyright notice and this permission notice shall be included
   // in all copies or substantial portions of the Software.
   //
   // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
   // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
   // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   //
   //////////////////////////////////////////////////////////////////////////
 #include <stdlib.h> #include <stdlib.h>
 #include "Sharable.h" #include "Sharable.h"
 #include "CIMBuffer.h" #include "CIMBuffer.h"
Line 5 
Line 33 
 #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 43 
 #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 "SCMOStreamer.h"
  
 #define INSTANCE_MAGIC 0xD6EF2219 #define INSTANCE_MAGIC 0xD6EF2219
 #define CLASS_MAGIC 0xA8D7DE41 #define CLASS_MAGIC 0xA8D7DE41
Line 24 
Line 57 
 #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 154 
     _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 174 
     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 192 
  
     _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 215 
     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 and 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 (rep->isNull)          if (isNull)
               flags |= FLAG_IS_NULL;
   
           if (rep->isArray)
               flags |= FLAG_IS_ARRAY;
   
           putUint32(flags);
       }
   
       // Type:
       putUint32(rep->type);
   
       if (isNull)
         return;         return;
  
       // Put value:
   
     if (rep->isArray)     if (rep->isArray)
     {     {
         switch (rep->type)         switch (rep->type)
         {         {
             case CIMTYPE_BOOLEAN:             case CIMTYPE_BOOLEAN:
                 putBooleanA(*((Array<Boolean>*)&rep->u));                  putBooleanA(*(reinterpret_cast<Array<Boolean>*>(&rep->u)));
                 break;                 break;
             case CIMTYPE_UINT8:             case CIMTYPE_UINT8:
                 putUint8A(*((Array<Uint8>*)&rep->u));                  putUint8A(*(reinterpret_cast<Array<Uint8>*>(&rep->u)));
                 break;                 break;
             case CIMTYPE_SINT8:             case CIMTYPE_SINT8:
                 putSint8A(*((Array<Sint8>*)&rep->u));                  putSint8A(*(reinterpret_cast<Array<Sint8>*>(&rep->u)));
                 break;                 break;
             case CIMTYPE_UINT16:             case CIMTYPE_UINT16:
                 putUint16A(*((Array<Uint16>*)&rep->u));                  putUint16A(*(reinterpret_cast<Array<Uint16>*>(&rep->u)));
                 break;                 break;
             case CIMTYPE_SINT16:             case CIMTYPE_SINT16:
                 putSint16A(*((Array<Sint16>*)&rep->u));                  putSint16A(*(reinterpret_cast<Array<Sint16>*>(&rep->u)));
                 break;                 break;
             case CIMTYPE_UINT32:             case CIMTYPE_UINT32:
                 putUint32A(*((Array<Uint32>*)&rep->u));                  putUint32A(*(reinterpret_cast<Array<Uint32>*>(&rep->u)));
                 break;                 break;
             case CIMTYPE_SINT32:             case CIMTYPE_SINT32:
                 putSint32A(*((Array<Sint32>*)&rep->u));                  putSint32A(*(reinterpret_cast<Array<Sint32>*>(&rep->u)));
                 break;                 break;
             case CIMTYPE_UINT64:             case CIMTYPE_UINT64:
                 putUint64A(*((Array<Uint64>*)&rep->u));                  putUint64A(*(reinterpret_cast<Array<Uint64>*>(&rep->u)));
                 break;                 break;
             case CIMTYPE_SINT64:             case CIMTYPE_SINT64:
                 putSint64A(*((Array<Sint64>*)&rep->u));                  putSint64A(*(reinterpret_cast<Array<Sint64>*>(&rep->u)));
                 break;                 break;
             case CIMTYPE_REAL32:             case CIMTYPE_REAL32:
                 putReal32A(*((Array<Real32>*)&rep->u));                  putReal32A(*(reinterpret_cast<Array<Real32>*>(&rep->u)));
                 break;                 break;
             case CIMTYPE_REAL64:             case CIMTYPE_REAL64:
                 putReal64A(*((Array<Real64>*)&rep->u));                  putReal64A(*(reinterpret_cast<Array<Real64>*>(&rep->u)));
                 break;                 break;
             case CIMTYPE_CHAR16:             case CIMTYPE_CHAR16:
                 putChar16A(*((Array<Char16>*)&rep->u));                  putChar16A(*(reinterpret_cast<Array<Char16>*>(&rep->u)));
                 break;                 break;
             case CIMTYPE_STRING:             case CIMTYPE_STRING:
                 putStringA(*((Array<String>*)&rep->u));                  putStringA(*(reinterpret_cast<Array<String>*>(&rep->u)));
                 break;                 break;
             case CIMTYPE_DATETIME:             case CIMTYPE_DATETIME:
                 putDateTimeA(*((Array<CIMDateTime>*)&rep->u));                  putDateTimeA(*(reinterpret_cast<Array<CIMDateTime>*>(&rep->u)));
                 break;                 break;
             case CIMTYPE_REFERENCE:             case CIMTYPE_REFERENCE:
                 putObjectPathA(*((Array<CIMObjectPath>*)&rep->u));                  putObjectPathA(
                       *(reinterpret_cast<Array<CIMObjectPath>*>(&rep->u)));
                 break;                 break;
             case CIMTYPE_INSTANCE:             case CIMTYPE_INSTANCE:
                 putInstanceA(*((Array<CIMInstance>*)&rep->u));                  putInstanceA(*(reinterpret_cast<Array<CIMInstance>*>(&rep->u)),
                       false, false);
                 break;                 break;
             case CIMTYPE_OBJECT:             case CIMTYPE_OBJECT:
                 putObjectA(*((Array<CIMObject>*)&rep->u));                  putObjectA(*(reinterpret_cast<Array<CIMObject>*>(&rep->u)),
                       false, false);
                 break;                 break;
             default:             default:
                 PEGASUS_ASSERT(0);                 PEGASUS_ASSERT(0);
Line 242 
Line 444 
                 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 257 
Line 459 
 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 570 
Line 783 
 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 604 
Line 820 
     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 614 
Line 843 
         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 637 
Line 869 
         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 653 
Line 885 
         kbs.append(kb);         kbs.append(kb);
     }     }
  
     x.set(host, *((CIMNamespaceName*)&nameSpace), _CIMNameCast(className), kbs);      x.set(
           host,
           *(reinterpret_cast<CIMNamespaceName*>(&nameSpace)),
           className,
           kbs);
  
     return true;     return true;
 } }
Line 662 
Line 898 
 { {
     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 670 
Line 906 
  
 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 690 
Line 926 
     x.~CIMQualifier();     x.~CIMQualifier();
  
     new(&x) CIMQualifier(     new(&x) CIMQualifier(
         _CIMNameCast(name),          name,
         value,         value,
         *((CIMFlavor*)&flavor),          *(reinterpret_cast<CIMFlavor*>(&flavor)),
         propagated);         propagated);
  
     return true;     return true;
Line 727 
Line 963 
     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 777 
Line 1110 
         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 829 
Line 1184 
         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 932 
Line 1287 
     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 959 
Line 1314 
 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 989 
Line 1343 
  
     // 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 1054 
Line 1408 
     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 1066 
Line 1420 
     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 1074 
Line 1428 
  
 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 1097 
Line 1451 
         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 1123 
Line 1477 
     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 1150 
Line 1504 
 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 1165 
Line 1518 
         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 1220 
Line 1574 
         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 1247 
Line 1601 
  
         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 1262 
Line 1616 
     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 1277 
Line 1634 
     if (x.isInstance())     if (x.isInstance())
     {     {
         putUint8('I');         putUint8('I');
         putInstance(CIMInstance(x));          putInstance(
               CIMInstance(x), includeHostAndNamespace, includeKeyBindings);
     }     }
     else     else
     {     {
Line 1400 
Line 1758 
     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);
   }
   
   
   void CIMBuffer::putSCMOClass(const SCMOClass& scmoClass)
   {
       SCMOStreamer::serializeClass(*this, scmoClass);
   }
   
   bool CIMBuffer::getSCMOClass(SCMOClass& scmoClass)
   {
       return SCMOStreamer::deserializeClass(*this, scmoClass);
   }
   
   
   void CIMBuffer::putSCMOInstanceA(Array<SCMOInstance>& x)
   {
       Uint32 n = x.size();
       _grow(n<<13);
   
       putUint32(n);
   
   
       SCMOStreamer scmoStreamer(*this,x);
       scmoStreamer.serialize();
   }
   
   bool CIMBuffer::getSCMOInstanceA(Array<SCMOInstance>& x)
   {
       Uint32 n;
   
       if (!getUint32(n))
           return false;
   
       SCMOStreamer scmoStreamer(*this,x);
       return scmoStreamer.deserialize();
   }
   
   
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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