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

Diff for /pegasus/src/Pegasus/Common/CIMValue.cpp between version 1.46 and 1.49.4.1

version 1.46, 2004/04/27 19:23:27 version 1.49.4.1, 2004/11/12 17:48:28
Line 29 
Line 29 
 //              Karl Schopmeyer, (k.schopmeyer@opengroup.org) //              Karl Schopmeyer, (k.schopmeyer@opengroup.org)
 //              Carol Ann Krug Graves, Hewlett-Packard Company //              Carol Ann Krug Graves, Hewlett-Packard Company
 //                (carolann_graves@hp.com) //                (carolann_graves@hp.com)
   //              Adriann Schuur (schuur@de.ibm.com) PEP 164
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 41 
Line 42 
 #include "XmlWriter.h" #include "XmlWriter.h"
 #include "CommonUTF.h" #include "CommonUTF.h"
  
   #include "CIMValueRep.h"
   
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 #define PEGASUS_ARRAY_T CIMValue #define PEGASUS_ARRAY_T CIMValue
Line 111 
Line 114 
     out << x.toString();     out << x.toString();
 } }
  
   inline void _toString(Array<Sint8>& out, const CIMObject& x)
   {
       out << x.toString();
   }
   
 template<class T> template<class T>
 void _toString(Array<Sint8>& out, const T* p, Uint32 size) void _toString(Array<Sint8>& out, const T* p, Uint32 size)
 { {
Line 124 
Line 132 
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
 // CIMValueRep  
 //  
 ////////////////////////////////////////////////////////////////////////////////  
   
 class CIMValueRep  
 {  
 public:  
     CIMValueRep()  
     {  
         reset();  
     }  
   
     ~CIMValueRep()  
     {  
     }  
   
     void reset()  
     {  
         _type = CIMTYPE_BOOLEAN;  
         _isArray = false;  
         _isNull = true;  
         _u._booleanValue = false;  
     }  
   
     CIMType _type;  
     Boolean _isArray;  
     Boolean _isNull;  
     Union _u;  
 };  
   
   
 ////////////////////////////////////////////////////////////////////////////////  
 //  
 // CIMValue // CIMValue
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
Line 262 
Line 237 
     set(x);     set(x);
 } }
  
   CIMValue::CIMValue(const CIMObject& x)
   {
       _rep = new CIMValueRep();
       set(x);
   }
   
 CIMValue::CIMValue(const Array<Boolean>& x) CIMValue::CIMValue(const Array<Boolean>& x)
 { {
     _rep = new CIMValueRep();     _rep = new CIMValueRep();
Line 352 
Line 333 
     set(x);     set(x);
 } }
  
   CIMValue::CIMValue(const Array<CIMObject>& x)
   {
       _rep = new CIMValueRep();
       set(x);
   }
   
 CIMValue::CIMValue(const CIMValue& x) CIMValue::CIMValue(const CIMValue& x)
 { {
     _rep = new CIMValueRep();     _rep = new CIMValueRep();
Line 460 
Line 447 
                     new Array<CIMObjectPath>(*(x._rep->_u._referenceArray));                     new Array<CIMObjectPath>(*(x._rep->_u._referenceArray));
                 break;                 break;
  
           case CIMTYPE_OBJECT:
                   _rep->_u._cimobjectArray =
                       new Array<CIMObject>(*(x._rep->_u._cimobjectArray));
                   break;
   
             default:             default:
                 PEGASUS_ASSERT(false);                 PEGASUS_ASSERT(false);
         }         }
Line 530 
Line 522 
                     new CIMObjectPath(*(x._rep->_u._referenceValue));                     new CIMObjectPath(*(x._rep->_u._referenceValue));
                 break;                 break;
  
               case CIMTYPE_OBJECT:
                   _rep->_u._cimobjectValue =
                       new CIMObject(x._rep->_u._cimobjectValue->clone());
                   break;
   
             // Should never get here. testing complete enum             // Should never get here. testing complete enum
             default:             default:
                 PEGASUS_ASSERT(false);                 PEGASUS_ASSERT(false);
Line 603 
Line 600 
                 delete _rep->_u._referenceArray;                 delete _rep->_u._referenceArray;
                 break;                 break;
  
               case CIMTYPE_OBJECT:
                   delete _rep->_u._cimobjectArray;
                   break;
   
             default:             default:
                 PEGASUS_ASSERT(false);                 PEGASUS_ASSERT(false);
         }         }
Line 637 
Line 638 
                 delete _rep->_u._referenceValue;                 delete _rep->_u._referenceValue;
                 break;                 break;
  
               case CIMTYPE_OBJECT:
                   delete _rep->_u._cimobjectValue;
                   break;
   
             default:             default:
                 PEGASUS_ASSERT(false);                 PEGASUS_ASSERT(false);
         }         }
Line 729 
Line 734 
             return _rep->_u._referenceArray->size();             return _rep->_u._referenceArray->size();
             break;             break;
  
           case CIMTYPE_OBJECT:
               return _rep->_u._cimobjectArray->size();
               break;
   
         //default:  // Handled below         //default:  // Handled below
     }     }
  
Line 810 
Line 819 
                 set(Array<CIMObjectPath>(arraySize));                 set(Array<CIMObjectPath>(arraySize));
                 break;                 break;
  
               case CIMTYPE_OBJECT:
                   set(Array<CIMObject>(arraySize));
                   break;
   
             default:             default:
                 throw TypeMismatchException();                 throw TypeMismatchException();
         }         }
Line 878 
Line 891 
                 set(CIMObjectPath());                 set(CIMObjectPath());
                 break;                 break;
  
               case CIMTYPE_OBJECT:
                   set(CIMObject());
                   break;
   
             default:             default:
                 throw TypeMismatchException();                 throw TypeMismatchException();
         }         }
Line 1009 
Line 1026 
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
  
   void CIMValue::set(const CIMObject& x)
   {
       clear();
       if (x.isUninitialized()) {
           // Don't need to clone since null CIMObjects aren't shared when created.
           // Doesn't work anyway, clone() throws an exception if null.
           _rep->_u._cimobjectValue = new CIMObject(x);
       }
       else {
           _rep->_u._cimobjectValue = new CIMObject(x.clone());
       }
       _rep->_type = CIMTYPE_OBJECT;
       _rep->_isNull = false;
   }
   
 void CIMValue::set(const Array<Boolean>& x) void CIMValue::set(const Array<Boolean>& x)
 { {
     clear();     clear();
Line 1144 
Line 1176 
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
  
   void CIMValue::set(const Array<CIMObject>& x)
   {
       clear();
       _rep->_u._cimobjectArray = new Array<CIMObject>(x);
       _rep->_type = CIMTYPE_OBJECT;
       _rep->_isArray = true;
       _rep->_isNull = false;
   }
   
 void CIMValue::get(Boolean& x) const void CIMValue::get(Boolean& x) const
 { {
     if (_rep->_type != CIMTYPE_BOOLEAN || _rep->_isArray)     if (_rep->_type != CIMTYPE_BOOLEAN || _rep->_isArray)
Line 1279 
Line 1320 
         x = *_rep->_u._referenceValue;         x = *_rep->_u._referenceValue;
 } }
  
   void CIMValue::get(CIMObject& x) const
   {
       if (_rep->_type != CIMTYPE_OBJECT || _rep->_isArray)
           throw TypeMismatchException();
   
       if (!_rep->_isNull)
           x = *_rep->_u._cimobjectValue;
   }
   
 void CIMValue::get(Array<Boolean>& x) const void CIMValue::get(Array<Boolean>& x) const
 { {
     if (_rep->_type != CIMTYPE_BOOLEAN || !_rep->_isArray)     if (_rep->_type != CIMTYPE_BOOLEAN || !_rep->_isArray)
Line 1414 
Line 1464 
         x = *_rep->_u._referenceArray;         x = *_rep->_u._referenceArray;
 } }
  
   void CIMValue::get(Array<CIMObject>& x) const
   {
       if (_rep->_type != CIMTYPE_OBJECT || !_rep->_isArray)
           throw TypeMismatchException();
   
       if (!_rep->_isNull)
           x = *_rep->_u._cimobjectArray;
   }
   
 Boolean CIMValue::equal(const CIMValue& x) const Boolean CIMValue::equal(const CIMValue& x) const
 { {
     if (!typeCompatible(x))     if (!typeCompatible(x))
Line 1486 
Line 1545 
                 return (*_rep->_u._referenceArray) ==                 return (*_rep->_u._referenceArray) ==
                     (*x._rep->_u._referenceArray);                     (*x._rep->_u._referenceArray);
  
               case CIMTYPE_OBJECT:
                   return (*_rep->_u._cimobjectArray) ==
                       (*x._rep->_u._cimobjectArray);
   
             default:             default:
                 PEGASUS_ASSERT(false);                 PEGASUS_ASSERT(false);
         }         }
Line 1541 
Line 1604 
                 return *_rep->_u._referenceValue ==                 return *_rep->_u._referenceValue ==
                     *x._rep->_u._referenceValue;                     *x._rep->_u._referenceValue;
  
               case CIMTYPE_OBJECT:
                   return (*_rep->_u._cimobjectValue).identical((*x._rep->_u._cimobjectValue));
   
             default:             default:
                 PEGASUS_ASSERT(false);                 PEGASUS_ASSERT(false);
         }         }
Line 1644 
Line 1710 
                                _rep->_u._referenceArray->size());                                _rep->_u._referenceArray->size());
                 break;                 break;
  
               case CIMTYPE_OBJECT:
                   _toString(out, _rep->_u._cimobjectArray->getData(),
                                  _rep->_u._cimobjectArray->size());
                   break;
   
             default:             default:
                 PEGASUS_ASSERT(false);                 PEGASUS_ASSERT(false);
         }         }
Line 1712 
Line 1783 
                 _toString(out, *_rep->_u._referenceValue);                 _toString(out, *_rep->_u._referenceValue);
                 break;                 break;
  
               case CIMTYPE_OBJECT:
                   _toString(out, *_rep->_u._cimobjectValue);
                   break;
   
             default:             default:
                 PEGASUS_ASSERT(false);                 PEGASUS_ASSERT(false);
         }         }

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