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

Return to CIMObjectPath.cpp CVS log

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

Diff for /pegasus/src/Pegasus/Common/CIMObjectPath.cpp between version 1.22 and 1.72

version 1.22, 2002/09/20 19:40:11

version 1.72, 2008/11/12 17:22:32

Line 1

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

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

// The Open Group, Tivoli Systems

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

Line 21

Line 29

//==============================================================================

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

// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)

// Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

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

#include <Pegasus/Common/Config.h>

#include <cctype>

#include <cstring>

#include <iostream>

#include "HashTable.h"

#include "CIMObjectPath.h"

#include "Indentor.h"

#include "CIMName.h"

#include "Destroyer.h"

#include "CIMValue.h"

#include "XmlWriter.h"

#include "XmlReader.h"

#include "ArrayInternal.h"

#include "CIMOMPort.h"

#include "HostLocator.h"

#include "System.h"

#include "CIMKeyBindingRep.h"

#include "CIMObjectPathRep.h"

PEGASUS_NAMESPACE_BEGIN

Line 77

Line 79

{

switch (str[i])

{

case '\n':

case '\\':

result.append("\\n");

result.append("\\\\");

break;

case '\r':

result.append("\\r");

break;

case '\t':

result.append("\\t");

break;

case '"':

Line 101

Line 95

return result;

}

static void _BubbleSort(Array<CIMKeyBinding>& x)

static int _compare(const void* p1, const void* p2)

{

Uint32 n = x.size();

const CIMKeyBinding* kb1 = (const CIMKeyBinding*)p1;

const CIMKeyBinding* kb2 = (const CIMKeyBinding*)p2;

if (n < 2)

return String::compareNoCase(

return;

kb1->getName().getString(),

kb2->getName().getString());

}

for (Uint32 i = 0; i < n - 1; i++)

static void _Sort(Array<CIMKeyBinding>& x)

{

for (Uint32 j = 0; j < n - 1; j++)

{

if (String::compareNoCase(x[j].getName().getString(),

CIMKeyBinding* data = (CIMKeyBinding*)x.getData();

x[j+1].getName().getString()) > 0)

Uint32 size = x.size();

{

CIMKeyBinding t = x[j];

x[j] = x[j+1];

x[j+1] = t;

}

////////////////////////////////////////////////////////////////////////////////

// CIMKeyBinding

// If the key is a reference, the keys in the reference must also be

// sorted

////////////////////////////////////////////////////////////////////////////////

for (Uint32 k = 0; k < size; k++)

class CIMKeyBindingRep

{

public:

CIMKeyBindingRep()

{

}

CIMKeyBinding& kb = data[k];

CIMKeyBindingRep(const CIMKeyBindingRep& x)

if (kb.getType() == CIMKeyBinding::REFERENCE)

: _name(x._name), _value(x._value), _type(x._type)

{

CIMObjectPath tmp(kb.getValue());

Array<CIMKeyBinding> keyBindings = tmp.getKeyBindings();

_Sort(keyBindings);

tmp.setKeyBindings(keyBindings);

kb.setValue(tmp.toString());

}

CIMKeyBindingRep(

const CIMName& name,

const String& value,

CIMKeyBinding::Type type)

: _name(name), _value(value), _type(type)

{

}

~CIMKeyBindingRep()

if (size < 2)

{

return;

}

CIMKeyBindingRep& operator=(const CIMKeyBindingRep& x)

qsort((void*)data, size, sizeof(CIMKeyBinding), _compare);

{

if (&x != this)

{

_name = x._name;

_value = x._value;

_type = x._type;

}

return *this;

}

CIMName _name;

String _value;

CIMKeyBinding::Type _type;

};

////////////////////////////////////////////////////////////////////////////////

// CIMKeyBinding

////////////////////////////////////////////////////////////////////////////////

CIMKeyBinding::CIMKeyBinding()

{

Line 180

Line 150

_rep = new CIMKeyBindingRep(*x._rep);

}

CIMKeyBinding::CIMKeyBinding(const CIMName& name, const String& value, Type type)

CIMKeyBinding::CIMKeyBinding(

const CIMName& name,

const String& value,

Type type)

{

_rep = new CIMKeyBindingRep(name, value, type);

}

Line 208

Line 181

case CIMTYPE_REFERENCE:

kbType = REFERENCE;

break;

// case CIMTYPE_REAL32:

// case CIMTYPE_REAL64:

case CIMTYPE_OBJECT:

case CIMTYPE_INSTANCE:

// From PEP 194: EmbeddedObjects cannot be keys.

throw TypeMismatchException();

break;

default:

kbType = NUMERIC;

break;

Line 291

Line 271

kbValue = XmlReader::stringToValue(0, getValue().getCString(),

value.getType());

break;

// case CIMTYPE_REAL32:

// case CIMTYPE_REAL64:

case CIMTYPE_OBJECT:

case CIMTYPE_INSTANCE:

// From PEP 194: EmbeddedObjects cannot be keys.

return false;

break;

default: // Numerics

if (getType() != NUMERIC) return false;

kbValue = XmlReader::stringToValue(0, getValue().getCString(),

Line 308

Line 295

Boolean operator==(const CIMKeyBinding& x, const CIMKeyBinding& y)

{

return

// Check that the names and types match

x.getName().equal(y.getName()) &&

if (!(x.getName().equal(y.getName())) ||

String::equal(x.getValue(), y.getValue()) &&

!(x.getType() == y.getType()))

x.getType() == y.getType();

{

return false;

}

switch (x.getType())

////////////////////////////////////////////////////////////////////////////////

// CIMObjectPath

////////////////////////////////////////////////////////////////////////////////

class CIMObjectPathRep

{

public:

case CIMKeyBinding::REFERENCE:

CIMObjectPathRep()

try

{

// References should be compared as CIMObjectPaths

return (CIMObjectPath(x.getValue()) == CIMObjectPath(y.getValue()));

}

catch (Exception&)

CIMObjectPathRep(const CIMObjectPathRep& x)

: _host(x._host), _nameSpace(x._nameSpace),

_className(x._className), _keyBindings(x._keyBindings)

{

// If CIMObjectPath parsing fails, just compare strings

return String::equal(x.getValue(), y.getValue());

}

break;

CIMObjectPathRep(

case CIMKeyBinding::BOOLEAN:

const String& host,

// Case-insensitive comparison is sufficient for booleans

const CIMNamespaceName& nameSpace,

return String::equalNoCase(x.getValue(), y.getValue());

const CIMName& className,

break;

const Array<CIMKeyBinding>& keyBindings)

case CIMKeyBinding::NUMERIC:

: _host(host), _nameSpace(nameSpace),

// Note: This comparison assumes XML syntax for integers

_className(className), _keyBindings(keyBindings)

// First try comparing as unsigned integers

{

}

Uint64 xValue;

Uint64 yValue;

~CIMObjectPathRep()

if (XmlReader::stringToUnsignedInteger(

x.getValue().getCString(), xValue) &&

XmlReader::stringToUnsignedInteger(

y.getValue().getCString(), yValue))

{

return (xValue == yValue);

}

CIMObjectPathRep& operator=(const CIMObjectPathRep& x)

// Next try comparing as signed integers

{

if (&x != this)

Sint64 xValue;

Sint64 yValue;

if (XmlReader::stringToSignedInteger(

x.getValue().getCString(), xValue) &&

XmlReader::stringToSignedInteger(

y.getValue().getCString(), yValue))

{

_host = x._host;

return (xValue == yValue);

_nameSpace = x._nameSpace;

_className = x._className;

_keyBindings = x._keyBindings;

}

return *this;

}

// Note: Keys may not be real values, so don't try comparing as reals

// We couldn't parse the numbers, so just compare the strings

return String::equal(x.getValue(), y.getValue());

break;

default: // CIMKeyBinding::STRING

return String::equal(x.getValue(), y.getValue());

break;

}

PEGASUS_UNREACHABLE(return false;)

}

////////////////////////////////////////////////////////////////////////////////

// Contains port as well (e.g., myhost:1234).

// CIMObjectPath

String _host;

////////////////////////////////////////////////////////////////////////////////

CIMNamespaceName _nameSpace;

template<class REP>

CIMName _className;

inline void Ref(REP* rep)

Array<CIMKeyBinding> _keyBindings;

{

};

rep->_refCounter++;

}

template<class REP>

inline void Unref(REP* rep)

{

if (rep->_refCounter.decAndTestIfZero())

delete rep;

}

CIMObjectPath::CIMObjectPath()

{

Line 378

Line 385

CIMObjectPath::CIMObjectPath(const CIMObjectPath& x)

{

_rep = new CIMObjectPathRep(*x._rep);

_rep = x._rep;

Ref(_rep);

}

CIMObjectPath::CIMObjectPath(const String& objectName)

Line 387

Line 395

CIMObjectPath tmpRef;

tmpRef.set(objectName);

_rep = new CIMObjectPathRep(*tmpRef._rep);

_rep = tmpRef._rep;

Ref(_rep);

}

CIMObjectPath::CIMObjectPath(

Line 399

Line 408

// Test the objectName out to see if we get an exception

CIMObjectPath tmpRef;

tmpRef.set(host, nameSpace, className, keyBindings);

_rep = tmpRef._rep;

_rep = new CIMObjectPathRep(*tmpRef._rep);

Ref(_rep);

}

CIMObjectPath::~CIMObjectPath()

{

delete _rep;

Unref(_rep);

}

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

{

*_rep = *x._rep;

if (x._rep != _rep)

{

Unref(_rep);

_rep = x._rep;

Ref(_rep);

}

return *this;

}

static inline CIMObjectPathRep* _copyOnWriteCIMObjectPathRep(

CIMObjectPathRep* rep)

{

if (rep->_refCounter.get() > 1)

{

CIMObjectPathRep* tmpRep= new CIMObjectPathRep(*rep);

Unref(rep);

return tmpRep;

}

else

{

return rep;

}

void CIMObjectPath::clear()

{

// If there is more than one reference

// remove reference and get a new shiny empty representation

if (_rep->_refCounter.get() > 1)

{

Unref(_rep);

_rep = new CIMObjectPathRep();

}

else

{

// If there is only one reference

// no need to copy the data, we own it

// just clear the fields

_rep->_host.clear();

_rep->_nameSpace.clear();

_rep->_className.clear();

_rep->_keyBindings.clear();

}

void CIMObjectPath::set(

const String& host,

Line 428

Line 470

const CIMName& className,

const Array<CIMKeyBinding>& keyBindings)

{

setHost(host);

if ((host != String::EMPTY) && !CIMObjectPathRep::isValidHostname(host))

setNameSpace(nameSpace);

{

setClassName(className);

throw MalformedObjectNameException(host);

setKeyBindings(keyBindings);

}

_rep = _copyOnWriteCIMObjectPathRep(_rep);

_rep->_host.assign(host);

_rep->_nameSpace = nameSpace;

_rep->_className = className;

_rep->_keyBindings = keyBindings;

_Sort(_rep->_keyBindings);

}

Boolean _parseHostElement(

Line 440

Line 490

String& host)

{

// See if there is a host name (true if it begins with "//"):

// Host is of the from <hostname>-<port> and begins with "//"

// Host is of the form <hostname>:<port> and begins with "//"

// and ends with "/":

if (p[0] != '/' || p[1] != '/')

Line 450

Line 500

p += 2;

//----------------------------------------------------------------------

char* slash = strchr(p, '/');

// Validate the hostname. Hostnames must match the following

if (!slash)

// regular expression: "[A-Za-z][A-Za-z0-9-]*"

//----------------------------------------------------------------------

char* q = p;

if (!isalpha(*q))

throw MalformedObjectNameException(objectName);

q++;

while (isalnum(*q) || *q == '-')

q++;

// We now expect a port (or default the port).

if (*q == ':')

{

q++;

// Check for a port number:

if (!isdigit(*q))

throw MalformedObjectNameException(objectName);

while (isdigit(*q))

q++;

// Finally, assign the host name:

host.assign(p, q - p);

}

else

{

host.assign(p, q - p);

// Assign the default port number:

host.append(":");

host.append(PEGASUS_CIMOM_DEFAULT_PORT_STRING);

}

// Check for slash terminating the entire sequence:

if (*q != '/')

String hostname = String(p, (Uint32)(slash - p));

if (!CIMObjectPathRep::isValidHostname(hostname))

{

host.clear();

throw MalformedObjectNameException(objectName);

}

host = hostname;

p = ++q;

// Do not step past the '/'; it will be consumed by the namespace parser

p = slash;

return true;

}

Line 519

Line 533

return false;

}

// A ':' as part of a keybinding value should not be interpreted as

// a namespace delimiter. Since keybinding pairs follow the first '.'

// in the object path string, the ':' delimiter only counts if it

// appears before the '.'.

char* dot = strchr(p, '.');

if (dot && (dot < colon))

{

return false;

}

//----------------------------------------------------------------------

// Validate the namespace path. Namespaces must match the following

// regular expression: "[A-Za-z_]+(/[A-Za-z_]+)*"

//----------------------------------------------------------------------

String namespaceName = String(p, colon - p);

String namespaceName = String(p, (Uint32)(colon - p));

if (!CIMNamespaceName::legal(namespaceName))

{

throw MalformedObjectNameException(objectName);

Line 536

Line 561

}

/**

ATTN: RK - Association classes have keys whose types are

ATTN-RK: The DMTF specification for the string form of an

references. These reference values must be treated specially

object path makes it impossible for a parser to distinguish

in the XML encoding, using the VALUE.REFERENCE tag structure.

between a key values of String type and Reference type.

Pegasus had been passing reference values simply as String

Given the ambiguity, this implementation takes a guess at the

values. For example, EnumerateInstanceNames returned

type of a quoted key value. If the value can be parsed into

KEYVALUEs of string type rather than VALUE.REFERENCEs.

a CIMObjectPath with at least one key binding, the type is

set to REFERENCE. Otherwise, the type is set to STRING.

I've modified the XmlReader::getKeyBindingElement() and

Note: This algorithm appears to be in line with what the Sun

XmlWriter::appendInstanceNameElement() methods to read and write

WBEM Services implementation does.

the XML in the proper format. However, making that change

required that a CIMObjectPath object be able to distinguish

To be totally correct, it would be necessary to retrieve the

between a key of String type and a key of reference type.

class definition and look up the types of the key properties

to determine how to interpret the key values. This is clearly

I've modified the String format of CIMObjectPaths slightly to

too inefficient for internal transformations between

allow efficient processing of references whose keys are also

CIMObjectPaths and String values.

of reference type. The "official" form uses the same

encoding for key values of String type and of reference type,

and so it would be necessary to retrieve the class definition

and look up the types of the key properties to determine how

to treat the key values. This is clearly too inefficient for

internal transformations between CIMObjectPaths and String

values.

The workaround is to encode a 'R' at the beginning of the

value for a key of reference type (before the opening '"').

This allows the parser to know a priori whether the key is of

String or reference type.

In this example:

MyClass.Key1="StringValue",Key2=R"RefClass.KeyA="StringA",KeyB=10"

Property Key1 of class MyClass is of String type, and so it

gets the usual encoding. Key2 is a reference property, so

the extra 'R' is inserted before its encoded value. Note

that this algorithm is recursive, such that RefClass could

include KeyC of reference type, which would also get encoded

with the 'R' notation.

The toString() method inserts the 'R' to provide symmetry. A

new CIMKeyBinding type (REFERENCE) has been defined to denote

keys in a CIMObjectPath that are of reference type. This

CIMKeyBinding type must be used appropriately for

CIMObjectPath::toString() to behave correctly.

A result of this change is that instances names in the

instance repository will include this extra 'R' character.

Note that for user-facing uses of the String encoding of

instance names (such as might appear in MOF for static

association instances or in the CGI client), this solution

is non-standard and therefore unacceptable. It is likely

that these points will need to process the more expensive

operation of retrieving the class definition to determine

the key property types.

void _parseKeyBindingPairs(

const String& objectName,

Line 622

Line 608

p = equalsign + 1;

CIMKeyBinding::Type type;

if (*p == 'R')

if (*p == '"')

{

p++;

// Could be CIMKeyBinding::STRING or CIMKeyBinding::REFERENCE

type = CIMKeyBinding::REFERENCE;

p++;

if (*p++ != '"')

Buffer keyValueUTF8(128);

throw MalformedObjectNameException(objectName);

while (*p && *p != '"')

{

// ATTN: need to handle special characters here:

if (*p == '\\')

*p++;

{

p++;

if ((*p != '\\') && (*p != '"'))

{

throw MalformedObjectNameException(objectName);

}

valueString.append(*p++);

keyValueUTF8.append(*p++);

}

if (*p++ != '"')

throw MalformedObjectNameException(objectName);

}

else if (*p == '"')

{

p++;

// Convert the UTF-8 value to a UTF-16 String

valueString.assign(

(const char*)keyValueUTF8.getData(),

keyValueUTF8.size());

Guess at the type of this quoted key value. If the value

can be parsed into a CIMObjectPath with at least one key

binding, the type is assumed to be a REFERENCE. Otherwise,

the type is set to STRING. (See method header for details.)

type = CIMKeyBinding::STRING;

while (*p && *p != '"')

/* Performance shortcut will check for

equal sign instead of doing the full

CIMObjectPath creation and exception handling

if (strchr(keyValueUTF8.getData(), '='))

{

// ATTN: need to handle special characters here:

// found an equal sign, high probability for a reference

try

if (*p == '\\')

{

*p++;

CIMObjectPath testForPath(valueString);

if (testForPath.getKeyBindings().size() > 0)

valueString.append(*p++);

{

// We've found a reference value!

type = CIMKeyBinding::REFERENCE;

}

catch (const Exception &)

{

// Not a reference value; leave type as STRING

}

if (*p++ != '"')

throw MalformedObjectNameException(objectName);

}

else if (toupper(*p) == 'T' || toupper(*p) == 'F')

{

Line 705

Line 712

isComma = true;

}

if (*p == '-')

{

Sint64 x;

if (!XmlReader::stringToSignedInteger(p, x))

throw MalformedObjectNameException(objectName);

}

else

{

Uint64 x;

if (!XmlReader::stringToUnsignedInteger(p, x))

throw MalformedObjectNameException(objectName);

}

valueString.assign(p, n);

Line 732

Line 747

}

_BubbleSort(keyBindings);

_Sort(keyBindings);

}

void CIMObjectPath::set(const String& objectName)

{

// the clear automatically ensures

// we have our own copy of the representation

clear();

//--------------------------------------------------------------------------

Line 748

Line 765

// Convert to a C String first:

char* p = strdup(objectName.getCString());

CString pCString = objectName.getCString();

Destroyer<char> destroyer(p);

char* p = const_cast<char*>((const char*) pCString);

Boolean gotHost;

Boolean gotNamespace;

Line 779

Line 796

return;

}

String className = String(p, dot - p);

String className = String(p, (Uint32)(dot - p));

if (!CIMName::legal(className))

{

throw MalformedObjectNameException(objectName);

Line 795

Line 812

CIMObjectPath& CIMObjectPath::operator=(const String& objectName)

{

// set will call clear, which will cause copyOnWrite if necessary

set(objectName);

return *this;

}

Line 806

Line 824

void CIMObjectPath::setHost(const String& host)

{

if ((host != String::EMPTY) &&

(host != System::getHostName()) &&

!CIMObjectPathRep::isValidHostname(host))

{

throw MalformedObjectNameException(host);

}

_rep = _copyOnWriteCIMObjectPathRep(_rep);

_rep->_host = host;

}

Line 816

Line 842

void CIMObjectPath::setNameSpace(const CIMNamespaceName& nameSpace)

{

_rep = _copyOnWriteCIMObjectPathRep(_rep);

_rep->_nameSpace = nameSpace;

}

Line 826

Line 853

void CIMObjectPath::setClassName(const CIMName& className)

{

_rep = _copyOnWriteCIMObjectPathRep(_rep);

_rep->_className = className;

}

Line 836

Line 864

void CIMObjectPath::setKeyBindings(const Array<CIMKeyBinding>& keyBindings)

{

_rep = _copyOnWriteCIMObjectPathRep(_rep);

_rep->_keyBindings = keyBindings;

_BubbleSort(_rep->_keyBindings);

_Sort(_rep->_keyBindings);

}

String CIMObjectPath::toString() const

Line 889

Line 918

CIMKeyBinding::Type type = keyBindings[i].getType();

if (type == CIMKeyBinding::REFERENCE)

if (type == CIMKeyBinding::STRING ||

objectName.append('R');

type == CIMKeyBinding::REFERENCE)

if (type == CIMKeyBinding::STRING || type == CIMKeyBinding::REFERENCE)

objectName.append('"');

objectName.append(value);

if (type == CIMKeyBinding::STRING || type == CIMKeyBinding::REFERENCE)

if (type == CIMKeyBinding::STRING ||

type == CIMKeyBinding::REFERENCE)

objectName.append('"');

if (i + 1 != n)

Line 910

Line 938

String CIMObjectPath::_toStringCanonical() const

{

CIMObjectPath ref = *this;

CIMObjectPath ref;

*ref._rep = *this->_rep;

// Normalize hostname by changing to lower case

ref._rep->_host.toLower(); // ICU_TODO:

// ATTN-RK-P2-20020510: Need to make hostname and namespace lower case?

// Normalize namespace by changing to lower case

if (!ref._rep->_nameSpace.isNull())

{

String nameSpaceLower = ref._rep->_nameSpace.getString();

nameSpaceLower.toLower(); // ICU_TODO:

ref._rep->_nameSpace = nameSpaceLower;

}

// Normalize class name by changing to lower case

if (!ref._rep->_className.isNull())

{

String classNameLower = ref._rep->_className.getString ();

classNameLower.toLower();

classNameLower.toLower(); // ICU_TODO:

ref._rep->_className = classNameLower;

}

for (Uint32 i = 0, n = ref._rep->_keyBindings.size(); i < n; i++)

{

// Normalize key binding name by changing to lower case

if (!ref._rep->_keyBindings[i]._rep->_name.isNull())

{

String keyBindingNameLower =

ref._rep->_keyBindings[i]._rep->_name.getString ();

keyBindingNameLower.toLower();

keyBindingNameLower.toLower(); // ICU_TODO:

ref._rep->_keyBindings[i]._rep->_name = keyBindingNameLower;

}

// ATTN-RK-20020826: Need to sort keys?

// Normalize the key value

switch (ref._rep->_keyBindings[i]._rep->_type)

{

case CIMKeyBinding::REFERENCE:

try

{

// Convert reference to CIMObjectPath and recurse

ref._rep->_keyBindings[i]._rep->_value =

CIMObjectPath(ref._rep->_keyBindings[i]._rep->_value).

_toStringCanonical();

}

catch (Exception&)

{

// Leave value unchanged if the CIMObjectPath parsing fails

}

break;

case CIMKeyBinding::BOOLEAN:

// Normalize the boolean string by changing to lower case

ref._rep->_keyBindings[i]._rep->_value.toLower(); // ICU_TODO:

break;

case CIMKeyBinding::NUMERIC:

// Normalize the numeric string by converting to integer and back

Uint64 uValue;

Sint64 sValue;

// First try converting to unsigned integer

if (XmlReader::stringToUnsignedInteger(

ref._rep->_keyBindings[i]._rep->_value.getCString(),

uValue))

{

char buffer[32]; // Should need 21 chars max

sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u", uValue);

ref._rep->_keyBindings[i]._rep->_value = String(buffer);

}

// Next try converting to signed integer

else if (XmlReader::stringToSignedInteger(

ref._rep->_keyBindings[i]._rep->_value.getCString(),

sValue))

{

char buffer[32]; // Should need 21 chars max

sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "d", sValue);

ref._rep->_keyBindings[i]._rep->_value = String(buffer);

}

// Leave value unchanged if it cannot be converted to an integer

break;

default: // CIMKeyBinding::STRING

// No normalization required for STRING

break;

}

// Note: key bindings are sorted when set in the CIMObjectPath

return ref.toString();

}

Line 934

Line 1029

Boolean CIMObjectPath::identical(const CIMObjectPath& x) const

{

return

String::equal(_rep->_host, x._rep->_host) &&

(_rep == x._rep) ||

(String::equalNoCase(_rep->_host, x._rep->_host) &&

_rep->_nameSpace.equal(x._rep->_nameSpace) &&

_rep->_className.equal(x._rep->_className) &&

_rep->_keyBindings == x._rep->_keyBindings;

(_rep->_keyBindings == x._rep->_keyBindings));

}

Uint32 CIMObjectPath::makeHashCode() const

Line 955

Line 1051

return !operator==(x, y);

}

#ifndef PEGASUS_REMOVE_DEPRECATED

PEGASUS_STD(ostream)& operator<<(

PEGASUS_STD(ostream)& os,

const CIMObjectPath& x)

{

return os << x.toString();

}

#endif

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.22
changed lines
	Added in v.1.72

No CVS admin address has been configured