(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.61 and 1.64

version 1.61, 2007/06/26 20:26:13 version 1.64, 2007/10/31 07:52:22
Line 408 
Line 408 
 class CIMObjectPathRep class CIMObjectPathRep
 { {
 public: public:
     CIMObjectPathRep()      CIMObjectPathRep(): _refCounter(1)
     {     {
     }     }
  
     CIMObjectPathRep(const CIMObjectPathRep& x)     CIMObjectPathRep(const CIMObjectPathRep& x)
         : _host(x._host), _nameSpace(x._nameSpace),          : _refCounter(1), _host(x._host), _nameSpace(x._nameSpace),
         _className(x._className), _keyBindings(x._keyBindings)         _className(x._className), _keyBindings(x._keyBindings)
     {     {
     }     }
Line 423 
Line 423 
         const CIMNamespaceName& nameSpace,         const CIMNamespaceName& nameSpace,
         const CIMName& className,         const CIMName& className,
         const Array<CIMKeyBinding>& keyBindings)         const Array<CIMKeyBinding>& keyBindings)
         : _host(host), _nameSpace(nameSpace),          : _refCounter(1), _host(host), _nameSpace(nameSpace),
         _className(className), _keyBindings(keyBindings)         _className(className), _keyBindings(keyBindings)
     {     {
     }     }
Line 451 
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 461 
Line 464 
     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 469 
Line 484 
  
 CIMObjectPath::CIMObjectPath(const CIMObjectPath& x) CIMObjectPath::CIMObjectPath(const CIMObjectPath& x)
 { {
     _rep = new CIMObjectPathRep(*x._rep);      _rep = x._rep;
       Ref(_rep);
 } }
  
 CIMObjectPath::CIMObjectPath(const String& objectName) CIMObjectPath::CIMObjectPath(const String& objectName)
Line 478 
Line 494 
     CIMObjectPath tmpRef;     CIMObjectPath tmpRef;
     tmpRef.set(objectName);     tmpRef.set(objectName);
  
     _rep = new CIMObjectPathRep(*tmpRef._rep);      _rep = tmpRef._rep;
       Ref(_rep);
 } }
  
 CIMObjectPath::CIMObjectPath( CIMObjectPath::CIMObjectPath(
Line 490 
Line 507 
     // 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;
     _rep = new CIMObjectPathRep(*tmpRef._rep);      Ref(_rep);
 } }
  
 CIMObjectPath::~CIMObjectPath() CIMObjectPath::~CIMObjectPath()
 { {
     delete _rep;      Unref(_rep);
 } }
  
 CIMObjectPath& CIMObjectPath::operator=(const CIMObjectPath& x) CIMObjectPath& CIMObjectPath::operator=(const CIMObjectPath& x)
 { {
     *_rep = *x._rep;      if (x._rep != _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 519 
Line 569 
     const CIMName& className,     const CIMName& className,
     const Array<CIMKeyBinding>& keyBindings)     const Array<CIMKeyBinding>& keyBindings)
 { {
    setHost(host);      if ((host != String::EMPTY) && !CIMObjectPathRep::isValidHostname(host))
    setNameSpace(nameSpace);      {
    setClassName(className);          throw MalformedObjectNameException(host);
    setKeyBindings(keyBindings);      }
   
       _rep = _copyOnWriteCIMObjectPathRep(_rep);
   
       _rep->_host.assign(host);
       _rep->_nameSpace = nameSpace;
       _rep->_className = className;
       _rep->_keyBindings = keyBindings;
       _BubbleSort(_rep->_keyBindings);
 } }
  
 Boolean _parseHostElement( Boolean _parseHostElement(
Line 655 
Line 713 
  
             p++;             p++;
  
               Array<Uint8> keyValueUTF8;
               keyValueUTF8.reserveCapacity(128);
   
             while (*p && *p != '"')             while (*p && *p != '"')
             {             {
                 if (*p == '\\')                 if (*p == '\\')
                 {                 {
                     *p++;                      p++;
  
                     if ((*p != '\\') && (*p != '"'))                     if ((*p != '\\') && (*p != '"'))
                     {                     {
Line 667 
Line 728 
                     }                     }
                 }                 }
  
                 valueString.append(*p++);                  keyValueUTF8.append(*p++);
             }             }
  
             if (*p++ != '"')             if (*p++ != '"')
                 throw MalformedObjectNameException(objectName);                 throw MalformedObjectNameException(objectName);
  
               // Convert the UTF-8 value to a UTF-16 String
   
               valueString.assign(
                   (const char*)keyValueUTF8.getData(),
                   keyValueUTF8.size());
   
             /*             /*
                 Guess at the type of this quoted key value.  If the value                 Guess at the type of this quoted key value.  If the value
                 can be parsed into a CIMObjectPath with at least one key                 can be parsed into a CIMObjectPath with at least one key
Line 777 
Line 844 
  
 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 835 
Line 904 
  
 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 850 
Line 920 
     {     {
         throw MalformedObjectNameException(host);         throw MalformedObjectNameException(host);
     }     }
       _rep = _copyOnWriteCIMObjectPathRep(_rep);
  
     _rep->_host = host;     _rep->_host = host;
 } }
Line 861 
Line 932 
  
 void CIMObjectPath::setNameSpace(const CIMNamespaceName& nameSpace) void CIMObjectPath::setNameSpace(const CIMNamespaceName& nameSpace)
 { {
       _rep = _copyOnWriteCIMObjectPathRep(_rep);
    _rep->_nameSpace = nameSpace;    _rep->_nameSpace = nameSpace;
 } }
  
Line 871 
Line 943 
  
 void CIMObjectPath::setClassName(const CIMName& className) void CIMObjectPath::setClassName(const CIMName& className)
 { {
       _rep = _copyOnWriteCIMObjectPathRep(_rep);
     _rep->_className = className;     _rep->_className = className;
 } }
  
Line 881 
Line 954 
  
 void CIMObjectPath::setKeyBindings(const Array<CIMKeyBinding>& keyBindings) void CIMObjectPath::setKeyBindings(const Array<CIMKeyBinding>& keyBindings)
 { {
       _rep = _copyOnWriteCIMObjectPathRep(_rep);
     _rep->_keyBindings = keyBindings;     _rep->_keyBindings = keyBindings;
     _BubbleSort(_rep->_keyBindings);     _BubbleSort(_rep->_keyBindings);
 } }
Line 954 
Line 1028 
  
 String CIMObjectPath::_toStringCanonical() const String CIMObjectPath::_toStringCanonical() const
 { {
     CIMObjectPath ref = *this;      CIMObjectPath ref;
       *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 1044 
Line 1119 
 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.61  
changed lines
  Added in v.1.64
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2