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.29 and 1.60.4.1

version 1.29, 2003/09/19 19:56:26

version 1.60.4.1, 2007/06/08 10:40:29

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 "XmlWriter.h"

#include "XmlReader.h"

#include "ArrayInternal.h"

#include "CIMOMPort.h"

#include "HostAddress.h"

PEGASUS_NAMESPACE_BEGIN

Line 186

_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 214

Line 217

case CIMTYPE_REFERENCE:

kbType = REFERENCE;

break;

// case CIMTYPE_REAL32:

// case CIMTYPE_REAL64:

case CIMTYPE_OBJECT:

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

case CIMTYPE_INSTANCE:

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

// From PEP 194: EmbeddedObjects cannot be keys.

throw TypeMismatchException();

break;

default:

kbType = NUMERIC;

break;

Line 297

Line 309

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

value.getType());

break;

// case CIMTYPE_REAL32:

// case CIMTYPE_REAL64:

case CIMTYPE_OBJECT:

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

case CIMTYPE_INSTANCE:

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

// From PEP 194: EmbeddedObjects cannot be keys.

return false;

break;

default: // Numerics

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

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

Line 314

Line 335

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

{

case CIMKeyBinding::REFERENCE:

try

{

// References should be compared as CIMObjectPaths

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

}

catch (Exception&)

{

// If CIMObjectPath parsing fails, just compare strings

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

}

break;

case CIMKeyBinding::BOOLEAN:

// Case-insensitive comparison is sufficient for booleans

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

break;

case CIMKeyBinding::NUMERIC:

// Note: This comparison assumes XML syntax for integers

// First try comparing as unsigned integers

{

Uint64 xValue;

Uint64 yValue;

if (XmlReader::stringToUnsignedInteger(

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

XmlReader::stringToUnsignedInteger(

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

{

return (xValue == yValue);

}

// Next try comparing as signed integers

{

Sint64 xValue;

Sint64 yValue;

if (XmlReader::stringToSignedInteger(

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

XmlReader::stringToSignedInteger(

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

{

return (xValue == yValue);

}

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

}

Line 366

Line 444

return *this;

}

static Boolean isValidHostname(const String& hostname)

{

HostAddress addr(hostname);

return addr.isValid();

}

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

Line 446

Line 531

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 456

Line 541

p += 2;

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

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

// Validate the hostname. A domain is allowed after the hostname.

if (!slash)

// Eg. xyz.company.com

// Hostnames must match the following regular expression:

// ^([A-Za-z][A-Za-z0-9-]*)(\.[A-Za-z][A-Za-z0-9-]*)*$

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

char* q = p;

Boolean foundDot = true;

while (foundDot == true)

{

foundDot = false;

if (!isalpha(*q))

throw MalformedObjectNameException(objectName);

q++;

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

{

q++;

}

if (*q == '.')

{

q++;

foundDot = true;

}

// 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(":");

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

host.append(PEGASUS_CIMOM_DEFAULT_PORT_STRING);

if (!CIMObjectPathRep::isValidHostname(hostname))

}

// Check for slash terminating the entire sequence:

if (*q != '/')

{

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 657

Line 690

type = CIMKeyBinding::REFERENCE;

}

catch (Exception & e)

catch (const Exception &)

{

// Not a reference value; leave type as STRING

}

Line 704

Line 737

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 747

Line 788

// Convert to a C String first:

CString pCString = objectName.getCStringUTF8();

CString pCString = objectName.getCString();

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

Boolean gotHost;

Boolean gotNamespace;

Line 805

Line 846

void CIMObjectPath::setHost(const String& host)

{

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

{

throw MalformedObjectNameException(host);

}

_rep->_host = host;

}

Line 888

Line 934

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

if (type == CIMKeyBinding::STRING || 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 908

Line 956

{

CIMObjectPath ref = *this;

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

// Normalize hostname by changing to lower case

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

// 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(); // 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 930

Line 1044

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

{

return

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

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

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

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

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

Line 951

Line 1065

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.29
changed lines
	Added in v.1.60.4.1

No CVS admin address has been configured