(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.31 and 1.64

version 1.31, 2003/11/11 21:35:39 version 1.64, 2007/10/31 07:52:22
Line 1 
Line 1 
 //%2003////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002  BMC Software, Hewlett-Packard Development  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // Company, L. P., IBM Corp., The Open Group, Tivoli Systems.  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;
 // IBM Corp.; EMC Corporation, The Open Group. // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // 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 copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 23 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@bmc.com)  
 //  
 // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)  
 //              Carol Ann Krug Graves, Hewlett-Packard Company  
 //                (carolann_graves@hp.com)  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <cctype>  
 #include <cstring> #include <cstring>
 #include <iostream> #include <iostream>
 #include "HashTable.h" #include "HashTable.h"
 #include "CIMObjectPath.h" #include "CIMObjectPath.h"
 #include "Indentor.h" #include "Indentor.h"
 #include "CIMName.h" #include "CIMName.h"
 #include "Destroyer.h"  
 #include "XmlWriter.h" #include "XmlWriter.h"
 #include "XmlReader.h" #include "XmlReader.h"
 #include "ArrayInternal.h" #include "ArrayInternal.h"
 #include "CIMOMPort.h"  #include "HostLocator.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 188 
Line 186 
     _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 216 
Line 217 
     case CIMTYPE_REFERENCE:     case CIMTYPE_REFERENCE:
         kbType = REFERENCE;         kbType = REFERENCE;
         break;         break;
   //  case CIMTYPE_REAL32:
   //  case CIMTYPE_REAL64:
       case CIMTYPE_OBJECT:
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
       case CIMTYPE_INSTANCE:
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
           // From PEP 194: EmbeddedObjects cannot be keys.
           throw TypeMismatchException();
           break;
     default:     default:
         kbType = NUMERIC;         kbType = NUMERIC;
         break;         break;
Line 299 
Line 309 
             kbValue = XmlReader::stringToValue(0, getValue().getCString(),             kbValue = XmlReader::stringToValue(0, getValue().getCString(),
                                                value.getType());                                                value.getType());
             break;             break;
   //      case CIMTYPE_REAL32:
   //      case CIMTYPE_REAL64:
           case CIMTYPE_OBJECT:
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
           case CIMTYPE_INSTANCE:
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
               // From PEP 194: EmbeddedObjects cannot be keys.
               return false;
               break;
         default:  // Numerics         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 316 
Line 335 
  
 Boolean operator==(const CIMKeyBinding& x, const CIMKeyBinding& y) Boolean operator==(const CIMKeyBinding& x, const CIMKeyBinding& y)
 { {
     return      // Check that the names and types match
         x.getName().equal(y.getName()) &&      if (!(x.getName().equal(y.getName())) ||
         String::equal(x.getValue(), y.getValue()) &&          !(x.getType() == y.getType()))
         x.getType() == y.getType();      {
           return false;
       }
   
       switch (x.getType())
       {
       case CIMKeyBinding::REFERENCE:
           try
           {
               // References should be compared as CIMObjectPaths
               return (CIMObjectPath(x.getValue()) == CIMObjectPath(y.getValue()));
           }
           catch (Exception&)
           {
               // If CIMObjectPath parsing fails, just compare strings
               return String::equal(x.getValue(), y.getValue());
           }
           break;
       case CIMKeyBinding::BOOLEAN:
           // Case-insensitive comparison is sufficient for booleans
           return String::equalNoCase(x.getValue(), y.getValue());
           break;
       case CIMKeyBinding::NUMERIC:
           // Note: This comparison assumes XML syntax for integers
           // First try comparing as unsigned integers
           {
               Uint64 xValue;
               Uint64 yValue;
               if (XmlReader::stringToUnsignedInteger(
                       x.getValue().getCString(), xValue) &&
                   XmlReader::stringToUnsignedInteger(
                       y.getValue().getCString(), yValue))
               {
                   return (xValue == yValue);
               }
           }
           // Next try comparing as signed integers
           {
               Sint64 xValue;
               Sint64 yValue;
               if (XmlReader::stringToSignedInteger(
                       x.getValue().getCString(), xValue) &&
                   XmlReader::stringToSignedInteger(
                       y.getValue().getCString(), yValue))
               {
                   return (xValue == yValue);
               }
           }
           // Note: Keys may not be real values, so don't try comparing as reals
           // We couldn't parse the numbers, so just compare the strings
           return String::equal(x.getValue(), y.getValue());
           break;
       default:  // CIMKeyBinding::STRING
           return String::equal(x.getValue(), y.getValue());
           break;
       }
   
       PEGASUS_UNREACHABLE(return false;)
 } }
  
  
Line 332 
Line 408 
 class CIMObjectPathRep class CIMObjectPathRep
 { {
 public: public:
     CIMObjectPathRep()      CIMObjectPathRep(): _refCounter(1)
     {     {
     }     }
  
     CIMObjectPathRep(const CIMObjectPathRep& x)     CIMObjectPathRep(const CIMObjectPathRep& x)
         : _host(x._host), _nameSpace(x._nameSpace),          : _refCounter(1), _host(x._host), _nameSpace(x._nameSpace),
         _className(x._className), _keyBindings(x._keyBindings)         _className(x._className), _keyBindings(x._keyBindings)
     {     {
     }     }
Line 347 
Line 423 
         const CIMNamespaceName& nameSpace,         const CIMNamespaceName& nameSpace,
         const CIMName& className,         const CIMName& className,
         const Array<CIMKeyBinding>& keyBindings)         const Array<CIMKeyBinding>& keyBindings)
         : _host(host), _nameSpace(nameSpace),          : _refCounter(1), _host(host), _nameSpace(nameSpace),
         _className(className), _keyBindings(keyBindings)         _className(className), _keyBindings(keyBindings)
     {     {
     }     }
Line 368 
Line 444 
         return *this;         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).     // Contains port as well (e.g., myhost:1234).
     //     //
Line 378 
Line 464 
     Array<CIMKeyBinding> _keyBindings;     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() CIMObjectPath::CIMObjectPath()
 { {
Line 386 
Line 484 
  
 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 395 
Line 494 
     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 407 
Line 507 
     // 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 436 
Line 569 
     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);          throw MalformedObjectNameException(host);
    setKeyBindings(keyBindings);      }
   
       _rep = _copyOnWriteCIMObjectPathRep(_rep);
   
       _rep->_host.assign(host);
       _rep->_nameSpace = nameSpace;
       _rep->_className = className;
       _rep->_keyBindings = keyBindings;
       _BubbleSort(_rep->_keyBindings);
 } }
  
 Boolean _parseHostElement( Boolean _parseHostElement(
Line 448 
Line 589 
     String& host)     String& host)
 { {
     // See if there is a host name (true if it begins with "//"):     // See if there is a host name (true if it begins with "//"):
     // Host is of the from <hostname>-<port> and begins with "//"      // Host is of the form <hostname>:<port> and begins with "//"
     // and ends with "/":     // and ends with "/":
  
     if (p[0] != '/' || p[1] != '/')     if (p[0] != '/' || p[1] != '/')
Line 458 
Line 599 
  
     p += 2;     p += 2;
  
     //----------------------------------------------------------------------      char* slash = strchr(p, '/');
     // Validate the hostname. A domain is allowed after the hostname.      if (!slash)
     // Eg. xyz.company.com  
     // Hostnames must match the following regular expression:  
     // ^([A-Za-z][A-Za-z0-9-]*)(\.[A-Za-z][A-Za-z0-9-]*)*$  
     //----------------------------------------------------------------------  
   
     char* q = p;  
   
     Boolean foundDot = true;  
     while (foundDot == true)  
     {  
         foundDot = false;  
   
         if (!isalpha(*q))  
             throw MalformedObjectNameException(objectName);  
   
         q++;  
   
         while (isalnum(*q) || *q == '-')  
         {  
             q++;  
         }  
   
         if (*q == '.')  
         {  
             q++;  
             foundDot = true;  
         }  
      }  
   
     // We now expect a port (or default the port).  
   
     if (*q == ':')  
     {     {
         q++;  
         // Check for a port number:  
   
         if (!isdigit(*q))  
             throw MalformedObjectNameException(objectName);             throw MalformedObjectNameException(objectName);
   
         while (isdigit(*q))  
             q++;  
   
         // Finally, assign the host name:  
   
         host.assign(p, q - p);  
     }     }
     else  
     {  
         host.assign(p, q - p);  
   
         // Assign the default port number:  
  
         host.append(":");      String hostname = String(p, (Uint32)(slash - p));
         host.append(PEGASUS_CIMOM_DEFAULT_PORT_STRING);      if (!CIMObjectPathRep::isValidHostname(hostname))
     }  
   
     // Check for slash terminating the entire sequence:  
   
     if (*q != '/')  
     {     {
         host.clear();  
         throw MalformedObjectNameException(objectName);         throw MalformedObjectNameException(objectName);
     }     }
       host = hostname;
  
     // Do not step past the '/'; it will be consumed by the namespace parser     // Do not step past the '/'; it will be consumed by the namespace parser
     p = q;      p = slash;
  
     return true;     return true;
 } }
Line 625 
Line 713 
  
             p++;             p++;
  
               Array<Uint8> keyValueUTF8;
               keyValueUTF8.reserveCapacity(128);
   
             while (*p && *p != '"')             while (*p && *p != '"')
             {             {
                 if (*p == '\\')                 if (*p == '\\')
                 {                 {
                     *p++;                      p++;
  
                     if ((*p != '\\') && (*p != '"'))                     if ((*p != '\\') && (*p != '"'))
                     {                     {
Line 637 
Line 728 
                     }                     }
                 }                 }
  
                 valueString.append(*p++);                  keyValueUTF8.append(*p++);
             }             }
  
             if (*p++ != '"')             if (*p++ != '"')
                 throw MalformedObjectNameException(objectName);                 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                 Guess at the type of this quoted key value.  If the value
                 can be parsed into a CIMObjectPath with at least one key                 can be parsed into a CIMObjectPath with at least one key
Line 660 
Line 757 
                     type = CIMKeyBinding::REFERENCE;                     type = CIMKeyBinding::REFERENCE;
                 }                 }
             }             }
             catch (Exception & e)              catch (const Exception &)
             {             {
                 // Not a reference value; leave type as STRING                 // Not a reference value; leave type as STRING
             }             }
Line 707 
Line 804 
                 isComma = true;                 isComma = true;
             }             }
  
               if (*p == '-')
               {
             Sint64 x;             Sint64 x;
   
             if (!XmlReader::stringToSignedInteger(p, x))             if (!XmlReader::stringToSignedInteger(p, x))
                 throw MalformedObjectNameException(objectName);                 throw MalformedObjectNameException(objectName);
               }
               else
               {
                   Uint64 x;
                   if (!XmlReader::stringToUnsignedInteger(p, x))
                       throw MalformedObjectNameException(objectName);
               }
  
             valueString.assign(p, n);             valueString.assign(p, n);
  
Line 739 
Line 844 
  
 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 750 
Line 857 
  
     // Convert to a C String first:     // Convert to a C String first:
  
     CString pCString = objectName.getCStringUTF8();      CString pCString = objectName.getCString();
     char* p = const_cast<char*>((const char*) pCString);     char* p = const_cast<char*>((const char*) pCString);
     Boolean gotHost;     Boolean gotHost;
     Boolean gotNamespace;     Boolean gotNamespace;
Line 797 
Line 904 
  
 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 808 
Line 916 
  
 void CIMObjectPath::setHost(const String& host) void CIMObjectPath::setHost(const String& host)
 { {
       if ((host != String::EMPTY) && !CIMObjectPathRep::isValidHostname(host))
       {
           throw MalformedObjectNameException(host);
       }
       _rep = _copyOnWriteCIMObjectPathRep(_rep);
   
     _rep->_host = host;     _rep->_host = host;
 } }
  
Line 818 
Line 932 
  
 void CIMObjectPath::setNameSpace(const CIMNamespaceName& nameSpace) void CIMObjectPath::setNameSpace(const CIMNamespaceName& nameSpace)
 { {
       _rep = _copyOnWriteCIMObjectPathRep(_rep);
    _rep->_nameSpace = nameSpace;    _rep->_nameSpace = nameSpace;
 } }
  
Line 828 
Line 943 
  
 void CIMObjectPath::setClassName(const CIMName& className) void CIMObjectPath::setClassName(const CIMName& className)
 { {
       _rep = _copyOnWriteCIMObjectPathRep(_rep);
     _rep->_className = className;     _rep->_className = className;
 } }
  
Line 838 
Line 954 
  
 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);     _BubbleSort(_rep->_keyBindings);
 } }
Line 891 
Line 1008 
  
             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 909 
Line 1028 
  
 String CIMObjectPath::_toStringCanonical() const String CIMObjectPath::_toStringCanonical() const
 { {
     CIMObjectPath ref = *this;      CIMObjectPath ref;
       *ref._rep = *this->_rep;
  
     // ATTN-RK-P2-20020510: Need to make hostname and namespace lower case?      // Normalize hostname by changing to lower case
       ref._rep->_host.toLower(); // ICU_TODO:
  
       // Normalize namespace by changing to lower case
       if (!ref._rep->_nameSpace.isNull())
       {
           String nameSpaceLower = ref._rep->_nameSpace.getString();
           nameSpaceLower.toLower(); // ICU_TODO:
           ref._rep->_nameSpace = nameSpaceLower;
       }
   
       // Normalize class name by changing to lower case
       if (!ref._rep->_className.isNull())
       {
     String classNameLower = ref._rep->_className.getString ();     String classNameLower = ref._rep->_className.getString ();
     classNameLower.toLower(); // ICU_TODO:     classNameLower.toLower(); // ICU_TODO:
     ref._rep->_className = classNameLower;     ref._rep->_className = classNameLower;
       }
  
     for (Uint32 i = 0, n = ref._rep->_keyBindings.size(); i < n; i++)     for (Uint32 i = 0, n = ref._rep->_keyBindings.size(); i < n; i++)
     {     {
           // Normalize key binding name by changing to lower case
           if (!ref._rep->_keyBindings[i]._rep->_name.isNull())
           {
         String keyBindingNameLower =         String keyBindingNameLower =
             ref._rep->_keyBindings[i]._rep->_name.getString ();             ref._rep->_keyBindings[i]._rep->_name.getString ();
         keyBindingNameLower.toLower();              keyBindingNameLower.toLower(); // ICU_TODO:
         ref._rep->_keyBindings[i]._rep->_name = keyBindingNameLower;         ref._rep->_keyBindings[i]._rep->_name = keyBindingNameLower;
     }     }
  
     // ATTN-RK-20020826: Need to sort keys?          // Normalize the key value
           switch (ref._rep->_keyBindings[i]._rep->_type)
           {
           case CIMKeyBinding::REFERENCE:
               try
               {
                   // Convert reference to CIMObjectPath and recurse
                   ref._rep->_keyBindings[i]._rep->_value =
                       CIMObjectPath(ref._rep->_keyBindings[i]._rep->_value).
                           _toStringCanonical();
               }
               catch (Exception&)
               {
                   // Leave value unchanged if the CIMObjectPath parsing fails
               }
               break;
           case CIMKeyBinding::BOOLEAN:
               // Normalize the boolean string by changing to lower case
               ref._rep->_keyBindings[i]._rep->_value.toLower(); // ICU_TODO:
               break;
           case CIMKeyBinding::NUMERIC:
               // Normalize the numeric string by converting to integer and back
               Uint64 uValue;
               Sint64 sValue;
               // First try converting to unsigned integer
               if (XmlReader::stringToUnsignedInteger(
                       ref._rep->_keyBindings[i]._rep->_value.getCString(),
                           uValue))
               {
                   char buffer[32];  // Should need 21 chars max
                   sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u", uValue);
                   ref._rep->_keyBindings[i]._rep->_value = String(buffer);
               }
               // Next try converting to signed integer
               else if (XmlReader::stringToSignedInteger(
                            ref._rep->_keyBindings[i]._rep->_value.getCString(),
                                sValue))
               {
                   char buffer[32];  // Should need 21 chars max
                   sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "d", sValue);
                   ref._rep->_keyBindings[i]._rep->_value = String(buffer);
               }
               // Leave value unchanged if it cannot be converted to an integer
               break;
           default:  // CIMKeyBinding::STRING
               // No normalization required for STRING
               break;
           }
       }
   
       // Note: key bindings are sorted when set in the CIMObjectPath
  
     return ref.toString();     return ref.toString();
 } }
Line 933 
Line 1119 
 Boolean CIMObjectPath::identical(const CIMObjectPath& x) const Boolean CIMObjectPath::identical(const CIMObjectPath& x) const
 { {
     return     return
         String::equal(_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
Line 954 
Line 1141 
     return !operator==(x, y);     return !operator==(x, y);
 } }
  
 #ifndef PEGASUS_REMOVE_DEPRECATED  
 PEGASUS_STD(ostream)& operator<<(  
     PEGASUS_STD(ostream)& os,  
     const CIMObjectPath& x)  
 {  
     return os << x.toString();  
 }  
 #endif  
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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