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.4 and 1.49

version 1.4, 2001/04/08 01:13:21

version 1.49, 2006/01/30 16:16:47

Line 1

//BEGIN_LICENSE

//%2006////////////////////////////////////////////////////////////////////////

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

// IBM Corp.; EMC Corporation, The Open Group.

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; Symantec 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.4 2001/04/08 01:13:21 mike

// Changed "ConstCIM" to "CIMConst"

// Revision 1.2 2001/02/19 01:47:16 mike

// Renamed names of the form CIMConst to CIMConst.

// Revision 1.1 2001/02/18 18:39:06 mike

// new

// Revision 1.2 2001/02/18 03:56:01 mike

// Changed more class names (e.g., ConstClassDecl -> CIMConstClass)

// Revision 1.1 2001/02/16 02:07:06 mike

// Renamed many classes and headers (using new CIM prefixes).

// Revision 1.3 2001/01/23 01:25:35 mike

// Reworked resolve scheme.

// Revision 1.2 2001/01/22 00:45:47 mike

// more work on resolve scheme

// Revision 1.1.1.1 2001/01/14 19:52:58 mike

// Pegasus import

//END_HISTORY

#include <cassert>

#include <Pegasus/Common/Config.h>

#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

#include "StrLit.h"

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(

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

// ensure name is not null

throw IllegalName();

if(name.isNull())

{

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

throw UninitializedObjectException();

throw IllegalName();

}

if (type == CIMType::NONE)

throw NullType();

}

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;

}

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)

if (x.isUninitialized())

throw UnitializedHandle();

throw UninitializedObjectException();

if (findParameter(x.getName()) != Uint32(-1))

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)

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

{

for (Uint32 i = 0, n = _parameters.getSize(); 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 Uint32(-1);

return PEG_NOT_FOUND;

}

CIMParameter CIMMethodRep::getParameter(Uint32 index)

{

if (index >= _parameters.size())

throw IndexOutOfBoundsException();

return _parameters[index];

}

CIMParameter CIMMethodRep::getParameter(Uint32 pos)

void CIMMethodRep::removeParameter(Uint32 index)

{

if (pos >= _parameters.getSize())

if (index >= _parameters.size())

throw OutOfBounds();

throw IndexOutOfBoundsException();

return _parameters[pos];

_parameters.remove (index);

}

Uint32 CIMMethodRep::getParameterCount() const

{

return _parameters.getSize();

return _parameters.size();

}

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 143

Line 168

// Check for type mismatch between return types.

assert (inheritedMethod);

PEGASUS_ASSERT(!inheritedMethod.isUninitialized());

// Validate the qualifiers of the method (according to

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

Line 154

Line 179

nameSpace,

CIMScope::METHOD,

false,

inheritedMethod._rep->_qualifiers);

inheritedMethod._rep->_qualifiers,

true);

// Validate each of the parameters:

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

for (Uint32 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 177

Line 203

nameSpace,

CIMScope::METHOD,

false,

dummy);

dummy,

true);

// Validate each of the parameters:

for (size_t i = 0; i < _parameters.getSize(); 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)

Line 190

Line 217

return x ? "true" : "false";

}

void CIMMethodRep::toXml(Array<Sint8>& out) const

void CIMMethodRep::toXml(Buffer& out) const

{

out << "<METHOD";

out << STRLIT("<METHOD NAME=\"") << _name;

out.append('"');

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

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

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

out.append('"');

if (_classOrigin.getLength())

if (!_classOrigin.isNull())

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

{

out << STRLIT(" CLASSORIGIN=\"") << _classOrigin;

out.append('"');

}

if (_propagated != false)

out << " PROPAGATED=\"" << _toString(_propagated) << "\"";

{

out << STRLIT(" PROPAGATED=\"") << _toString(_propagated);

out.append('"');

}

out << ">\n";

out << STRLIT(">\n");

_qualifiers.toXml(out);

for (Uint32 i = 0, n = _parameters.getSize(); 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 << STRLIT("</METHOD>\n");

}

void CIMMethodRep::print(std::ostream &os) const

/**

{

The BNF for this is;

Array<Sint8> tmp;

methodDeclaration = [ qualifierList ] dataType methodName

toXml(tmp);

"(" [ parameterList ] ")" ";"

tmp.append('\0');

os << tmp.getData() << std::endl;

}

CIMMethodRep::CIMMethodRep()

parameterList = parameter *( "," parameter )

Format with qualifiers on one line and declaration on another. Start

with newline but none at the end.

void CIMMethodRep::toMof(Buffer& out) const //ATTNKS:

{

// Output the qualifier list starting on new line

if (_qualifiers.getCount())

out.append('\n');

}

_qualifiers.toMof(out);

CIMMethodRep::CIMMethodRep(const CIMMethodRep& x) :

// output the type, MethodName and ParmeterList left enclosure

Sharable(),

out.append('\n');

_name(x._name),

out << cimTypeToString(_type);

_type(x._type),

out.append(' ');

_classOrigin(x._classOrigin),

out << _name;

_propagated(x._propagated)

out.append('(');

{

x._qualifiers.cloneTo(_qualifiers);

_parameters.reserve(x._parameters.getSize());

// output the param list separated by commas.

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

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

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

{

// If not first, output comma separator

if (i)

out << STRLIT(", ");

MofWriter::appendParameterElement(out, _parameters[i]);

}

CIMMethodRep& CIMMethodRep::operator=(const CIMMethodRep& x)

// output the parameterlist and method terminator

{

out << STRLIT(");");

return *this;

}

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

{

if (_name != x->_name)

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

return false;

if (_type != x->_type)

Line 258

Line 298

if (!_qualifiers.identical(x->_qualifiers))

return false;

if (_parameters.getSize() != x->_parameters.getSize())

if (_parameters.size() != x->_parameters.size())

return false;

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

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

{

if (!_parameters[i].identical(x->_parameters[i]))

return false;

Line 270

Line 310

return true;

}

void CIMMethodRep::setType(CIMType type)

{

_type = type;

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.4
changed lines
	Added in v.1.49

No CVS admin address has been configured