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.46 and 1.74

version 1.46, 2005/02/28 21:12:22

version 1.74, 2008/12/02 09:00:43

Line 1

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

//%LICENSE////////////////////////////////////////////////////////////////

// Licensed to The Open Group (TOG) under one or more contributor license

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

// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with

// this work for additional information regarding copyright ownership.

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

// Each contributor licenses this file to you under the OpenPegasus Open

// Source License; you may not use this file except in compliance with the

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

// License.

// EMC Corporation; VERITAS Software 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.

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

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

#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 "HostLocator.h"

#include "System.h"

#include "CIMKeyBindingRep.h"

#include "CIMObjectPathRep.h"

PEGASUS_NAMESPACE_BEGIN

Line 99

Line 93

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;

return String::compareNoCase(

kb1->getName().getString(),

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

}

static void _Sort(Array<CIMKeyBinding>& x)

{

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)

{

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

CIMKeyBinding& kb = data[k];

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

{

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 141

Line 138

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

class CIMKeyBindingRep

{

public:

CIMKeyBindingRep()

{

}

CIMKeyBindingRep(const CIMKeyBindingRep& x)

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

{

}

CIMKeyBindingRep(

const CIMName& name,

const String& value,

CIMKeyBinding::Type type)

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

{

}

~CIMKeyBindingRep()

{

}

CIMKeyBindingRep& operator=(const CIMKeyBindingRep& x)

{

if (&x != this)

{

_name = x._name;

_value = x._value;

_type = x._type;

}

return *this;

}

CIMName _name;

String _value;

CIMKeyBinding::Type _type;

};

CIMKeyBinding::CIMKeyBinding()

{

_rep = new CIMKeyBindingRep();

Line 192

Line 148

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

Line 182

// case CIMTYPE_REAL32:

// case CIMTYPE_REAL64:

case CIMTYPE_OBJECT:

case CIMTYPE_INSTANCE:

// From PEP 194: EmbeddedObjects cannot be keys.

throw TypeMismatchException();

break;

Line 312

Line 272

// case CIMTYPE_REAL32:

// case CIMTYPE_REAL64:

case CIMTYPE_OBJECT:

case CIMTYPE_INSTANCE:

// From PEP 194: EmbeddedObjects cannot be keys.

return false;

break;

Line 350

Line 311

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 385

Line 346

}

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

Line 363

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

class CIMObjectPathRep

template<class REP>

{

inline void Ref(REP* rep)

public:

CIMObjectPathRep()

{

}

CIMObjectPathRep(const CIMObjectPathRep& x)

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

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

{

}

CIMObjectPathRep(

const String& host,

const CIMNamespaceName& nameSpace,

const CIMName& className,

const Array<CIMKeyBinding>& keyBindings)

: _host(host), _nameSpace(nameSpace),

_className(className), _keyBindings(keyBindings)

{

}

~CIMObjectPathRep()

{

}

CIMObjectPathRep& operator=(const CIMObjectPathRep& x)

{

if (&x != this)

{

_host = x._host;

_nameSpace = x._nameSpace;

_className = x._className;

_keyBindings = x._keyBindings;

}

return *this;

}

static Boolean isValidHostname(const String& 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;

rep->_refCounter++;

}

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

template<class REP>

inline void Unref(REP* rep)

{

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

if (rep->_refCounter.decAndTestIfZero())

// flag to false

delete rep;

if (isalpha(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 (hostname[i] == char(0));

}

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

String _host;

CIMNamespaceName _nameSpace;

CIMName _className;

Array<CIMKeyBinding> _keyBindings;

};

CIMObjectPath::CIMObjectPath()

{

_rep = new CIMObjectPathRep();

Line 601

Line 383

CIMObjectPath::CIMObjectPath(const CIMObjectPath& x)

{

_rep = new CIMObjectPathRep(*x._rep);

_rep = x._rep;

Ref(_rep);

}

CIMObjectPath::CIMObjectPath(const String& objectName)

Line 610

Line 393

CIMObjectPath tmpRef;

tmpRef.set(objectName);

_rep = new CIMObjectPathRep(*tmpRef._rep);

_rep = tmpRef._rep;

Ref(_rep);

}

CIMObjectPath::CIMObjectPath(

Line 622

Line 406

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

Line 468

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 787

Line 612

p++;

Buffer keyValueUTF8(128);

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

{

if (*p == '\\')

{

*p++;

p++;

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

{

Line 799

Line 626

}

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 813

Line 646

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 827

Line 667

// Not a reference value; leave type as STRING

}

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

{

type = CIMKeyBinding::BOOLEAN;

Line 869

Line 710

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 896

Line 745

}

_BubbleSort(keyBindings);

_Sort(keyBindings);

}

void CIMObjectPath::set(const String& objectName)

{

// the clear automatically ensures

// we have our own copy of the representation

clear();

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

Line 959

Line 810

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

{

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

set(objectName);

return *this;

}

Line 970

Line 822

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 985

Line 840

void CIMObjectPath::setNameSpace(const CIMNamespaceName& nameSpace)

{

_rep = _copyOnWriteCIMObjectPathRep(_rep);

_rep->_nameSpace = nameSpace;

}

Line 995

Line 851

void CIMObjectPath::setClassName(const CIMName& className)

{

_rep = _copyOnWriteCIMObjectPathRep(_rep);

_rep->_className = className;

}

Line 1005

Line 862

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

{

_rep = _copyOnWriteCIMObjectPathRep(_rep);

_rep->_keyBindings = keyBindings;

_BubbleSort(_rep->_keyBindings);

_Sort(_rep->_keyBindings);

}

String CIMObjectPath::toString() const

Line 1058

Line 916

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 1076

Line 936

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 1166

Line 1027

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.46
changed lines
	Added in v.1.74

No CVS admin address has been configured