(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.1 and 1.36.2.1

version 1.1, 2001/02/18 18:39:06 version 1.36.2.1, 2005/09/30 16:28:15
Line 1 
Line 1 
 //BEGIN_LICENSE  //%2005////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000 The Open Group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
   // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   //
   // 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: Carol Ann Krug Graves, Hewlett-Packard Company
   //                  (carolann_graves@hp.com)
   //              David Dillard, VERITAS Software Corp.
   //                  (david.dillard@veritas.com)
 // //
 // 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 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.  
 //  
 //END_LICENSE  
 //BEGIN_HISTORY  
 //  
 // Author:  
 //  
 // $Log$  
 // Revision 1.1  2001/02/18 18:39:06  mike  
 // new  
 //  
 // Revision 1.1  2001/02/16 02:07:06  mike  
 // Renamed many classes and headers (using new CIM prefixes).  
 //  
 // Revision 1.2  2001/01/22 00:45:47  mike  
 // more work on resolve scheme  
 //  
 // Revision 1.1.1.1  2001/01/14 19:53:02  mike  
 // Pegasus import  
 //  
 //  
 //END_HISTORY  
  
   #include <Pegasus/Common/Config.h>
 #include <cstdio> #include <cstdio>
 #include "CIMParameter.h" #include "CIMParameter.h"
   #include "CIMParameterRep.h"
 #include "Indentor.h" #include "Indentor.h"
 #include "CIMName.h" #include "CIMName.h"
 #include "CIMScope.h" #include "CIMScope.h"
Line 47 
Line 47 
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   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);
   }
   
 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)
 { {
     if (!CIMName::legal(name))      // ensure name is not null
         throw IllegalName();      if(name.isNull())
       {
     if (_type == CIMType::NONE)          throw UninitializedObjectException();
         throw NullType();      }
   
     if (_arraySize && !_isArray)  
         throw IncompatibleTypes();  
  
     if (referenceClassName.getLength())      if((_arraySize != 0) && !_isArray)
     {     {
         if (!CIMName::legal(referenceClassName))          throw TypeMismatchException();
             throw IllegalName();      }
  
         if (_type != CIMType::REFERENCE)      if (!referenceClassName.isNull())
         {         {
             throw ExpectedReferenceValue();          if (_type != CIMTYPE_REFERENCE)
           {
               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() CIMParameterRep::~CIMParameterRep()
 { {
   
 } }
  
 void CIMParameterRep::setName(const String& name)  void CIMParameterRep::setName(const CIMName& name)
   {
       // ensure name is not null
       if(name.isNull())
 { {
     if (!CIMName::legal(name))          throw UninitializedObjectException();
         throw IllegalName();      }
  
     _name = name;     _name = name;
 } }
  
   void CIMParameterRep::removeQualifier(Uint32 index)
   {
       if (index >= _qualifiers.getCount())
           throw IndexOutOfBoundsException();
   
       _qualifiers.removeQualifier (index);
   }
   
 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 115 
Line 137 
         nameSpace,         nameSpace,
         CIMScope::PARAMETER,         CIMScope::PARAMETER,
         false,         false,
         dummy);          dummy,
           true);
 } }
  
 void CIMParameterRep::toXml(Array<Sint8>& out) const  void CIMParameterRep::toXml(Buffer& out) const
 { {
     if (_isArray)     if (_isArray)
     {     {
         out << "<PARAMETER.ARRAY";          if (_type == CIMTYPE_REFERENCE)
           {
               out << "<PARAMETER.REFARRAY";
         out << " NAME=\"" << _name << "\" ";         out << " NAME=\"" << _name << "\" ";
  
         out << " TYPE=\"" << TypeToString(_type) << "\"";              if (!_referenceClassName.isNull())
               {
                   out << " REFERENCECLASS=\"" << _referenceClassName.getString()
                       << "\"";
               }
  
         if (_arraySize)         if (_arraySize)
         {         {
Line 139 
Line 167 
  
         _qualifiers.toXml(out);         _qualifiers.toXml(out);
  
         out << "</PARAMETER.ARRAY>\n";              out << "</PARAMETER.REFARRAY>\n";
     }     }
     else     else
     {     {
         out << "<PARAMETER";              out << "<PARAMETER.ARRAY";
               out << " NAME=\"" << _name << "\" ";
               out << " TYPE=\"" << cimTypeToString (_type) << "\"";
   
               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 << " NAME=\"" << _name << "\" ";
           if (!_referenceClassName.isNull())
           {
               out << " REFERENCECLASS=\"" << _referenceClassName.getString() <<
                      "\"";
           }
           out << ">\n";
  
         out << " TYPE=\"" << TypeToString(_type) << "\"";          _qualifiers.toXml(out);
  
           out << "</PARAMETER.REFERENCE>\n";
       }
       else
       {
           out << "<PARAMETER";
           out << " NAME=\"" << _name << "\" ";
           out << " TYPE=\"" << cimTypeToString (_type) << "\"";
         out << ">\n";         out << ">\n";
  
         _qualifiers.toXml(out);         _qualifiers.toXml(out);
Line 157 
Line 217 
     }     }
 } }
  
 void CIMParameterRep::print() const  /** 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(Buffer& out) const
   {
       // Output the qualifiers for the parameter
       _qualifiers.toMof(out);
   
       if (_qualifiers.getCount())
           out << " ";
   
       // Output the data type and name
       out << cimTypeToString (_type) << " " <<  _name;
   
       if (_isArray)
 { {
     Array<Sint8> tmp;          //Output the array indicator "[ [arraysize] ]"
     toXml(tmp);          if (_arraySize)
     tmp.append('\0');          {
     std::cout << tmp.getData() << std::endl;              char buffer[32];
               sprintf(buffer, "[%d]", _arraySize);
               out << buffer;
           }
           else
               out << "[]";
       }
 } }
  
   
 Boolean CIMParameterRep::identical(const CIMParameterRep* x) const Boolean CIMParameterRep::identical(const CIMParameterRep* x) const
 { {
     if (_name != x->_name)      if (!_name.equal (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 182 
Line 274 
     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);  
 }  
   
 CIMParameterRep& CIMParameterRep::operator=(const CIMParameterRep& x)  
 {  
     return *this;  
 }  
   
 void CIMParameterRep::setType(CIMType type)  
 {  
     _type = type;  
   
     if (_referenceClassName.getLength() == 0 && _type == CIMType::REFERENCE)  
     {  
         throw MissingReferenceClassName();  
     }  
 }  
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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