KeyedObject.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_KEYEDOBJECT_H
#define GAUDIKERNEL_KEYEDOBJECT_H

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

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

template <class KEY>
class GAUDI_API 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 = 0;
  bool m_hasKey = false;
  unsigned long addRef();
  unsigned long release();
  void setKey( const key_type& key );

public:
  KeyedObject() = default;
  KeyedObject( const key_type& kval ) : m_key( kval ), m_refCount( 0 ), m_hasKey( true ) {}
  ~KeyedObject() override;
  const key_type& key() const { return m_key; }
  bool hasKey() const { return m_hasKey; } 
  long index() const override { return traits::identifier( m_key ); }
  StreamBuffer& serialize( StreamBuffer& s ) const override;
  StreamBuffer& serialize( StreamBuffer& s ) override;

private:
  KeyedObject( const KeyedObject& copy ) : ContainedObject( copy ), m_refCount( 0 ), m_hasKey( true ) {}
};

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

// Standard destructor.
template <class KEY>
inline KeyedObject<KEY>::~KeyedObject()
{
  ObjectContainerBase* p = const_cast<ObjectContainerBase*>( parent() );
  if ( p ) {
    setParent( nullptr );
    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