(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.62.4.4 and 1.63

version 1.62.4.4, 2008/02/13 12:06:38 version 1.63, 2007/10/23 17:38:45
Line 93 
Line 93 
     return result;     return result;
 } }
  
 static int _compare(const void* p1, const void* p2)  static void _BubbleSort(Array<CIMKeyBinding>& x)
 { {
     const CIMKeyBinding* kb1 = (const CIMKeyBinding*)p1;      Uint32 n = x.size();
     const CIMKeyBinding* kb2 = (const CIMKeyBinding*)p2;  
   
     return String::compareNoCase(  
         kb1->getName().getString(),  
         kb2->getName().getString());  
 }  
   
 static void _Sort(Array<CIMKeyBinding>& x)  
 {  
     CIMKeyBinding* data = (CIMKeyBinding*)x.getData();  
     Uint32 size = x.size();  
  
     //     //
     //  If the key is a reference, the keys in the reference must also be     //  If the key is a reference, the keys in the reference must also be
     //  sorted     //  sorted
     //     //
     for (Uint32 k = 0; k < size; k++)      for (Uint32 k = 0; k < n ; k++)
           if (x[k].getType () == CIMKeyBinding::REFERENCE)
     {     {
         CIMKeyBinding& kb = data[k];              CIMObjectPath tmp (x[k].getValue ());
   
         if (kb.getType() == CIMKeyBinding::REFERENCE)  
         {  
             CIMObjectPath tmp(kb.getValue());  
             Array<CIMKeyBinding> keyBindings = tmp.getKeyBindings();             Array<CIMKeyBinding> keyBindings = tmp.getKeyBindings();
             _Sort(keyBindings);              _BubbleSort (keyBindings);
             tmp.setKeyBindings(keyBindings);             tmp.setKeyBindings(keyBindings);
             kb.setValue(tmp.toString());              x[k].setValue (tmp.toString ());
         }  
     }     }
  
     if (size < 2)      if (n < 2)
         return;         return;
  
     qsort((void*)data, size, sizeof(CIMKeyBinding), _compare);      for (Uint32 i = 0; i < n - 1; i++)
       {
           for (Uint32 j = 0; j < n - 1; j++)
           {
               if (String::compareNoCase(x[j].getName().getString(),
                                         x[j+1].getName().getString()) > 0)
               {
                   CIMKeyBinding t = x[j];
                   x[j] = x[j+1];
                   x[j+1] = t;
               }
           }
       }
 } }
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
Line 411 
Line 408 
 class CIMObjectPathRep class CIMObjectPathRep
 { {
 public: public:
     CIMObjectPathRep(): _refCounter(1)      CIMObjectPathRep()
     {     {
     }     }
  
     CIMObjectPathRep(const CIMObjectPathRep& x)     CIMObjectPathRep(const CIMObjectPathRep& x)
         : _refCounter(1), _host(x._host), _nameSpace(x._nameSpace),          : _host(x._host), _nameSpace(x._nameSpace),
         _className(x._className), _keyBindings(x._keyBindings)         _className(x._className), _keyBindings(x._keyBindings)
     {     {
     }     }
Line 426 
Line 423 
         const CIMNamespaceName& nameSpace,         const CIMNamespaceName& nameSpace,
         const CIMName& className,         const CIMName& className,
         const Array<CIMKeyBinding>& keyBindings)         const Array<CIMKeyBinding>& keyBindings)
         : _refCounter(1), _host(host), _nameSpace(nameSpace),          : _host(host), _nameSpace(nameSpace),
         _className(className), _keyBindings(keyBindings)         _className(className), _keyBindings(keyBindings)
     {     {
     }     }
Line 454 
Line 451 
         return addr.isValid();         return addr.isValid();
     }     }
  
     // reference counter as member to avoid  
     // virtual function resolution overhead  
     AtomicInt _refCounter;  
     //     //
     // Contains port as well (e.g., myhost:1234).     // Contains port as well (e.g., myhost:1234).
     //     //
Line 467 
Line 461 
     Array<CIMKeyBinding> _keyBindings;     Array<CIMKeyBinding> _keyBindings;
 }; };
  
 template<class REP>  
 inline void Ref(REP* rep)  
 {  
         rep->_refCounter++;  
 }  
   
 template<class REP>  
 inline void Unref(REP* rep)  
 {  
     if (rep->_refCounter.decAndTestIfZero())  
         delete rep;  
 }  
  
 CIMObjectPath::CIMObjectPath() CIMObjectPath::CIMObjectPath()
 { {
Line 487 
Line 469 
  
 CIMObjectPath::CIMObjectPath(const CIMObjectPath& x) CIMObjectPath::CIMObjectPath(const CIMObjectPath& x)
 { {
     _rep = x._rep;      _rep = new CIMObjectPathRep(*x._rep);
     Ref(_rep);  
 } }
  
 CIMObjectPath::CIMObjectPath(const String& objectName) CIMObjectPath::CIMObjectPath(const String& objectName)
Line 497 
Line 478 
     CIMObjectPath tmpRef;     CIMObjectPath tmpRef;
     tmpRef.set(objectName);     tmpRef.set(objectName);
  
     _rep = tmpRef._rep;      _rep = new CIMObjectPathRep(*tmpRef._rep);
     Ref(_rep);  
 } }
  
 CIMObjectPath::CIMObjectPath( CIMObjectPath::CIMObjectPath(
Line 510 
Line 490 
     // Test the objectName out to see if we get an exception     // Test the objectName out to see if we get an exception
     CIMObjectPath tmpRef;     CIMObjectPath tmpRef;
     tmpRef.set(host, nameSpace, className, keyBindings);     tmpRef.set(host, nameSpace, className, keyBindings);
     _rep = tmpRef._rep;  
     Ref(_rep);      _rep = new CIMObjectPathRep(*tmpRef._rep);
 } }
  
 CIMObjectPath::~CIMObjectPath() CIMObjectPath::~CIMObjectPath()
 { {
     Unref(_rep);      delete _rep;
 } }
  
 CIMObjectPath& CIMObjectPath::operator=(const CIMObjectPath& x) CIMObjectPath& CIMObjectPath::operator=(const CIMObjectPath& x)
 { {
     if (x._rep != _rep)      *_rep = *x._rep;
     {  
         Unref(_rep);  
         _rep = x._rep;  
         Ref(_rep);  
     }  
     return *this;     return *this;
 } }
  
 static inline CIMObjectPathRep* _copyOnWriteCIMObjectPathRep(  
     CIMObjectPathRep* rep)  
 {  
     if (rep->_refCounter.get() > 1)  
     {  
         CIMObjectPathRep* tmpRep= new CIMObjectPathRep(*rep);  
         Unref(rep);  
         return tmpRep;  
     }  
     else  
     {  
         return rep;  
     }  
 }  
   
 void CIMObjectPath::clear() void CIMObjectPath::clear()
 { {
     // If there is more than one reference  
     // remove reference and get a new shiny empty representation  
     if (_rep->_refCounter.get() > 1)  
     {  
         Unref(_rep);  
         _rep = new CIMObjectPathRep();  
     }  
     else  
     {  
         // If there is only one reference  
         // no need to copy the data, we own it  
         // just clear the fields  
         _rep->_host.clear();         _rep->_host.clear();
         _rep->_nameSpace.clear();         _rep->_nameSpace.clear();
         _rep->_className.clear();         _rep->_className.clear();
         _rep->_keyBindings.clear();         _rep->_keyBindings.clear();
     }     }
 }  
  
 void CIMObjectPath::set( void CIMObjectPath::set(
     const String& host,     const String& host,
Line 572 
Line 519 
     const CIMName& className,     const CIMName& className,
     const Array<CIMKeyBinding>& keyBindings)     const Array<CIMKeyBinding>& keyBindings)
 { {
     if ((host != String::EMPTY) && !CIMObjectPathRep::isValidHostname(host))     setHost(host);
     {     setNameSpace(nameSpace);
         throw MalformedObjectNameException(host);     setClassName(className);
     }     setKeyBindings(keyBindings);
   
     _rep = _copyOnWriteCIMObjectPathRep(_rep);  
   
     _rep->_host.assign(host);  
     _rep->_nameSpace = nameSpace;  
     _rep->_className = className;  
     _rep->_keyBindings = keyBindings;  
     _Sort(_rep->_keyBindings);  
 } }
  
 Boolean _parseHostElement( Boolean _parseHostElement(
Line 716 
Line 655 
  
             p++;             p++;
  
             Buffer keyValueUTF8(128);              Array<Uint8> keyValueUTF8;
               keyValueUTF8.reserveCapacity(128);
  
             while (*p && *p != '"')             while (*p && *p != '"')
             {             {
Line 750 
Line 690 
              */              */
             type = CIMKeyBinding::STRING;             type = CIMKeyBinding::STRING;
  
             /* Performance shortcut will check for  
                equal sign instead of doing the full  
                CIMObjectPath creation and exception handling  
             */  
             if (strchr(keyValueUTF8.getData(), '='))  
             {  
                 // found an equal sign, high probability for a reference  
                 try                 try
                 {                 {
                     CIMObjectPath testForPath(valueString);                     CIMObjectPath testForPath(valueString);
Line 771 
Line 704 
                     // Not a reference value; leave type as STRING                     // Not a reference value; leave type as STRING
                 }                 }
             }             }
         }  
         else if (toupper(*p) == 'T' || toupper(*p) == 'F')         else if (toupper(*p) == 'T' || toupper(*p) == 'F')
         {         {
             type = CIMKeyBinding::BOOLEAN;             type = CIMKeyBinding::BOOLEAN;
Line 849 
Line 781 
         }         }
     }     }
  
     _Sort(keyBindings);      _BubbleSort(keyBindings);
 } }
  
 void CIMObjectPath::set(const String& objectName) void CIMObjectPath::set(const String& objectName)
 { {
     // the clear automatically ensures  
     // we have our own copy of the representation  
     clear();     clear();
  
     //--------------------------------------------------------------------------     //--------------------------------------------------------------------------
Line 914 
Line 844 
  
 CIMObjectPath& CIMObjectPath::operator=(const String& objectName) CIMObjectPath& CIMObjectPath::operator=(const String& objectName)
 { {
     // set will call clear, which will cause copyOnWrite if necessary  
     set(objectName);     set(objectName);
     return *this;     return *this;
 } }
Line 926 
Line 855 
  
 void CIMObjectPath::setHost(const String& host) void CIMObjectPath::setHost(const String& host)
 { {
     if ((host != String::EMPTY) &&      if ((host != String::EMPTY) && !CIMObjectPathRep::isValidHostname(host))
         (host != System::getHostName()) &&  
         !CIMObjectPathRep::isValidHostname(host))  
     {     {
         throw MalformedObjectNameException(host);         throw MalformedObjectNameException(host);
     }     }
     _rep = _copyOnWriteCIMObjectPathRep(_rep);  
  
     _rep->_host = host;     _rep->_host = host;
 } }
Line 944 
Line 870 
  
 void CIMObjectPath::setNameSpace(const CIMNamespaceName& nameSpace) void CIMObjectPath::setNameSpace(const CIMNamespaceName& nameSpace)
 { {
     _rep = _copyOnWriteCIMObjectPathRep(_rep);  
    _rep->_nameSpace = nameSpace;    _rep->_nameSpace = nameSpace;
 } }
  
Line 955 
Line 880 
  
 void CIMObjectPath::setClassName(const CIMName& className) void CIMObjectPath::setClassName(const CIMName& className)
 { {
     _rep = _copyOnWriteCIMObjectPathRep(_rep);  
     _rep->_className = className;     _rep->_className = className;
 } }
  
Line 966 
Line 890 
  
 void CIMObjectPath::setKeyBindings(const Array<CIMKeyBinding>& keyBindings) void CIMObjectPath::setKeyBindings(const Array<CIMKeyBinding>& keyBindings)
 { {
     _rep = _copyOnWriteCIMObjectPathRep(_rep);  
     _rep->_keyBindings = keyBindings;     _rep->_keyBindings = keyBindings;
     _Sort(_rep->_keyBindings);      _BubbleSort(_rep->_keyBindings);
 } }
  
 String CIMObjectPath::toString() const String CIMObjectPath::toString() const
Line 1040 
Line 963 
  
 String CIMObjectPath::_toStringCanonical() const String CIMObjectPath::_toStringCanonical() const
 { {
     CIMObjectPath ref;      CIMObjectPath ref = *this;
     *ref._rep = *this->_rep;  
  
     // Normalize hostname by changing to lower case     // Normalize hostname by changing to lower case
     ref._rep->_host.toLower(); // ICU_TODO:     ref._rep->_host.toLower(); // ICU_TODO:
Line 1131 
Line 1053 
 Boolean CIMObjectPath::identical(const CIMObjectPath& x) const Boolean CIMObjectPath::identical(const CIMObjectPath& x) const
 { {
     return     return
         String::equalNoCase(_rep->_host, x._rep->_host) &&          (_rep == x._rep) ||
           (String::equalNoCase(_rep->_host, x._rep->_host) &&
         _rep->_nameSpace.equal(x._rep->_nameSpace) &&         _rep->_nameSpace.equal(x._rep->_nameSpace) &&
         _rep->_className.equal(x._rep->_className) &&         _rep->_className.equal(x._rep->_className) &&
         _rep->_keyBindings == x._rep->_keyBindings;           (_rep->_keyBindings == x._rep->_keyBindings));
 } }
  
 Uint32 CIMObjectPath::makeHashCode() const Uint32 CIMObjectPath::makeHashCode() const

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