pegasus/src/Pegasus/Common/CIMMethodRep.cpp - diff

Return to CIMMethodRep.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/CIMMethodRep.cpp between version 1.23 and 1.38

version 1.23, 2002/05/15 12:28:21

version 1.38, 2003/07/31 14:25:20

Line 1

//%/////////////////////////////////////////////////////////////////////////////

// The Open Group, Tivoli Systems

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

Line 22

Line 23

// Author: Mike Brasher (mbrasher@bmc.com)

// Modified By:

// Modified By: Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

//%/////////////////////////////////////////////////////////////////////////////

#include <Pegasus/Common/Config.h>

#include <cassert>

#include "CIMMethod.h"

#include "CIMMethodRep.h"

#include "Resolver.h"

#include "Indentor.h"

#include "CIMName.h"

#include "CIMScope.h"

#include "XmlWriter.h"

#include "MofWriter.h"

#include <Pegasus/Common/MessageLoader.h> //l10n

PEGASUS_NAMESPACE_BEGIN

CIMMethodRep::CIMMethodRep(

const String& name,

const CIMName& name,

CIMType type,

const String& classOrigin,

const CIMName& classOrigin,

Boolean propagated)

: _name(name), _type(type),

_classOrigin(classOrigin), _propagated(propagated)

{

if (!CIMName::legal(name))

throw IllegalName();

if (classOrigin.size() && !CIMName::legal(classOrigin))

throw IllegalName();

if (type == CIMType::NONE)

throw NullType();

}

CIMMethodRep::~CIMMethodRep()

Line 61

Line 56

}

void CIMMethodRep::setName(const String& name)

void CIMMethodRep::setName(const CIMName& name)

{

if (!CIMName::legal(name))

throw IllegalName();

_name = name;

}

void CIMMethodRep::setClassOrigin(const String& classOrigin)

void CIMMethodRep::setClassOrigin(const CIMName& classOrigin)

{

if (!CIMName::legal(classOrigin))

throw IllegalName();

_classOrigin = classOrigin;

}

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);

}

Uint32 CIMMethodRep::findParameter(const String& name) const

Uint32 CIMMethodRep::findParameter(const CIMName& name) const

{

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 PEG_NOT_FOUND;

}

CIMParameter CIMMethodRep::getParameter(Uint32 pos)

CIMParameter CIMMethodRep::getParameter(Uint32 index)

{

if (pos >= _parameters.size())

if (index >= _parameters.size())

throw OutOfBounds();

throw IndexOutOfBoundsException();

return _parameters[pos];

return _parameters[index];

}

void CIMMethodRep::removeParameter(Uint32 index)

{

if (index >= _parameters.size())

throw IndexOutOfBoundsException();

_parameters.remove (index);

}

Uint32 CIMMethodRep::getParameterCount() const

Line 114

Line 118

void CIMMethodRep::resolve(

DeclContext* declContext,

const String& nameSpace,

const CIMNamespaceName& nameSpace,

const CIMConstMethod& inheritedMethod)

{

// ATTN: Check to see if this method has same signature as

Line 122

Line 126

// Check for type mismatch between return types.

assert (!inheritedMethod.isNull());

PEGASUS_ASSERT(!inheritedMethod.isUninitialized());

// Validate the qualifiers of the method (according to

// superClass's method with the same name). This method

Line 139

Line 143

// Validate each of the parameters:

for (size_t i = 0; i < _parameters.size(); i++)

_parameters[i].resolve(declContext, nameSpace);

Resolver::resolveParameter (_parameters[i], declContext, nameSpace);

_classOrigin = inheritedMethod.getClassOrigin();

}

void CIMMethodRep::resolve(

DeclContext* declContext,

const String& nameSpace)

const CIMNamespaceName& nameSpace)

{

// Validate the qualifiers:

Line 163

Line 167

// Validate each of the parameters:

for (size_t i = 0; i < _parameters.size(); i++)

_parameters[i].resolve(declContext, nameSpace);

Resolver::resolveParameter (_parameters[i], declContext, nameSpace);

}

static const char* _toString(Boolean x)

Line 177

Line 181

out << " NAME=\"" << _name << "\"";

out << " TYPE=\"" << _type.toString() << "\"";

out << " TYPE=\"" << cimTypeToString (_type) << "\"";

if (_classOrigin.size())

if (!_classOrigin.isNull())

out << " CLASSORIGIN=\"" << _classOrigin << "\"";

if (_propagated != false)

Line 213

Line 217

_qualifiers.toMof(out);

// output the type, MethodName and ParmeterList left enclosure

out << "\n" << _type.toString() << " " << _name << "(";

out << "\n" << cimTypeToString (_type) << " " << _name << "(";

// output the param list separated by commas.

Line 245

Line 249

{

x._qualifiers.cloneTo(_qualifiers);

_parameters.reserve(x._parameters.size());

_parameters.reserveCapacity(x._parameters.size());

for (Uint32 i = 0, n = x._parameters.size(); i < n; i++)

_parameters.append(x._parameters[i].clone());

Line 253

Line 257

Boolean CIMMethodRep::identical(const CIMMethodRep* x) const

{

if (_name != x->_name)

if (!_name.equal (x->_name))

return false;

if (_type != x->_type)

Line 277

Line 281

void CIMMethodRep::setType(CIMType type)

{

_type = type;

if (type == CIMType::NONE)

throw NullType();

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.23
changed lines
	Added in v.1.38

No CVS admin address has been configured