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

version 1.12, 2002/08/26 22:57:44 version 1.22, 2002/09/20 19:40:11
Line 32 
Line 32 
 #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 44 
Line 45 
  
 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 77 
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 111 
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 123 
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 CIMName& 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 164 
Line 166 
  
     CIMName _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 CIMName& 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 CIMName& KeyBinding::getName() const  const CIMName& CIMKeyBinding::getName() const
 { {
     return _rep->_name;     return _rep->_name;
 } }
  
 void KeyBinding::setName(const CIMName& 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;
 } }
  
 Boolean operator==(const KeyBinding& x, const KeyBinding& y)  Boolean CIMKeyBinding::equal(CIMValue value)
   {
       if (value.isArray())
       {
           return false;
       }
   
       CIMValue kbValue;
   
       try
       {
           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 value.equal(kbValue);
   }
   
   Boolean operator==(const CIMKeyBinding& x, const CIMKeyBinding& y)
 { {
     return     return
         x.getName().equal(y.getName()) &&         x.getName().equal(y.getName()) &&
Line 256 
Line 338 
         const String& host,         const String& host,
         const CIMNamespaceName& nameSpace,         const CIMNamespaceName& nameSpace,
         const CIMName& 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 285 
Line 367 
  
     CIMNamespaceName _nameSpace;     CIMNamespaceName _nameSpace;
     CIMName _className;     CIMName _className;
     Array<KeyBinding> _keyBindings;      Array<CIMKeyBinding> _keyBindings;
 }; };
  
  
Line 312 
Line 394 
     const String& host,     const String& host,
     const CIMNamespaceName& nameSpace,     const CIMNamespaceName& nameSpace,
     const CIMName& 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 344 
Line 426 
     const String& host,     const String& host,
     const CIMNamespaceName& nameSpace,     const CIMNamespaceName& nameSpace,
     const CIMName& className,     const CIMName& className,
     const Array<KeyBinding>& keyBindings)      const Array<CIMKeyBinding>& keyBindings)
 { {
    setHost(host);    setHost(host);
    setNameSpace(nameSpace);    setNameSpace(nameSpace);
Line 352 
Line 434 
    setKeyBindings(keyBindings);    setKeyBindings(keyBindings);
 } }
  
 Boolean CIMObjectPath::_parseHostElement(  Boolean _parseHostElement(
     const String& objectName,     const String& objectName,
     char*& p,     char*& p,
     String& host)     String& host)
Line 423 
Line 505 
     return true;     return true;
 } }
  
 Boolean CIMObjectPath::_parseNamespaceElement(  Boolean _parseNamespaceElement(
     const String& objectName,     const String& objectName,
     char*& p,     char*& p,
     CIMNamespaceName& nameSpace)     CIMNamespaceName& nameSpace)
Line 495 
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 510 
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)      Array<CIMKeyBinding>& keyBindings)
 { {
     // Get the key-value pairs:     // Get the key-value pairs:
  
Line 528 
Line 610 
         }         }
  
         *equalsign = 0;         *equalsign = 0;
         CIMName keyString(p);  
  
         if (!CIMName::legal(keyString))          if (!CIMName::legal(p))
             throw MalformedObjectNameException(objectName);             throw MalformedObjectNameException(objectName);
  
           CIMName keyName (p);
   
         // Get the value part:         // Get the value part:
  
         String valueString;         String valueString;
         p = equalsign + 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 MalformedObjectNameException(objectName);                 throw MalformedObjectNameException(objectName);
Line 565 
Line 648 
         {         {
             p++;             p++;
  
             type = KeyBinding::STRING;              type = CIMKeyBinding::STRING;
  
             while (*p && *p != '"')             while (*p && *p != '"')
             {             {
Line 582 
Line 665 
         }         }
         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 604 
Line 687 
         }         }
         else         else
         {         {
             type = KeyBinding::NUMERIC;              type = CIMKeyBinding::NUMERIC;
  
             char* r = p;             char* r = p;
             Uint32 n = 0;             Uint32 n = 0;
Line 637 
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)
         {         {
Line 664 
Line 748 
  
     // Convert to a C String first:     // Convert to a C String first:
  
     char* p = objectName.allocateCString();      char* p = strdup(objectName.getCString());
     ArrayDestroyer<char> destroyer(p);      Destroyer<char> destroyer(p);
     Boolean gotHost;     Boolean gotHost;
     Boolean gotNamespace;     Boolean gotNamespace;
  
Line 691 
Line 775 
         // 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 = p;          _rep->_className = CIMName (p);
         return;         return;
     }     }
  
Line 745 
Line 829 
     _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.isNull() || _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 ());
  
     //     //
     //  ATTN-CAKG-P2-20020726:  The following condition does not correctly     //  ATTN-CAKG-P2-20020726:  The following condition does not correctly
Line 793 
Line 877 
  
         // 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 824 
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?
  
     String classNameLower = ref._rep->_className;      String classNameLower = ref._rep->_className.getString ();
     classNameLower.toLower();     classNameLower.toLower();
     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++)
     {     {
         String keyBindingNameLower = ref._rep->_keyBindings[i]._rep->_name;          String keyBindingNameLower =
               ref._rep->_keyBindings[i]._rep->_name.getString ();
         keyBindingNameLower.toLower();         keyBindingNameLower.toLower();
         ref._rep->_keyBindings[i]._rep->_name = keyBindingNameLower;         ref._rep->_keyBindings[i]._rep->_name = keyBindingNameLower;
     }     }
  
     // ATTN-RK-20020826: Need to sort keys?     // ATTN-RK-20020826: Need to sort keys?
  
     return ref.toString(includeHost);      return ref.toString();
 } }
  
 Boolean CIMObjectPath::identical(const CIMObjectPath& x) const Boolean CIMObjectPath::identical(const CIMObjectPath& x) const
Line 870 
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.12  
changed lines
  Added in v.1.22
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2