(file) Return to CIMObjectPath.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/CIMObjectPath.cpp between version 1.48 and 1.78

version 1.48, 2005/03/26 15:52:03 version 1.78, 2011/12/12 05:52:44
Line 1 
Line 1 
 //%2005////////////////////////////////////////////////////////////////////////  //%LICENSE////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development  // 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
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;  // 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
 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;  // Source License; you may not use this file except in compliance with the
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.  // License.
 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;  //
 // 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)  
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 41 
Line 34 
 #include <iostream> #include <iostream>
 #include "HashTable.h" #include "HashTable.h"
 #include "CIMObjectPath.h" #include "CIMObjectPath.h"
 #include "Indentor.h"  
 #include "CIMName.h" #include "CIMName.h"
 #include "Destroyer.h"  #include "CIMValue.h"
 #include "XmlWriter.h"  
 #include "XmlReader.h" #include "XmlReader.h"
   #include <Pegasus/Common/StringConversion.h>
 #include "ArrayInternal.h" #include "ArrayInternal.h"
   #include "HostLocator.h"
   #include "System.h"
   #include "CIMKeyBindingRep.h"
   #include "CIMObjectPathRep.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 98 
Line 94 
     return result;     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     //  If the key is a reference, the keys in the reference must also be
     //  sorted     //  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 ();             Array <CIMKeyBinding> keyBindings = tmp.getKeyBindings ();
             _BubbleSort (keyBindings);              _Sort(keyBindings);
             tmp.setKeyBindings (keyBindings);             tmp.setKeyBindings (keyBindings);
             x[k].setValue (tmp.toString ());              kb.setValue(tmp.toString());
           }
         }         }
  
     if (n < 2)      if (size < 2)
         return;         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 140 
Line 139 
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
 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() CIMKeyBinding::CIMKeyBinding()
 { {
     _rep = new CIMKeyBindingRep();     _rep = new CIMKeyBindingRep();
Line 191 
Line 149 
     _rep = new CIMKeyBindingRep(*x._rep);     _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);     _rep = new CIMKeyBindingRep(name, value, type);
 } }
Line 222 
Line 183 
 //  case CIMTYPE_REAL32: //  case CIMTYPE_REAL32:
 //  case CIMTYPE_REAL64: //  case CIMTYPE_REAL64:
     case CIMTYPE_OBJECT:     case CIMTYPE_OBJECT:
       case CIMTYPE_INSTANCE:
         // From PEP 194: EmbeddedObjects cannot be keys.         // From PEP 194: EmbeddedObjects cannot be keys.
         throw TypeMismatchException();         throw TypeMismatchException();
         break;         break;
Line 311 
Line 273 
 //      case CIMTYPE_REAL32: //      case CIMTYPE_REAL32:
 //      case CIMTYPE_REAL64: //      case CIMTYPE_REAL64:
         case CIMTYPE_OBJECT:         case CIMTYPE_OBJECT:
           case CIMTYPE_INSTANCE:
             // From PEP 194: EmbeddedObjects cannot be keys.             // From PEP 194: EmbeddedObjects cannot be keys.
             return false;             return false;
             break;  
         default:  // Numerics         default:  // Numerics
             if (getType() != NUMERIC) return false;             if (getType() != NUMERIC) return false;
             kbValue = XmlReader::stringToValue(0, getValue().getCString(),             kbValue = XmlReader::stringToValue(0, getValue().getCString(),
Line 349 
Line 311 
         catch (Exception&)         catch (Exception&)
         {         {
             // If CIMObjectPath parsing fails, just compare strings             // 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 CIMKeyBinding::BOOLEAN:
         // Case-insensitive comparison is sufficient for booleans         // 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:     case CIMKeyBinding::NUMERIC:
         // Note: This comparison assumes XML syntax for integers         // Note: This comparison assumes XML syntax for integers
         // First try comparing as unsigned integers         // First try comparing as unsigned integers
         {         {
             Uint64 xValue;             Uint64 xValue;
             Uint64 yValue;             Uint64 yValue;
             if (XmlReader::stringToUnsignedInteger(              if (StringConversion::stringToUnsignedInteger(
                     x.getValue().getCString(), xValue) &&                     x.getValue().getCString(), xValue) &&
                 XmlReader::stringToUnsignedInteger(                  StringConversion::stringToUnsignedInteger(
                     y.getValue().getCString(), yValue))                     y.getValue().getCString(), yValue))
             {             {
                 return (xValue == yValue);                 return (xValue == yValue);
Line 374 
Line 334 
         {         {
             Sint64 xValue;             Sint64 xValue;
             Sint64 yValue;             Sint64 yValue;
             if (XmlReader::stringToSignedInteger(              if (StringConversion::stringToSignedInteger(
                     x.getValue().getCString(), xValue) &&                     x.getValue().getCString(), xValue) &&
                 XmlReader::stringToSignedInteger(                  StringConversion::stringToSignedInteger(
                     y.getValue().getCString(), yValue))                     y.getValue().getCString(), yValue))
             {             {
                 return (xValue == yValue);                 return (xValue == yValue);
Line 384 
Line 344 
         }         }
         // Note: Keys may not be real values, so don't try comparing as reals         // 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         // 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     default:  // CIMKeyBinding::STRING
         return (String::equal(x.getValue(), y.getValue()));          return String::equal(x.getValue(), y.getValue());
         break;  
     }     }
  
     PEGASUS_UNREACHABLE(return false;)     PEGASUS_UNREACHABLE(return false;)
Line 401 
Line 359 
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
 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 (hostname[0].isDigit())  
         {  
             //--------------------------------------------------------------  
             // 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 (!hostname[i].isDigit())  
                 {  
                     isValid = false;  
                     break;  
                 }  
   
                 while (hostname[i].isDigit())  // skip over digits  
                 {  
                     octetValue = octetValue*10 + (hostname[i] - '0');  
                     i++;  
                 }  
   
                 if (octetValue > 255)  
                 {                 {
                     isValid = false;          rep->_refCounter++;
                     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  template<class REP>
                 // to have 4 (or more) leading all-numeric host segments.  inline void Unref(REP* rep)
                 if ((octet == 4) && (hostname[i] != ':') && hostname[i] != char(0))  
                 {                 {
                     isValid = false;      if (rep->_refCounter.decAndTestIfZero())
                     break;          delete rep;
                 }                 }
             }  
         }  
         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 (!hostname[i].isAlnum())  
                 {  
                     return false;  
                 }  
   
                 while (hostname[i].isAlnum() || (hostname[i] == '-'))  
                 {  
                     // If a non-digit is encountered, set "all-numeric"  
                     // flag to false  
                     if (hostname[i].isAlpha() || (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 (!hostname[++i].isDigit())  
             {  
                 return false;  
             }  
   
             while (hostname[++i].isDigit());  
         }  
   
         return (hostname[i] == char(0));  
     }  
   
     //  
     // Contains port as well (e.g., myhost:1234).  
     //  
     String _host;  
   
     CIMNamespaceName _nameSpace;  
     CIMName _className;  
     Array<CIMKeyBinding> _keyBindings;  
 };  
   
  
 CIMObjectPath::CIMObjectPath() CIMObjectPath::CIMObjectPath()
 { {
Line 600 
Line 379 
  
 CIMObjectPath::CIMObjectPath(const CIMObjectPath& x) CIMObjectPath::CIMObjectPath(const CIMObjectPath& x)
 { {
     _rep = new CIMObjectPathRep(*x._rep);      _rep = x._rep;
       Ref(_rep);
 } }
  
 CIMObjectPath::CIMObjectPath(const String& objectName) CIMObjectPath::CIMObjectPath(const String& objectName)
Line 609 
Line 389 
     CIMObjectPath tmpRef;     CIMObjectPath tmpRef;
     tmpRef.set(objectName);     tmpRef.set(objectName);
  
     _rep = new CIMObjectPathRep(*tmpRef._rep);      _rep = tmpRef._rep;
       Ref(_rep);
 } }
  
 CIMObjectPath::CIMObjectPath( CIMObjectPath::CIMObjectPath(
Line 621 
Line 402 
     // Test the objectName out to see if we get an exception     // Test the objectName out to see if we get an exception
     CIMObjectPath tmpRef;     CIMObjectPath tmpRef;
     tmpRef.set(host, nameSpace, className, keyBindings);     tmpRef.set(host, nameSpace, className, keyBindings);
       _rep = tmpRef._rep;
     _rep = new CIMObjectPathRep(*tmpRef._rep);      Ref(_rep);
 } }
  
 CIMObjectPath::~CIMObjectPath() CIMObjectPath::~CIMObjectPath()
 { {
     delete _rep;      Unref(_rep);
 } }
  
 CIMObjectPath& CIMObjectPath::operator=(const CIMObjectPath& x) CIMObjectPath& CIMObjectPath::operator=(const CIMObjectPath& x)
 { {
     *_rep = *x._rep;      if (x._rep != _rep)
       {
           Unref(_rep);
           _rep = x._rep;
           Ref(_rep);
       }
     return *this;     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() 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->_host.clear();
     _rep->_nameSpace.clear();     _rep->_nameSpace.clear();
     _rep->_className.clear();     _rep->_className.clear();
     _rep->_keyBindings.clear();     _rep->_keyBindings.clear();
 } }
   }
  
 void CIMObjectPath::set( void CIMObjectPath::set(
     const String& host,     const String& host,
Line 650 
Line 464 
     const CIMName& className,     const CIMName& className,
     const Array<CIMKeyBinding>& keyBindings)     const Array<CIMKeyBinding>& keyBindings)
 { {
    setHost(host);      if ((host != String::EMPTY) && !CIMObjectPathRep::isValidHostname(host))
    setNameSpace(nameSpace);      {
    setClassName(className);          MessageLoaderParms mlParms(
    setKeyBindings(keyBindings);              "Common.CIMObjectPath.INVALID_HOSTNAME",
               "$0, reason:\"invalid hostname\"",
               host);
   
           throw MalformedObjectNameException(mlParms);
       }
   
       _rep = _copyOnWriteCIMObjectPathRep(_rep);
   
       _rep->_host.assign(host);
       _rep->_nameSpace = nameSpace;
       _rep->_className = className;
       _rep->_keyBindings = keyBindings;
       _Sort(_rep->_keyBindings);
 } }
  
 Boolean _parseHostElement( Boolean _parseHostElement(
Line 675 
Line 502 
     char* slash = strchr(p, '/');     char* slash = strchr(p, '/');
     if (!slash)     if (!slash)
     {     {
         throw MalformedObjectNameException(objectName);          MessageLoaderParms mlParms(
               "Common.CIMObjectPath.MISSING_SLASH_AFTER_HOST",
               "$0, reason:\"missing slash after hostname\"",
               objectName);
           throw MalformedObjectNameException(mlParms);
     }     }
  
     String hostname = String(p, (Uint32)(slash - p));     String hostname = String(p, (Uint32)(slash - p));
     if (!CIMObjectPathRep::isValidHostname(hostname))     if (!CIMObjectPathRep::isValidHostname(hostname))
     {     {
         throw MalformedObjectNameException(objectName);          MessageLoaderParms mlParms(
               "Common.CIMObjectPath.INVALID_HOSTNAME",
               "$0, reason:\"invalid hostname\"",
               objectName);
           throw MalformedObjectNameException(mlParms);
     }     }
     host = hostname;     host = hostname;
  
Line 724 
Line 559 
     String namespaceName = String(p, (Uint32)(colon - p));     String namespaceName = String(p, (Uint32)(colon - p));
     if (!CIMNamespaceName::legal(namespaceName))     if (!CIMNamespaceName::legal(namespaceName))
     {     {
         throw MalformedObjectNameException(objectName);          MessageLoaderParms mlParms(
               "Common.CIMObjectPath.INVALID_NAMESPACE",
               "$0, reason:\"invalid namespace name\"",
               objectName);
           throw MalformedObjectNameException(mlParms);
     }     }
     nameSpace = namespaceName;     nameSpace = namespaceName;
  
Line 764 
Line 603 
         char* equalsign = strchr(p, '=');         char* equalsign = strchr(p, '=');
         if (!equalsign)         if (!equalsign)
         {         {
             throw MalformedObjectNameException(objectName);              MessageLoaderParms mlParms(
                   "Common.CIMObjectPath.INVALID_KEYVALUEPAIR",
                   "$0, reason:\"invalid key-value pair, missing equal sign\"",
                   objectName);
               throw MalformedObjectNameException(mlParms);
         }         }
  
         *equalsign = 0;         *equalsign = 0;
  
         if (!CIMName::legal(p))         if (!CIMName::legal(p))
             throw MalformedObjectNameException(objectName);          {
               MessageLoaderParms mlParms(
                   "Common.CIMObjectPath.INVALID_KEYNAME",
                   "$0, reason:\"invalid key-value pair, invalid key name:$1\"",
                   objectName,
                   p);
               throw MalformedObjectNameException(mlParms);
           }
  
         CIMName keyName (p);         CIMName keyName (p);
  
Line 786 
Line 636 
  
             p++;             p++;
  
               Buffer keyValueUTF8(128);
   
             while (*p && *p != '"')             while (*p && *p != '"')
             {             {
                 if (*p == '\\')                 if (*p == '\\')
                 {                 {
                     *p++;                      p++;
  
                     if ((*p != '\\') && (*p != '"'))                     if ((*p != '\\') && (*p != '"'))
                     {                     {
                         throw MalformedObjectNameException(objectName);                          MessageLoaderParms mlParms(
                               "Common.CIMObjectPath.INVALID_KEYVALUE",
                               "$0, reason:\"invalid key-value pair, "
                                   "malformed value\"",
                               objectName);
                           throw MalformedObjectNameException(mlParms);
                     }                     }
                 }                 }
  
                 valueString.append(*p++);                  keyValueUTF8.append(*p++);
             }             }
  
             if (*p++ != '"')             if (*p++ != '"')
                 throw MalformedObjectNameException(objectName);              {
                   MessageLoaderParms mlParms(
                       "Common.CIMObjectPath.INVALID_KEYVALUEPAIR_MISSINGQUOTE",
                       "$0, reason:\"invalid key-value pair, "
                           "missing quote in key value\"",
                       objectName);
                   throw MalformedObjectNameException(mlParms);
               }
   
               // 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                 Guess at the type of this quoted key value.  If the value
Line 812 
Line 682 
              */              */
             type = CIMKeyBinding::STRING;             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             try
             {             {
                 CIMObjectPath testForPath(valueString);                 CIMObjectPath testForPath(valueString);
Line 826 
Line 703 
                 // Not a reference value; leave type as STRING                 // Not a reference value; leave type as STRING
             }             }
         }         }
           }
         else if (toupper(*p) == 'T' || toupper(*p) == 'F')         else if (toupper(*p) == 'T' || toupper(*p) == 'F')
         {         {
             type = CIMKeyBinding::BOOLEAN;             type = CIMKeyBinding::BOOLEAN;
Line 842 
Line 720 
  
             if (!(((strncmp(p, "TRUE", n) == 0) && n == 4) ||             if (!(((strncmp(p, "TRUE", n) == 0) && n == 4) ||
                   ((strncmp(p, "FALSE", n) == 0) && n == 5)))                   ((strncmp(p, "FALSE", n) == 0) && n == 5)))
                 throw MalformedObjectNameException(objectName);              {
                   MessageLoaderParms mlParms(
                       "Common.CIMObjectPath.INVALID_BOOLVALUE",
                       "$0, reason:\"invalid key-value pair, "
                           "value should be TRUE or FALSE\"",
                       objectName);
                   throw MalformedObjectNameException(mlParms);
               }
  
             valueString.assign(p, n);             valueString.assign(p, n);
  
Line 868 
Line 753 
                 isComma = true;                 isComma = true;
             }             }
  
               if (*p == '-')
               {
             Sint64 x;             Sint64 x;
                   if (!StringConversion::stringToSignedInteger(p, x))
             if (!XmlReader::stringToSignedInteger(p, x))                  {
                 throw MalformedObjectNameException(objectName);                      MessageLoaderParms mlParms(
                           "Common.CIMObjectPath.INVALID_NEGATIVNUMBER_VALUE",
                           "$0, reason:\"invalid key-value pair, "
                               "invalid negative number value $1\"",
                           objectName,
                           p);
                       throw MalformedObjectNameException(mlParms);
                   }
               }
               else
               {
                   Uint64 x;
                   if (!StringConversion::stringToUnsignedInteger(p, x))
                   {
                       MessageLoaderParms mlParms(
                           "Common.CIMObjectPath.INVALID_NEGATIVNUMBER_VALUE",
                           "$0, reason:\"invalid key-value pair, "
                               "invalid number value $1\"",
                           objectName,
                           p);
                       throw MalformedObjectNameException(mlParms);
                   }
               }
  
             valueString.assign(p, n);             valueString.assign(p, n);
  
Line 890 
Line 799 
         {         {
             if (*p++ != ',')             if (*p++ != ',')
             {             {
                 throw MalformedObjectNameException(objectName);                  MessageLoaderParms mlParms(
                       "Common.CIMObjectPath.INVALID_KEYVALUEPAIR_MISSCOMMA",
                       "$0, reason:\"invalid key-value pair, "
                           "next key-value pair has to start with comma\"",
                       objectName);
                   throw MalformedObjectNameException(mlParms);
             }             }
         }         }
     }     }
  
     _BubbleSort(keyBindings);      _Sort(keyBindings);
 } }
  
 void CIMObjectPath::set(const String& objectName) void CIMObjectPath::set(const String& objectName)
 { {
       // the clear automatically ensures
       // we have our own copy of the representation
     clear();     clear();
  
     //--------------------------------------------------------------------------     //--------------------------------------------------------------------------
Line 921 
Line 837 
  
     if (gotHost && !gotNamespace)     if (gotHost && !gotNamespace)
     {     {
         throw MalformedObjectNameException(objectName);          MessageLoaderParms mlParms(
               "Common.CIMObjectPath.MISSING_NAMESPACE",
               "$0, reason:\"host specified, missing namespace\"",
               objectName);
           throw MalformedObjectNameException(mlParms);
     }     }
  
     // Extract the class name:     // Extract the class name:
Line 932 
Line 852 
     {     {
         if (!CIMName::legal(p))         if (!CIMName::legal(p))
         {         {
             throw MalformedObjectNameException(objectName);              MessageLoaderParms mlParms(
                   "Common.CIMObjectPath.INVALID_CLASSNAME",
                   "$0, reason:\"class name $1 not a legal CIM name\"",
                   objectName,
                   p);
               throw MalformedObjectNameException(mlParms);
         }         }
  
         // ATTN: remove this later: a reference should only be able to hold         // ATTN: remove this later: a reference should only be able to hold
Line 945 
Line 870 
     String className = String(p, (Uint32)(dot - p));     String className = String(p, (Uint32)(dot - p));
     if (!CIMName::legal(className))     if (!CIMName::legal(className))
     {     {
         throw MalformedObjectNameException(objectName);          MessageLoaderParms mlParms(
               "Common.CIMObjectPath.INVALID_CLASSNAME",
               "$0, reason:\"class name $1 not a legal CIM name\"",
               objectName,
               className);
           throw MalformedObjectNameException(mlParms);
     }     }
     _rep->_className = className;     _rep->_className = className;
  
Line 958 
Line 888 
  
 CIMObjectPath& CIMObjectPath::operator=(const String& objectName) CIMObjectPath& CIMObjectPath::operator=(const String& objectName)
 { {
       // set will call clear, which will cause copyOnWrite if necessary
     set(objectName);     set(objectName);
     return *this;     return *this;
 } }
Line 969 
Line 900 
  
 void CIMObjectPath::setHost(const String& host) void CIMObjectPath::setHost(const String& host)
 { {
     if ((host != String::EMPTY) && !CIMObjectPathRep::isValidHostname(host))      if ((host != String::EMPTY) &&
     {          (host != System::getHostName()) &&
         throw MalformedObjectNameException(host);          !CIMObjectPathRep::isValidHostname(host))
       {
           MessageLoaderParms mlParms(
               "Common.CIMObjectPath.INVALID_HOSTNAME",
               "$0, reason:\"invalid hostname\"",
               host);
           throw MalformedObjectNameException(mlParms);
     }     }
       _rep = _copyOnWriteCIMObjectPathRep(_rep);
  
     _rep->_host = host;     _rep->_host = host;
 } }
Line 984 
Line 922 
  
 void CIMObjectPath::setNameSpace(const CIMNamespaceName& nameSpace) void CIMObjectPath::setNameSpace(const CIMNamespaceName& nameSpace)
 { {
       _rep = _copyOnWriteCIMObjectPathRep(_rep);
    _rep->_nameSpace = nameSpace;    _rep->_nameSpace = nameSpace;
 } }
  
Line 994 
Line 933 
  
 void CIMObjectPath::setClassName(const CIMName& className) void CIMObjectPath::setClassName(const CIMName& className)
 { {
       _rep = _copyOnWriteCIMObjectPathRep(_rep);
     _rep->_className = className;     _rep->_className = className;
 } }
  
Line 1004 
Line 944 
  
 void CIMObjectPath::setKeyBindings(const Array<CIMKeyBinding>& keyBindings) void CIMObjectPath::setKeyBindings(const Array<CIMKeyBinding>& keyBindings)
 { {
       _rep = _copyOnWriteCIMObjectPathRep(_rep);
     _rep->_keyBindings = keyBindings;     _rep->_keyBindings = keyBindings;
     _BubbleSort(_rep->_keyBindings);      _Sort(_rep->_keyBindings);
 } }
  
 String CIMObjectPath::toString() const String CIMObjectPath::toString() const
Line 1057 
Line 998 
  
             CIMKeyBinding::Type type = keyBindings[i].getType();             CIMKeyBinding::Type type = keyBindings[i].getType();
  
             if (type == CIMKeyBinding::STRING || type == CIMKeyBinding::REFERENCE)              if (type == CIMKeyBinding::STRING ||
                   type == CIMKeyBinding::REFERENCE)
                 objectName.append('"');                 objectName.append('"');
  
             objectName.append(value);             objectName.append(value);
  
             if (type == CIMKeyBinding::STRING || type == CIMKeyBinding::REFERENCE)              if (type == CIMKeyBinding::STRING ||
                   type == CIMKeyBinding::REFERENCE)
                 objectName.append('"');                 objectName.append('"');
  
             if (i + 1 != n)             if (i + 1 != n)
Line 1075 
Line 1018 
  
 String CIMObjectPath::_toStringCanonical() const String CIMObjectPath::_toStringCanonical() const
 { {
     CIMObjectPath ref = *this;      CIMObjectPath ref;
       *ref._rep = *this->_rep;
  
     // Normalize hostname by changing to lower case     // Normalize hostname by changing to lower case
     ref._rep->_host.toLower(); // ICU_TODO:     ref._rep->_host.toLower(); // ICU_TODO:
Line 1132 
Line 1076 
             Uint64 uValue;             Uint64 uValue;
             Sint64 sValue;             Sint64 sValue;
             // First try converting to unsigned integer             // First try converting to unsigned integer
             if (XmlReader::stringToUnsignedInteger(              if (StringConversion::stringToUnsignedInteger(
                     ref._rep->_keyBindings[i]._rep->_value.getCString(),                     ref._rep->_keyBindings[i]._rep->_value.getCString(),
                         uValue))                         uValue))
             {             {
Line 1141 
Line 1085 
                 ref._rep->_keyBindings[i]._rep->_value = String(buffer);                 ref._rep->_keyBindings[i]._rep->_value = String(buffer);
             }             }
             // Next try converting to signed integer             // Next try converting to signed integer
             else if (XmlReader::stringToSignedInteger(              else if (StringConversion::stringToSignedInteger(
                          ref._rep->_keyBindings[i]._rep->_value.getCString(),                          ref._rep->_keyBindings[i]._rep->_value.getCString(),
                              sValue))                              sValue))
             {             {
Line 1165 
Line 1109 
 Boolean CIMObjectPath::identical(const CIMObjectPath& x) const Boolean CIMObjectPath::identical(const CIMObjectPath& x) const
 { {
     return     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->_nameSpace.equal(x._rep->_nameSpace) &&
         _rep->_className.equal(x._rep->_className) &&         _rep->_className.equal(x._rep->_className) &&
         _rep->_keyBindings == x._rep->_keyBindings;           (_rep->_keyBindings == x._rep->_keyBindings));
 } }
  
 Uint32 CIMObjectPath::makeHashCode() const Uint32 CIMObjectPath::makeHashCode() const

Legend:
Removed from v.1.48  
changed lines
  Added in v.1.78
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2