(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.37.2.1 and 1.46

version 1.37.2.1, 2002/10/28 15:43:21 version 1.46, 2005/05/17 15:47:12
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2005////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // 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 25 
Line 31 
 // //
 // Modified By: Carol Ann Krug Graves, Hewlett-Packard Company // Modified By: Carol Ann Krug Graves, Hewlett-Packard Company
 //                (carolann_graves@hp.com) //                (carolann_graves@hp.com)
   //              David Dillard, VERITAS Software Corp.
   //                  (david.dillard@veritas.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 37 
Line 45 
 #include "CIMScope.h" #include "CIMScope.h"
 #include "XmlWriter.h" #include "XmlWriter.h"
 #include "MofWriter.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)
   {
       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.isNull())      if (x.isUninitialized())
         throw UninitializedHandle();          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) const  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 116 
Line 157 
  
 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 124 
Line 165 
  
     // Check for type mismatch between return types.     // Check for type mismatch between return types.
  
     PEGASUS_ASSERT(!inheritedMethod.isNull());      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 140 
Line 181 
  
     // 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++)
         Resolver::resolveParameter (_parameters[i], declContext, nameSpace);         Resolver::resolveParameter (_parameters[i], declContext, nameSpace);
  
     _classOrigin = inheritedMethod.getClassOrigin();     _classOrigin = inheritedMethod.getClassOrigin();
Line 148 
Line 189 
  
 void CIMMethodRep::resolve( void CIMMethodRep::resolve(
     DeclContext* declContext,     DeclContext* declContext,
     const String& nameSpace)      const CIMNamespaceName& nameSpace)
 { {
     // Validate the qualifiers:     // Validate the qualifiers:
  
Line 164 
Line 205 
  
     // 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++)
         Resolver::resolveParameter (_parameters[i], declContext, nameSpace);         Resolver::resolveParameter (_parameters[i], declContext, nameSpace);
 } }
  
Line 173 
Line 214 
     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";
  
Line 181 
Line 222 
  
     out << " TYPE=\"" << cimTypeToString (_type) << "\"";     out << " TYPE=\"" << cimTypeToString (_type) << "\"";
  
     if (_classOrigin.size())      if (!_classOrigin.isNull())
         out << " CLASSORIGIN=\"" << _classOrigin << "\"";         out << " CLASSORIGIN=\"" << _classOrigin << "\"";
  
     if (_propagated != false)     if (_propagated != false)
Line 206 
Line 247 
     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 233 
Line 274 
 } }
  
  
 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.reserveCapacity(x._parameters.size());  
   
     for (Uint32 i = 0, n = x._parameters.size(); i < n; i++)  
         _parameters.append(x._parameters[i].clone());  
 }  
   
 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 279 
Line 300 
 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.37.2.1  
changed lines
  Added in v.1.46
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2