KeyedContainer.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_KEYEDCONTAINER_H
#define GAUDIKERNEL_KEYEDCONTAINER_H

// Include files
#include <iterator>
#include <algorithm>

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

// Framework include files
#include "GaudiKernel/ObjectContainerBase.h"
#include "GaudiKernel/KeyedObjectManager.h"
#include "GaudiKernel/KeyedObject.h"

// Forward declarations
// template <class T, class M> class KeyedContainer;

#ifdef WIN32
#define FORCE_INLINE __forceinline
#else
#define FORCE_INLINE inline
#endif

template <class DATATYPE, class MAPPING=Containers::HashMap >
class GAUDI_API KeyedContainer: public ObjectContainerBase
{
  friend struct GaudiDict::KeyedContainerDict<DATATYPE>;

public:
  typedef DATATYPE                                  contained_type;
  typedef MAPPING                                   container_type;

  typedef typename std::vector<contained_type*>     seq_type;
  typedef typename contained_type::key_type         key_type;
  typedef typename seq_type::value_type             value_type;
  typedef typename seq_type::reference              reference;
  typedef typename seq_type::const_reference        const_reference;
  typedef typename seq_type::iterator               iterator;
  typedef typename seq_type::const_iterator         const_iterator;
  typedef typename seq_type::reverse_iterator       reverse_iterator;
  typedef typename seq_type::const_reverse_iterator const_reverse_iterator;
private:
  typedef typename Containers::traits<container_type, contained_type> traits;

  container_type m_cont;
  seq_type       m_sequential;
  seq_type*      m_random;

#ifdef CHECK_KEYED_CONTAINER
  value_type i_object(const key_type& k) const  {
    if ( 0 == m_cont.isDirect() )  {
      if ( traits::checkBounds(m_random, k) )  {
        value_type p = *(m_random->begin()+traits::hash(k));
        if ( traits::checkKey(p, k) ) {
          return p;
        }
      }
      return 0;
    }
    value_type p = value_type(m_cont.object(traits::hash(k)));
    return traits::checkKey(p, k) ? p : 0;
  }
#else
  FORCE_INLINE value_type i_object(const key_type& k) const  {
    return 0==m_cont.isDirect()
      ? value_type(*(m_random->begin()+traits::hash(k)))
      : value_type(m_cont.object(traits::hash(k)));
  }
#endif
  long i_erase(const_reference v, const key_type& k)   {
    value_type p = value_type(m_cont.erase(traits::hash(k), v));
    if ( p )    {
      if ( p->parent() == this )  {
        p->setParent(0);
      }
    }
    return traits::release(p) <= 0 ? (long) Containers::OBJ_ERASED
                                   : (long) Containers::OBJ_DELETED;
  }

  struct _InsertRelease {
    KeyedContainer<DATATYPE,MAPPING>* m_obj;
    _InsertRelease(KeyedContainer<DATATYPE,MAPPING>* p) : m_obj(p) {}
    void operator()(value_type p) {
      m_obj->insert(p);
      traits::release(p);
    }
  };

  struct _RemoveRelease {
    ObjectContainerBase* m_obj;
    _RemoveRelease(ObjectContainerBase* p) : m_obj(p) {}
    void operator()(value_type p) {
      const ObjectContainerBase* par = p->parent();
      if ( par == m_obj )  {
        p->setParent(0);
      }
      traits::release(p);
    }
  };

public:
  KeyedContainer(void)
  {
    // avoid problems with strict-aliasing rules
    seq_type** rptr = &m_random;
    seq_type*  sptr = &m_sequential;
    m_cont.setup((void*)sptr,(void**)rptr);
  }
  virtual ~KeyedContainer();

  virtual const CLID& clID() const      {              return this->classID(); }
  static const CLID& classID()          {
    static CLID clid = contained_type::classID() + container_type::classID();
    return clid;
  }

  virtual size_type numberOfObjects() const   {  return m_sequential.size();       }
  virtual long add(ContainedObject* pObject);

  virtual long remove(ContainedObject* pObject);

  virtual ContainedObject* containedObject(long key_value) const  {
    return i_object( traits::makeKey( key_value ) );
  }
  virtual long index(const ContainedObject* p) const;
  virtual size_type containedObjects(std::vector<ContainedObject*>& v) const;

  size_type size() const                {      return m_sequential.size();    }
  bool empty() const                    {      return m_sequential.empty();   }
  void reserve(size_type value)         {      m_cont.reserve(value);          }
  void clear()                          {      erase(begin(), end());          }
  virtual const std::vector<const ContainedObject*>* containedObjects() const;
  virtual StatusCode update();

  iterator begin()                      {      return m_sequential.begin();   }
  const_iterator begin()  const         {      return m_sequential.begin();   }
  iterator end()                        {      return m_sequential.end();     }
  const_iterator end()  const           {      return m_sequential.end();     }
  reverse_iterator rbegin()             {      return m_sequential.rbegin();  }
  const_reverse_iterator rbegin() const {      return m_sequential.rbegin();  }
  reverse_iterator rend()               {      return m_sequential.rend();    }
  const_reverse_iterator rend() const   {      return m_sequential.rend();    }

  value_type object(const key_type& kval) const     {  return i_object(kval);  }

  value_type operator()(const key_type& kval) const {  return i_object(kval);  }

  long erase(const key_type& kval)  { return i_erase(0, kval);  }

  long erase(const value_type val) {
    return (val) ? i_erase(val, val->key()) : (long) Containers::OBJ_NOT_FOUND;
  }

  long erase(iterator pos)   {                return erase(*pos);              }

  void erase(iterator pos_start, iterator pos_stop, bool use_temp=false);

  const key_type& insert(const value_type val, const key_type& kval);

  const key_type& insert(const value_type val);
};


// Destructor
template <class DATATYPE, class MAPPING> inline
KeyedContainer<DATATYPE, MAPPING>::~KeyedContainer()
{
  erase(begin(), end());
  m_cont.clear();
}

// Configure direct access
template <class DATATYPE, class MAPPING> inline
StatusCode KeyedContainer<DATATYPE, MAPPING>::update()
{
  int count = 0;
  m_cont.clearDirect();
  typename seq_type::iterator i = m_sequential.begin();
  typename seq_type::iterator s = m_sequential.end();
  for ( ; i != s; i++ )  {
    typename seq_type::value_type v = *i;
    if ( v )  {
      if ( !v->hasKey() ) {
        traits::setKey(v, v->key());
        traits::addRef(v);
      }
      long k0 = traits::hash(v->key());
      if(m_cont.insertDirect(this, v, v, k0) == Containers::OBJ_INSERTED)   {
      }
    }
    else  {
      ++count;
    }
  }
  if ( count > 0 )  {
    Containers::cannotInsertToContainer();
  }
  return StatusCode::SUCCESS;
}


// Retrieve the full content of the object container by reference.
template <class DATATYPE, class MAPPING> inline
const std::vector<const ContainedObject*>*
KeyedContainer<DATATYPE, MAPPING>::containedObjects() const  {
  return (const std::vector<const ContainedObject*>*)
    ((0==m_cont.isDirect()) ? m_random : &m_sequential);
}

template <class DATATYPE, class MAPPING> inline
const typename KeyedContainer<DATATYPE, MAPPING>::key_type&
KeyedContainer<DATATYPE, MAPPING>::insert(const value_type val,
                                          const key_type& kval)
{
  if ( val )    {
    long k0 = traits::hash(kval);
    if ( !val->hasKey() || (traits::hash(val->key()) == k0) )    {
      if(m_cont.insert(this,val,val,k0) == Containers::OBJ_INSERTED)   {
        if ( !val->hasKey() ) traits::setKey(val, kval);
        traits::addRef(val);
        return val->key();
      }
    }
  }
  // Cannot insert object...indicate bad object insertion...
  Containers::cannotInsertToContainer();
  return val->key();
}

// Insert object
template <class DATATYPE, class MAPPING> //inline
const typename KeyedContainer<DATATYPE, MAPPING>::key_type&
KeyedContainer<DATATYPE, MAPPING>::insert(const value_type val)
{
  if ( 0 != val )   {
    if ( val->hasKey() )   {
      if (m_cont.insert(this,val,val,traits::hash(val->key()))
          == Containers::OBJ_INSERTED)   {
        traits::addRef(val);
        return val->key();
      }
    }
    long k0;
    if ( m_cont.insert(this, val, val, &k0) == Containers::OBJ_INSERTED )   {
      traits::setKey(val, traits::makeKey(k0));
      traits::addRef(val);
      return val->key();
    }
  }
  // Cannot insert object...indicate bad object insertion...
  Containers::cannotInsertToContainer();
  return val->key();
}

template <class DATATYPE, class MAPPING> inline
long KeyedContainer<DATATYPE, MAPPING>::index(const ContainedObject* p) const
{
  const contained_type* ptr = dynamic_cast<const contained_type*>(p);
  if ( ptr ) return traits::identifier(ptr->key());
  return -1;
}

// Retrieve the full content of the object container.
template <class DATATYPE, class MAPPING> inline
typename KeyedContainer<DATATYPE, MAPPING>::size_type KeyedContainer<DATATYPE, MAPPING>::containedObjects
(std::vector<ContainedObject*>& vec) const
{
  typename seq_type::const_iterator i = m_sequential.begin();
  typename seq_type::const_iterator s = m_sequential.end();
  vec.clear();
  vec.reserve(size());
  for ( ; i != s; i++ )  {
    ContainedObject* p = const_cast<typename seq_type::value_type>(*i);
    vec.push_back(p);
  }
  return vec.size();
}

// ObjectContainerBase overload: Add an object to the container.
template <class DATATYPE, class MAPPING> inline
long KeyedContainer<DATATYPE, MAPPING>::add(ContainedObject* pObject)
{
  return traits::identifier(insert(dynamic_cast<typename seq_type::value_type>(pObject)));
}

// ObjectContainerBase overload: Remove an object from the container.
template <class DATATYPE, class MAPPING> inline
long KeyedContainer<DATATYPE, MAPPING>::remove(ContainedObject* p)
{
  contained_type* p1 = dynamic_cast<contained_type*>(p);
  if ( p1 )    {  // Normal case; object still fully intact
    return this->erase(p1);
  }
  else if ( p )   {
    const ObjectContainerBase* par = p->parent();
    // The following should never occur: object is in a funny state,
    // Because the parent was explicitly set to NULL in the
    // KeyeObject destructor.
    // - It cannot be a KeyedObject:  It would not have a parent
    // - Still the parent is present: We are not in the destructor
    //                                of KeyedObject
    if ( par )  {
      Containers::invalidContainerOperation();
    }
    return m_cont.erase(0, p)==0 ? (long) Containers::OBJ_ERASED
                                 : (long) Containers::OBJ_NOT_FOUND;
  }
  return (long) Containers::OBJ_NOT_FOUND;
}

template <class DATATYPE, class MAPPING> inline
void
KeyedContainer<DATATYPE, MAPPING>::erase(iterator start_pos,
                                         iterator stop_pos,
                                         bool use_tmp)
{
  bool is_start = start_pos == m_sequential.begin();
  bool is_stop  = stop_pos  == m_sequential.end();
  if ( is_start && is_stop )  {
    // Nothing special. Taken care of by Keyed object manager
  }
  else if ( is_start || is_stop || use_tmp )  {
    std::vector<DATATYPE*> tmp(m_sequential.begin(), start_pos);
    tmp.insert(tmp.end(), stop_pos, m_sequential.end());
    std::for_each(tmp.begin(), tmp.end(), traits::addRef);
    this->erase(m_sequential.begin(), m_sequential.end());
    std::for_each(tmp.begin(), tmp.end(), _InsertRelease(this));
    return;
  }
  std::for_each(start_pos, stop_pos, _RemoveRelease(this));
  seq_type *sptr = &m_sequential; // avoid problems with strict-aliasing rules
  std::vector<void*>* v = (std::vector<void*>*)sptr;
  std::vector<void*>::iterator i1 =
    v->begin() + std::distance(m_sequential.begin(), start_pos);
  std::vector<void*>::iterator i2 =
    v->begin() + std::distance(m_sequential.begin(), stop_pos);
  m_cont.erase(i1, i2);
}

#undef FORCE_INLINE
#endif // GAUDIKERNEL_KEYEDCONTAINER_H