1 kumpf 1.1.2.1 //%/////////////////////////////////////////////////////////////////////////////
  2               //
  3               // Copyright (c) 2000, 2001 BMC Software, Hewlett-Packard Company, IBM,
  4               // The Open Group, Tivoli Systems
  5               //
  6               // Permission is hereby granted, free of charge, to any person obtaining a copy
  7               // of this software and associated documentation files (the "Software"), to 
  8               // deal in the Software without restriction, including without limitation the 
  9               // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 
 10               // sell copies of the Software, and to permit persons to whom the Software is
 11               // furnished to do so, subject to the following conditions:
 12               // 
 13               // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN 
 14               // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
 15               // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 16               // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 
 17               // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 
 18               // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 
 19               // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 20               // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 21               //
 22 kumpf 1.1.2.1 //==============================================================================
 23               //
 24               // Author: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
 25               //
 26               // Modified By:
 27               //
 28               //%/////////////////////////////////////////////////////////////////////////////
 29               
 30               #include <cstdio>
 31               #include "CIMParamValue.h"
 32               #include "Indentor.h"
 33               #include "CIMName.h"
 34               #include "CIMScope.h"
 35               #include "XmlWriter.h"
 36               
 37               PEGASUS_NAMESPACE_BEGIN
 38               
 39               CIMParamValueRep::CIMParamValueRep(
 40                   CIMParameter parameter,
 41                   CIMValue value,
 42                   Boolean isArray,
 43 kumpf 1.1.2.1     Uint32 arraySize,
 44                   const String& referenceClassName) 
 45                   : _parameter(parameter), _value(value),
 46                   _isArray(isArray), _arraySize(arraySize), 
 47                   _referenceClassName(referenceClassName)
 48               {
 49                   if (_arraySize && !_isArray)
 50               	throw IncompatibleTypes();
 51               
 52                   if (referenceClassName.size())
 53                   {
 54               	if (!CIMName::legal(referenceClassName))
 55               	    throw IllegalName();
 56                   }
 57               }
 58               
 59               CIMParamValueRep::~CIMParamValueRep()
 60               {
 61               
 62               }
 63               
 64 kumpf 1.1.2.1 void CIMParamValueRep::resolve(
 65                   DeclContext* declContext,
 66                   const String& nameSpace)
 67               {
 68                   // Validate the qualifiers of the method (according to
 69                   // superClass's method with the same name). This method
 70                   // will throw an exception if the validation fails.
 71               
 72                   CIMQualifierList dummy;
 73               
 74                   _qualifiers.resolve(
 75               	declContext,
 76               	nameSpace,
 77               	CIMScope::PARAMETER,
 78               	false,
 79               	dummy);
 80               }
 81               
 82               void CIMParamValueRep::toXml(Array<Sint8>& out) const
 83               {
 84                   if (_isArray)
 85 kumpf 1.1.2.1     {
 86               	out << " ARGUMENT.ARRAY";
 87               
 88               	out << " PARAMETER_NAME=\"" << _parameter.getName() << "\"";
 89               
 90               	out << " PARAMETER_TYPE=\"" << TypeToString(_parameter.getType()) << "\"";
 91               
 92               	out << " VALUE=\"" << _value.toString() << "\"";
 93               
 94               	if (_arraySize)
 95               	{
 96               	    char buffer[32];
 97               	    sprintf(buffer, "%d", _arraySize);
 98               	    out << " ARRAYSIZE=\"" << buffer << "\"";
 99               	}
100               
101               	out << ">\n";
102               
103               	_qualifiers.toXml(out);
104               
105               	out << "</PARAMETER.ARRAY>\n";
106 kumpf 1.1.2.1     }
107                   else
108                   {
109               	out << " ARGUMENT";
110               	out << " PARAMETER.NAME=\"" << _parameter.getName() << "\"";
111               	out << " PARAMETER.TYPE=\"" << TypeToString(_parameter.getType()) << "\"";
112               	out << " PARAMETER.VALUE=\"" << _value.toString() << "\"";
113               	out << ">\n";
114               	_qualifiers.toXml(out);
115               	out << "</ARGUMENT>\n";
116                   }
117               }
118               
119               /** toMof - puts the Mof representation of the ParamValue object to
120                   the output parameter array
121                   The BNF for this conversion is:
122                   parameterList    = 	parameter *( "," parameter )
123               
124               	parameter    = 	[ qualifierList ] (dataType|objectRef) parameterName
125               				[ array ]
126               
127 kumpf 1.1.2.1 	parameterName= 	IDENTIFIER
128               	
129               	array 	     = 	"[" [positiveDecimalValue] "]"
130               	
131                   Format on a single line.
132                   */
133               void CIMParamValueRep::toMof(Array<Sint8>& out) const
134               {
135                   // Output the qualifiers for the parameter
136                   _qualifiers.toMof(out);
137               
138                   if (_qualifiers.getCount())
139               	out << " ";
140               
141                   // Output the data parameter and value
142                   out << _parameter.getName() 
143               	<< " " << TypeToString(_parameter.getType())
144               	<< " " << _value.toString();
145               
146                   if (_isArray)
147                   {
148 kumpf 1.1.2.1 	//Output the array indicator "[ [arraysize] ]"
149               	if (_arraySize)
150               	{
151               	    char buffer[32];
152               	    sprintf(buffer, "[%d]", _arraySize);
153               	    out << buffer;
154               	}
155               	else
156               	    out << "[]";
157                   }
158               }
159               
160               void CIMParamValueRep::print(PEGASUS_STD(ostream) &os) const 
161               {
162                   Array<Sint8> tmp;
163                   toXml(tmp);
164                   tmp.append('\0');
165                   os << tmp.getData() << PEGASUS_STD(endl);
166               }
167               
168               Boolean CIMParamValueRep::identical(const CIMParamValueRep* x) const
169 kumpf 1.1.2.1 {
170                   if (_parameter != x->_parameter)
171               	return false;
172               
173                   if (_value != x->_value)
174               	return false;
175               
176                   if (_referenceClassName != x->_referenceClassName)
177               	return false;
178               
179                   if (!_qualifiers.identical(x->_qualifiers))
180               	return false;
181               
182                   return true;
183               }
184               
185               CIMParamValueRep::CIMParamValueRep()
186               {
187               
188               }
189               
190 kumpf 1.1.2.1 CIMParamValueRep::CIMParamValueRep(const CIMParamValueRep& x) :
191                   Sharable(),
192                   _parameter(x._parameter),
193                   _value(x._value),
194                   _isArray(x._isArray),
195                   _arraySize(x._arraySize),
196                   _referenceClassName(x._referenceClassName)
197               {
198                   x._qualifiers.cloneTo(_qualifiers);
199               }
200               
201               CIMParamValueRep& CIMParamValueRep::operator=(const CIMParamValueRep& x) 
202               { 
203                   return *this; 
204               }
205               
206               void CIMParamValueRep::setParameter(CIMParameter parameter)
207               { 
208                   _parameter = parameter;
209               
210                   if (_referenceClassName.size() == 0)
211 kumpf 1.1.2.1     {
212               	throw MissingReferenceClassName();
213                   }
214               }
215               
216               void CIMParamValueRep::setValue(CIMValue value)
217               { 
218                   _value = value;
219               
220                   if (_referenceClassName.size() == 0)
221                   {
222               	throw MissingReferenceClassName();
223                   }
224               }
225               
226               PEGASUS_NAMESPACE_END