KeyedObjectManager.cpp

Go to the documentation of this file.

// Include files
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/GaudiException.h"
#include "GaudiKernel/ContainedObject.h"
#include "GaudiKernel/KeyedObjectManager.h"
#include <algorithm>
#include <map>
#include "GaudiKernel/HashMap.h"

namespace Containers    {
  struct hashmap   {
    typedef GaudiUtils::HashMap<long, void*> map_type;
    map_type               m;
    std::vector<void*>     v;
    bool insert(void* obj, long key)    {
      auto p = m.insert(map_type::value_type(key,obj));
      return p.second;
    }
    hashmap() = default;
    hashmap(hashmap&&) = default;
  };
  struct map   {
    typedef std::map<long, void*>      map_type;
    map_type                m;
    std::vector<void*>      v;
    bool insert(void* obj, long key)    {
      auto p = m.insert(map_type::value_type(key,obj));
      return p.second;
    }
    map() = default;
    map(map&&) = default;
  };
  struct array {
    typedef std::vector<long> map_type;
    std::vector<long>         m_idx;
    std::vector<void*>        v;
    struct decrement   {
      long m_min;
      decrement(long m) : m_min(m) {}
      bool operator()(long& j)  const {
        if ( j > m_min ) --j;
        return true;
      }
    };
    array() = default;
    array(array&&) = default;
  };
  struct vector {
    typedef std::vector<void*>  map_type;
    std::vector<void*>          v;
    vector() = default;
    vector(vector&&) = default;
  };

  template <class CONT>
  class find   {
    const void* m_obj;
    typedef typename CONT::value_type v_type;
  public:
    find(const void* o) : m_obj(o) {}
    bool operator()(const void* cmp)  const {
      return cmp == m_obj;
    }
    bool operator()(const v_type& cmp)  const {
      return (*this)(cmp.second);
    }
  };
}
void Containers::cannotAssignObjectKey()   {
  throw GaudiException("Cannot assign key to keyed object! Object already has a key.",
                       "KeyedObject",
                       0);
}
void Containers::cannotInsertToContainer()   {
  throw GaudiException("Cannot insert element to Keyed Container!",
                       "KeyedContainer",
                       0);
}

void Containers::containerIsInconsistent()   {
  throw GaudiException("Keyed Container structures are inconsistent - severe problem!",
                       "KeyedContainer",
                       0);
}

void Containers::invalidContainerOperation()   {
  throw GaudiException("Keyed Container cannot satisfy request - severe problem!",
                       "KeyedContainer",
                       0);
}

template <class T>
Containers::KeyedObjectManager<T>::KeyedObjectManager()
: m_seq(nullptr), m_direct(0)
{
  if ( sizeof(typename T::map_type) > sizeof(m_setup.buffer) )    {
    throw GaudiException("Basic STL contaier sizes are incompatible",
                         "KeyedContainer",
                         0);
  }
  m_setup.s = ::new(m_setup.buffer+sizeof(m_setup.s)) T();
  m_keyCtxt = -1;
}

template <class T>
Containers::KeyedObjectManager<T>::KeyedObjectManager(KeyedObjectManager&& other):
    m_seq(nullptr),
    m_direct(other.m_direct),
    m_keyCtxt(other.m_keyCtxt)
{
  m_setup.s = ::new(m_setup.buffer + sizeof(m_setup.s)) T(std::move(*other.m_setup.s));

  other.m_keyCtxt = -1;
  other.m_seq = nullptr;
  other.m_direct = 0;
}

template <class T>
Containers::KeyedObjectManager<T>::~KeyedObjectManager()
{
  m_setup.s->~T();
}

template <class T> void
Containers::KeyedObjectManager<T>::setup(void* seq, void** rndm)
{
  m_seq = (seq_type*)seq;
  *rndm = &m_setup.s->v;
}

template <class T>
void Containers::KeyedObjectManager<T>::onDirty()   const  {
  m_direct = 1;
  auto &s = *m_setup.s;
  long i = 0;
  for(auto p: s.v) s.insert(p, i++);
  s.v.clear();
}

template <class T>
long Containers::KeyedObjectManager<T>::insert(
                                ObjectContainerBase* pBase,
                                ContainedObject* pObject,
                                void* obj,
                                long* key)
{
  *key = ++m_keyCtxt;
  return insert(pBase, pObject, obj, *key);
}

template <class T>
long Containers::KeyedObjectManager<T>::insert(
                                ObjectContainerBase* pBase,
                                ContainedObject* pObject,
                                void* obj,
                                long key)
{
  if ( key > m_keyCtxt )  {
    m_keyCtxt = key;
  }
  if ( 1==m_direct )  {
    if ( m_setup.s->insert(obj, key) )   {
      if ( !pObject->parent() )  {
        pObject->setParent(pBase);
      }
      m_seq->push_back(obj);
      return OBJ_INSERTED;
    }
  }
  else if ( key == long(m_setup.s->v.size()) )  {
    m_setup.s->v.push_back(obj);
    if ( !pObject->parent() )  {
      pObject->setParent(pBase);
    }
    m_seq->push_back(obj);
    return OBJ_INSERTED;
  }
  else  {
    // Document is dirty now...
    // need to copy all pointers from the vector to the map
    onDirty();
    return insert(pBase, pObject, obj, key);
  }
  cannotInsertToContainer();
  return OBJ_CANNOT_INSERT;
}

template <class T>
long Containers::KeyedObjectManager<T>::insertDirect(
                                ObjectContainerBase* pBase,
                                ContainedObject* pObject,
                                void* obj,
                                long key)
{
  if ( key > m_keyCtxt )  {
    m_keyCtxt = key;
  }
  if ( 1==m_direct )  {
    if ( m_setup.s->insert(obj, key) )   {
      if ( !pObject->parent() )  {
        pObject->setParent(pBase);
      }
      return OBJ_INSERTED;
    }
  }
  else if ( key == long(m_setup.s->v.size()) )  {
    m_setup.s->v.push_back(obj);
    if ( !pObject->parent() )  {
      pObject->setParent(pBase);
    }
    return OBJ_INSERTED;
  }
  else  {
    // Document is dirty now...
    // need to copy all pointers from the vector to the map
    onDirty();
    return insertDirect(pBase, pObject, obj, key);
  }
  cannotInsertToContainer();
  return OBJ_CANNOT_INSERT;
}

// Remove object from container
template <class T>
void* Containers::KeyedObjectManager<T>::erase(long  key,
                                               const void* obj) {
  typedef typename T::map_type MTYP;
  typedef find<MTYP> FND;
  if ( 1 == m_direct )   {
    auto& m = m_setup.s->m;
    auto i = (obj ? std::find_if(m.begin(),m.end(),FND(obj))
                  : m_setup.s->m.find(key) );
    if ( i != m_setup.s->m.end() )   {
      void* o = i->second;
      auto j = std::find(m_seq->begin(),m_seq->end(),o);
      if ( j != m_seq->end() )   {
        m_seq->erase(j);
        m_setup.s->m.erase(i);
        return o;
      }
    }
    containerIsInconsistent();
  }
  onDirty();
  return erase(key, obj);
}

template <class T>
void* Containers::KeyedObjectManager<T>::object(long key)  const
{
  if ( 0 == m_direct )   onDirty();
  auto i = m_setup.s->m.find(key);
  if ( i != m_setup.s->m.end() )  return (*i).second;
  return nullptr;
}

template <class T>
void Containers::KeyedObjectManager<T>::reserve(long len)
{
  switch( m_direct )   {
  case 1:
    break;
  case 0:
    m_setup.s->v.reserve(len);
    break;
  default:
    break;
  }
  m_seq->reserve(len);
}

template <class T>
void Containers::KeyedObjectManager<T>::clear()
{
  clearDirect();
  m_seq->clear();
}

template <class T>
void Containers::KeyedObjectManager<T>::clearDirect()
{
  switch( m_direct )   {
  case 1:
    m_setup.s->m.clear();
    break;
  case 0:
    m_setup.s->v.clear();
    break;
  default:
    break;
  }
  m_direct = 0;
  m_keyCtxt = -1;
}

// Remove object by sequential iterators
template <class T>
long Containers::KeyedObjectManager<T>::erase(seq_type::iterator beg,
                                              seq_type::iterator end)
{
  typedef typename T::map_type MTYP;
  typedef find<MTYP> FND;
  if ( 0 == m_direct )    {
    onDirty();
    return erase(beg, end);
  }
  if ( beg == m_seq->begin() && end == m_seq->end() )   {
    clear();
  }
  else  {
    for ( auto j=beg; j != end; ++j)  {
      auto& m = m_setup.s->m;
      auto  i = std::find_if(m.begin(),m.end(),FND(*j));
      if ( i != m_setup.s->m.end() ) {
        m_setup.s->m.erase(i);
        continue;
      }
      containerIsInconsistent();
    }
    m_seq->erase(beg, end);
  }
  return OBJ_ERASED;
}

namespace Containers {

  /*  First specialize static methods and then instantiate templated class to appear as symbols in the library
      This order in needed for gcc 4.0 (MacOSX) */

  template<>
  CLID KeyedObjectManager< Containers::map >::classID()   {
    return CLID_ObjectVector+0x00030000;
  }
  template<>
  CLID KeyedObjectManager< Containers::hashmap >::classID()   {
    return CLID_ObjectVector+0x00040000;
  }

  template class KeyedObjectManager<Containers::hashmap>;
  template class KeyedObjectManager<Containers::map>;
}

/*
 *
 *
 *  Inline code for indirection array implementation
 *
 */
typedef Containers::array __A;

namespace Containers {

//__forceinline
template<> void*
KeyedObjectManager< __A >::object(long value) const
{
#ifdef CHECK_KEYED_CONTAINER
  unsigned long siz = m_setup.s->m_idx.size();
  if ( value >= 0 && size_t(value) < siz )  {
    long ent =  *(m_setup.s->m_idx.begin()+value);
    if ( ent >= 0 )  {
      return *(m_setup.s->v.begin() + ent);
    }
  }
  return nullptr;
#else
  return *(m_setup.s->v.begin() + (*(m_setup.s->m_idx.begin()+value)));
#endif
}

template<>
void KeyedObjectManager< __A >::onDirty()  const {
  m_direct = 1;
  m_setup.s->m_idx.reserve(m_setup.s->v.size()+1);
  for(int i = 0, stop = m_setup.s->v.size(); i < stop; ++i)   {
    if ( !m_setup.s->v[i] )  {
      containerIsInconsistent();
    }
    m_setup.s->m_idx.push_back(i);
  }
}

// Insert new object into container
template<>
long KeyedObjectManager< __A >::insert(ObjectContainerBase* b,
                                                   ContainedObject* c,
                                                   void* o,
                                                   long* k)
{
  // auto key creation only possible for direct access!
  if ( 0 == m_direct )    {
    m_seq->push_back(o);
    m_setup.s->v.push_back(o);
    if ( !c->parent() ) c->setParent(b);
    *k = ++m_keyCtxt;
    return OBJ_INSERTED;
  }
  cannotInsertToContainer();
  return OBJ_CANNOT_INSERT;
}

// Insert new object into container
template<>
long KeyedObjectManager< __A >::insert(ObjectContainerBase* b,
                                                   ContainedObject* c,
                                                   void* o,
                                                   long k)
{
  if ( 0 == m_direct )    {
    if ( k == m_keyCtxt+1 ) {
      return insert(b, c, o, &k);
    }
    onDirty();
    return insert(b, c, o, k);
  }
  if ( k > m_keyCtxt ) m_keyCtxt = k;
  if ( k+1 > long(m_setup.s->m_idx.size()) )   {
    m_setup.s->m_idx.resize(k+1, -1);
  }
  auto idx = m_setup.s->m_idx.begin()+k;
  if ( *idx == -1 )  {
    *idx = m_setup.s->v.size();
    m_setup.s->v.push_back(o);
    m_seq->push_back(o);
    if ( !c->parent() ) c->setParent(b);
    return OBJ_INSERTED;
  }
  cannotInsertToContainer();
  return OBJ_CANNOT_INSERT;
}

// Insert new object into container
template<> long
KeyedObjectManager< __A >::insertDirect(ObjectContainerBase* b,
                            ContainedObject* c,
                            void* o,
                            long k)
{
  if ( 0 == m_direct )    {
    if ( k == m_keyCtxt+1 ) {
      m_setup.s->v.push_back(o);
      if ( !c->parent() ) c->setParent(b);
      ++m_keyCtxt;
      return OBJ_INSERTED;
    }
    onDirty();
    return insertDirect(b, c, o, k);
  }
  if ( k > m_keyCtxt ) m_keyCtxt = k;
  if ( k+1 > long(m_setup.s->m_idx.size()) )   {
    m_setup.s->m_idx.resize(k+1, -1);
  }
  auto idx = m_setup.s->m_idx.begin()+k;
  if ( *idx == -1 )  {
    *idx = m_setup.s->v.size();
    m_setup.s->v.push_back(o);
    if ( !c->parent() ) c->setParent(b);
    return OBJ_INSERTED;
  }
  cannotInsertToContainer();
  return OBJ_CANNOT_INSERT;
}

// Clear content of the vector
template<>
void KeyedObjectManager< __A >::clearDirect() {
  m_setup.s->v.clear();
  m_setup.s->m_idx.clear();
  m_direct = 0;
  m_keyCtxt = -1;
}

// Remove object from container (very inefficient if key is invalid)
template<>
void* KeyedObjectManager< __A >::erase(long key,
                                                   const void* obj)
{
  typedef std::vector<long> id_type;
  typedef id_type::iterator id_iter;
  if ( 0 == m_direct )    {
    onDirty();
    return erase(key, obj);
  }
  if ( obj )   {
    id_type& idx = m_setup.s->m_idx;
    for (auto & elem : idx)    {
      auto j = m_setup.s->v.begin()+(elem);
      auto k = std::find(m_seq->begin(),m_seq->end(),*j);
      if ( *j == obj )   {
        void* o = *j;
        m_seq->erase(k);
        m_setup.s->v.erase(j);
        std::for_each(m_setup.s->m_idx.begin(),
                      m_setup.s->m_idx.end(),
                      array::decrement(elem));
        elem = -1;
        return o;
      }
    }
  }
  else if ( key >= 0 && key < long(m_setup.s->m_idx.size()) )   {
    auto idx = m_setup.s->m_idx.begin()+key;
    if ( *idx != -1 )   {
      auto i = m_setup.s->v.begin()+(*idx);
      if ( i == m_setup.s->v.end() )   {
        containerIsInconsistent();
      }
      void* o = *i;
      auto j=std::find(m_seq->begin(),m_seq->end(),o);
      if ( j == m_seq->end() )   {
        containerIsInconsistent();
      }
      m_seq->erase(j);
      m_setup.s->v.erase(i);
      std::for_each(m_setup.s->m_idx.begin(),
                    m_setup.s->m_idx.end(),
                    array::decrement(*idx));
      *idx = -1;
      return o;
    }
  }
  containerIsInconsistent();
  return nullptr;
}

// Remove object by sequential iterators
template<>
long KeyedObjectManager< __A >::erase(seq_type::iterator beg,
                                                  seq_type::iterator end)
{
  typedef std::vector<long> id_type;
  typedef id_type::iterator id_iter;
  if ( beg == m_seq->begin() && end == m_seq->end() )   {
    clear();
    return OBJ_ERASED;
  }
  else if ( 0 == m_direct )    {
    onDirty();
    return erase(beg, end);
  }
  else  {
    long cnt = 0, nobj = end-beg;
    id_type& idx = m_setup.s->m_idx;
    for (auto & elem : idx)    {
      auto j = m_setup.s->v.begin()+(elem);
      auto k = std::find(beg,end,*j);
      if ( k != end )   {
        m_setup.s->v.erase(j);
        std::for_each(m_setup.s->m_idx.begin(),
                      m_setup.s->m_idx.end(),
                      array::decrement(elem));
        elem = -1;
        cnt++;
        if ( cnt == nobj ) break;
      }
    }
    m_seq->erase(beg, end);
    if ( cnt != nobj )  {
      containerIsInconsistent();
    }
    return OBJ_ERASED;
  }
  // cannot reach this point
}

template<>
CLID KeyedObjectManager< __A >::classID()   {
  return CLID_ObjectVector+0x00050000;
}
}
template class Containers::KeyedObjectManager<__A>;
/*
  *
  *
  *  Implementation for objects with vector like access
  *
  *
  **/
typedef Containers::vector __V;

namespace Containers {
// Access single entry by long(integer) key
template<>
void* KeyedObjectManager< __V >::object(long /* value */) const
{
  invalidContainerOperation();
  return nullptr;
}

template<>
void KeyedObjectManager<__V>::onDirty()   const  {
  invalidContainerOperation();
}

// Insert new object into container
template<>
long KeyedObjectManager< __V >::insert(ObjectContainerBase* b,
                                                   ContainedObject* c,
                                                   void* o,
                                                   long* k)
{
  m_seq->push_back(o);
  m_setup.s->v.push_back(o);
  if ( !c->parent() ) c->setParent(b);
  *k = (m_setup.s->v.size()-1);
  return OBJ_INSERTED;
}

// Insert new object into container
template<>
long KeyedObjectManager< __V >::insert(ObjectContainerBase* b,
                                                   ContainedObject* c,
                                                   void* o,
                                                   long k)
{
  if ( k == long(m_setup.s->v.size()) ) {
    return insert(b, c, o, &k);
  }
  cannotInsertToContainer();
  return OBJ_CANNOT_INSERT;
}

// Insert new object into container
template<> long
KeyedObjectManager< __V >::insertDirect(ObjectContainerBase* b,
                            ContainedObject* c,
                            void* o,
                            long k)
{
  if ( k == long(m_setup.s->v.size()) ) {
    m_setup.s->v.push_back(o);
    if ( !c->parent() ) c->setParent(b);
    return OBJ_INSERTED;
  }
  cannotInsertToContainer();
  return OBJ_CANNOT_INSERT;
}

// Clear content of the vector
template<>
void KeyedObjectManager< __V >::clearDirect()  {
  m_setup.s->v.clear();
  m_direct = 0;
  m_keyCtxt = -1;
}

// Remove object from container (very inefficient if key is invalid)
template<> void*
KeyedObjectManager< __V >::erase(long /* key */,
                                             const void* /* obj */)
{
  invalidContainerOperation();
  return nullptr;
}

// Remove object by sequential iterators
template<>
long KeyedObjectManager< __V >::erase(seq_type::iterator beg,
                                                  seq_type::iterator end)
{
  if ( beg == m_seq->begin() && end == m_seq->end() )   {
    clear();
    return OBJ_ERASED;
  }
  invalidContainerOperation();
  return OBJ_ERASED;
}

template<>
CLID KeyedObjectManager< __V >::classID()   {
  return CLID_ObjectVector+0x00060000;
}

}
template class Containers::KeyedObjectManager<__V>;