(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.26.10.1

version 1.2, 2002/05/16 03:07:02 version 1.26.10.1, 2003/08/13 19:39:50
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();
  
       //
       //  If the key is a reference, the keys in the reference must also be
       //  sorted
       //
       for (Uint32 k = 0; k < n ; k++)
           if (x[k].getType () == CIMKeyBinding::REFERENCE)
           {
               CIMObjectPath tmp (x[k].getValue ());
               Array <CIMKeyBinding> keyBindings = tmp.getKeyBindings ();
               _BubbleSort (keyBindings);
               tmp.setKeyBindings (keyBindings);
               x[k].setValue (tmp.toString ());
           }
   
     if (n < 2)     if (n < 2)
         return;         return;
  
Line 108 
Line 126 
     {     {
         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 139 
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
 // 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 178 
         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);
   }
   
   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;
 } }
  
 KeyBinding::~KeyBinding()      _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 350 
  
     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 379 
     //     //
     String _host;     String _host;
  
     String _nameSpace;      CIMNamespaceName _nameSpace;
     String _className;      CIMName _className;
     Array<KeyBinding> _keyBindings;      Array<CIMKeyBinding> _keyBindings;
 }; };
  
  
Line 326 
Line 404 
     _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 438 
  
 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 448 
    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 396 
Line 465 
     p += 2;     p += 2;
  
     //----------------------------------------------------------------------     //----------------------------------------------------------------------
     // Validate the hostname. Hostnames must match the following      // Validate the hostname. A domain is allowed after the hostname.
     // regular expression: "[A-Za-z][A-Za-z0-9-]*"      // 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;     char* q = p;
  
       Boolean foundDot = true;
       while (foundDot == true)
       {
           foundDot = false;
   
     if (!isalpha(*q))     if (!isalpha(*q))
         throw IllformedObjectName(objectName);              throw MalformedObjectNameException(objectName);
  
     q++;     q++;
  
     while (isalnum(*q) || *q == '-')     while (isalnum(*q) || *q == '-')
           {
         q++;         q++;
           }
   
           if (*q == '.')
           {
               q++;
               foundDot = true;
           }
        }
  
     // We now expect a port (or default the port).     // We now expect a port (or default the port).
  
Line 418 
Line 503 
         // 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 527 
     if (*q != '/')     if (*q != '/')
     {     {
         host.clear();         host.clear();
         throw IllformedObjectName(objectName);          throw MalformedObjectNameException(objectName);
     }     }
  
     p = ++q;     p = ++q;
Line 450 
Line 535 
     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, ':');
     // Validate the namespace path.  Namespaces must match the following      if (!colon)
     // regular expression: "[A-Za-z_]+(/[A-Za-z_]+)*"  
     //----------------------------------------------------------------------  
   
     char* q = p;  
   
     for (;;)  
     {     {
         // Pass the next token:  
   
         if (!*q || (!isalpha(*q) && *q != '_'))  
             return false;             return false;
       }
  
         q++;      // A ':' as part of a keybinding value should not be interpreted as
       // a namespace delimiter.  Since keybinding pairs follow the first '.'
         while (isalnum(*q) || *q == '_')      // in the object path string, the ':' delimiter only counts if it
             q++;      // appears before the '.'.
  
         if (!*q)      char* dot = strchr(p, '.');
       if (dot && (dot < colon))
       {
             return false;             return false;
       }
  
         if (*q == ':')      //----------------------------------------------------------------------
             break;      // Validate the namespace path.  Namespaces must match the following
       // regular expression: "[A-Za-z_]+(/[A-Za-z_]+)*"
       //----------------------------------------------------------------------
  
         if (*q == '/')      String namespaceName = String(p, (Uint32)(colon - p));
       if (!CIMNamespaceName::legal(namespaceName))
         {         {
             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 618 
     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 633 
     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 644 
     {     {
         // 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(p))
               throw MalformedObjectNameException(objectName);
  
         if (!CIMName::legal(keyString))          CIMName keyName (p);
             throw IllformedObjectName(objectName);  
  
         // 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 683 
             }             }
  
             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 702 
             }             }
  
             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 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 IllformedObjectName(objectName);                  throw MalformedObjectNameException(objectName);
  
             valueString.assign(p, n);             valueString.assign(p, n);
  
Line 648 
Line 728 
         }         }
         else         else
         {         {
             type = KeyBinding::NUMERIC;              type = CIMKeyBinding::NUMERIC;
  
             char* r = p;             char* r = p;
             Uint32 n = 0;             Uint32 n = 0;
Line 669 
Line 749 
             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 761 
             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 776 
     _BubbleSort(keyBindings);     _BubbleSort(keyBindings);
 } }
  
 void CIMObjectPath::set(const String& objectName)  throw(IllformedObjectName)  void CIMObjectPath::set(const String& objectName)
 { {
     clear();     clear();
  
Line 708 
Line 789 
  
     // Convert to a C String first:     // Convert to a C String first:
  
     char* p = objectName.allocateCString(1);      CString pCString = objectName.getCStringUTF8();
     ArrayDestroyer<char> destroyer(p);      char* p = const_cast<char*>((const char*) pCString);
     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 810 
     {     {
         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, (Uint32)(dot - p));
       if (!CIMName::legal(className))
       {
           throw MalformedObjectNameException(objectName);
       }
       _rep->_className = className;
  
     // Advance past dot:     // Advance past dot:
  
Line 758 
Line 840 
     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 850 
     _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 949 
     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(); // ICU_TODO:
       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 996 
     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.26.10.1
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2