(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.15 and 1.16

version 1.15, 2002/09/05 02:15:32 version 1.16, 2002/09/12 17:27:01
Line 44 
Line 44 
  
 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 100 
Line 100 
     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 113 
Line 113 
         {         {
             if (String::compareNoCase(x[j].getName(), x[j+1].getName()) > 0)             if (String::compareNoCase(x[j].getName(), x[j+1].getName()) > 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 123 
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
 // 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 164 
  
     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()
 { {
     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 operator==(const CIMKeyBinding& x, const CIMKeyBinding& y)
 { {
     return     return
         x.getName().equal(y.getName()) &&         x.getName().equal(y.getName()) &&
Line 256 
Line 256 
         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 285 
  
     CIMNamespaceName _nameSpace;     CIMNamespaceName _nameSpace;
     CIMName _className;     CIMName _className;
     Array<KeyBinding> _keyBindings;      Array<CIMKeyBinding> _keyBindings;
 }; };
  
  
Line 312 
Line 312 
     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 344 
     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 495 
Line 495 
     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 513 
Line 513 
 void CIMObjectPath::_parseKeyBindingPairs( void CIMObjectPath::_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 537 
Line 537 
  
         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 565 
         {         {
             p++;             p++;
  
             type = KeyBinding::STRING;              type = CIMKeyBinding::STRING;
  
             while (*p && *p != '"')             while (*p && *p != '"')
             {             {
Line 582 
Line 582 
         }         }
         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 604 
         }         }
         else         else
         {         {
             type = KeyBinding::NUMERIC;              type = CIMKeyBinding::NUMERIC;
  
             char* r = p;             char* r = p;
             Uint32 n = 0;             Uint32 n = 0;
Line 637 
Line 637 
             p = p + n;             p = p + n;
         }         }
  
         keyBindings.append(KeyBinding(keyString, valueString, type));          keyBindings.append(CIMKeyBinding(keyString, valueString, type));
  
         if (*p)         if (*p)
         {         {
Line 745 
Line 745 
     _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);
Line 793 
Line 793 
  
         // 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++)
         {         {
Line 803 
Line 803 
             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)

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