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.51 and 1.68

version 1.51, 2005/05/20 08:58:48

version 1.68, 2008/02/06 08:27:55

Line 1

//%2005////////////////////////////////////////////////////////////////////////

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

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

Line 8

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

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)

// Dave Sudlik, IBM (dsudlik@us.ibm.com)

// Vijay Eli, IBM (vijayeli@in.ibm.com), bug#2556.

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

#include <Pegasus/Common/Config.h>

Line 47

Line 41

#include "XmlWriter.h"

#include "XmlReader.h"

#include "ArrayInternal.h"

#include "HostLocator.h"

#include "System.h"

PEGASUS_NAMESPACE_BEGIN

Line 98

Line 94

return result;

}

static void _BubbleSort(Array<CIMKeyBinding>& x)

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

{

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

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

return String::compareNoCase(

kb1->getName().getString(),

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

}

static void _Sort(Array<CIMKeyBinding>& x)

{

Uint32 n = x.size();

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

Uint32 size = x.size();

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

// sorted

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

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

if (x[k].getType () == CIMKeyBinding::REFERENCE)

{

CIMKeyBinding& kb = data[k];

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

{

CIMObjectPath tmp (x[k].getValue ());

CIMObjectPath tmp(kb.getValue());

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

_BubbleSort (keyBindings);

_Sort(keyBindings);

tmp.setKeyBindings (keyBindings);

x[k].setValue (tmp.toString ());

kb.setValue(tmp.toString());

}

if (n < 2)

if (size < 2)

return;

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

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

{

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

{

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

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

{

CIMKeyBinding t = x[j];

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

x[j+1] = t;

}

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

Line 191

Line 190

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

Line 224

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

Line 311

Line 316

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

Line 349

Line 357

catch (Exception&)

{

// If CIMObjectPath parsing fails, just compare strings

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

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

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

break;

case CIMKeyBinding::NUMERIC:

// Note: This comparison assumes XML syntax for integers

Line 384

Line 392

}

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

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

break;

default: // CIMKeyBinding::STRING

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

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

break;

}

Line 404

Line 412

class CIMObjectPathRep

{

public:

CIMObjectPathRep()

CIMObjectPathRep(): _refCounter(1)

{

}

CIMObjectPathRep(const CIMObjectPathRep& x)

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

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

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

{

}

Line 419

Line 427

const CIMNamespaceName& nameSpace,

const CIMName& className,

const Array<CIMKeyBinding>& keyBindings)

: _host(host), _nameSpace(nameSpace),

: _refCounter(1), _host(host), _nameSpace(nameSpace),

_className(className), _keyBindings(keyBindings)

{

}

Line 442

Line 450

static Boolean isValidHostname(const String& hostname)

{

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

HostLocator addr(hostname);

// Validate the hostname. The hostname value may or may not be a

// fully-qualified domain name (e.g., xyz.company.com) or may be an

// IP address. A port number may follow the hostname.

// Hostnames must match one of the following regular expressions:

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

// ^([0-9]*\.[0-9]*\.[0-9]*\.[0-9]*)(:[0-9]*)?$

// Note for Bug#1462. Be careful here, from RFC 1123:

// - The syntax of a legal Internet host name was specified in

// RFC-952 [DNS:4]. One aspect of host name syntax is hereby

// changed: the restriction on the first character is relaxed to

// allow either a letter or a digit.

// - If a dotted-decimal number can be entered without identifying

// delimiters, then a full syntactic check must be made, because

// a segment of a host domain name is now allowed to begin with a

// digit and could legally be entirely numeric (see Section 6.1.2.4).

// However, a valid host name can never have the dotted-decimal form

// #.#.#.#, since at least the highest-level component label will be

// alphabetic.

// The algorithm below has been updated accordingly.

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

Uint32 i = 0;

Boolean isValid = false;

if (isdigit(hostname[0]))

{

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

// Attempt to validate an IP address, but keep in mind that it

// might be a host name, since the leading character can now be

// a digit.

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

isValid = true;

for (Uint32 octet=1; octet<=4; octet++)

{

Uint32 octetValue = 0;

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

// If a non-digit is encountered in the input parameter,

// then break from here and attempt to validate as host name.

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

if (!isdigit(hostname[i]))

{

isValid = false;

break;

}

while (isdigit(hostname[i])) // skip over digits

{

octetValue = octetValue*10 + (hostname[i] - '0');

i++;

}

if (octetValue > 255)

{

isValid = false;

break;

}

// Check for invalid character in IP address

if ((octet != 4) && (hostname[i++] != '.'))

{

isValid = false;

break;

}

// Check for the case where it's a valid host name that happens

// to have 4 (or more) leading all-numeric host segments.

if ((octet == 4) && (hostname[i] != ':') && hostname[i] != char(0))

{

isValid = false;

break;

}

if (!isValid) // if it is not a valid IP address

{

i = 0; // reset index for host name check

// Validate a host name

isValid = true;

Boolean expectHostSegment = true;

Boolean hostSegmentIsNumeric;

while (expectHostSegment == true)

{

expectHostSegment = false;

hostSegmentIsNumeric = true; // assume all-numeric host segment

if (!isalnum(hostname[i]))

{

return false;

}

while (isalnum(hostname[i]) || (hostname[i] == '-') ||

(hostname[i] == '_'))

{

// If a non-digit is encountered, set "all-numeric"

// flag to false

if (isalpha(hostname[i]) || (hostname[i] == '-') ||

(hostname[i] == '_')) {

hostSegmentIsNumeric = false;

}

i++;

}

if (hostname[i] == '.')

{

i++;

expectHostSegment = true;

}

// If the last Host Segment is all numeric, then return false.

// RFC 1123 says "highest-level component label will be alphabetic".

if (hostSegmentIsNumeric) {

return false;

}

if (!isValid) // if not a valid IP address or host name

{

return false;

}

// Check for a port number:

if (hostname[i] == ':')

{

if (!isdigit(hostname[++i]))

{

return false;

}

while (isdigit(hostname[++i]));

return addr.isValid();

}

return (hostname[i] == char(0));

}

// reference counter as member to avoid

// virtual function resolution overhead

AtomicInt _refCounter;

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

Line 594

Line 468

Array<CIMKeyBinding> _keyBindings;

};

template<class REP>

inline void Ref(REP* rep)

{

rep->_refCounter++;

}

template<class REP>

inline void Unref(REP* rep)

{

if (rep->_refCounter.decAndTestIfZero())

delete rep;

}

CIMObjectPath::CIMObjectPath()

{

Line 602

Line 488

CIMObjectPath::CIMObjectPath(const CIMObjectPath& x)

{

_rep = new CIMObjectPathRep(*x._rep);

_rep = x._rep;

Ref(_rep);

}

CIMObjectPath::CIMObjectPath(const String& objectName)

Line 611

Line 498

CIMObjectPath tmpRef;

tmpRef.set(objectName);

_rep = new CIMObjectPathRep(*tmpRef._rep);

_rep = tmpRef._rep;

Ref(_rep);

}

CIMObjectPath::CIMObjectPath(

Line 623

Line 511

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

Line 573

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 788

Line 717

p++;

Buffer keyValueUTF8(128);

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

{

if (*p == '\\')

{

*p++;

p++;

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

{

Line 800

Line 731

}

valueString.append(*p++);

keyValueUTF8.append(*p++);

}

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

throw MalformedObjectNameException(objectName);

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

Line 814

Line 751

type = CIMKeyBinding::STRING;

/* Performance shortcut will check for

equal sign instead of doing the full

CIMObjectPath creation and exception handling

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

{

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

try

{

CIMObjectPath testForPath(valueString);

Line 828

Line 772

// Not a reference value; leave type as STRING

}

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

{

type = CIMKeyBinding::BOOLEAN;

Line 870

Line 815

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 897

Line 850

}

_BubbleSort(keyBindings);

_Sort(keyBindings);

}

void CIMObjectPath::set(const String& objectName)

{

// the clear automatically ensures

// we have our own copy of the representation

clear();

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

Line 960

Line 915

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

{

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

set(objectName);

return *this;

}

Line 971

Line 927

void CIMObjectPath::setHost(const String& host)

{

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

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

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

!CIMObjectPathRep::isValidHostname(host))

{

throw MalformedObjectNameException(host);

}

_rep = _copyOnWriteCIMObjectPathRep(_rep);

_rep->_host = host;

}

Line 986

Line 945

void CIMObjectPath::setNameSpace(const CIMNamespaceName& nameSpace)

{

_rep = _copyOnWriteCIMObjectPathRep(_rep);

_rep->_nameSpace = nameSpace;

}

Line 996

Line 956

void CIMObjectPath::setClassName(const CIMName& className)

{

_rep = _copyOnWriteCIMObjectPathRep(_rep);

_rep->_className = className;

}

Line 1006

Line 967

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

{

_rep = _copyOnWriteCIMObjectPathRep(_rep);

_rep->_keyBindings = keyBindings;

_BubbleSort(_rep->_keyBindings);

_Sort(_rep->_keyBindings);

}

String CIMObjectPath::toString() const

Line 1059

Line 1021

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 1077

Line 1041

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:

Line 1167

Line 1132

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

{

return

String::equalNoCase(_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

Legend:

Removed from v.1.51
changed lines
	Added in v.1.68

No CVS admin address has been configured