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

Diff for /pegasus/src/Pegasus/Common/CIMMethod.cpp between version 1.12 and 1.31

version 1.12, 2002/05/14 03:27:25 version 1.31, 2007/10/23 17:45:38
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // 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.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec 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 20 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@bmc.com)  
 //  
 // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include "CIMMethod.h" #include "CIMMethod.h"
Line 52 
Line 57 
 } }
  
 CIMMethod::CIMMethod( CIMMethod::CIMMethod(
     const String& name,      const CIMName& name,
     CIMType type,     CIMType type,
     const String& classOrigin,      const CIMName& classOrigin,
     Boolean propagated)     Boolean propagated)
 { {
     _rep = new CIMMethodRep(name, type, classOrigin, propagated);     _rep = new CIMMethodRep(name, type, classOrigin, propagated);
Line 65 
Line 70 
 { {
 } }
  
 CIMMethod::CIMMethod(const CIMConstMethod& x)  
 {  
     Inc(_rep = x._rep);  
 }  
   
 CIMMethod::~CIMMethod() CIMMethod::~CIMMethod()
 { {
     Dec(_rep);     Dec(_rep);
Line 85 
Line 85 
     return *this;     return *this;
 } }
  
 const String& CIMMethod::getName() const  const CIMName& CIMMethod::getName() const
 { {
     _checkRep();      CheckRep(_rep);
     return _rep->getName();     return _rep->getName();
 } }
  
 void CIMMethod::setName(const String& name)  void CIMMethod::setName(const CIMName& name)
 { {
     _checkRep();      CheckRep(_rep);
     _rep->setName(name);     _rep->setName(name);
 } }
  
 CIMType CIMMethod::getType() const CIMType CIMMethod::getType() const
 { {
     _checkRep();      CheckRep(_rep);
     return _rep->getType();     return _rep->getType();
 } }
  
 void CIMMethod::setType(CIMType type) void CIMMethod::setType(CIMType type)
 { {
     _checkRep();      CheckRep(_rep);
     _rep->setType(type);     _rep->setType(type);
 } }
  
 const String& CIMMethod::getClassOrigin() const  const CIMName& CIMMethod::getClassOrigin() const
 { {
     _checkRep();      CheckRep(_rep);
     return _rep->getClassOrigin();     return _rep->getClassOrigin();
 } }
  
 void CIMMethod::setClassOrigin(const String& classOrigin)  void CIMMethod::setClassOrigin(const CIMName& classOrigin)
 { {
     _checkRep();      CheckRep(_rep);
     _rep->setClassOrigin(classOrigin);     _rep->setClassOrigin(classOrigin);
 } }
  
 Boolean CIMMethod::getPropagated() const Boolean CIMMethod::getPropagated() const
 { {
     _checkRep();      CheckRep(_rep);
     return _rep->getPropagated();     return _rep->getPropagated();
 } }
  
 void CIMMethod::setPropagated(Boolean propagated) void CIMMethod::setPropagated(Boolean propagated)
 { {
     _checkRep();      CheckRep(_rep);
     _rep->setPropagated(propagated);     _rep->setPropagated(propagated);
 } }
  
 CIMMethod& CIMMethod::addQualifier(const CIMQualifier& x) CIMMethod& CIMMethod::addQualifier(const CIMQualifier& x)
 { {
     _checkRep();      CheckRep(_rep);
     _rep->addQualifier(x);     _rep->addQualifier(x);
     return *this;     return *this;
 } }
  
 Uint32 CIMMethod::findQualifier(const String& name) const  Uint32 CIMMethod::findQualifier(const CIMName& name) const
 { {
     _checkRep();      CheckRep(_rep);
     return _rep->findQualifier(name);     return _rep->findQualifier(name);
 } }
  
 Boolean CIMMethod::existsQualifier(const String& name) const  CIMQualifier CIMMethod::getQualifier(Uint32 index)
 {  
     _checkRep();  
     return _rep->existsQualifier(name);  
 }  
   
 CIMQualifier CIMMethod::getQualifier(Uint32 pos)  
 { {
     _checkRep();      CheckRep(_rep);
     return _rep->getQualifier(pos);      return _rep->getQualifier(index);
 } }
  
 CIMConstQualifier CIMMethod::getQualifier(Uint32 pos) const  CIMConstQualifier CIMMethod::getQualifier(Uint32 index) const
 { {
     _checkRep();      CheckRep(_rep);
     return _rep->getQualifier(pos);      return _rep->getQualifier(index);
 } }
  
 void CIMMethod::removeQualifier(Uint32 pos)  void CIMMethod::removeQualifier(Uint32 index)
 { {
     _checkRep();      CheckRep(_rep);
     _rep->removeQualifier(pos);      _rep->removeQualifier(index);
 } }
  
 Uint32 CIMMethod::getQualifierCount() const Uint32 CIMMethod::getQualifierCount() const
 { {
     _checkRep();      CheckRep(_rep);
     return _rep->getQualifierCount();     return _rep->getQualifierCount();
 } }
  
 CIMMethod& CIMMethod::addParameter(const CIMParameter& x) CIMMethod& CIMMethod::addParameter(const CIMParameter& x)
 { {
     _checkRep();      CheckRep(_rep);
     _rep->addParameter(x);     _rep->addParameter(x);
     return *this;     return *this;
 } }
  
 Uint32 CIMMethod::findParameter(const String& name) const  Uint32 CIMMethod::findParameter(const CIMName& name) const
 { {
     _checkRep();      CheckRep(_rep);
     return _rep->findParameter(name);     return _rep->findParameter(name);
 } }
  
 CIMParameter CIMMethod::getParameter(Uint32 pos)  CIMParameter CIMMethod::getParameter(Uint32 index)
 {  
     _checkRep();  
     return _rep->getParameter(pos);  
 }  
   
 CIMConstParameter CIMMethod::getParameter(Uint32 pos) const  
 {  
     _checkRep();  
     return _rep->getParameter(pos);  
 }  
   
 Uint32 CIMMethod::getParameterCount() const  
 {  
     _checkRep();  
     return _rep->getParameterCount();  
 }  
   
 void CIMMethod::resolve(  
     DeclContext* declContext,  
     const String& nameSpace,  
     const CIMConstMethod& method)  
 {  
     _checkRep();  
     _rep->resolve(declContext, nameSpace, method);  
 }  
   
 void CIMMethod::resolve(  
     DeclContext* declContext,  
     const String& nameSpace)  
 { {
     _checkRep();      CheckRep(_rep);
     _rep->resolve(declContext, nameSpace);      return _rep->getParameter(index);
 } }
  
 Boolean CIMMethod::isNull() const  CIMConstParameter CIMMethod::getParameter(Uint32 index) const
 { {
     return (_rep == 0)? true : false;      CheckRep(_rep);
       return _rep->getParameter(index);
 } }
  
 void CIMMethod::toXml(Array<Sint8>& out) const  void CIMMethod::removeParameter (Uint32 index)
 { {
     _checkRep();      CheckRep(_rep);
     _rep->toXml(out);      _rep->removeParameter (index);
 } }
  
 void CIMMethod::print(PEGASUS_STD(ostream)& o) const  Uint32 CIMMethod::getParameterCount() const
 { {
     _checkRep();      CheckRep(_rep);
     _rep->print(o);      return _rep->getParameterCount();
 } }
  
 void CIMMethod::toMof(Array<Sint8>& out) const  Boolean CIMMethod::isUninitialized() const
 { {
     _checkRep();      return _rep == 0;
     _rep->toMof(out);  
 } }
  
 Boolean CIMMethod::identical(const CIMConstMethod& x) const Boolean CIMMethod::identical(const CIMConstMethod& x) const
 { {
     x._checkRep();      CheckRep(x._rep);
     _checkRep();      CheckRep(_rep);
     return _rep->identical(x._rep);     return _rep->identical(x._rep);
 } }
  
Line 259 
Line 224 
     return CIMMethod(_rep->clone());     return CIMMethod(_rep->clone());
 } }
  
 void CIMMethod::_checkRep() const  
 {  
     if (!_rep)  
         ThrowUninitializedHandle();  
 }  
   
  
 /////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
 // //
Line 288 
Line 247 
 } }
  
 CIMConstMethod::CIMConstMethod( CIMConstMethod::CIMConstMethod(
     const String& name,      const CIMName& name,
     CIMType type,     CIMType type,
     const String& classOrigin,      const CIMName& classOrigin,
     Boolean propagated)     Boolean propagated)
 { {
     _rep = new CIMMethodRep(name, type, classOrigin, propagated);     _rep = new CIMMethodRep(name, type, classOrigin, propagated);
Line 321 
Line 280 
     return *this;     return *this;
 } }
  
 const String& CIMConstMethod::getName() const  const CIMName& CIMConstMethod::getName() const
 { {
     _checkRep();      CheckRep(_rep);
     return _rep->getName();     return _rep->getName();
 } }
  
 CIMType CIMConstMethod::getType() const CIMType CIMConstMethod::getType() const
 { {
     _checkRep();      CheckRep(_rep);
     return _rep->getType();     return _rep->getType();
 } }
  
 const String& CIMConstMethod::getClassOrigin() const  const CIMName& CIMConstMethod::getClassOrigin() const
 { {
     _checkRep();      CheckRep(_rep);
     return _rep->getClassOrigin();     return _rep->getClassOrigin();
 } }
  
 Boolean CIMConstMethod::getPropagated() const Boolean CIMConstMethod::getPropagated() const
 { {
     _checkRep();      CheckRep(_rep);
     return _rep->getPropagated();     return _rep->getPropagated();
 } }
  
 Uint32 CIMConstMethod::findQualifier(const String& name) const  Uint32 CIMConstMethod::findQualifier(const CIMName& name) const
 { {
     _checkRep();      CheckRep(_rep);
     return _rep->findQualifier(name);     return _rep->findQualifier(name);
 } }
  
 CIMConstQualifier CIMConstMethod::getQualifier(Uint32 pos) const  CIMConstQualifier CIMConstMethod::getQualifier(Uint32 index) const
 { {
     _checkRep();      CheckRep(_rep);
     return _rep->getQualifier(pos);      return _rep->getQualifier(index);
 } }
  
 Uint32 CIMConstMethod::getQualifierCount() const Uint32 CIMConstMethod::getQualifierCount() const
 { {
     _checkRep();      CheckRep(_rep);
     return _rep->getQualifierCount();     return _rep->getQualifierCount();
 } }
  
 Uint32 CIMConstMethod::findParameter(const String& name) const  Uint32 CIMConstMethod::findParameter(const CIMName& name) const
 { {
     _checkRep();      CheckRep(_rep);
     return _rep->findParameter(name);     return _rep->findParameter(name);
 } }
  
 CIMConstParameter CIMConstMethod::getParameter(Uint32 pos) const  CIMConstParameter CIMConstMethod::getParameter(Uint32 index) const
 { {
     _checkRep();      CheckRep(_rep);
     return _rep->getParameter(pos);      return _rep->getParameter(index);
 } }
  
 Uint32 CIMConstMethod::getParameterCount() const Uint32 CIMConstMethod::getParameterCount() const
 { {
     _checkRep();      CheckRep(_rep);
     return _rep->getParameterCount();     return _rep->getParameterCount();
 } }
  
 Boolean CIMConstMethod::isNull() const  Boolean CIMConstMethod::isUninitialized() const
 { {
     return (_rep == 0)? true : false;      return _rep == 0;
 }  
   
 void CIMConstMethod::toXml(Array<Sint8>& out) const  
 {  
     _checkRep();  
     _rep->toXml(out);  
 }  
   
 void CIMConstMethod::print(PEGASUS_STD(ostream)& o) const  
 {  
     _checkRep();  
     _rep->print(o);  
 } }
  
 Boolean CIMConstMethod::identical(const CIMConstMethod& x) const Boolean CIMConstMethod::identical(const CIMConstMethod& x) const
 { {
     x._checkRep();      CheckRep(x._rep);
     _checkRep();      CheckRep(_rep);
     return _rep->identical(x._rep);     return _rep->identical(x._rep);
 } }
  
Line 410 
Line 357 
     return CIMMethod(_rep->clone());     return CIMMethod(_rep->clone());
 } }
  
 void CIMConstMethod::_checkRep() const  
 {  
     if (!_rep)  
         ThrowUninitializedHandle();  
 }  
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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