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

Diff for /pegasus/src/Pegasus/Common/CIMMethodRep.cpp between version 1.14 and 1.45

version 1.14, 2001/12/13 14:53:50 version 1.45, 2005/05/17 14:55:08
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2005////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 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 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 22 
Line 29 
 // //
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By:  // Modified By: Carol Ann Krug Graves, Hewlett-Packard Company
   //                  (carolann_graves@hp.com)
   //              David Dillard, VERITAS Software Corp.
   //                  (david.dillard@veritas.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include <cassert>  #include <Pegasus/Common/Config.h>
 #include "CIMMethod.h" #include "CIMMethod.h"
   #include "CIMMethodRep.h"
   #include "Resolver.h"
 #include "Indentor.h" #include "Indentor.h"
 #include "CIMName.h" #include "CIMName.h"
 #include "CIMScope.h" #include "CIMScope.h"
 #include "XmlWriter.h" #include "XmlWriter.h"
   #include "MofWriter.h"
   #include <Pegasus/Common/MessageLoader.h> //l10n
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   CIMMethodRep::CIMMethodRep()
   {
   }
   
   CIMMethodRep::CIMMethodRep(const CIMMethodRep& x) :
       Sharable(),
       _name(x._name),
       _type(x._type),
       _classOrigin(x._classOrigin),
       _propagated(x._propagated)
   {
       // ensure name is not null
       if(name.isNull())
       {
           throw UninitializedObjectException();
       }
   
       x._qualifiers.cloneTo(_qualifiers);
   
       _parameters.reserveCapacity(x._parameters.size());
   
       for (Uint32 i = 0, n = x._parameters.size(); i < n; i++)
       {
           _parameters.append(x._parameters[i].clone());
       }
   }
   
 CIMMethodRep::CIMMethodRep( CIMMethodRep::CIMMethodRep(
     const String& name,      const CIMName& name,
     CIMType type,     CIMType type,
     const String& classOrigin,      const CIMName& classOrigin,
     Boolean propagated)     Boolean propagated)
     : _name(name), _type(type),     : _name(name), _type(type),
     _classOrigin(classOrigin), _propagated(propagated)     _classOrigin(classOrigin), _propagated(propagated)
 { {
     if (!CIMName::legal(name))      // ensure name is not null
         throw IllegalName();      if(name.isNull())
       {
     if (classOrigin.size() && !CIMName::legal(classOrigin))          throw UninitializedObjectException();
         throw IllegalName();      }
   
     if (type == CIMType::NONE)  
         throw NullType();  
 } }
  
 CIMMethodRep::~CIMMethodRep() CIMMethodRep::~CIMMethodRep()
 { {
   
 } }
  
 void CIMMethodRep::setName(const String& name)  void CIMMethodRep::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 CIMMethodRep::setClassOrigin(const String& classOrigin)  void CIMMethodRep::setClassOrigin(const CIMName& classOrigin)
 { {
     if (!CIMName::legal(classOrigin))  
         throw IllegalName();  
   
     _classOrigin = classOrigin;     _classOrigin = classOrigin;
 } }
  
 void CIMMethodRep::addParameter(const CIMParameter& x) void CIMMethodRep::addParameter(const CIMParameter& x)
 { {
     if (!x)      if (x.isUninitialized())
         throw UnitializedHandle();          throw UninitializedObjectException();
  
     if (findParameter(x.getName()) != PEG_NOT_FOUND)      if (findParameter(x.getName()) != PEG_NOT_FOUND){
         throw AlreadyExists();          //l10n
                   //throw AlreadyExistsException
               //("parameter \"" + x.getName().getString () + "\"");
           MessageLoaderParms parms("Common.CIMMethodRep.PARAMETER",
                                                            "parameter \"$0\"",
                                                            x.getName().getString());
           throw AlreadyExistsException(parms);
       }
  
     _parameters.append(x);     _parameters.append(x);
 } }
  
 Uint32 CIMMethodRep::findParameter(const String& name)  Uint32 CIMMethodRep::findParameter(const CIMName& name) const
 { {
     for (Uint32 i = 0, n = _parameters.size(); i < n; i++)     for (Uint32 i = 0, n = _parameters.size(); i < n; i++)
     {     {
         if (CIMName::equal(_parameters[i].getName(), name))          if (name.equal(_parameters[i].getName()))
             return i;             return i;
     }     }
  
     return PEG_NOT_FOUND;     return PEG_NOT_FOUND;
 } }
  
 CIMParameter CIMMethodRep::getParameter(Uint32 pos)  CIMParameter CIMMethodRep::getParameter(Uint32 index)
   {
       if (index >= _parameters.size())
           throw IndexOutOfBoundsException();
   
       return _parameters[index];
   }
   
   void CIMMethodRep::removeParameter(Uint32 index)
 { {
     if (pos >= _parameters.size())      if (index >= _parameters.size())
         throw OutOfBounds();          throw IndexOutOfBoundsException();
  
     return _parameters[pos];      _parameters.remove (index);
 } }
  
 Uint32 CIMMethodRep::getParameterCount() const Uint32 CIMMethodRep::getParameterCount() const
Line 111 
Line 163 
  
 void CIMMethodRep::resolve( void CIMMethodRep::resolve(
     DeclContext* declContext,     DeclContext* declContext,
     const String& nameSpace,      const CIMNamespaceName& nameSpace,
     const CIMConstMethod& inheritedMethod)     const CIMConstMethod& inheritedMethod)
 { {
     // ATTN: Check to see if this method has same signature as     // ATTN: Check to see if this method has same signature as
Line 119 
Line 171 
  
     // Check for type mismatch between return types.     // Check for type mismatch between return types.
  
     assert (inheritedMethod);      PEGASUS_ASSERT(!inheritedMethod.isUninitialized());
  
     // 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 130 
Line 182 
         nameSpace,         nameSpace,
         CIMScope::METHOD,         CIMScope::METHOD,
         false,         false,
         inheritedMethod._rep->_qualifiers);          inheritedMethod._rep->_qualifiers,
           true);
  
     // Validate each of the parameters:     // Validate each of the parameters:
  
     for (size_t i = 0; i < _parameters.size(); i++)      for (Uint32 i = 0; i < _parameters.size(); i++)
         _parameters[i].resolve(declContext, nameSpace);          Resolver::resolveParameter (_parameters[i], declContext, nameSpace);
  
     _classOrigin = inheritedMethod.getClassOrigin();     _classOrigin = inheritedMethod.getClassOrigin();
 } }
  
 void CIMMethodRep::resolve( void CIMMethodRep::resolve(
     DeclContext* declContext,     DeclContext* declContext,
     const String& nameSpace)      const CIMNamespaceName& nameSpace)
 { {
     // Validate the qualifiers:     // Validate the qualifiers:
  
Line 153 
Line 206 
         nameSpace,         nameSpace,
         CIMScope::METHOD,         CIMScope::METHOD,
         false,         false,
         dummy);          dummy,
           true);
  
     // Validate each of the parameters:     // Validate each of the parameters:
  
     for (size_t i = 0; i < _parameters.size(); i++)      for (Uint32 i = 0; i < _parameters.size(); i++)
         _parameters[i].resolve(declContext, nameSpace);          Resolver::resolveParameter (_parameters[i], declContext, nameSpace);
 } }
  
 static const char* _toString(Boolean x) static const char* _toString(Boolean x)
Line 166 
Line 220 
     return x ? "true" : "false";     return x ? "true" : "false";
 } }
  
 void CIMMethodRep::toXml(Array<Sint8>& out) const  void CIMMethodRep::toXml(Array<char>& out) const
 { {
     out << "<METHOD";     out << "<METHOD";
  
     out << " NAME=\"" << _name << "\"";     out << " NAME=\"" << _name << "\"";
  
     out << " TYPE=\"" << TypeToString(_type) << "\"";      out << " TYPE=\"" << cimTypeToString (_type) << "\"";
  
     if (_classOrigin.size())      if (!_classOrigin.isNull())
         out << " CLASSORIGIN=\"" << _classOrigin << "\"";         out << " CLASSORIGIN=\"" << _classOrigin << "\"";
  
     if (_propagated != false)     if (_propagated != false)
Line 185 
Line 239 
     _qualifiers.toXml(out);     _qualifiers.toXml(out);
  
     for (Uint32 i = 0, n = _parameters.size(); i < n; i++)     for (Uint32 i = 0, n = _parameters.size(); i < n; i++)
         _parameters[i].toXml(out);          XmlWriter::appendParameterElement(out, _parameters[i]);
  
     out << "</METHOD>\n";     out << "</METHOD>\n";
 } }
  
 void CIMMethodRep::print(PEGASUS_STD(ostream) &os) const  
 {  
     Array<Sint8> tmp;  
     toXml(tmp);  
     tmp.append('\0');  
     os << tmp.getData() << PEGASUS_STD(endl);  
 }  
   
 /** /**
     The BNF for this is;     The BNF for this is;
     methodDeclaration   =  [ qualifierList ] dataType methodName     methodDeclaration   =  [ qualifierList ] dataType methodName
Line 207 
Line 253 
     Format with qualifiers on one line and declaration on another. Start     Format with qualifiers on one line and declaration on another. Start
     with newline but none at the end.     with newline but none at the end.
 */ */
 void CIMMethodRep::toMof(Array<Sint8>& out) const   //ATTNKS:  void CIMMethodRep::toMof(Array<char>& out) const   //ATTNKS:
 { {
     // Output the qualifier list starting on new line     // Output the qualifier list starting on new line
     if (_qualifiers.getCount())     if (_qualifiers.getCount())
Line 216 
Line 262 
     _qualifiers.toMof(out);     _qualifiers.toMof(out);
  
     // output the type, MethodName and ParmeterList left enclosure     // output the type, MethodName and ParmeterList left enclosure
     out << "\n" << TypeToString(_type) << " " << _name << "(";      out << "\n" << cimTypeToString (_type) << " " << _name << "(";
  
     // output the param list separated by commas.     // output the param list separated by commas.
  
Line 226 
Line 272 
         if (i)         if (i)
             out << ", ";             out << ", ";
  
         _parameters[i].toMof(out);          MofWriter::appendParameterElement(out, _parameters[i]);
     }     }
  
     // output the parameterlist and method terminator     // output the parameterlist and method terminator
Line 234 
Line 280 
 } }
  
  
 CIMMethodRep::CIMMethodRep()  
 {  
   
 }  
   
 CIMMethodRep::CIMMethodRep(const CIMMethodRep& x) :  
     Sharable(),  
     _name(x._name),  
     _type(x._type),  
     _classOrigin(x._classOrigin),  
     _propagated(x._propagated)  
 {  
     x._qualifiers.cloneTo(_qualifiers);  
   
     _parameters.reserve(x._parameters.size());  
   
     for (Uint32 i = 0, n = x._parameters.size(); i < n; i++)  
         _parameters.append(x._parameters[i].clone());  
 }  
   
 CIMMethodRep& CIMMethodRep::operator=(const CIMMethodRep& x)  
 {  
     return *this;  
 }  
   
 Boolean CIMMethodRep::identical(const CIMMethodRep* x) const Boolean CIMMethodRep::identical(const CIMMethodRep* x) const
 { {
     if (_name != x->_name)      if (!_name.equal (x->_name))
         return false;         return false;
  
     if (_type != x->_type)     if (_type != x->_type)
Line 285 
Line 306 
 void CIMMethodRep::setType(CIMType type) void CIMMethodRep::setType(CIMType type)
 { {
     _type = type;     _type = type;
   
     if (type == CIMType::NONE)  
         throw NullType();  
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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