In This Package:

KeyedObject.h

Go to the documentation of this file.

// $Id $
#ifndef GAUDIKERNEL_KEYEDOBJECT_H
#define GAUDIKERNEL_KEYEDOBJECT_H

namespace GaudiDict  {
  template <class T> struct KeyedObjectDict;
}

// Framework include files
#include "GaudiKernel/ContainedObject.h"
#include "GaudiKernel/KeyedTraits.h"
#include "GaudiKernel/KeyedContainer.h"

template < class KEY >
class KeyedObject : public ContainedObject    {
  friend struct GaudiDict::KeyedObjectDict<KEY>;
public:
  typedef KEY key_type;

protected:
  typedef typename Containers::key_traits<key_type> traits;
//#ifdef _WIN32
//  friend traits;
//#else
  friend struct Containers::key_traits<key_type>;
//#endif

  key_type m_key;
  long     m_refCount;
  bool     m_hasKey;
  unsigned long addRef();
  unsigned long release();
  void setKey(const key_type& key);
public:
  KeyedObject() : m_refCount(0), m_hasKey(false) {                             }
  KeyedObject(const key_type& kval):m_key(kval),m_refCount(0),m_hasKey(true) { }
  virtual ~KeyedObject();
  const key_type& key() const           {                     return m_key;    }
  bool hasKey()   const                 {                     return m_hasKey; }  
  virtual long index() const            {    return traits::identifier(m_key); }
  virtual StreamBuffer& serialize( StreamBuffer& s ) const;
  virtual StreamBuffer& serialize( StreamBuffer& s );
private:
  KeyedObject(const KeyedObject& copy) : ContainedObject(copy) {               }
};

/*
 *
 *
 *  Inline code for keyed KeyedObject class
 *
 */

// Standard destructor.
template<class KEY> inline
KeyedObject<KEY>::~KeyedObject() 
{
  ObjectContainerBase* p = const_cast<ObjectContainerBase*>(parent());
  if ( p )  {
    setParent(0);
    p->remove(this);
  }
}

// Add reference to object (Increase reference counter).
template<class KEY> inline
unsigned long KeyedObject<KEY>::addRef() {
  return ++m_refCount; 
}

// Release reference. If the reference count is ZERO, delete the object.
template<class KEY> inline
unsigned long KeyedObject<KEY>::release() {
  long cnt = --m_refCount;
  if ( cnt <= 0 )  {
    delete this;
  }
  return cnt;
}

/*  Set object key. The key for consistency reasons 
    can be set only once for the object. Any attempt to
    redefine the key results in an exception.
*/
template<class KEY> inline
void KeyedObject<KEY>::setKey(const key_type& key) {
  if ( !m_hasKey )   {
    m_key = key;
    m_hasKey = true;
    return;
  }
  Containers::cannotAssignObjectKey();
}

// Serialize the object for writing
template<class KEY> inline
StreamBuffer& KeyedObject<KEY>::serialize( StreamBuffer& s ) const {
  return ContainedObject::serialize(s) << traits::identifier(m_key);
}

// Serialize the object for reading
template<class KEY> inline
StreamBuffer& KeyedObject<KEY>::serialize( StreamBuffer& s ) {
  long k;
  ContainedObject::serialize(s) >> k;
  m_key = traits::makeKey(k);
  m_hasKey = true;
  return s;
}
#endif // GAUDIKERNEL_KEYEDOBJECT_H

---