(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.2 and 1.22

version 1.2, 2002/05/16 03:07:02 version 1.22, 2002/09/20 19:40:11
Line 1 
Line 1 
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
   // The Open Group, Tivoli Systems
 // //
 // 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 24 
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.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 <cctype>
 #include <cstring> #include <cstring>
   #include <iostream>
 #include "HashTable.h" #include "HashTable.h"
 #include "CIMObjectPath.h" #include "CIMObjectPath.h"
 #include "Indentor.h" #include "Indentor.h"
Line 36 
Line 40 
 #include "Destroyer.h" #include "Destroyer.h"
 #include "XmlWriter.h" #include "XmlWriter.h"
 #include "XmlReader.h" #include "XmlReader.h"
 #include "Array.h"  #include "ArrayInternal.h"
 #include "CIMOMPort.h" #include "CIMOMPort.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 #define PEGASUS_ARRAY_T KeyBinding  #define PEGASUS_ARRAY_T CIMKeyBinding
 # include "ArrayImpl.h" # include "ArrayImpl.h"
 #undef PEGASUS_ARRAY_T #undef PEGASUS_ARRAY_T
  
Line 74 
Line 78 
         switch (str[i])         switch (str[i])
         {         {
             case '\n':             case '\n':
                 result += "\\n";                  result.append("\\n");
                 break;                 break;
  
             case '\r':             case '\r':
                 result += "\\r";                  result.append("\\r");
                 break;                 break;
  
             case '\t':             case '\t':
                 result += "\\t";                  result.append("\\t");
                 break;                 break;
  
             case '"':             case '"':
                 result += "\\\"";                  result.append("\\\"");
                 break;                 break;
  
             default:             default:
                 result += str[i];                  result.append(str[i]);
         }         }
     }     }
  
     return result;     return result;
 } }
  
 static void _BubbleSort(Array<KeyBinding>& x)  static void _BubbleSort(Array<CIMKeyBinding>& x)
 { {
     Uint32 n = x.size();     Uint32 n = x.size();
  
Line 108 
Line 112 
     {     {
         for (Uint32 j = 0; j < n - 1; j++)         for (Uint32 j = 0; j < n - 1; j++)
         {         {
             if (String::compareNoCase(x[j].getName(), x[j+1].getName()) > 0)              if (String::compareNoCase(x[j].getName().getString(),
                                         x[j+1].getName().getString()) > 0)
             {             {
                 KeyBinding t = x[j];                  CIMKeyBinding t = x[j];
                 x[j] = x[j+1];                 x[j] = x[j+1];
                 x[j+1] = t;                 x[j+1] = t;
             }             }
Line 120 
Line 125 
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
 // KeyBinding  // CIMKeyBinding
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
 class KeyBindingRep  class CIMKeyBindingRep
 { {
 public: public:
     KeyBindingRep()      CIMKeyBindingRep()
     {     {
     }     }
  
     KeyBindingRep(const KeyBindingRep& x)      CIMKeyBindingRep(const CIMKeyBindingRep& x)
         : _name(x._name), _value(x._value), _type(x._type)         : _name(x._name), _value(x._value), _type(x._type)
     {     {
     }     }
  
     KeyBindingRep(      CIMKeyBindingRep(
         const String& name,          const CIMName& name,
         const String& value,         const String& value,
         KeyBinding::Type type)          CIMKeyBinding::Type type)
         : _name(name), _value(value), _type(type)         : _name(name), _value(value), _type(type)
     {     {
     }     }
  
     ~KeyBindingRep()      ~CIMKeyBindingRep()
     {     {
     }     }
  
     KeyBindingRep& operator=(const KeyBindingRep& x)      CIMKeyBindingRep& operator=(const CIMKeyBindingRep& x)
     {     {
         if (&x != this)         if (&x != this)
         {         {
Line 159 
Line 164 
         return *this;         return *this;
     }     }
  
     String _name;      CIMName _name;
     String _value;     String _value;
     KeyBinding::Type _type;      CIMKeyBinding::Type _type;
 }; };
  
  
 KeyBinding::KeyBinding()  CIMKeyBinding::CIMKeyBinding()
 { {
     _rep = new KeyBindingRep();      _rep = new CIMKeyBindingRep();
 } }
  
 KeyBinding::KeyBinding(const KeyBinding& x)  CIMKeyBinding::CIMKeyBinding(const CIMKeyBinding& x)
 { {
     _rep = new KeyBindingRep(*x._rep);      _rep = new CIMKeyBindingRep(*x._rep);
 } }
  
 KeyBinding::KeyBinding(const String& name, const String& value, Type type)  CIMKeyBinding::CIMKeyBinding(const CIMName& name, const String& value, Type type)
 { {
     _rep = new KeyBindingRep(name, value, type);      _rep = new CIMKeyBindingRep(name, value, type);
 } }
  
 KeyBinding::~KeyBinding()  CIMKeyBinding::CIMKeyBinding(const CIMName& name, const CIMValue& value)
   {
       if (value.isArray())
       {
           throw TypeMismatchException();
       }
   
       String kbValue = value.toString();
       Type kbType;
   
       switch (value.getType())
       {
       case CIMTYPE_BOOLEAN:
           kbType = BOOLEAN;
           break;
       case CIMTYPE_CHAR16:
       case CIMTYPE_STRING:
       case CIMTYPE_DATETIME:
           kbType = STRING;
           break;
       case CIMTYPE_REFERENCE:
           kbType = REFERENCE;
           break;
       default:
           kbType = NUMERIC;
           break;
       }
   
       _rep = new CIMKeyBindingRep(name, kbValue, kbType);
   }
   
   CIMKeyBinding::~CIMKeyBinding()
 { {
     delete _rep;     delete _rep;
 } }
  
 KeyBinding& KeyBinding::operator=(const KeyBinding& x)  CIMKeyBinding& CIMKeyBinding::operator=(const CIMKeyBinding& x)
 { {
     *_rep = *x._rep;     *_rep = *x._rep;
     return *this;     return *this;
 } }
  
 const String& KeyBinding::getName() const  const CIMName& CIMKeyBinding::getName() const
 { {
     return _rep->_name;     return _rep->_name;
 } }
  
 void KeyBinding::setName(const String& name)  void CIMKeyBinding::setName(const CIMName& name)
 { {
     _rep->_name = name;     _rep->_name = name;
 } }
  
 const String& KeyBinding::getValue() const  const String& CIMKeyBinding::getValue() const
 { {
     return _rep->_value;     return _rep->_value;
 } }
  
 void KeyBinding::setValue(const String& value)  void CIMKeyBinding::setValue(const String& value)
 { {
     _rep->_value = value;     _rep->_value = value;
 } }
  
 KeyBinding::Type KeyBinding::getType() const  CIMKeyBinding::Type CIMKeyBinding::getType() const
 { {
     return _rep->_type;     return _rep->_type;
 } }
  
 void KeyBinding::setType(KeyBinding::Type type)  void CIMKeyBinding::setType(CIMKeyBinding::Type type)
 { {
     _rep->_type = type;     _rep->_type = type;
 } }
  
 const char* KeyBinding::typeToString(KeyBinding::Type type)  Boolean CIMKeyBinding::equal(CIMValue value)
 { {
     switch (type)      if (value.isArray())
     {     {
         case KeyBinding::BOOLEAN:          return false;
             return "boolean";      }
   
         case KeyBinding::STRING:  
             return "string";  
  
         case KeyBinding::NUMERIC:      CIMValue kbValue;
             return "numeric";  
  
         case KeyBinding::REFERENCE:      try
         default:      {
             PEGASUS_ASSERT(false);          switch (value.getType())
           {
           case CIMTYPE_CHAR16:
               if (getType() != STRING) return false;
               kbValue.set(getValue()[0]);
               break;
           case CIMTYPE_DATETIME:
               if (getType() != STRING) return false;
               kbValue.set(CIMDateTime(getValue()));
               break;
           case CIMTYPE_STRING:
               if (getType() != STRING) return false;
               kbValue.set(getValue());
               break;
           case CIMTYPE_REFERENCE:
               if (getType() != REFERENCE) return false;
               kbValue.set(CIMObjectPath(getValue()));
               break;
           case CIMTYPE_BOOLEAN:
               if (getType() != BOOLEAN) return false;
               kbValue = XmlReader::stringToValue(0, getValue().getCString(),
                                                  value.getType());
               break;
           default:  // Numerics
               if (getType() != NUMERIC) return false;
               kbValue = XmlReader::stringToValue(0, getValue().getCString(),
                                                  value.getType());
               break;
           }
       }
       catch (Exception&)
       {
           return false;
     }     }
  
     return "unknown";      return value.equal(kbValue);
 } }
  
 Boolean operator==(const KeyBinding& x, const KeyBinding& y)  Boolean operator==(const CIMKeyBinding& x, const CIMKeyBinding& y)
 { {
     return     return
         CIMName::equal(x.getName(), y.getName()) &&          x.getName().equal(y.getName()) &&
         String::equal(x.getValue(), y.getValue()) &&         String::equal(x.getValue(), y.getValue()) &&
         x.getType() == y.getType();         x.getType() == y.getType();
 } }
Line 272 
Line 336 
  
     CIMObjectPathRep(     CIMObjectPathRep(
         const String& host,         const String& host,
         const String& nameSpace,          const CIMNamespaceName& nameSpace,
         const String& className,          const CIMName& className,
         const Array<KeyBinding>& keyBindings)          const Array<CIMKeyBinding>& keyBindings)
         : _host(host), _nameSpace(nameSpace),         : _host(host), _nameSpace(nameSpace),
         _className(className), _keyBindings(keyBindings)         _className(className), _keyBindings(keyBindings)
     {     {
Line 301 
Line 365 
     //     //
     String _host;     String _host;
  
     String _nameSpace;      CIMNamespaceName _nameSpace;
     String _className;      CIMName _className;
     Array<KeyBinding> _keyBindings;      Array<CIMKeyBinding> _keyBindings;
 }; };
  
  
Line 326 
Line 390 
     _rep = new CIMObjectPathRep(*tmpRef._rep);     _rep = new CIMObjectPathRep(*tmpRef._rep);
 } }
  
 CIMObjectPath::CIMObjectPath(const char* objectName)  
 {  
     // Test the objectName out to see if we get an exception  
     CIMObjectPath tmpRef;  
     tmpRef.set(objectName);  
   
     _rep = new CIMObjectPathRep(*tmpRef._rep);  
 }  
   
 CIMObjectPath::CIMObjectPath( CIMObjectPath::CIMObjectPath(
     const String& host,     const String& host,
     const String& nameSpace,      const CIMNamespaceName& nameSpace,
     const String& className,      const CIMName& className,
     const Array<KeyBinding>& keyBindings)      const Array<CIMKeyBinding>& keyBindings)
 { {
     // 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;
Line 369 
Line 424 
  
 void CIMObjectPath::set( void CIMObjectPath::set(
     const String& host,     const String& host,
     const String& nameSpace,      const CIMNamespaceName& nameSpace,
     const String& className,      const CIMName& className,
     const Array<KeyBinding>& keyBindings)  throw(IllformedObjectName, IllegalName)      const Array<CIMKeyBinding>& keyBindings)
 { {
    setHost(host);    setHost(host);
    setNameSpace(nameSpace);    setNameSpace(nameSpace);
Line 379 
Line 434 
    setKeyBindings(keyBindings);    setKeyBindings(keyBindings);
 } }
  
 Boolean CIMObjectPath::_parseHostElement(  Boolean _parseHostElement(
     const String& objectName,     const String& objectName,
     char*& p,     char*& p,
     String& host) throw(IllformedObjectName)      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 from <hostname>-<port> and begins with "//"
Line 403 
Line 458 
     char* q = p;     char* q = p;
  
     if (!isalpha(*q))     if (!isalpha(*q))
         throw IllformedObjectName(objectName);          throw MalformedObjectNameException(objectName);
  
     q++;     q++;
  
Line 418 
Line 473 
         // Check for a port number:         // Check for a port number:
  
         if (!isdigit(*q))         if (!isdigit(*q))
             throw IllformedObjectName(objectName);              throw MalformedObjectNameException(objectName);
  
         while (isdigit(*q))         while (isdigit(*q))
             q++;             q++;
Line 442 
Line 497 
     if (*q != '/')     if (*q != '/')
     {     {
         host.clear();         host.clear();
         throw IllformedObjectName(objectName);          throw MalformedObjectNameException(objectName);
     }     }
  
     p = ++q;     p = ++q;
Line 450 
Line 505 
     return true;     return true;
 } }
  
 Boolean CIMObjectPath::_parseNamespaceElement(  Boolean _parseNamespaceElement(
     const String& objectName,     const String& objectName,
     char*& p,     char*& p,
     String& nameSpace)      CIMNamespaceName& nameSpace)
 { {
     // If we don't find a valid namespace name followed by a ':', we     // If we don't find a valid namespace name followed by a ':', we
     // assume we're not looking at a namespace name.     // assume we're not looking at a namespace name.
  
       char* colon = strchr(p, ':');
       if (!colon)
       {
           return false;
       }
   
     //----------------------------------------------------------------------     //----------------------------------------------------------------------
     // Validate the namespace path.  Namespaces must match the following     // Validate the namespace path.  Namespaces must match the following
     // regular expression: "[A-Za-z_]+(/[A-Za-z_]+)*"     // regular expression: "[A-Za-z_]+(/[A-Za-z_]+)*"
     //----------------------------------------------------------------------     //----------------------------------------------------------------------
  
     char* q = p;      String namespaceName = String(p, colon - p);
       if (!CIMNamespaceName::legal(namespaceName))
     for (;;)  
     {  
         // Pass the next token:  
   
         if (!*q || (!isalpha(*q) && *q != '_'))  
             return false;  
   
         q++;  
   
         while (isalnum(*q) || *q == '_')  
             q++;  
   
         if (!*q)  
             return false;  
   
         if (*q == ':')  
             break;  
   
         if (*q == '/')  
         {         {
             q++;          throw MalformedObjectNameException(objectName);
             continue;  
         }  
   
         return false;  
     }     }
       nameSpace = namespaceName;
  
     nameSpace.assign(p, q - p);      p = colon+1;
     p = ++q;  
     return true;     return true;
 } }
  
Line 539 
Line 577 
     with the 'R' notation.     with the 'R' notation.
  
     The toString() method inserts the 'R' to provide symmetry.  A     The toString() method inserts the 'R' to provide symmetry.  A
     new KeyBinding type (REFERENCE) has been defined to denote      new CIMKeyBinding type (REFERENCE) has been defined to denote
     keys in a CIMObjectPath that are of reference type.  This     keys in a CIMObjectPath that are of reference type.  This
     KeyBinding type must be used appropriately for      CIMKeyBinding type must be used appropriately for
     CIMObjectPath::toString() to behave correctly.     CIMObjectPath::toString() to behave correctly.
  
     A result of this change is that instances names in the     A result of this change is that instances names in the
Line 554 
Line 592 
     operation of retrieving the class definition to determine     operation of retrieving the class definition to determine
     the key property types.     the key property types.
 */ */
 void CIMObjectPath::_parseKeyBindingPairs(  void _parseKeyBindingPairs(
     const String& objectName,     const String& objectName,
     char*& p,     char*& p,
     Array<KeyBinding>& keyBindings)  throw(IllformedObjectName)      Array<CIMKeyBinding>& keyBindings)
 { {
     // Get the key-value pairs:     // Get the key-value pairs:
  
Line 565 
Line 603 
     {     {
         // Get key part:         // Get key part:
  
         char* key = strtok(p, "=");          char* equalsign = strchr(p, '=');
           if (!equalsign)
         if (!key)  
         {         {
             throw IllformedObjectName(objectName);              throw MalformedObjectNameException(objectName);
         }         }
  
         String keyString(key);          *equalsign = 0;
  
         if (!CIMName::legal(keyString))          if (!CIMName::legal(p))
             throw IllformedObjectName(objectName);              throw MalformedObjectNameException(objectName);
   
           CIMName keyName (p);
  
         // Get the value part:         // Get the value part:
  
         String valueString;         String valueString;
         p = p + strlen(key) + 1;          p = equalsign + 1;
         KeyBinding::Type type;          CIMKeyBinding::Type type;
  
         if (*p == 'R')         if (*p == 'R')
         {         {
             p++;             p++;
  
             type = KeyBinding::REFERENCE;              type = CIMKeyBinding::REFERENCE;
  
             if (*p++ != '"')             if (*p++ != '"')
                 throw IllformedObjectName(objectName);                  throw MalformedObjectNameException(objectName);
  
             while (*p && *p != '"')             while (*p && *p != '"')
             {             {
Line 603 
Line 642 
             }             }
  
             if (*p++ != '"')             if (*p++ != '"')
                 throw IllformedObjectName(objectName);                  throw MalformedObjectNameException(objectName);
         }         }
         else if (*p == '"')         else if (*p == '"')
         {         {
             p++;             p++;
  
             type = KeyBinding::STRING;              type = CIMKeyBinding::STRING;
  
             while (*p && *p != '"')             while (*p && *p != '"')
             {             {
Line 622 
Line 661 
             }             }
  
             if (*p++ != '"')             if (*p++ != '"')
                 throw IllformedObjectName(objectName);                  throw MalformedObjectNameException(objectName);
         }         }
         else if (toupper(*p) == 'T' || toupper(*p) == 'F')         else if (toupper(*p) == 'T' || toupper(*p) == 'F')
         {         {
             type = KeyBinding::BOOLEAN;              type = CIMKeyBinding::BOOLEAN;
  
             char* r = p;             char* r = p;
             Uint32 n = 0;             Uint32 n = 0;
Line 640 
Line 679 
  
             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 IllformedObjectName(objectName);                  throw MalformedObjectNameException(objectName);
  
             valueString.assign(p, n);             valueString.assign(p, n);
  
Line 648 
Line 687 
         }         }
         else         else
         {         {
             type = KeyBinding::NUMERIC;              type = CIMKeyBinding::NUMERIC;
  
             char* r = p;             char* r = p;
             Uint32 n = 0;             Uint32 n = 0;
Line 669 
Line 708 
             Sint64 x;             Sint64 x;
  
             if (!XmlReader::stringToSignedInteger(p, x))             if (!XmlReader::stringToSignedInteger(p, x))
                 throw IllformedObjectName(objectName);                  throw MalformedObjectNameException(objectName);
  
             valueString.assign(p, n);             valueString.assign(p, n);
  
Line 681 
Line 720 
             p = p + n;             p = p + n;
         }         }
  
         keyBindings.append(KeyBinding(keyString, valueString, type));          keyBindings.append(CIMKeyBinding(keyName.getString (), valueString,
               type));
  
         if (*p)         if (*p)
         {         {
             if (*p++ != ',')             if (*p++ != ',')
             {             {
                 throw IllformedObjectName(objectName);                  throw MalformedObjectNameException(objectName);
             }             }
         }         }
     }     }
Line 695 
Line 735 
     _BubbleSort(keyBindings);     _BubbleSort(keyBindings);
 } }
  
 void CIMObjectPath::set(const String& objectName)  throw(IllformedObjectName)  void CIMObjectPath::set(const String& objectName)
 { {
     clear();     clear();
  
Line 708 
Line 748 
  
     // Convert to a C String first:     // Convert to a C String first:
  
     char* p = objectName.allocateCString(1);      char* p = strdup(objectName.getCString());
     ArrayDestroyer<char> destroyer(p);      Destroyer<char> destroyer(p);
     Boolean gotHost;     Boolean gotHost;
     Boolean gotNamespace;     Boolean gotNamespace;
  
     // null terminate the C String  
     // ATTN-RK-P3-20020301: Is the +1 correct?  
     p[objectName.size() + 1]= '\0';  
   
     gotHost = _parseHostElement(objectName, p, _rep->_host);     gotHost = _parseHostElement(objectName, p, _rep->_host);
     gotNamespace = _parseNamespaceElement(objectName, p, _rep->_nameSpace);     gotNamespace = _parseNamespaceElement(objectName, p, _rep->_nameSpace);
  
     if (gotHost && !gotNamespace)     if (gotHost && !gotNamespace)
     {     {
         throw IllformedObjectName(objectName);          throw MalformedObjectNameException(objectName);
     }     }
  
     // Extract the class name:     // Extract the class name:
Line 733 
Line 769 
     {     {
         if (!CIMName::legal(p))         if (!CIMName::legal(p))
         {         {
             throw IllformedObjectName(objectName);              throw MalformedObjectNameException(objectName);
         }         }
  
         // ATTN: remove this later: a reference should only be able to hold         // ATTN: remove this later: a reference should only be able to hold
         // an instance name.         // an instance name.
  
         _rep->_className.assign(p);          _rep->_className = CIMName (p);
         return;         return;
     }     }
  
     _rep->_className.assign(p, dot - p);      String className = String(p, dot - p);
       if (!CIMName::legal(className))
       {
           throw MalformedObjectNameException(objectName);
       }
       _rep->_className = className;
  
     // Advance past dot:     // Advance past dot:
  
Line 758 
Line 799 
     return *this;     return *this;
 } }
  
 CIMObjectPath& CIMObjectPath::operator=(const char* objectName)  
 {  
     set(objectName);  
     return *this;  
 }  
   
 const String& CIMObjectPath::getHost() const const String& CIMObjectPath::getHost() const
 { {
     return _rep->_host;     return _rep->_host;
Line 774 
Line 809 
     _rep->_host = host;     _rep->_host = host;
 } }
  
 const String& CIMObjectPath::getNameSpace() const  const CIMNamespaceName& CIMObjectPath::getNameSpace() const
 { {
     return _rep->_nameSpace;     return _rep->_nameSpace;
 } }
  
 void CIMObjectPath::setNameSpace(const String& nameSpace) throw(IllegalName)  void CIMObjectPath::setNameSpace(const CIMNamespaceName& nameSpace)
 { {
     String temp;  
   
     // check each namespace segment (delimted by '/') for correctness  
   
     for(Uint32 i = 0; i < nameSpace.size(); i += temp.size() + 1)  
     {  
         // isolate the segment beginning at i and ending at the first  
         // ocurrance of '/' after i or eos  
   
         temp = nameSpace.subString(i, nameSpace.subString(i).find('/'));  
   
         // check segment for correctness  
   
         if(!CIMName::legal(temp))  
         {  
             throw IllegalName() ;  
         }  
     }  
   
    _rep->_nameSpace = nameSpace;    _rep->_nameSpace = nameSpace;
 } }
  
 const String& CIMObjectPath::getClassName() const  const CIMName& CIMObjectPath::getClassName() const
 { {
     return _rep->_className;     return _rep->_className;
 } }
  
 const Boolean CIMObjectPath::equalClassName(const String& classname) const  void CIMObjectPath::setClassName(const CIMName& className)
 {  
     return (String::equalNoCase(classname, CIMObjectPath::getClassName()));  
 }  
   
 void CIMObjectPath::setClassName(const String& className) throw(IllegalName)  
 { {
     if (!CIMName::legal(className))  
         throw IllegalName();  
   
     _rep->_className = className;     _rep->_className = className;
 } }
  
 const Array<KeyBinding>& CIMObjectPath::getKeyBindings() const  const Array<CIMKeyBinding>& CIMObjectPath::getKeyBindings() const
 { {
     return _rep->_keyBindings;     return _rep->_keyBindings;
 } }
  
 void CIMObjectPath::setKeyBindings(const Array<KeyBinding>& keyBindings)  void CIMObjectPath::setKeyBindings(const Array<CIMKeyBinding>& keyBindings)
 { {
     _rep->_keyBindings = keyBindings;     _rep->_keyBindings = keyBindings;
     _BubbleSort(_rep->_keyBindings);     _BubbleSort(_rep->_keyBindings);
 } }
  
 String CIMObjectPath::toString(Boolean includeHost) const  String CIMObjectPath::toString() const
 { {
     String objectName;     String objectName;
  
     // Get the host:     // Get the host:
  
     if (_rep->_host.size() && includeHost)      if (_rep->_host.size())
     {     {
         objectName = "//";         objectName = "//";
         objectName += _rep->_host;          objectName.append(_rep->_host);
         objectName += "/";          objectName.append("/");
     }     }
  
     // Get the namespace (if we have a host name, we must write namespace):     // Get the namespace (if we have a host name, we must write namespace):
  
     if (_rep->_nameSpace.size() || _rep->_host.size())      if (!_rep->_nameSpace.isNull() || _rep->_host.size())
     {     {
         objectName += _rep->_nameSpace;          objectName.append(_rep->_nameSpace.getString ());
         objectName += ":";          objectName.append(":");
     }     }
  
     // Get the class name:     // Get the class name:
  
     objectName.append(getClassName());      objectName.append(getClassName().getString ());
  
     if (isInstanceName())      //
       //  ATTN-CAKG-P2-20020726:  The following condition does not correctly
       //  distinguish instanceNames from classNames in every case
       //  The instanceName of a singleton instance of a keyless class has no
       //  key bindings
       //
       if (_rep->_keyBindings.size () != 0)
     {     {
         objectName.append('.');         objectName.append('.');
  
         // Append each key-value pair:         // Append each key-value pair:
  
         const Array<KeyBinding>& keyBindings = getKeyBindings();          const Array<CIMKeyBinding>& keyBindings = getKeyBindings();
  
         for (Uint32 i = 0, n = keyBindings.size(); i < n; i++)         for (Uint32 i = 0, n = keyBindings.size(); i < n; i++)
         {         {
             objectName.append(keyBindings[i].getName());              objectName.append(keyBindings[i].getName().getString ());
             objectName.append('=');             objectName.append('=');
  
             const String& value = _escapeSpecialCharacters(             const String& value = _escapeSpecialCharacters(
                 keyBindings[i].getValue());                 keyBindings[i].getValue());
  
             KeyBinding::Type type = keyBindings[i].getType();              CIMKeyBinding::Type type = keyBindings[i].getType();
  
             if (type == KeyBinding::REFERENCE)              if (type == CIMKeyBinding::REFERENCE)
                 objectName.append('R');                 objectName.append('R');
  
             if (type == KeyBinding::STRING || type == KeyBinding::REFERENCE)              if (type == CIMKeyBinding::STRING || type == CIMKeyBinding::REFERENCE)
                 objectName.append('"');                 objectName.append('"');
  
             objectName.append(value);             objectName.append(value);
  
             if (type == KeyBinding::STRING || type == KeyBinding::REFERENCE)              if (type == CIMKeyBinding::STRING || type == CIMKeyBinding::REFERENCE)
                 objectName.append('"');                 objectName.append('"');
  
             if (i + 1 != n)             if (i + 1 != n)
Line 894 
Line 908 
     return objectName;     return objectName;
 } }
  
 String CIMObjectPath::toStringCanonical(Boolean includeHost) const  String CIMObjectPath::_toStringCanonical() const
 { {
     CIMObjectPath ref = *this;     CIMObjectPath ref = *this;
  
     // ATTN-RK-P2-20020510: Need to make hostname and namespace lower case?     // ATTN-RK-P2-20020510: Need to make hostname and namespace lower case?
  
     ref._rep->_className.toLower();      String classNameLower = ref._rep->_className.getString ();
       classNameLower.toLower();
       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++)
     {     {
         ref._rep->_keyBindings[i]._rep->_name.toLower();          String keyBindingNameLower =
               ref._rep->_keyBindings[i]._rep->_name.getString ();
           keyBindingNameLower.toLower();
           ref._rep->_keyBindings[i]._rep->_name = keyBindingNameLower;
     }     }
  
     return ref.toString(includeHost);      // ATTN-RK-20020826: Need to sort keys?
 }  
  
 CIMObjectPath CIMObjectPath::clone() const      return ref.toString();
 {  
     return CIMObjectPath(*this);  
 } }
  
 Boolean CIMObjectPath::identical(const CIMObjectPath& x) const Boolean CIMObjectPath::identical(const CIMObjectPath& x) const
 { {
     return     return
         String::equal(_rep->_host, x._rep->_host) &&         String::equal(_rep->_host, x._rep->_host) &&
         CIMName::equal(_rep->_nameSpace, x._rep->_nameSpace) &&          _rep->_nameSpace.equal(x._rep->_nameSpace) &&
         CIMName::equal(_rep->_className, 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
 { {
     return HashFunc<String>::hash(toStringCanonical());      return HashFunc<String>::hash(_toStringCanonical());
 }  
   
 Boolean CIMObjectPath::isInstanceName() const  
 {  
     return _rep->_keyBindings.size() != 0;  
 }  
   
 KeyBindingArray CIMObjectPath::getKeyBindingArray()  
 {  
     return KeyBindingArray();  
 } }
  
   
 Boolean operator==(const CIMObjectPath& x, const CIMObjectPath& y) Boolean operator==(const CIMObjectPath& x, const CIMObjectPath& y)
 { {
     return x.identical(y);     return x.identical(y);
Line 950 
Line 955 
     return !operator==(x, y);     return !operator==(x, y);
 } }
  
   #ifndef PEGASUS_REMOVE_DEPRECATED
 PEGASUS_STD(ostream)& operator<<( PEGASUS_STD(ostream)& operator<<(
     PEGASUS_STD(ostream)& os,     PEGASUS_STD(ostream)& os,
     const CIMObjectPath& x)     const CIMObjectPath& x)
 { {
     return os << x.toString();     return os << x.toString();
 } }
   #endif
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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