KeyedObject.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2026 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <GaudiKernel/ContainedObject.h>
#include <GaudiKernel/KeyedContainer.h>
#include <GaudiKernel/KeyedTraits.h>
 
namespace GaudiDict {
  template <class T>
  struct KeyedObjectDict;
}

template <class KEY>
class GAUDI_API KeyedObject : public ContainedObject {
  friend struct GaudiDict::KeyedObjectDict<KEY>;
 
public:
  typedef KEY key_type;
 
protected:
  using traits = Containers::key_traits<key_type>;
  friend struct Containers::key_traits<key_type>;

  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;
}