(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.64 and 1.76.4.3

version 1.64, 2007/10/31 07:52:22 version 1.76.4.3, 2013/06/03 22:35:12
Line 1 
Line 1 
 //%2006////////////////////////////////////////////////////////////////////////  //%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.  
 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;  
 // EMC Corporation; Symantec Corporation; The Open Group.  
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy  // Permission is hereby granted, free of charge, to any person obtaining a
 // of this software and associated documentation files (the "Software"), to  // copy of this software and associated documentation files (the "Software"),
 // deal in the Software without restriction, including without limitation the  // to deal in the Software without restriction, including without limitation
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or  // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 // sell copies of the Software, and to permit persons to whom the Software is  // and/or sell copies of the Software, and to permit persons to whom the
 // furnished to do so, subject to the following conditions:  // Software is furnished to do so, subject to the following conditions:
 // //
 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN  // The above copyright notice and this permission notice shall be included
 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED  // in all copies or substantial portions of the Software.
 // "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.  
 // //
 //==============================================================================  // 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.
   //
   //////////////////////////////////////////////////////////////////////////
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 36 
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 "XmlWriter.h"  #include "CIMValue.h"
 #include "XmlReader.h" #include "XmlReader.h"
   #include <Pegasus/Common/StringConversion.h>
 #include "ArrayInternal.h" #include "ArrayInternal.h"
 #include "HostLocator.h" #include "HostLocator.h"
   #include "System.h"
   #include "CIMKeyBindingRep.h"
   #include "CIMObjectPathRep.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 93 
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 135 
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 220 
Line 183 
 //  case CIMTYPE_REAL32: //  case CIMTYPE_REAL32:
 //  case CIMTYPE_REAL64: //  case CIMTYPE_REAL64:
     case CIMTYPE_OBJECT:     case CIMTYPE_OBJECT:
 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT  
     case CIMTYPE_INSTANCE:     case CIMTYPE_INSTANCE:
 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT  
         // From PEP 194: EmbeddedObjects cannot be keys.         // From PEP 194: EmbeddedObjects cannot be keys.
         throw TypeMismatchException();         throw TypeMismatchException();
         break;         break;
Line 312 
Line 273 
 //      case CIMTYPE_REAL32: //      case CIMTYPE_REAL32:
 //      case CIMTYPE_REAL64: //      case CIMTYPE_REAL64:
         case CIMTYPE_OBJECT:         case CIMTYPE_OBJECT:
 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT  
         case CIMTYPE_INSTANCE:         case CIMTYPE_INSTANCE:
 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT  
             // 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 355 
Line 313 
             // 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 378 
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 389 
Line 345 
         // 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 405 
Line 359 
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
 class CIMObjectPathRep  
 {  
 public:  
     CIMObjectPathRep(): _refCounter(1)  
     {  
     }  
   
     CIMObjectPathRep(const CIMObjectPathRep& x)  
         : _refCounter(1), _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)  
         : _refCounter(1), _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)  
     {  
         HostLocator addr(hostname);  
   
         return addr.isValid();  
     }  
   
     // reference counter as member to avoid  
     // virtual function resolution overhead  
     AtomicInt _refCounter;  
     //  
     // Contains port as well (e.g., myhost:1234).  
     //  
     String _host;  
   
     CIMNamespaceName _nameSpace;  
     CIMName _className;  
     Array<CIMKeyBinding> _keyBindings;  
 };  
   
 template<class REP> template<class REP>
 inline void Ref(REP* rep) inline void Ref(REP* rep)
 { {
Line 571 
Line 466 
 { {
     if ((host != String::EMPTY) && !CIMObjectPathRep::isValidHostname(host))     if ((host != String::EMPTY) && !CIMObjectPathRep::isValidHostname(host))
     {     {
         throw MalformedObjectNameException(host);          MessageLoaderParms mlParms(
               "Common.CIMObjectPath.INVALID_HOSTNAME",
               "$0, reason:\"invalid hostname\"",
               host);
   
           throw MalformedObjectNameException(mlParms);
     }     }
  
     _rep = _copyOnWriteCIMObjectPathRep(_rep);     _rep = _copyOnWriteCIMObjectPathRep(_rep);
Line 580 
Line 480 
     _rep->_nameSpace = nameSpace;     _rep->_nameSpace = nameSpace;
     _rep->_className = className;     _rep->_className = className;
     _rep->_keyBindings = keyBindings;     _rep->_keyBindings = keyBindings;
     _BubbleSort(_rep->_keyBindings);      _Sort(_rep->_keyBindings);
 } }
  
 Boolean _parseHostElement( Boolean _parseHostElement(
Line 602 
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 651 
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 691 
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 713 
Line 636 
  
             p++;             p++;
  
             Array<Uint8> keyValueUTF8;              Buffer keyValueUTF8(128);
             keyValueUTF8.reserveCapacity(128);  
  
             while (*p && *p != '"')             while (*p && *p != '"')
             {             {
Line 724 
Line 646 
  
                     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);
                     }                     }
                 }                 }
  
Line 732 
Line 659 
             }             }
  
             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             // Convert the UTF-8 value to a UTF-16 String
  
Line 748 
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 762 
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 778 
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 807 
Line 756 
             if (*p == '-')             if (*p == '-')
             {             {
                 Sint64 x;                 Sint64 x;
                 if (!XmlReader::stringToSignedInteger(p, x))                  if (!StringConversion::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             else
             {             {
                 Uint64 x;                 Uint64 x;
                 if (!XmlReader::stringToUnsignedInteger(p, x))                  if (!StringConversion::stringToUnsignedInteger(p, x))
                     throw MalformedObjectNameException(objectName);                  {
                       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 834 
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)
Line 867 
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 878 
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 891 
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 916 
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 = _copyOnWriteCIMObjectPathRep(_rep);
  
Line 956 
Line 946 
 { {
     _rep = _copyOnWriteCIMObjectPathRep(_rep);     _rep = _copyOnWriteCIMObjectPathRep(_rep);
     _rep->_keyBindings = keyBindings;     _rep->_keyBindings = keyBindings;
     _BubbleSort(_rep->_keyBindings);      _Sort(_rep->_keyBindings);
 } }
  
 String CIMObjectPath::toString() const String CIMObjectPath::toString() const
Line 988 
Line 978 
     //  ATTN-CAKG-P2-20020726:  The following condition does not correctly     //  ATTN-CAKG-P2-20020726:  The following condition does not correctly
     //  distinguish instanceNames from classNames in every case     //  distinguish instanceNames from classNames in every case
     //  The instanceName of a singleton instance of a keyless class has no     //  The instanceName of a singleton instance of a keyless class has no
     //  key bindings      //  key bindings. See BUG_3302
     //     //
     if (_rep->_keyBindings.size () != 0)     if (_rep->_keyBindings.size () != 0)
     {     {
Line 1086 
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 1095 
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))
             {             {

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