(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.11.2.2 and 1.18

version 1.11.2.2, 2001/08/01 11:17:36 version 1.18, 2002/02/22 22:50:07
Line 22 
Line 22 
 // //
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By:  // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
   //              Karl Schopmeyer, (k.schopmeyer@opengroup.org)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 170 
Line 171 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // _toXml() and _toMof routines:  // _toString, _toXml(), and _toMof routines:
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 inline void _toXml(Array<Sint8>& out, Boolean x)  inline void _toString(Array<Sint8>& out, Boolean x)
 {  
     out << (x ? "TRUE" : "FALSE");  
 }  
 inline void _toMof(Array<Sint8>& out, Boolean x)  
 { {
     out << (x ? "TRUE" : "FALSE");     out << (x ? "TRUE" : "FALSE");
 } }
  
   inline void _toXml(Array<Sint8>& out, Boolean x) { _toString(out, x); }
   inline void _toMof(Array<Sint8>& out, Boolean x) { _toString(out, x); }
   
 template<class T> template<class T>
 inline void _integerToXml(Array<Sint8>& out, const T& x)  inline void _integerToString(Array<Sint8>& out, const T& x)
 { {
     char buffer[32];     char buffer[32];
     sprintf(buffer, "%d", x);     sprintf(buffer, "%d", x);
     out << (char*)buffer;     out << (char*)buffer;
 } }
 /* ATTNKS template<class T>  
 inline void _integerToMof(Array<Sint8>& out, const T& x)  
 {  
     char buffer[32];  
     sprintf(buffer, "%d", x);  
     out << (char*)buffer;  
 }  
 */  
 inline void _toXml(Array<Sint8>& out, Uint8 x) { _integerToXml(out, x); }  
 inline void _toMof(Array<Sint8>& out, Uint8 x) { _integerToXml(out, x); }  
   
 inline void _toXml(Array<Sint8>& out, Sint8 x) { _integerToXml(out, x); }  
 inline void _toMof(Array<Sint8>& out, Sint8 x) { _integerToXml(out, x); }  
   
 inline void _toXml(Array<Sint8>& out, Uint16 x) { _integerToXml(out, x); }  
 inline void _toMof(Array<Sint8>& out, Uint16 x) { _integerToXml(out, x); }  
  
 inline void _toXml(Array<Sint8>& out, Sint16 x) { _integerToXml(out, x); }  inline void _toString(Array<Sint8>& out, Uint8 x) { _integerToString(out, x); }
 inline void _toMof(Array<Sint8>& out, Sint16 x) { _integerToXml(out, x); }  inline void _toXml(Array<Sint8>& out, Uint8 x) { _integerToString(out, x); }
   inline void _toMof(Array<Sint8>& out, Uint8 x) { _integerToString(out, x); }
   
   inline void _toString(Array<Sint8>& out, Sint8 x) { _integerToString(out, x); }
   inline void _toXml(Array<Sint8>& out, Sint8 x) { _integerToString(out, x); }
   inline void _toMof(Array<Sint8>& out, Sint8 x) { _integerToString(out, x); }
   
   inline void _toString(Array<Sint8>& out, Uint16 x) { _integerToString(out, x); }
   inline void _toXml(Array<Sint8>& out, Uint16 x) { _integerToString(out, x); }
   inline void _toMof(Array<Sint8>& out, Uint16 x) { _integerToString(out, x); }
   
   inline void _toString(Array<Sint8>& out, Sint16 x) { _integerToString(out, x); }
   inline void _toXml(Array<Sint8>& out, Sint16 x) { _integerToString(out, x); }
   inline void _toMof(Array<Sint8>& out, Sint16 x) { _integerToString(out, x); }
   
   inline void _toString(Array<Sint8>& out, Uint32 x) { _integerToString(out, x); }
   inline void _toXml(Array<Sint8>& out, Uint32 x) { _integerToString(out, x); }
   inline void _toMof(Array<Sint8>& out, Uint32 x) { _integerToString(out, x); }
   
   inline void _toString(Array<Sint8>& out, Sint32 x) { _integerToString(out, x); }
   inline void _toXml(Array<Sint8>& out, Sint32 x) { _integerToString(out, x); }
   inline void _toMof(Array<Sint8>& out, Sint32 x) { _integerToString(out, x); }
  
 inline void _toXml(Array<Sint8>& out, Uint32 x) { _integerToXml(out, x); }  inline void _toString(Array<Sint8>& out, Uint64 x)
 inline void _toMof(Array<Sint8>& out, Uint32 x) { _integerToXml(out, x); }  
   
 inline void _toXml(Array<Sint8>& out, Sint32 x) { _integerToXml(out, x); }  
 inline void _toMof(Array<Sint8>& out, Sint32 x) { _integerToXml(out, x); }  
   
 inline void _toXml(Array<Sint8>& out, Uint64 x)  
 {  
     char buffer[128];  
     _UnsignedIntToStr(x, buffer);  
     out << buffer;  
 }  
 inline void _toMof(Array<Sint8>& out, Uint64 x)  
 { {
     char buffer[128];     char buffer[128];
     _UnsignedIntToStr(x, buffer);     _UnsignedIntToStr(x, buffer);
     out << buffer;     out << buffer;
 } }
  
 inline void _toXml(Array<Sint8>& out, Sint64 x)  inline void _toXml(Array<Sint8>& out, Uint64 x) { _toString(out, x); }
 {  inline void _toMof(Array<Sint8>& out, Uint64 x) { _toString(out, x); }
     char buffer[128];  
     _SignedIntToStr(x, buffer);  inline void _toString(Array<Sint8>& out, Sint64 x)
     out << buffer;  
 }  
 inline void _toMof(Array<Sint8>& out, Sint64 x)  
 { {
     char buffer[128];     char buffer[128];
     _SignedIntToStr(x, buffer);     _SignedIntToStr(x, buffer);
     out << buffer;     out << buffer;
 } }
  
 void _toXml(Array<Sint8>& out, Real32 x)  inline void _toXml(Array<Sint8>& out, Sint64 x) { _toString(out, x); }
   inline void _toMof(Array<Sint8>& out, Sint64 x) { _toString(out, x); }
   
   void _toString(Array<Sint8>& out, Real32 x)
 { {
     // ATTN: Does this format match the CIM/XML format?  
     char buffer[128];     char buffer[128];
     sprintf(buffer, "%f", x);  
     out << buffer;  
 }  
 void _toMof(Array<Sint8>& out, Real32 x)  
 {  
     // ATTN: Does this format match the CIM/XML format?     // ATTN: Does this format match the CIM/XML format?
     char buffer[128];  
     sprintf(buffer, "%f", x);     sprintf(buffer, "%f", x);
     out << buffer;     out << buffer;
 } }
  
 void _toXml(Array<Sint8>& out, Real64 x)  inline void _toXml(Array<Sint8>& out, Real32 x) { _toString(out, x); }
   inline void _toMof(Array<Sint8>& out, Real32 x) { _toString(out, x); }
   
   void _toString(Array<Sint8>& out, Real64 x)
 { {
     char buffer[128];     char buffer[128];
       // ATTN: Does this format match the CIM/XML format?
     sprintf(buffer, "%f", x);     sprintf(buffer, "%f", x);
     out << buffer;     out << buffer;
 } }
 void _toMof(Array<Sint8>& out, Real64 x)  
   inline void _toXml(Array<Sint8>& out, Real64 x) { _toString(out, x); }
   inline void _toMof(Array<Sint8>& out, Real64 x) { _toString(out, x); }
   
   inline void _toString(Array<Sint8>& out, Char16 x)
 { {
     char buffer[128];      // ATTN: How to convert 16-bit characters to printable form?
     sprintf(buffer, "%f", x);      out.append(Sint8(x));
     out << buffer;  
 } }
   
 inline void _toXml(Array<Sint8>& out, Char16 x) inline void _toXml(Array<Sint8>& out, Char16 x)
 { {
     XmlWriter::appendSpecial(out, x);     XmlWriter::appendSpecial(out, x);
Line 279 
Line 271 
     XmlWriter::appendSpecial(out, x);     XmlWriter::appendSpecial(out, x);
 } }
  
   inline void _toString(Array<Sint8>& out, const String& x)
   {
       out << x;
   }
   
 inline void _toXml(Array<Sint8>& out, const String& x) inline void _toXml(Array<Sint8>& out, const String& x)
 { {
     XmlWriter::appendSpecial(out, x);     XmlWriter::appendSpecial(out, x);
 } }
   
   /** _toMof Internal function to convert the string back
       to MOF format and output it.
       The conversions are:
       \b // \x0008: backspace BS
       \t // \x0009: horizontal tab HT
       \n // \x000A: linefeed LF
       \f // \x000C: form feed FF
       \r // \x000D: carriage return CR
       \" // \x0022: double quote "
       \’ // \x0027: single quote '
       \\ // \x005C: backslash \
       \x<hex> // where <hex> is one to four hex digits
       \X<hex> // where <hex> is one to four hex digits
   */
   /* ATTN:KS - We need to account for characters greater than x'7f
   */
 inline void _toMof(Array<Sint8>& out, const String& x) inline void _toMof(Array<Sint8>& out, const String& x)
 { {
     out << "\"";     out << "\"";
     const Char16* tmp = x.getData();     const Char16* tmp = x.getData();
     char c;     char c;
     while (c = *tmp++)      while ((c = *tmp++))
     {     {
         switch (c)         switch (c)
         {         {
             case '"':          case '\\':
                 out.append("'", 1);                  out.append("\\\\",2);
                 break;                 break;
  
             case ' ':              case '\b':
                 out.append(Sint8(c));                  out.append("\\b",2);
                   break;
   
               case '\t':
                   out.append("\\t",2);
                   break;
   
               case '\n':
                   out.append("\\n",2);
                   break;
   
               case '\f':
                   out.append("\\f",2);
                   break;
   
               case '\r':
                   out.append("\\r",2);
                   break;
   
              /* case '\'':
                   out.append("\\'", 2);
                   break;*/
   
               case '"':
                   out.append("\\\"", 2);
                 break;                 break;
  
             default:             default:
Line 308 
Line 346 
     out << "\"";     out << "\"";
 } }
  
 inline void _toXml(Array<Sint8>& out, const CIMDateTime& x)  inline void _toString(Array<Sint8>& out, const CIMDateTime& x)
 { {
     out << x.getString();     out << x.getString();
 } }
 inline void _toMof(Array<Sint8>& out, const CIMDateTime& x)  
   inline void _toXml(Array<Sint8>& out, const CIMDateTime& x) { _toString(out, x); }
   inline void _toMof(Array<Sint8>& out, const CIMDateTime& x) { _toString(out, x); }
   
   inline void _toString(Array<Sint8>& out, const CIMReference& x)
   {
       out << x.toString();
   }
   inline void _toXml(Array<Sint8>& out, const CIMReference& x)
 { {
     out << x.getString();      x.toXml(out);
   }
   inline void _toMof(Array<Sint8>& out, const CIMReference& x)
   {
       x.toMof(out);
   }
   
   template<class T>
   void _toString(Array<Sint8>& out, const T* p, Uint32 size)
   {
       while (size--)
       {
           _toString(out, *p++);
           out << " ";
       }
   }
   
   void _toXml(Array<Sint8>& out, const CIMReference* p, Uint32 size)
   {
       out << "<VALUE.REFARRAY>\n";
       while (size--)
       {
           _toXml(out, *p++);
       }
       out << "</VALUE.REFARRAY>\n";
 } }
  
 template<class T> template<class T>
 void _toXml(Array<Sint8>& out, const T* p, Uint32 size) void _toXml(Array<Sint8>& out, const T* p, Uint32 size)
 { {
       out << "<VALUE.ARRAY>\n";
   
     while (size--)     while (size--)
     {     {
         out << "<VALUE>";         out << "<VALUE>";
Line 328 
Line 400 
  
         out << "</VALUE>\n";         out << "</VALUE>\n";
     }     }
   
       out << "</VALUE.ARRAY>\n";
 } }
   /** _toMof Array -
       arrayInitializer  = "{" constantValue*( "," constantValue)"}"
   
   */
 template<class T> template<class T>
 void _toMof(Array<Sint8>& out, const T* p, Uint32 size) void _toMof(Array<Sint8>& out, const T* p, Uint32 size)
 { {
     Boolean isFirstEntry = true;     Boolean isFirstEntry = true;
       // if there are any entries in the array output them
       if (size)
       {
     out << "{";     out << "{";
     while (size--)     while (size--)
     {     {
Line 345 
Line 426 
         _toMof(out, *p++);         _toMof(out, *p++);
     }     }
     out << "}";     out << "}";
 }  
  
 template<class T>  
 void _toStr(Array<Sint8>& out, const T* p, Uint32 size)  
 {  
     while (size--)  
     {  
         _toXml(out, *p++);  
         out << " ";  
     }     }
 } }
  
Line 368 
Line 441 
     _init();     _init();
 } }
  
   CIMValue::CIMValue(CIMType type, Boolean isArray, Uint32 arraySize)
   {
       _init();
       setNullValue(type, isArray, arraySize);
   }
   
 CIMValue::CIMValue(const CIMValue& x) CIMValue::CIMValue(const CIMValue& x)
 { {
     _init();     _init();
Line 450 
Line 529 
             case CIMType::DATETIME:             case CIMType::DATETIME:
                 _Inc(_u._dateTimeArray = x._u._dateTimeArray);                 _Inc(_u._dateTimeArray = x._u._dateTimeArray);
                 break;                 break;
   
               case CIMType::REFERENCE:
                   _Inc(_u._referenceArray = x._u._referenceArray);
                   break;
               default:
                   throw CIMValueInvalidType();
         }         }
     }     }
     else     else
Line 508 
Line 593 
                 break;                 break;
  
             case CIMType::STRING:             case CIMType::STRING:
                 _u._stringValue = new String(*(x._u._stringValue));                  new(_u._stringValue) String(*((String*)x._u._stringValue));
                 break;                 break;
  
             case CIMType::DATETIME:             case CIMType::DATETIME:
Line 519 
Line 604 
                 _u._referenceValue                 _u._referenceValue
                     = new CIMReference(*(x._u._referenceValue));                     = new CIMReference(*(x._u._referenceValue));
                 break;                 break;
   
               // Should never get here. testing complete enum
               default:
                   throw CIMValueInvalidType();
         }         }
     }     }
 } }
Line 591 
Line 680 
             break;             break;
  
         case CIMType::REFERENCE:         case CIMType::REFERENCE:
             return 0;              return _u._referenceArray->size;
               break;
           // Should never get here. switch on complete enum
           default:
               throw CIMValueInvalidType();
     }     }
  
     // Unreachable!     // Unreachable!
       PEGASUS_ASSERT(false);
     return 0;     return 0;
 } }
  
   //ATTN: P1  KS Problem with Compiler when I added the defaults to clear, the compiler
   // gets an exception very early.  Disabled the exceptions to keep compiler running for
   // the minute.
 void CIMValue::clear() void CIMValue::clear()
 { {
       // ATTN: KS P1 should we be setting NULL=true here????. Right now it only
       // clears the value component. Note that the last thing we do is init
       // and that does the isNull=false.
       //
     if (_isArray)     if (_isArray)
     {     {
         switch (_type)         switch (_type)
Line 659 
Line 760 
             case CIMType::DATETIME:             case CIMType::DATETIME:
                 _Dec(_u._dateTimeArray);                 _Dec(_u._dateTimeArray);
                 break;                 break;
   
               case CIMType::REFERENCE:
                   _Dec(_u._referenceArray);
                   break;
   
               //default:
                   //throw CIMValueInvalidType();
         }         }
     }     }
     else     else
Line 680 
Line 788 
                 break;                 break;
  
             case CIMType::STRING:             case CIMType::STRING:
                 delete _u._stringValue;                  ((String*)_u._stringValue)->~String();
                 break;                 break;
  
             case CIMType::DATETIME:             case CIMType::DATETIME:
Line 690 
Line 798 
             case CIMType::REFERENCE:             case CIMType::REFERENCE:
                 delete _u._referenceValue;                 delete _u._referenceValue;
                 break;                 break;
               //default:
                   //throw CIMValueInvalidType();
         }         }
     }     }
  
Line 698 
Line 808 
  
 void CIMValue::toXml(Array<Sint8>& out) const void CIMValue::toXml(Array<Sint8>& out) const
 { {
       // If the CIMValue is Null, no element is returned.
       //ATTNCH: Feb 12 added the isNull test KS
       // Note that I output absolutely nothing
   
       if (_isNull)
       {
           // out << "\n";
           return;
       }
     if (_isArray)     if (_isArray)
     {     {
         out << "<VALUE.ARRAY>\n";  
   
         switch (_type)         switch (_type)
         {         {
             case CIMType::BOOLEAN:             case CIMType::BOOLEAN:
             {             {
                   // ATTN-RK-P3-20020220: Why can't this just use
                   // _toXml(out, _u._booleanArray->data(), _u._booleanArray->size);
                   // like everybody else?
                   out << "<VALUE.ARRAY>\n";
   
                 for (Uint32 i = 0, n = _u._booleanArray->size; i < n; i++)                 for (Uint32 i = 0, n = _u._booleanArray->size; i < n; i++)
                 {                 {
                     out << "<VALUE>";                     out << "<VALUE>";
                     _toXml(out, Boolean(_u._booleanArray->data()[i]));                     _toXml(out, Boolean(_u._booleanArray->data()[i]));
                     out << "</VALUE>\n";                     out << "</VALUE>\n";
                 }                 }
   
                   out << "</VALUE.ARRAY>\n";
                 break;                 break;
             }             }
  
Line 766 
Line 890 
             case CIMType::DATETIME:             case CIMType::DATETIME:
                 _toXml(out, _u._dateTimeArray->data(), _u._dateTimeArray->size);                 _toXml(out, _u._dateTimeArray->data(), _u._dateTimeArray->size);
                 break;                 break;
         }  
  
         out << "</VALUE.ARRAY>\n";              case CIMType::REFERENCE:
                   _toXml(out, _u._referenceArray->data(),
                               _u._referenceArray->size);
                   break;
   
               default:
                   throw CIMValueInvalidType();
           }
     }     }
     else if (_type == CIMType::REFERENCE)     else if (_type == CIMType::REFERENCE)
     {     {
         _u._referenceValue->toXml(out);          // Has to be separate because it uses VALUE.REFERENCE tag
           _toXml(out, *_u._referenceValue);
     }     }
     else     else
     {     {
Line 829 
Line 960 
                 break;                 break;
  
             case CIMType::STRING:             case CIMType::STRING:
                 _toXml(out, *_u._stringValue);                  _toXml(out, *((String*)_u._stringValue));
                 break;                 break;
  
             case CIMType::DATETIME:             case CIMType::DATETIME:
                 _toXml(out, *_u._dateTimeValue);                 _toXml(out, *_u._dateTimeValue);
                 break;                 break;
               default:
                   throw CIMValueInvalidType();
         }         }
  
         out << "</VALUE>\n";         out << "</VALUE>\n";
     }     }
 } }
 void CIMValue::toMof(Array<Sint8>& out) const    //ATTNKS:  
   String CIMValue::toXml() const
   {
       Array<Sint8> out;
       toXml(out);
       out.append('\0');
       return String(out.getData());
   }
   
   void CIMValue::toMof(Array<Sint8>& out) const
 { {
       // if the CIMValue is Null we return nothing.
       if (_isNull)
           return;
   
     if (_isArray)     if (_isArray)
     {     {
         switch (_type)         switch (_type)
         {         {
             case CIMType::BOOLEAN:             case CIMType::BOOLEAN:
             {             {
                 for (Uint32 i = 0, n = _u._booleanArray->size; i < n; i++)                  _toMof(out, _u._booleanArray->data(), _u._booleanArray->size);
                 {  
                     _toMof(out, Boolean(_u._booleanArray->data()[i]));  
                 }  
                 break;                 break;
             }             }
             case CIMType::UINT8:             case CIMType::UINT8:
Line 904 
Line 1047 
  
             case CIMType::DATETIME:             case CIMType::DATETIME:
                 _toMof(out, _u._dateTimeArray->data(),                 _toMof(out, _u._dateTimeArray->data(),
                             _u._dateTimeArray->size); break;                              _u._dateTimeArray->size);
         }                  break;
   
               case CIMType::REFERENCE:
                   _toMof(out, _u._referenceArray->data(),
                               _u._referenceArray->size);
                   break;
   
               default:
                   throw CIMValueInvalidType();
     }     }
     else if (_type == CIMType::REFERENCE)  
     {  
         _u._referenceValue->toMof(out);  
     }     }
     else     else
     {     {
Line 964 
Line 1112 
                 break;                 break;
  
             case CIMType::STRING:             case CIMType::STRING:
                 _toMof(out, *_u._stringValue);                  _toMof(out, *((String*)_u._stringValue));
                 break;                 break;
  
             case CIMType::DATETIME:             case CIMType::DATETIME:
                 _toMof(out, *_u._dateTimeValue);                 _toMof(out, *_u._dateTimeValue);
                 break;                 break;
   
               case CIMType::REFERENCE:
                   _toMof(out, *_u._referenceValue);
                   break;
   
               default:
                   throw CIMValueInvalidType();
         }         }
     }     }
 } }
Line 983 
Line 1138 
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
 } }
  
   
 void CIMValue::set(Boolean x) void CIMValue::set(Boolean x)
 { {
     clear();     clear();
     _u._booleanValue = (Uint8)x;     _u._booleanValue = (Uint8)x;
     _type = CIMType::BOOLEAN;     _type = CIMType::BOOLEAN;
       _isNull = false;
 } }
  
 void CIMValue::set(Uint8 x) void CIMValue::set(Uint8 x)
Line 995 
Line 1152 
     clear();     clear();
     _u._uint8Value = x;     _u._uint8Value = x;
     _type = CIMType::UINT8;     _type = CIMType::UINT8;
       _isNull = false;
 } }
  
 void CIMValue::set(Sint8 x) void CIMValue::set(Sint8 x)
Line 1002 
Line 1160 
     clear();     clear();
     _u._sint8Value = x;     _u._sint8Value = x;
     _type = CIMType::SINT8;     _type = CIMType::SINT8;
       _isNull = false;
 } }
  
 void CIMValue::set(Uint16 x) void CIMValue::set(Uint16 x)
Line 1009 
Line 1168 
     clear();     clear();
     _u._uint16Value = x;     _u._uint16Value = x;
     _type = CIMType::UINT16;     _type = CIMType::UINT16;
       _isNull = false;
 } }
  
 void CIMValue::set(Sint16 x) void CIMValue::set(Sint16 x)
Line 1016 
Line 1176 
     clear();     clear();
     _u._sint16Value = x;     _u._sint16Value = x;
     _type = CIMType::SINT16;     _type = CIMType::SINT16;
       _isNull = false;
 } }
  
 void CIMValue::set(Uint32 x) void CIMValue::set(Uint32 x)
Line 1023 
Line 1184 
     clear();     clear();
     _u._uint32Value = x;     _u._uint32Value = x;
     _type = CIMType::UINT32;     _type = CIMType::UINT32;
       _isNull = false;
 } }
  
 void CIMValue::set(Sint32 x) void CIMValue::set(Sint32 x)
Line 1030 
Line 1192 
     clear();     clear();
     _u._sint32Value = x;     _u._sint32Value = x;
     _type = CIMType::SINT32;     _type = CIMType::SINT32;
       _isNull = false;
 } }
  
 void CIMValue::set(Uint64 x) void CIMValue::set(Uint64 x)
Line 1037 
Line 1200 
     clear();     clear();
     _u._uint64Value = x;     _u._uint64Value = x;
     _type = CIMType::UINT64;     _type = CIMType::UINT64;
       _isNull = false;
 } }
  
 void CIMValue::set(Sint64 x) void CIMValue::set(Sint64 x)
Line 1044 
Line 1208 
     clear();     clear();
     _u._sint64Value = x;     _u._sint64Value = x;
     _type = CIMType::SINT64;     _type = CIMType::SINT64;
       _isNull = false;
 } }
  
 void CIMValue::set(Real32 x) void CIMValue::set(Real32 x)
Line 1051 
Line 1216 
     clear();     clear();
     _u._real32Value = x;     _u._real32Value = x;
     _type = CIMType::REAL32;     _type = CIMType::REAL32;
       _isNull = false;
 } }
  
 void CIMValue::set(Real64 x) void CIMValue::set(Real64 x)
Line 1058 
Line 1224 
     clear();     clear();
     _u._real64Value = x;     _u._real64Value = x;
     _type = CIMType::REAL64;     _type = CIMType::REAL64;
       _isNull = false;
 } }
  
 void CIMValue::set(const Char16& x) void CIMValue::set(const Char16& x)
Line 1065 
Line 1232 
     clear();     clear();
     _u._char16Value = x;     _u._char16Value = x;
     _type = CIMType::CHAR16;     _type = CIMType::CHAR16;
       _isNull = false;
 } }
  
 void CIMValue::set(const String& x) void CIMValue::set(const String& x)
 { {
     clear();     clear();
     _u._stringValue = new String(x);      new(_u._stringValue) String(x);
     _type = CIMType::STRING;     _type = CIMType::STRING;
       _isNull = false;
 } }
  
 void CIMValue::set(const char* x) void CIMValue::set(const char* x)
 { {
     set(String(x));     set(String(x));
       _isNull = false;
 } }
  
 void CIMValue::set(const CIMDateTime& x) void CIMValue::set(const CIMDateTime& x)
Line 1084 
Line 1254 
     clear();     clear();
     _u._dateTimeValue = new CIMDateTime(x);     _u._dateTimeValue = new CIMDateTime(x);
     _type = CIMType::DATETIME;     _type = CIMType::DATETIME;
       _isNull = false;
 } }
  
 void CIMValue::set(const CIMReference& x) void CIMValue::set(const CIMReference& x)
Line 1091 
Line 1262 
     clear();     clear();
     _u._referenceValue = new CIMReference(x);     _u._referenceValue = new CIMReference(x);
     _type = CIMType::REFERENCE;     _type = CIMType::REFERENCE;
       _isNull = false;
 } }
  
 void CIMValue::set(const Array<Boolean>& x) void CIMValue::set(const Array<Boolean>& x)
Line 1219 
Line 1391 
     _isNull = false;     _isNull = false;
 } }
  
   void CIMValue::set(const Array<CIMReference>& x)
   {
       clear();
       _Inc(_u._referenceArray = x._rep);
       _type = CIMType::REFERENCE;
       _isArray = true;
       _isNull = false;
   }
   
 void CIMValue::get(Boolean& x) const void CIMValue::get(Boolean& x) const
 { {
     if (_type != CIMType::BOOLEAN || _isArray)     if (_type != CIMType::BOOLEAN || _isArray)
Line 1320 
Line 1501 
     if (_type != CIMType::STRING || _isArray)     if (_type != CIMType::STRING || _isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = *_u._stringValue;      x = *((String*)_u._stringValue);
 } }
  
 void CIMValue::get(CIMDateTime& x) const void CIMValue::get(CIMDateTime& x) const
Line 1445 
Line 1626 
  
 void CIMValue::get(Array<CIMDateTime>& x) const void CIMValue::get(Array<CIMDateTime>& x) const
 { {
   #ifdef CIMValueisNullexception
       if (_isNull)
           throw CIMValueIsNull();
   #endif
   
     if (_type != CIMType::DATETIME || !_isArray)     if (_type != CIMType::DATETIME || !_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x.set(_u._dateTimeArray);     x.set(_u._dateTimeArray);
 } }
  
   void CIMValue::get(Array<CIMReference>& x) const
   {
       if (_type != CIMType::REFERENCE || !_isArray)
           throw TypeMismatch();
   
       x.set(_u._referenceArray);
   }
   
 void CIMValue::_init() void CIMValue::_init()
 { {
     _type = CIMType::NONE;     _type = CIMType::NONE;
Line 1464 
Line 1658 
     if (!x.typeCompatible(y))     if (!x.typeCompatible(y))
         return false;         return false;
  
       if (x._isNull != y._isNull)
           return false;
   
     if (x._isArray)     if (x._isArray)
     {     {
         switch (x._type)         switch (x._type)
Line 1523 
Line 1720 
             case CIMType::DATETIME:             case CIMType::DATETIME:
                 return Array<CIMDateTime>(x._u._dateTimeArray) ==                 return Array<CIMDateTime>(x._u._dateTimeArray) ==
                     Array<CIMDateTime>(y._u._dateTimeArray);                     Array<CIMDateTime>(y._u._dateTimeArray);
   
               case CIMType::REFERENCE:
                   return Array<CIMReference>(x._u._referenceArray) ==
                       Array<CIMReference>(y._u._referenceArray);
               default:
                   throw CIMValueInvalidType();
         }         }
     }     }
     else     else
Line 1566 
Line 1769 
                 return x._u._char16Value == y._u._char16Value;                 return x._u._char16Value == y._u._char16Value;
  
             case CIMType::STRING:             case CIMType::STRING:
                 return String::equal(*x._u._stringValue, *y._u._stringValue);                  return String::equal(
                       *((String*)x._u._stringValue),
                       *((String*)y._u._stringValue));
  
             case CIMType::DATETIME:             case CIMType::DATETIME:
                 return *x._u._dateTimeValue == *y._u._dateTimeValue;                 return *x._u._dateTimeValue == *y._u._dateTimeValue;
  
             case CIMType::REFERENCE:             case CIMType::REFERENCE:
                 return *x._u._referenceValue == *y._u._referenceValue;                 return *x._u._referenceValue == *y._u._referenceValue;
               default:
                   throw CIMValueInvalidType();
         }         }
     }     }
  
Line 1582 
Line 1789 
  
 void CIMValue::setNullValue(CIMType type, Boolean isArray, Uint32 arraySize) void CIMValue::setNullValue(CIMType type, Boolean isArray, Uint32 arraySize)
 { {
     _isNull = true;  
  
     clear();     clear();
  
Line 1645 
Line 1851 
             case CIMType::DATETIME:             case CIMType::DATETIME:
                 set(Array<CIMDateTime>(arraySize));                 set(Array<CIMDateTime>(arraySize));
                 break;                 break;
   
               case CIMType::REFERENCE:
                   set(Array<CIMReference>(arraySize));
                   break;
               default:
                   throw CIMValueInvalidType();
         }         }
     }     }
     else     else
Line 1710 
Line 1922 
             case CIMType::REFERENCE:             case CIMType::REFERENCE:
                 set(CIMReference());                 set(CIMReference());
                 break;                 break;
               default:
                   throw CIMValueInvalidType();
         }         }
     }     }
   
       // Set the Null attribute. Note that this must be after the set
       // because the set functions sets the _isNull.
   
       _isNull = true;
 } }
  
 String CIMValue::toString() const String CIMValue::toString() const
 { {
     Array<Sint8> out;     Array<Sint8> out;
  
       //ATTN: Not sure what we should do with getstring for Null CIMValues
       //Choice return empty string or exception out.
       if (_isNull)
           return String();
   
     if (_isArray)     if (_isArray)
     {     {
         switch (_type)         switch (_type)
         {         {
             case CIMType::BOOLEAN:             case CIMType::BOOLEAN:
             {             {
                 for (Uint32 i = 0, n = _u._booleanArray->size; i < n; i++)                  int size = _u._booleanArray->size;
                   bool *p = _u._booleanArray->data();
                   for (Uint32 i = 0; i < _u._booleanArray->size; i++)
                 {                 {
                     _toXml(out, Boolean(_u._booleanArray->data()[i]));                      _toString(out, Boolean(_u._booleanArray->data()[i]));
   
                     out << " ";                     out << " ";
                 }                 }
                 break;                 break;
             }             }
  
             case CIMType::UINT8:             case CIMType::UINT8:
                 _toStr(out, _u._uint8Array->data(), _u._uint8Array->size);                  _toString(out, _u._uint8Array->data(), _u._uint8Array->size);
                 break;                 break;
  
             case CIMType::SINT8:             case CIMType::SINT8:
                 _toStr(out, _u._sint8Array->data(), _u._sint8Array->size);                  _toString(out, _u._sint8Array->data(), _u._sint8Array->size);
                 break;                 break;
  
             case CIMType::UINT16:             case CIMType::UINT16:
                 _toStr(out, _u._uint16Array->data(), _u._uint16Array->size);                  _toString(out, _u._uint16Array->data(), _u._uint16Array->size);
                 break;                 break;
  
             case CIMType::SINT16:             case CIMType::SINT16:
                 _toStr(out, _u._sint16Array->data(), _u._sint16Array->size);                  _toString(out, _u._sint16Array->data(), _u._sint16Array->size);
                 break;                 break;
  
             case CIMType::UINT32:             case CIMType::UINT32:
                 _toStr(out, _u._uint32Array->data(), _u._uint32Array->size);                  _toString(out, _u._uint32Array->data(), _u._uint32Array->size);
                 break;                 break;
  
             case CIMType::SINT32:             case CIMType::SINT32:
                 _toStr(out, _u._sint32Array->data(), _u._sint32Array->size);                  _toString(out, _u._sint32Array->data(), _u._sint32Array->size);
                 break;                 break;
  
             case CIMType::UINT64:             case CIMType::UINT64:
                 _toStr(out, _u._uint64Array->data(), _u._uint64Array->size);                  _toString(out, _u._uint64Array->data(), _u._uint64Array->size);
                 break;                 break;
  
             case CIMType::SINT64:             case CIMType::SINT64:
                 _toStr(out, _u._sint64Array->data(), _u._sint64Array->size);                  _toString(out, _u._sint64Array->data(), _u._sint64Array->size);
                 break;                 break;
  
             case CIMType::REAL32:             case CIMType::REAL32:
                 _toStr(out, _u._real32Array->data(), _u._real32Array->size);                  _toString(out, _u._real32Array->data(), _u._real32Array->size);
                 break;                 break;
  
             case CIMType::REAL64:             case CIMType::REAL64:
                 _toStr(out, _u._real64Array->data(), _u._real64Array->size);                  _toString(out, _u._real64Array->data(), _u._real64Array->size);
                 break;                 break;
  
             case CIMType::CHAR16:             case CIMType::CHAR16:
                 _toStr(out, _u._char16Array->data(), _u._char16Array->size);                  _toString(out, _u._char16Array->data(), _u._char16Array->size);
                 break;                 break;
  
             case CIMType::STRING:             case CIMType::STRING:
                 _toStr(out, _u._stringArray->data(), _u._stringArray->size);                  _toString(out, _u._stringArray->data(), _u._stringArray->size);
                 break;                 break;
  
             case CIMType::DATETIME:             case CIMType::DATETIME:
                 _toStr(out, _u._dateTimeArray->data(), _u._dateTimeArray->size);                  _toString(out, _u._dateTimeArray->data(), _u._dateTimeArray->size);
                 break;                 break;
   
               case CIMType::REFERENCE:
                   _toString(out, _u._referenceArray->data(), _u._referenceArray->size);
                   break;
   
               default:
                   throw CIMValueInvalidType();
         }         }
     }     }
     else if (_type == CIMType::REFERENCE)  
     {  
         return _u._referenceValue->toString();  
     }  
     else     else
     {     {
         switch (_type)         switch (_type)
         {         {
             case CIMType::BOOLEAN:             case CIMType::BOOLEAN:
                 _toXml(out, Boolean(_u._booleanValue != 0));                  _toString(out, Boolean(_u._booleanValue != 0));
                 break;                 break;
  
             case CIMType::UINT8:             case CIMType::UINT8:
                 _toXml(out, _u._uint8Value);                  _toString(out, _u._uint8Value);
                 break;                 break;
  
             case CIMType::SINT8:             case CIMType::SINT8:
                 _toXml(out, _u._sint8Value);                  _toString(out, _u._sint8Value);
                 break;                 break;
  
             case CIMType::UINT16:             case CIMType::UINT16:
                 _toXml(out, _u._uint16Value);                  _toString(out, _u._uint16Value);
                 break;                 break;
  
             case CIMType::SINT16:             case CIMType::SINT16:
                 _toXml(out, _u._sint16Value);                  _toString(out, _u._sint16Value);
                 break;                 break;
  
             case CIMType::UINT32:             case CIMType::UINT32:
                 _toXml(out, _u._uint32Value);                  _toString(out, _u._uint32Value);
                 break;                 break;
  
             case CIMType::SINT32:             case CIMType::SINT32:
                 _toXml(out, _u._sint32Value);                  _toString(out, _u._sint32Value);
                 break;                 break;
  
             case CIMType::UINT64:             case CIMType::UINT64:
                 _toXml(out, _u._uint64Value);                  _toString(out, _u._uint64Value);
                 break;                 break;
  
             case CIMType::SINT64:             case CIMType::SINT64:
                 _toXml(out, _u._sint64Value);                  _toString(out, _u._sint64Value);
                 break;                 break;
  
             case CIMType::REAL32:             case CIMType::REAL32:
                 _toXml(out, _u._real32Value);                  _toString(out, _u._real32Value);
                 break;                 break;
  
             case CIMType::REAL64:             case CIMType::REAL64:
                 _toXml(out, _u._real64Value);                  _toString(out, _u._real64Value);
                 break;                 break;
  
             case CIMType::CHAR16:             case CIMType::CHAR16:
                 _toXml(out, Char16(_u._char16Value));                  _toString(out, Char16(_u._char16Value));
                 break;                 break;
  
             case CIMType::STRING:             case CIMType::STRING:
                 _toXml(out, *_u._stringValue);                  _toString(out, *((String*)_u._stringValue));
                 break;                 break;
  
             case CIMType::DATETIME:             case CIMType::DATETIME:
                 _toXml(out, *_u._dateTimeValue);                  _toString(out, *_u._dateTimeValue);
                 break;                 break;
   
               case CIMType::REFERENCE:
                   _toString(out, *_u._referenceValue);
                   break;
   
               default:
                   throw CIMValueInvalidType();
         }         }
     }     }
  

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