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

Diff for /pegasus/src/Pegasus/Common/CIMParamValueRep.cpp between version 1.1.2.2 and 1.7

version 1.1.2.2, 2001/11/15 20:15:24 version 1.7, 2002/03/04 15:10:05
Line 23 
Line 23 
 // //
 // Author: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com) // Author: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
 // //
 // Modified By:  // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
   #include <Pegasus/Common/Config.h>
 #include <cstdio> #include <cstdio>
 #include "CIMParamValue.h"  
 #include "Indentor.h"  
 #include "CIMName.h"  
 #include "CIMScope.h"  
 #include "XmlWriter.h" #include "XmlWriter.h"
   #include "CIMParamValue.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 CIMParamValueRep::CIMParamValueRep( CIMParamValueRep::CIMParamValueRep(
     CIMParameter parameter,      String parameterName,
     CIMValue value,     CIMValue value,
     Boolean isArray,      Boolean isTyped)
     Uint32 arraySize,      : _parameterName(parameterName), _value(value), _isTyped(isTyped)
     const String& referenceClassName)  
     : _parameter(parameter), _value(value),  
     _isArray(isArray), _arraySize(arraySize),  
     _referenceClassName(referenceClassName)  
 { {
     if (_arraySize && !_isArray)  
         throw IncompatibleTypes();  
   
     if (referenceClassName.size())  
     {  
         if (!CIMName::legal(referenceClassName))  
             throw IllegalName();  
     }  
 } }
  
 CIMParamValueRep::~CIMParamValueRep() CIMParamValueRep::~CIMParamValueRep()
Line 61 
Line 47 
  
 } }
  
 void CIMParamValueRep::resolve(  //------------------------------------------------------------------------------
     DeclContext* declContext,  //
     const String& nameSpace)  //     <!ELEMENT PARAMVALUE (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY)?>
 {  //     <!ATTLIST PARAMVALUE
     // Validate the qualifiers of the method (according to  //         %CIMName;
     // superClass's method with the same name). This method  //         %ParamType;>
     // will throw an exception if the validation fails.  //
   //------------------------------------------------------------------------------
     CIMQualifierList dummy;  
   
     _qualifiers.resolve(  
         declContext,  
         nameSpace,  
         CIMScope::PARAMETER,  
         false,  
         dummy);  
 }  
   
 void CIMParamValueRep::toXml(Array<Sint8>& out) const void CIMParamValueRep::toXml(Array<Sint8>& out) const
 { {
     if (_isArray)      out << "<PARAMVALUE NAME=\"" << _parameterName << "\"";
     {  
         out << " ARGUMENT.ARRAY";  
  
         out << " PARAMETER_NAME=\"" << _parameter.getName() << "\"";      CIMType type = _value.getType();
  
         out << " PARAMETER_TYPE=\"" << TypeToString(_parameter.getType()) << "\"";      if (_isTyped && (type != CIMType::NONE))
   
         out << " VALUE=\"";  
         _value.toXml(out);  
         out << "\"";  
   
         if (_arraySize)  
         {         {
             char buffer[32];          out << " PARAMTYPE=\"" << TypeToString(type) << "\"";
             sprintf(buffer, "%d", _arraySize);  
             out << " ARRAYSIZE=\"" << buffer << "\"";  
         }         }
  
         out << ">\n";         out << ">\n";
       /*KSTEST*/
       _value.toXml(out, false);
  
         _qualifiers.toXml(out);      out << "</PARAMVALUE>\n";
   
         out << "</PARAMETER.ARRAY>\n";  
     }  
     else  
     {  
         out << " ARGUMENT";  
         out << " PARAMETER.NAME=\"" << _parameter.getName() << "\"";  
         out << " PARAMETER.TYPE=\"" << TypeToString(_parameter.getType()) << "\"";  
         out << " PARAMETER.VALUE=\"";  
         _value.toXml(out);  
         out << "\"";  
         out << ">\n";  
         _qualifiers.toXml(out);  
         out << "</ARGUMENT>\n";  
     }  
 }  
   
 /** toMof - puts the Mof representation of the ParamValue object to  
     the output parameter array  
     The BNF for this conversion is:  
     parameterList    =  parameter *( "," parameter )  
   
         parameter    =  [ qualifierList ] (dataType|objectRef) parameterName  
                                 [ array ]  
   
         parameterName=  IDENTIFIER  
   
         array        =  "[" [positiveDecimalValue] "]"  
   
     Format on a single line.  
     */  
 void CIMParamValueRep::toMof(Array<Sint8>& out) const  
 {  
     // Output the qualifiers for the parameter  
     _qualifiers.toMof(out);  
   
     if (_qualifiers.getCount())  
         out << " ";  
   
     // Output the data parameter and value  
     out << _parameter.getName()  
         << " " << TypeToString(_parameter.getType())  
         << " ";  
     _value.toXml(out);  
   
     if (_isArray)  
     {  
         //Output the array indicator "[ [arraysize] ]"  
         if (_arraySize)  
         {  
             char buffer[32];  
             sprintf(buffer, "[%d]", _arraySize);  
             out << buffer;  
         }  
         else  
             out << "[]";  
     }  
 } }
  
 void CIMParamValueRep::print(PEGASUS_STD(ostream) &os) const void CIMParamValueRep::print(PEGASUS_STD(ostream) &os) const
Line 172 
Line 83 
  
 Boolean CIMParamValueRep::identical(const CIMParamValueRep* x) const Boolean CIMParamValueRep::identical(const CIMParamValueRep* x) const
 { {
     if (_parameter != x->_parameter)      if (_parameterName != x->_parameterName)
         return false;         return false;
  
     if (_value != x->_value)     if (_value != x->_value)
         return false;         return false;
  
     if (_referenceClassName != x->_referenceClassName)      if (_isTyped != x->_isTyped)
         return false;  
   
     if (!_qualifiers.identical(x->_qualifiers))  
         return false;         return false;
  
     return true;     return true;
Line 194 
Line 102 
  
 CIMParamValueRep::CIMParamValueRep(const CIMParamValueRep& x) : CIMParamValueRep::CIMParamValueRep(const CIMParamValueRep& x) :
     Sharable(),     Sharable(),
     _parameter(x._parameter),      _parameterName(x._parameterName),
     _value(x._value),     _value(x._value),
     _isArray(x._isArray),      _isTyped(x._isTyped)
     _arraySize(x._arraySize),  
     _referenceClassName(x._referenceClassName)  
 { {
     x._qualifiers.cloneTo(_qualifiers);  
 } }
  
   // ATTN-RK-P3-20010219: Is this correct?  (See also CIMMethodRep.cpp,
   // CIMParameterRep.cpp, CIMPropertyRep.cpp, CIMQualifierDeclRep.cpp,
   // CIMQualifierRep.cpp)
 CIMParamValueRep& CIMParamValueRep::operator=(const CIMParamValueRep& x) CIMParamValueRep& CIMParamValueRep::operator=(const CIMParamValueRep& x)
 { {
     return *this;     return *this;
 } }
  
 void CIMParamValueRep::setParameter(CIMParameter parameter)  void CIMParamValueRep::setParameterName(String& parameterName)
 { {
     _parameter = parameter;      _parameterName = parameterName;
   
     if (_referenceClassName.size() == 0)  
     {  
         throw MissingReferenceClassName();  
     }  
 } }
  
 void CIMParamValueRep::setValue(CIMValue value)  void CIMParamValueRep::setValue(CIMValue& value)
 { {
     _value = value;     _value = value;
   }
  
     if (_referenceClassName.size() == 0)  void CIMParamValueRep::setIsTyped(Boolean isTyped)
     {     {
         throw MissingReferenceClassName();      _isTyped = isTyped;
     }  
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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