(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.34 and 1.35

version 1.34, 2002/06/10 20:33:49 version 1.35, 2002/07/19 18:47:11
Line 224 
Line 224 
     set(x);     set(x);
 } }
  
 CIMValue::CIMValue(const char* x)  
 {  
     _rep = new CIMValueRep();  
     set(x);  
 }  
   
 CIMValue::CIMValue(const CIMDateTime& x) CIMValue::CIMValue(const CIMDateTime& x)
 { {
     _rep = new CIMValueRep();     _rep = new CIMValueRep();
Line 632 
Line 626 
  
 Boolean CIMValue::typeCompatible(const CIMValue& x) const Boolean CIMValue::typeCompatible(const CIMValue& x) const
 { {
     return _rep->_type == x._rep->_type && _rep->_isArray == x._rep->_isArray;      return (_rep->_type == x._rep->_type &&
               _rep->_isArray == x._rep->_isArray);
   //            getArraySize() == x.getArraySize());
 } }
  
 Boolean CIMValue::isArray() const Boolean CIMValue::isArray() const
Line 980 
Line 976 
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
  
 void CIMValue::set(const char* x)  
 {  
     set(String(x));  
     _rep->_isNull = false;  
 }  
   
 void CIMValue::set(const CIMDateTime& x) void CIMValue::set(const CIMDateTime& x)
 { {
     clear();     clear();
Line 1382 
Line 1372 
     x = *_rep->_u._referenceArray;     x = *_rep->_u._referenceArray;
 } }
  
 CIMValue CIMValue::clone() const  Boolean CIMValue::equal(const CIMValue& x) const
   {
       if (!typeCompatible(x))
           return false;
   
       if (_rep->_isNull != x._rep->_isNull)
           return false;
   
       if (_rep->_isArray)
       {
           switch (_rep->_type)
 { {
     return CIMValue(*this);              case CIMType::BOOLEAN:
                   return (*_rep->_u._booleanArray) ==
                       (*x._rep->_u._booleanArray);
   
               case CIMType::UINT8:
                   return (*_rep->_u._uint8Array) ==
                       (*x._rep->_u._uint8Array);
   
               case CIMType::SINT8:
                   return (*_rep->_u._sint8Array) ==
                       (*x._rep->_u._sint8Array);
   
               case CIMType::UINT16:
                   return (*_rep->_u._uint16Array) ==
                       (*x._rep->_u._uint16Array);
   
               case CIMType::SINT16:
                   return (*_rep->_u._sint16Array) ==
                       (*x._rep->_u._sint16Array);
   
               case CIMType::UINT32:
                   return (*_rep->_u._uint32Array) ==
                       (*x._rep->_u._uint32Array);
   
               case CIMType::SINT32:
                   return (*_rep->_u._sint32Array) ==
                       (*x._rep->_u._sint32Array);
   
               case CIMType::UINT64:
                   return (*_rep->_u._uint64Array) ==
                       (*x._rep->_u._uint64Array);
   
               case CIMType::SINT64:
                   return (*_rep->_u._sint64Array) ==
                       (*x._rep->_u._sint64Array);
   
               case CIMType::REAL32:
                   return (*_rep->_u._real32Array) ==
                       (*x._rep->_u._real32Array);
   
               case CIMType::REAL64:
                   return (*_rep->_u._real64Array) ==
                       (*x._rep->_u._real64Array);
   
               case CIMType::CHAR16:
                   return (*_rep->_u._char16Array) ==
                       (*x._rep->_u._char16Array);
   
               case CIMType::STRING:
                   return (*_rep->_u._stringArray) ==
                       (*x._rep->_u._stringArray);
   
               case CIMType::DATETIME:
                   return (*_rep->_u._dateTimeArray) ==
                       (*x._rep->_u._dateTimeArray);
   
               case CIMType::REFERENCE:
                   return (*_rep->_u._referenceArray) ==
                       (*x._rep->_u._referenceArray);
               default:
                   throw CIMValueInvalidType();
           }
       }
       else
       {
           switch (_rep->_type)
           {
               case CIMType::BOOLEAN:
                   return _rep->_u._booleanValue == x._rep->_u._booleanValue;
   
               case CIMType::UINT8:
                   return _rep->_u._uint8Value == x._rep->_u._uint8Value;
   
               case CIMType::SINT8:
                   return _rep->_u._sint8Value == x._rep->_u._sint8Value;
   
               case CIMType::UINT16:
                   return _rep->_u._uint16Value == x._rep->_u._uint16Value;
   
               case CIMType::SINT16:
                   return _rep->_u._sint16Value == x._rep->_u._sint16Value;
   
               case CIMType::UINT32:
                   return _rep->_u._uint32Value == x._rep->_u._uint32Value;
   
               case CIMType::SINT32:
                   return _rep->_u._sint32Value == x._rep->_u._sint32Value;
   
               case CIMType::UINT64:
                   return _rep->_u._uint64Value == x._rep->_u._uint64Value;
   
               case CIMType::SINT64:
                   return _rep->_u._sint64Value == x._rep->_u._sint64Value;
   
               case CIMType::REAL32:
                   return _rep->_u._real32Value == x._rep->_u._real32Value;
   
               case CIMType::REAL64:
                   return _rep->_u._real64Value == x._rep->_u._real64Value;
   
               case CIMType::CHAR16:
                   return _rep->_u._char16Value == x._rep->_u._char16Value;
   
               case CIMType::STRING:
                   return String::equal(*_rep->_u._stringValue,
                                        *x._rep->_u._stringValue);
   
               case CIMType::DATETIME:
                   return *_rep->_u._dateTimeValue == *x._rep->_u._dateTimeValue;
   
               case CIMType::REFERENCE:
                   return *_rep->_u._referenceValue ==
                       *x._rep->_u._referenceValue;
   
               default:
                   throw CIMValueInvalidType();
           }
       }
   
       // Unreachable!
       return false;
 } }
  
 String CIMValue::toString() const String CIMValue::toString() const
Line 1561 
Line 1681 
  
 Boolean operator==(const CIMValue& x, const CIMValue& y) Boolean operator==(const CIMValue& x, const CIMValue& y)
 { {
     if (!x.typeCompatible(y))      return x.equal(y);
         return false;  
   
     if (x._rep->_isNull != y._rep->_isNull)  
         return false;  
   
     if (x._rep->_isArray)  
     {  
         switch (x._rep->_type)  
         {  
             case CIMType::BOOLEAN:  
                 return (*x._rep->_u._booleanArray) ==  
                     (*y._rep->_u._booleanArray);  
   
             case CIMType::UINT8:  
                 return (*x._rep->_u._uint8Array) ==  
                     (*y._rep->_u._uint8Array);  
   
             case CIMType::SINT8:  
                 return (*x._rep->_u._sint8Array) ==  
                     (*y._rep->_u._sint8Array);  
   
             case CIMType::UINT16:  
                 return (*x._rep->_u._uint16Array) ==  
                     (*y._rep->_u._uint16Array);  
   
             case CIMType::SINT16:  
                 return (*x._rep->_u._sint16Array) ==  
                     (*y._rep->_u._sint16Array);  
   
             case CIMType::UINT32:  
                 return (*x._rep->_u._uint32Array) ==  
                     (*y._rep->_u._uint32Array);  
   
             case CIMType::SINT32:  
                 return (*x._rep->_u._sint32Array) ==  
                     (*y._rep->_u._sint32Array);  
   
             case CIMType::UINT64:  
                 return (*x._rep->_u._uint64Array) ==  
                     (*y._rep->_u._uint64Array);  
   
             case CIMType::SINT64:  
                 return (*x._rep->_u._sint64Array) ==  
                     (*y._rep->_u._sint64Array);  
   
             case CIMType::REAL32:  
                 return (*x._rep->_u._real32Array) ==  
                     (*y._rep->_u._real32Array);  
   
             case CIMType::REAL64:  
                 return (*x._rep->_u._real64Array) ==  
                     (*y._rep->_u._real64Array);  
   
             case CIMType::CHAR16:  
                 return (*x._rep->_u._char16Array) ==  
                     (*y._rep->_u._char16Array);  
   
             case CIMType::STRING:  
                 return (*x._rep->_u._stringArray) ==  
                     (*y._rep->_u._stringArray);  
   
             case CIMType::DATETIME:  
                 return (*x._rep->_u._dateTimeArray) ==  
                     (*y._rep->_u._dateTimeArray);  
   
             case CIMType::REFERENCE:  
                 return (*x._rep->_u._referenceArray) ==  
                     (*y._rep->_u._referenceArray);  
             default:  
                 throw CIMValueInvalidType();  
         }  
     }  
     else  
     {  
         switch (x._rep->_type)  
         {  
             case CIMType::BOOLEAN:  
                 return x._rep->_u._booleanValue == y._rep->_u._booleanValue;  
   
             case CIMType::UINT8:  
                 return x._rep->_u._uint8Value == y._rep->_u._uint8Value;  
   
             case CIMType::SINT8:  
                 return x._rep->_u._sint8Value == y._rep->_u._sint8Value;  
   
             case CIMType::UINT16:  
                 return x._rep->_u._uint16Value == y._rep->_u._uint16Value;  
   
             case CIMType::SINT16:  
                 return x._rep->_u._sint16Value == y._rep->_u._sint16Value;  
   
             case CIMType::UINT32:  
                 return x._rep->_u._uint32Value == y._rep->_u._uint32Value;  
   
             case CIMType::SINT32:  
                 return x._rep->_u._sint32Value == y._rep->_u._sint32Value;  
   
             case CIMType::UINT64:  
                 return x._rep->_u._uint64Value == y._rep->_u._uint64Value;  
   
             case CIMType::SINT64:  
                 return x._rep->_u._sint64Value == y._rep->_u._sint64Value;  
   
             case CIMType::REAL32:  
                 return x._rep->_u._real32Value == y._rep->_u._real32Value;  
   
             case CIMType::REAL64:  
                 return x._rep->_u._real64Value == y._rep->_u._real64Value;  
   
             case CIMType::CHAR16:  
                 return x._rep->_u._char16Value == y._rep->_u._char16Value;  
   
             case CIMType::STRING:  
                 return String::equal(*x._rep->_u._stringValue,  
                                      *y._rep->_u._stringValue);  
   
             case CIMType::DATETIME:  
                 return *x._rep->_u._dateTimeValue == *y._rep->_u._dateTimeValue;  
   
             case CIMType::REFERENCE:  
                 return *x._rep->_u._referenceValue ==  
                     *y._rep->_u._referenceValue;  
   
             default:  
                 throw CIMValueInvalidType();  
         }  
     }  
   
     // Unreachable!  
     return false;  
 } }
  
 Boolean operator!=(const CIMValue& x, const CIMValue& y) Boolean operator!=(const CIMValue& x, const CIMValue& y)
 { {
     return !operator==(x, y);      return !x.equal(y);
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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