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

Diff for /pegasus/src/Pegasus/Common/CIMParameterRep.cpp between version 1.17 and 1.51

version 1.17, 2002/05/15 04:03:21 version 1.51, 2008/12/02 09:00:43
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%LICENSE////////////////////////////////////////////////////////////////
 //  
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM  
 //  
 // Permission is hereby granted, free of charge, to any person obtaining a copy  
 // of this software and associated documentation files (the "Software"), to  
 // deal in the Software without restriction, including without limitation the  
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or  
 // sell copies of the Software, and to permit persons to whom the Software is  
 // furnished to do so, subject to the following conditions:  
 //  
 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN  
 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED  
 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT  
 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR  
 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT  
 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN  
 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION  
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  
 // //
 //==============================================================================  // Licensed to The Open Group (TOG) under one or more contributor license
   // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
   // this work for additional information regarding copyright ownership.
   // Each contributor licenses this file to you under the OpenPegasus Open
   // Source License; you may not use this file except in compliance with the
   // License.
   //
   // Permission is hereby granted, free of charge, to any person obtaining a
   // copy of this software and associated documentation files (the "Software"),
   // to deal in the Software without restriction, including without limitation
   // the rights to use, copy, modify, merge, publish, distribute, sublicense,
   // and/or sell copies of the Software, and to permit persons to whom the
   // Software is furnished to do so, subject to the following conditions:
   //
   // The above copyright notice and this permission notice shall be included
   // in all copies or substantial portions of the Software.
   //
   // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
   // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
   // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // //
 // Author: Mike Brasher (mbrasher@bmc.com)  //////////////////////////////////////////////////////////////////////////
 //  
 // Modified By:  
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 30 
Line 33 
 #include <cstdio> #include <cstdio>
 #include "CIMParameter.h" #include "CIMParameter.h"
 #include "CIMParameterRep.h" #include "CIMParameterRep.h"
 #include "Indentor.h"  
 #include "CIMName.h" #include "CIMName.h"
 #include "CIMScope.h" #include "CIMScope.h"
 #include "XmlWriter.h"  #include "StrLit.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   CIMParameterRep::CIMParameterRep(const CIMParameterRep& x) :
       _name(x._name),
       _type(x._type),
       _isArray(x._isArray),
       _arraySize(x._arraySize),
       _referenceClassName(x._referenceClassName),
       _refCounter(1),
       _ownerCount(0)
   {
       x._qualifiers.cloneTo(_qualifiers);
       // Set the CIM name tag.
       _nameTag = generateCIMNameTag(_name);
   }
   
 CIMParameterRep::CIMParameterRep( CIMParameterRep::CIMParameterRep(
     const String& name,      const CIMName& name,
     CIMType type,     CIMType type,
     Boolean isArray,     Boolean isArray,
     Uint32 arraySize,     Uint32 arraySize,
     const String& referenceClassName)      const CIMName& referenceClassName)
     : _name(name), _type(type),     : _name(name), _type(type),
     _isArray(isArray), _arraySize(arraySize),     _isArray(isArray), _arraySize(arraySize),
     _referenceClassName(referenceClassName)      _referenceClassName(referenceClassName),
       _refCounter(1),
       _ownerCount(0)
 { {
     if (!CIMName::legal(name))      // ensure name is not null
         throw IllegalName();      if (name.isNull())
       {
     if (_type == CIMType::NONE)          throw UninitializedObjectException();
         throw NullType();      }
       // Set the CIM name tag.
     if (_arraySize && !_isArray)      _nameTag = generateCIMNameTag(_name);
         throw IncompatibleTypes();  
  
     if (referenceClassName.size())      if ((_arraySize != 0) && !_isArray)
     {     {
         if (!CIMName::legal(referenceClassName))          throw TypeMismatchException();
             throw IllegalName();      }
  
         if (_type != CIMType::REFERENCE)      if (!referenceClassName.isNull())
       {
           if (_type != CIMTYPE_REFERENCE)
         {         {
             throw ExpectedReferenceValue();              throw TypeMismatchException();
         }         }
     }     }
     else     else
     {     {
           if (_type == CIMTYPE_REFERENCE)
     // ATTN: revisit this later!          {
 #if 0              throw TypeMismatchException();
         if (_type == CIMType::REFERENCE)          }
             throw MissingReferenceClassName();  
 #endif  
     }     }
 } }
  
 CIMParameterRep::~CIMParameterRep()  void CIMParameterRep::setName(const CIMName& name)
 { {
       // ensure name is not null
       if (name.isNull())
       {
           throw UninitializedObjectException();
 } }
       if (_ownerCount != 0 && _name != name)
 void CIMParameterRep::setName(const String& name)  
 { {
     if (!CIMName::legal(name))          MessageLoaderParms parms(
         throw IllegalName();              "Common.CIMParameterRep.CONTAINED_PARAMETER_NAMECHANGEDEXCEPTION",
               "Attempted to change the name of a parameter"
                   " already in a container.");
           throw Exception(parms);
       }
     _name = name;     _name = name;
       // Set the CIM name tag.
       _nameTag = generateCIMNameTag(_name);
 } }
  
 void CIMParameterRep::resolve( void CIMParameterRep::resolve(
     DeclContext* declContext,     DeclContext* declContext,
     const String& nameSpace)      const CIMNamespaceName& nameSpace)
 { {
     // Validate the qualifiers of the method (according to     // Validate the qualifiers of the method (according to
     // superClass's method with the same name). This method     // superClass's method with the same name). This method
Line 109 
Line 133 
         true);         true);
 } }
  
 void CIMParameterRep::toXml(Array<Sint8>& out) const  Boolean CIMParameterRep::identical(const CIMParameterRep* x) const
 {  
     if (_isArray)  
     {  
         out << "<PARAMETER.ARRAY";  
   
         out << " NAME=\"" << _name << "\" ";  
   
         out << " TYPE=\"" << _type.toString() << "\"";  
   
         if (_arraySize)  
         {  
             char buffer[32];  
             sprintf(buffer, "%d", _arraySize);  
             out << " ARRAYSIZE=\"" << buffer << "\"";  
         }  
   
         out << ">\n";  
   
         _qualifiers.toXml(out);  
   
         out << "</PARAMETER.ARRAY>\n";  
     }  
     else if (_type == CIMType::REFERENCE)  
     {  
         out << "<PARAMETER.REFERENCE";  
         out << " NAME=\"" << _name << "\" ";  
         out << " REFERENCECLASS=\"" << _referenceClassName << "\"";  
         out << ">\n";  
   
         _qualifiers.toXml(out);  
   
         out << "</PARAMETER.REFERENCE>\n";  
     }  
     else  
     {  
         out << "<PARAMETER";  
         out << " NAME=\"" << _name << "\" ";  
         out << " TYPE=\"" << _type.toString() << "\"";  
         out << ">\n";  
   
         _qualifiers.toXml(out);  
   
         out << "</PARAMETER>\n";  
     }  
 }  
   
 /** toMof - puts the Mof representation of teh Parameter 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 CIMParameterRep::toMof(Array<Sint8>& out) const  
 {  
     // Output the qualifiers for the parameter  
     _qualifiers.toMof(out);  
   
     if (_qualifiers.getCount())  
         out << " ";  
   
     // Output the data type and name  
     out << _type.toString() << " " <<  _name;  
   
     if (_isArray)  
     {     {
         //Output the array indicator "[ [arraysize] ]"      // If the pointers are the same, the objects must be identical
         if (_arraySize)      if (this == x)
         {         {
             char buffer[32];          return true;
             sprintf(buffer, "[%d]", _arraySize);  
             out << buffer;  
         }  
         else  
             out << "[]";  
     }  
 }  
   
   
 void CIMParameterRep::print(PEGASUS_STD(ostream) &os) const  
 {  
     Array<Sint8> tmp;  
     toXml(tmp);  
     tmp.append('\0');  
     os << tmp.getData() << PEGASUS_STD(endl);  
 } }
  
 Boolean CIMParameterRep::identical(const CIMParameterRep* x) const      if (!_name.equal (x->_name))
 {  
     if (_name != x->_name)  
         return false;         return false;
  
     if (_type != x->_type)     if (_type != x->_type)
         return false;         return false;
  
     if (_referenceClassName != x->_referenceClassName)      if (!_referenceClassName.equal (x->_referenceClassName))
         return false;         return false;
  
     if (!_qualifiers.identical(x->_qualifiers))     if (!_qualifiers.identical(x->_qualifiers))
Line 221 
Line 156 
     return true;     return true;
 } }
  
 CIMParameterRep::CIMParameterRep()  
 {  
   
 }  
   
 CIMParameterRep::CIMParameterRep(const CIMParameterRep& x) :  
     Sharable(),  
     _name(x._name),  
     _type(x._type),  
     _isArray(x._isArray),  
     _arraySize(x._arraySize),  
     _referenceClassName(x._referenceClassName)  
 {  
     x._qualifiers.cloneTo(_qualifiers);  
 }  
   
 void CIMParameterRep::setType(CIMType type)  
 {  
     _type = type;  
   
     if (_referenceClassName.size() == 0 && _type == CIMType::REFERENCE)  
     {  
         throw MissingReferenceClassName();  
     }  
 }  
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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