LCRTRelations.h

Go to the documentation of this file.

#ifndef LCRTRelations_H
#define LCRTRelations_H 1

#include <iostream>
#include <vector>
#include <list>
#include <map>
#ifndef __CINT__
#include <typeindex>
#endif
#include <memory>

#include <Exceptions.h>

namespace lcrtrel_helper{

  //------------------ internal helper typdefs, function and classes ----------

  template <bool B>
  struct can_call_ext{};
  template <>
  struct can_call_ext<true>{ static void check(){/* no_op */ } ; };

  // /** Function pointer for delete function */
  // typedef void (*DeleteFPtr)(void*) ;

  struct SimplePtrInit{ static void* init() { return 0 ; } } ;

  template <class T>
  struct CreationPtrInit{ static void* init() { return new T ; } } ;

  struct NoDelete{ static void clean(void *) { /* no_op */ } } ;

  template <class T>
  struct DeletePtr{ static void clean(void *v) { delete (T*) v ; } } ;

  template <class T>
  struct DeleteElements {
    static void clean(void *v) { 
      T* vec = static_cast<T*>(v) ;
      for( typename T::iterator it = vec->begin();it != vec->end(); ++it){
           delete *it ;
      }
      delete vec  ;    
    } 
  };


  // /** Map of pointers to extension obbjects*/
  // typedef std::map< unsigned , void * > PtrMap ;

  // /** Vector of delete  functions */
  // typedef std::vector< DeleteFPtr > DPtrVec ;

  //typedef std::vector< void * > PtrVec ;


  template <class U, class T , class I, class D, bool b>
  struct LCBaseTraits {
    // traits definitions
    typedef T*  ptr ;  
    typedef U tag ;    // this ensures that a new class instance is created for every user extension
    static const int allowed_to_call_ext = b ;
    
    LCBaseTraits<U, T, I, D, b>(const LCBaseTraits&) = delete ;
    LCBaseTraits<U, T, I, D, b>& operator=(const LCBaseTraits&) = delete ;
    
  public:
    inline LCBaseTraits<U, T, I, D, b>() {
      _pointer = (ptr) I::init();
    }
    
    inline ~LCBaseTraits<U, T, I, D, b>() {
      D::clean( _pointer );
    }
    
    inline ptr& pointer() {
      return _pointer;
    }
    
  protected:
    ptr     _pointer{};
  };


  template <class U, class T , class I=SimplePtrInit, class D=NoDelete , bool b=1>
  struct LCBaseLinkTraits : public LCBaseTraits<U,T,I,D,b>{

    typedef LCBaseTraits<U,T,I,D,b> base ;

    typedef T*& ext_type ;                 // return value of  ext<>()
    typedef T*  rel_type ;                 // return value of  rel<>() 
    typedef typename base::ptr obj_ptr ;   // pointer to object

    static const bool is_container=false ;
  };

  template <class U, class T , class I=CreationPtrInit<T>, class D=DeletePtr<T> , bool b=1>
  struct LCBaseLinkContainerTraits : public LCBaseTraits<U,T,I,D,b>{

    typedef LCBaseTraits<U,T,I,D,b> base ;

    typedef       T*  ext_type ;              // return value of  ext<>()
    typedef const T*  rel_type ;              // return value of  rel<>() 
    typedef typename T::value_type obj_ptr ;  // pointer to object

    typedef typename T::iterator iterator ;
    typedef typename T::const_iterator const_iterator ;

    static const bool is_container=true ;
  };


  template <class U, class T> 
  struct RelationOneSide  : 
    public LCBaseLinkTraits<U,T,SimplePtrInit,NoDelete,false> {};
  
  
  template <class U, class T> 
  struct RelationManySide :
    public LCBaseLinkContainerTraits< U, std::list<T*>,
                      CreationPtrInit< std::list<T*> > , 
                      DeletePtr<std::list<T*> > ,false  > {};
  
  template <class U> struct FromRelation{} ;
  
  template <class U> struct ToRelation{} ;
  
  
  template <class From, class To>
  struct BiDirectional{
    typedef From from  ;
    typedef To   to  ;
  } ;
  
  
  template <bool is_container>
  struct objorcont{

    template <class T, class S>
    inline static void add( T t, S s) { t->push_back( s )  ; }

    template <class T, class S>
    inline static void remove( T t, S s) { t->remove( s )  ; }
  };


  template <>
  struct objorcont<false>{

    template <class T, class S> 
    inline static void add( T& t, S s) { t = s ; }

    template <class T, class S>
    inline static void remove( T& t, S ) { t = 0 ; }
  };

  //-----------end of  internal helper typdefs, function and classes ----------


} // end namespace lcrtrel_helper

namespace lcrtrel{

  using namespace lcrtrel_helper ;

  template <class U, typename T> 
  struct LCExtension : public LCBaseLinkTraits< U, T > {};

  template <class U, typename T> 
  class LCOwnedExtension : public LCBaseLinkTraits< U, T , SimplePtrInit , DeletePtr<T> > {};


  template <class U, class T> 
  class LCExtensionVector :
    public LCBaseLinkContainerTraits< U, std::vector<T*>,
                      CreationPtrInit< std::vector<T*> > , 
                      DeletePtr<std::vector<T*> > > {};


  template <class U, class T> 
  class LCOwnedExtensionVector : 
    public LCBaseLinkContainerTraits< U, std::vector<T*>,
                      CreationPtrInit< std::vector<T*> > , 
                      DeleteElements< std::vector<T*> > > {};


  template <class U, class T> 
  class LCExtensionList :
    public LCBaseLinkContainerTraits< U, std::list<T*>,
                      CreationPtrInit< std::list<T*> > , 
                      DeletePtr<std::list<T*> > > {};

  template <class U, class T> 
  class LCOwnedExtensionList : 
    public LCBaseLinkContainerTraits< U, std::list<T*>,
                      CreationPtrInit< std::list<T*> > , 
                      DeleteElements<  std::list<T*> > > {};


  template <class U, class From, class To>
  struct LC1To1Relation : 
    public BiDirectional<RelationOneSide<FromRelation<U>,From>,
             RelationOneSide<ToRelation<U>,To> > {

  } ; 

  template <class U, class From, class To>
  struct LC1ToNRelation : 
    public BiDirectional<RelationOneSide<FromRelation<U>,From>,
             RelationManySide<ToRelation<U>,To> > {
  } ; 

  template <class U, class From, class To>
  struct LCNToNRelation : 
    public BiDirectional<RelationManySide<FromRelation<U>,From>,
             RelationManySide<ToRelation<U>,To> > {
  } ; 


  template <class U >
  struct LCIntExtension{  
    
    typedef long ptr ;  // base pointer type - use long to work for 64 bit (long is 32 on 32-bit systems/64 on 64bit systems)
    typedef long& ext_type ;                
    typedef U tag ;     // this ensures that a new class instance is created for every user extension
    static const int allowed_to_call_ext = 1 ;
    
    LCIntExtension<U>() = default ;
    
    ~LCIntExtension<U>() = default ;
    
    inline ptr& pointer() {
      return _pointer;
    }
    
  private:
    ptr     _pointer{0};
  };



  template <class U >
  struct LCFloatExtension{// FIXME: need to check on 64 bit architecture...

#ifdef  __i386__
    typedef float  ptr ;  // base pointer type 
    typedef float& ext_type ;     // return value of  ext<>()

#else  // use double on 64bit systems
    typedef double  ptr ;  // base pointer type 
    typedef double& ext_type ;     // return value of  ext<>()
#endif    
    typedef U tag ;     // this ensures that a new class instance is created for every user extension
    static const int allowed_to_call_ext = 1 ;

    LCFloatExtension<U>() = default ;
    
    ~LCFloatExtension<U>() = default ;
    
    inline ptr& pointer() {
      return _pointer;
    }
    
  private:
    ptr     _pointer{0};
  };
  
  
  template <class U >
  struct LCBoolExtension{  
    
    typedef bool ptr ;  // base pointer type
    typedef bool& ext_type ;                
    typedef U tag ;     // this ensures that a new class instance is created for every user extension
    static const int allowed_to_call_ext = 1 ;
    
    LCBoolExtension<U>() = default ;
    
    ~LCBoolExtension<U>() = default ;
    
    inline ptr& pointer() {
      return _pointer;
    }
    
  private:
    ptr     _pointer{false};
  };
  

  //--------------------------------------------------------------------



  class LCRTRelations ;

  // exclude from dictionary (template lookup does not work)
#ifndef __CINT__

  template <class R> 
  void set_relation( typename R::from::obj_ptr f, 
             typename R::to::obj_ptr t) ;

  template <class R> 
  void unset_relation(typename R::from::obj_ptr f );


  template <class R> 
  void add_relation( typename R::from::obj_ptr f, 
             typename R::to::obj_ptr t) ;


  template <class R> 
  void remove_relation( typename R::from::obj_ptr f, 
            typename R::to::obj_ptr t) ;


  template <class R> 
  void remove_relations(typename R::from::obj_ptr f );


  template <class R> 
  void merge_relations( typename R::from::obj_ptr f1, 
            typename R::from::obj_ptr f2) ;



  class LCRTRelations {

    // declare functions for relation handling as friends
    template <class R> 
    friend void set_relation( typename R::from::obj_ptr f, 
                  typename R::to::obj_ptr t);
    template <class R> 
    friend void unset_relation(typename R::from::obj_ptr f );

    template <class R> 
    friend void add_relation( typename R::from::obj_ptr f, 
                  typename R::to::obj_ptr t) ;
    template <class R> 
    friend void remove_relation( typename R::from::obj_ptr f, 
                 typename R::to::obj_ptr t) ;
    template <class R> 
    friend void remove_relations(typename R::from::obj_ptr f );

    template <class R> 
    friend void merge_relations( typename R::from::obj_ptr f1, 
                 typename R::from::obj_ptr f2) ;

  public:
    // traits definitions
    typedef std::type_index                         ext_index ;
    typedef std::shared_ptr<void>                   ext_type ;
    typedef std::map<ext_index, ext_type>     ext_map ;
    
  public:
    template <class V>
    inline typename V::ext_type ext() { 
      can_call_ext<V::allowed_to_call_ext>::check() ;
      return  ptr<V>() ;
    }

    template <class V>
    inline const typename V::ext_type ext() const { 
      can_call_ext<V::allowed_to_call_ext>::check() ;
      return  ptr<V>() ;
    }

    template <class V>
    inline typename V::rel_type rel() {
      return  ptr<V>() ;
    }
    
  private:
    template <class V>
    typename V::ptr & ptr() const {
      // Look in extension map for the specific user type
      auto iter = _extensionMap.find( std::type_index( typeid( V ) ) ) ;
      // The final user extension
      std::shared_ptr<V> userExtension = nullptr ;
      
      if( iter != _extensionMap.end() ) {
        // get the user extension
        userExtension = std::static_pointer_cast<V>( iter->second ) ;
      }
      else {
        userExtension = std::make_shared<V>();
        ext_map::value_type element(
          std::type_index( typeid(V) ) , // the user extension element type info
          userExtension                  // the user extension itself
        );
        iter = _extensionMap.insert( element ).first;
      }
      if( nullptr == userExtension ) {
        throw EVENT::Exception("  Invalid user extension cast !!!  ") ;
      }
      return userExtension->pointer();
    }
    
  private:
    mutable ext_map          _extensionMap {};  
  } ;
  

  //----------------------- relation function definitions -----------------------------------


  template <class R> 
  void unset_relation(typename R::from::obj_ptr f){
  
    if( f != 0 ){
    
      LCRTRelations* t = f->LCRTRelations::template rel<typename R::to>() ;
    
      if( t != 0 ) 
    t->LCRTRelations::ptr<typename R::from>() = 0 ;
    
      f->LCRTRelations::template ptr<typename R::to>() = 0 ;
    }
  }

  template <class R> 
  void set_relation(typename R::from::obj_ptr f, typename R::to::obj_ptr t){
  
    // clear old relations first
    unset_relation<R>( f ) ;
    unset_relation<R>(t->LCRTRelations::template rel<typename R::from>() ) ; 
  
    f->LCRTRelations::template ptr<typename R::to>() =  t ;
    t->LCRTRelations::template ptr<typename R::from>() =  f ;
  }




  template <class R> 
  void add_relation(  typename R::from::obj_ptr f, 
              typename R::to::obj_ptr t){

    f->LCRTRelations::template ptr<typename R::to>()->push_back( t ) ;

    //   std::cout << " ask to assign " << f << " to " << t << std::endl ;
    objorcont<R::from::is_container>::add( t->LCRTRelations::template ptr<typename R::from>() , f ) ; 
  }




  template <class R> 
  void remove_relation( typename R::from::obj_ptr f, 
            typename R::to::obj_ptr t ) {
  
    f->LCRTRelations::template ptr<typename R::to>()->remove( t ) ;

    objorcont<R::from::is_container>::remove( t->LCRTRelations::template ptr<typename R::from>() , f ) ; 
  }


  template <class R> 
  void remove_relations( typename R::from::obj_ptr f ) {
  
    typename R::to::ptr cl = f->LCRTRelations::template ptr<typename R::to>() ;
  
    for( typename R::to::iterator it = cl->begin(); it!=cl->end(); ++it){
    
      objorcont<R::from::is_container>::remove((*it)->LCRTRelations::template ptr<typename R::from>(), f ) ; 

    }
    cl->clear() ;
  }

  template <class R> 
  void merge_relations(typename R::from::obj_ptr f1, 
               typename R::from::obj_ptr f2 ) {
  
    typename R::to::ptr  lt2 = f2->LCRTRelations::template ptr<typename R::to>() ;
  
    for( typename R::to::iterator it = lt2->begin() ;it !=  lt2->end() ; it++ ){
    
      objorcont<R::from::is_container>::remove( (*it)->LCRTRelations::template ptr<typename R::from>(), f2 ) ; 
      objorcont<R::from::is_container>::add( (*it)->LCRTRelations::template ptr<typename R::from>(), f1 ) ; 
    }

    f1->LCRTRelations::template ptr<typename R::to>()->merge( *lt2 ) ;
  }
#endif // __CINT__

} // end namespace

#endif