ObjContainer.h

Go to the documentation of this file.

/*
   Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 */
/* Dear emacs, this is -*-c++-*- */
#ifndef TRKEXTOOLS_OBJCONTAINER_H
#define TRKEXTOOLS_OBJCONTAINER_H 
#include <vector>
#include <utility>
#include <limits>
#include <sstream>
#include <iostream>
#include <cassert>
#include <memory>
 
#include "CxxUtils/checker_macros.h"
 
template<class T_Obj>
class ObjContainer;
 
template<class T_Obj>
class ObjPtr;
 
 
class ObjRef;
 
template<class T_Obj>
T_Obj*
cloneObj(const T_Obj* obj)
{
  return (obj ? new T_Obj(*obj) : obj);
}
 
template<class T_Obj>
std::unique_ptr<T_Obj>
uniqueClone(const T_Obj* obj)
{
  return std::unique_ptr<T_Obj>(cloneObj(obj));
}
 
 
 
class ObjRef {
   template <class T_Obj_>
   friend class ObjContainer;
   template <class T_Obj_>
   friend class ObjPtr;
 
public:
   ObjRef()                           = default;
 
   ObjRef(unsigned short idx) : m_index(idx) {}
 
   ObjRef(const  ObjRef &ref) = default;
 
   ObjRef( ObjRef &&ref) : m_index(ref.m_index) {ref.m_index=invalid(); }
 
   bool isValid() const { return m_index != invalid(); }
 
   operator bool() const { return isValid();  }
 
    ObjRef &operator=(const  ObjRef &ref) = default;
 
    ObjRef &operator=( ObjRef &&ref) {
      if (this != &ref) {
         m_index=ref.m_index;
         ref.m_index = invalid();
      }
      return *this;
   }
 
   bool  operator==(const  ObjRef &obj) const {
      return obj.idx() == idx();
   }
 
   bool  operator!=(const  ObjRef &obj) const {
      return obj.idx() != idx();
   }
 
private:
   unsigned short idx() const { return m_index; };
 
   static constexpr unsigned short invalid()  { return  std::numeric_limits<unsigned short>::max(); }
   unsigned short m_index = invalid();
};
 
class ObjContainerBase {
   template <class T_Obj_>
   friend class ObjPtr;
 
protected:
   static void throwNoContainer() {
      throw std::logic_error("No object container.");
   }
 
   static void throwMaximumCapacitiyExceeded(size_t max_objs) {
      std::stringstream msg;
      msg << "Maximum object container capacity exceeded (" << max_objs << "). Bail out.";
      throw std::runtime_error(msg.str());
   }
 
   static void throwMaximumNumberOfSharesExceeded(size_t max_shares) {
      std::stringstream msg;
      msg << "Maximum number of shares exceeded (" << max_shares << "). Bail out.";
      throw std::runtime_error(msg.str());
   }
 
   static void throwInvalidObject( size_t idx, size_t n_objs) {
      std::stringstream msg;
      msg << "Invalid object reference. Index " << idx << " not in allowed range [0.." << n_objs << "). Bail out.";
      throw std::logic_error(msg.str());
   }
 
   static void throwObjectAlreadyDeleted(size_t idx) {
      std::stringstream msg;
      msg << "Object " << idx << " already deleted. Bail out.";
      throw std::logic_error(msg.str());
   }
 
   static void throwObjectExistsAlready(const void *ptr) {
      std::stringstream msg;
      msg << "Object " << ptr << " already registered. Bail out.";
      throw std::logic_error(msg.str());
   }
 
   static void throwObjectStillAlive(const void *ptr, size_t cnt) {
      std::stringstream msg;
      msg << "Managed object " << ptr << " still has " << cnt << " references, but the container is now being destructed.";
      throw std::logic_error(msg.str());
   }
 
   static void warnShareDropAfterRelease(size_t idx) {
      (void) idx;
   }
};
 
template <class T_Obj>
class ObjContainer : public ObjContainerBase
{
   template <class T_Obj_>
   friend class ObjPtr;
public:
   ObjContainer(unsigned int min_size=0) { m_objs.reserve(min_size); }
 
   ~ObjContainer() noexcept(false) {
      for (std::pair<T_Obj *, short> &elm : m_objs) {
         if (elm.second>0) {
            this->throwObjectStillAlive(elm.first,static_cast<size_t>(elm.second));
         }
         if (elm.first && elm.second>0) {
            this->throwObjectStillAlive(elm.first,static_cast<size_t>(elm.second));
         }
      }
   }
 
   bool isValid( ObjRef ref) const {
      return ref.idx() < m_objs.size() && m_objs[ref.idx()].first; // @TODO the latter test should not be necessary
   }
 
   // debug :
   std::pair<short, bool > search(T_Obj *obj) const {
       ObjRef ref(find(obj));
      return std::make_pair( ref ? m_objs[ref.idx()].second : short{},  ref.isValid() );
   }
 
   unsigned short size() const { return static_cast<unsigned short>(m_objs.size()); }
protected:
    ObjRef registerObj(T_Obj &obj) {
      return registerObj(&obj, s_externalObj);
   }
 
    ObjRef registerObj(T_Obj *obj) {
      return registerObj(obj, 0);
   }
 
    ObjRef share( ObjRef ref) {
      ensureValidity(ref);
      switch(m_objs[ref.idx()].second)  {
      case s_externalObj: { return ref; }
 
      case s_releasedObj: { this->warnShareDropAfterRelease( ref.idx() );
                            
                            return ref; }
 
      case 0:             if (!m_objs[ref.idx()].first) {this->throwObjectAlreadyDeleted( ref.idx());}
                          [[fallthrough]]; // throws exception
 
      default:            { break; }
      }
 
      if (m_objs[ref.idx()].second >= std::numeric_limits<short>::max()) {
         this->throwMaximumNumberOfSharesExceeded(std::numeric_limits<short>::max()); // clone object and add new slot ?
      }
      ++(m_objs[ref.idx()].second);
 
      return ref;
   }
 
   void drop(  ObjRef &ref) {
      ensureValidity(ref);
      switch(m_objs[ref.idx()].second)  {
      case s_externalObj: { return ; }
 
      case s_releasedObj: { this->warnShareDropAfterRelease( ref.idx() );
                            return ; }
 
      case 0:             this->throwObjectAlreadyDeleted( ref.idx());
                          [[fallthrough]]; // throws exception
 
      default:            { break; }
      }
 
      if (--(m_objs[ref.idx()].second) == 0) {
         T_Obj *obj=m_objs[ref.idx()].first;
         delete obj;
         m_objs[ref.idx()].first=nullptr;
         assert(!find(obj)); // Ensure that deleted objects are not referenced anymore
         if (m_freeIdx == std::numeric_limits<unsigned short>::max()) {
            m_freeIdx=ref.idx();
         }
         ref= ObjRef();
      }
   }
 
   const T_Obj *get(  ObjRef ref) const {
      ensureExists(ref);
      return m_objs[ref.idx()].first;
   }
 
    T_Obj *get(  ObjRef ref) {
       ensureExists(ref);
       return m_objs[ref.idx()].first;
    }
 
   T_Obj *release(  ObjRef ref) {
      ensureValidity(ref);
      switch (m_objs[ref.idx() ].second) {
      case 0: this->throwObjectAlreadyDeleted( ref.idx());
              [[fallthrough]]; // will not fall through, because of exception
      case s_releasedObj:
              [[fallthrough]]; // indeed, should also clone the object
      case s_externalObj:   return cloneObj(m_objs[ref.idx()].first);
      default:
         m_objs[ref.idx()].second = s_releasedObj;
        
         return m_objs[ref.idx()].first;
      }
   }
 
   bool isOwned(  ObjRef ref) const {
      return count(ref) == 1;
   }
 
   bool isShared(  ObjRef ref) const {
      return count(ref) > 1;
   }
 
   bool isExtern(  ObjRef ref) const {
      return count(ref) == s_externalObj;
   }
   
   short count( ObjRef ref) const{
     return m_objs[ref.idx() ].second;
   }
 
protected:
    ObjRef find( T_Obj *obj) const {
      for (typename std::vector< std::pair<T_Obj *, short> >::const_reverse_iterator
              iter =m_objs.rbegin();
           iter != m_objs.rend();
           ++iter) {
         if (iter->first == obj) {
            assert( m_objs.at(m_objs.rend()-iter-1).first == obj);
             ObjRef ref( static_cast<unsigned short>(m_objs.rend()-iter-1) ); // @TODO std::distance ?
            ensureValidity(ref);
            return ref;
         }
      }
      return  ObjRef();
   }
 
   void ensureValidity( ObjRef ref) const {
      if (!isValid(ref)) this->throwInvalidObject( ref.idx(), m_objs.size());
   }
 
   void ensureExists( ObjRef ref) const {
      ensureValidity(ref);
      if (m_objs[ref.idx() ].second == 0) { this->throwObjectAlreadyDeleted( ref.idx()); }
   }
 
   void checkCapacity() {
      if (m_objs.size() >= std::numeric_limits<unsigned short>::max()) {
         this->throwMaximumCapacitiyExceeded(m_objs.size());
      }
   }
 
    ObjRef registerObj(T_Obj *obj, short initial_count) {
      if (!obj) return  ObjRef{};
      checkCapacity();
 
       ObjRef ref = find(obj);
      if (isValid(ref))  {
         switch(m_objs.at(ref.idx()).second) {
         case 0: {
            break;
         }
         case s_releasedObj:
            if (initial_count == s_externalObj) {
               break;
            }
            [[fallthrough]];
         default:
            this->throwObjectExistsAlready( obj);
         }
         //         return ref;
      }
      if (m_freeIdx == std::numeric_limits<unsigned short>::max() && m_objs.size() >= m_objs.capacity()) {
         for (typename std::vector< std::pair<T_Obj *, short> >::const_reverse_iterator
                 iter =m_objs.rbegin();
              iter != m_objs.rend();
              ++iter) {
            if (iter->second==0) {
               m_freeIdx=m_objs.rend()-iter-1;
            }
         }
      }
      if (m_freeIdx == std::numeric_limits<unsigned short>::max()) {
         ref=ObjRef(static_cast<unsigned short>(m_objs.size()));
         m_objs.push_back(std::make_pair(obj, initial_count));
      } else {
         m_objs[m_freeIdx] = std::make_pair( obj,initial_count);
         ref=ObjRef(m_freeIdx);
         m_freeIdx = std::numeric_limits<unsigned short>::max();
      }
      ensureValidity(ref);
      return ref;
   }
 
   constexpr static short s_externalObj = -2;       
   constexpr static short s_releasedObj = -1;       
 
   std::vector< std::pair<T_Obj *, short> > m_objs; 
   unsigned short                                           m_freeIdx=std::numeric_limits<unsigned short>::max();
};
 
template <class T_Obj>
class ObjPtr {
public:
   ObjPtr()                 = default;
   ObjPtr(ObjPtr &&obj_ptr) = default;
 
   ObjPtr(const ObjPtr &obj_ptr)
      : m_container(obj_ptr.m_container)
   {
      shareAndSet(obj_ptr.index());
   }
 
   ObjPtr(ObjContainer<T_Obj>& container, const T_Obj& obj)
     : m_container(&container)
     , m_ref(m_container->registerObj(obj))
   {}
 
 
   ObjPtr(ObjContainer<T_Obj>& container, std::unique_ptr<T_Obj> obj)
     : ObjPtr(container, container.registerObj(obj.release()))
   {}
 
   ObjPtr(ObjContainer<T_Obj>& container,  ObjRef ref =  ObjRef())
     : m_container(&container)
     , m_ref(ref ? container.share(ref) : ref)
   {}
 
   ~ObjPtr() noexcept(false){
     if (m_ref) {
       m_container->drop(m_ref);
     }
   }
 
   operator bool() const { return m_container && m_container->isValid(m_ref); }
 
   ObjPtr &operator=(const ObjPtr &obj) {
      if (obj.m_ref != m_ref) {
         if (*this) {
            m_container->drop(m_ref);
         }
         if (obj.m_container) {
            assert( !m_container || m_container == obj.m_container);
            m_container = obj.m_container;
         }
         shareAndSet(obj.index());
      }
      return *this;
   }
 
   ObjPtr &operator=(ObjPtr &&obj) {
      if (&obj != this) {
         if (*this) {
            m_container->drop(m_ref);
         }
         m_ref = std::move(obj.m_ref);
         if (obj.m_container) {
            assert( !m_container || m_container == obj.m_container);
            m_container = obj.m_container;
         }
      }
      return *this;
   }
 
   ObjPtr &operator=( ObjRef ref) {
      if (ref != m_ref) {
         if (*this) {
            m_container->drop(m_ref);
         }
         if (!m_container) {
            ObjContainerBase::throwNoContainer();
         }
         shareAndSet(ref);
      }
      return *this;
   }
 
   bool  operator==(const ObjPtr &obj) const {
      return obj.m_ref == m_ref;
   }
 
   bool  operator!=(const ObjPtr &obj) const {
      return obj.m_ref != m_ref;
   }
 
   T_Obj &operator*() {
      return *m_container->get(m_ref);
   }
 
   T_Obj *operator->() {
      return get();
   }
 
   T_Obj *get() {
      if (!m_ref) return nullptr;
      else        return m_container->get(m_ref);
   }
 
   // @TODO useful ? the container does not really allow for const-access.
 
   const T_Obj *get() const {
      if (!m_ref) return nullptr;
      else        return std::as_const(*m_container).get(m_ref);
   }
 
   T_Obj *release() {
      if (!m_ref) return nullptr;
      else        return m_container->release(m_ref);
   }
   
    std::unique_ptr<T_Obj> to_unique() {
      return std::unique_ptr<T_Obj>(release());
    }
 
    ObjRef index() const { return m_ref; }
 
 protected:
 
   void shareAndSet( ObjRef ref) {
      if (ref) {
         assert(m_container);
         m_ref=m_container->share(ref);
      }
      else {
         m_ref=ref;
      }
   }
 
 public:
   bool isOwned() const {
      return m_container->isOwned(m_ref);
   }
 
   bool isShared() const {
      return m_container->isShared(m_ref);
   }
 
   bool isExtern() const {
      return m_container->isExtern(m_ref);
   }
 
 
private:
   ObjContainer<T_Obj>  *m_container = nullptr; 
    ObjRef                                  m_ref {};              
};
#endif