LCRTRelations.h

#ifndef LCRTRelations_H
#define LCRTRelations_H 1

#include <iostream>
#include <vector>
#include <list>
#include <map>

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

  typedef void (*DeleteFPtr)(void*) ;

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

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

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

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


  typedef std::map< unsigned , void * > PtrMap ;

  typedef std::vector< DeleteFPtr > DPtrVec ;

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


  template <class U, class T , class I, class D, bool b>
  struct LCBaseTraits{
  
    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 ;
  
    static void clean(void *v) {
      D::clean( v ) ;
    }
    static ptr init() {
      return (ptr) I::init() ;
    }
    static DeleteFPtr deletePtr() { return  &clean ; }  ;
  };


  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 ;
    
    static void clean(void *) { }

    static ptr init() { 
      return 0 ; 
    }
    static DeleteFPtr deletePtr() { return  &clean ; }  ;

  };



  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 ;
    static void clean(void *) { }
    static ptr init() { return 0 ; }
    static DeleteFPtr deletePtr() { return  &clean ; }  ;
  };
  

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



  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:
  
    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>() ;
    }
  
  

    //   LCRTRelations() { 
    //     _vec = new PtrVec( 32  ) ; // initialize to prevent from to many resizes
    //   }
    //   ~LCRTRelations() {
    //    for( unsigned i=0 ; i< cleaners().size() ; ++i){
    //      cleaners()[i]( _vec->operator[](i)  ) ;  // call the delete function
    //    }
    //    delete _vec ;
    //   }



    ~LCRTRelations() {
      for( PtrMap::iterator it = _map.begin() ; it != _map.end() ; ++it ){
        cleaners()[ it->first ] ( it->second ) ;  // call the delete function
      }
    }
  
    //   void print(){
    //     std::cout << " ---- LCRTRelations -- : " << std::endl ;
    //     typedef std::map< void * , void*  > MyPtrMap ;
    //     MyPtrMap& map = *(MyPtrMap*) &_map ;
    //     for( MyPtrMap::iterator it = map.begin() ;
    //   it != map.end() ; ++it ){
    //       std::cout << "      ----   key : " << &(it->first) << " value " 
    //          <<  (void*)it->second  << std::endl ;
    //     }
    //   }


  protected:


    template <class V>
    typename V::ptr & ptr() const {
      
      // convert the pointer to the generic PtrMap to a Map that holds V::ptr objects
      typedef std::map< unsigned , typename V::ptr  > MyPtrMap ;
      
      // going through a pointer to char* avoids the strict-aliasing warning of gcc 
      char* char_map = reinterpret_cast<char *> ( &_map ) ;
      MyPtrMap* map = reinterpret_cast<MyPtrMap*>( char_map ) ;
      
      typename MyPtrMap::iterator it = map->find( typeID<V>() ) ;
      
      if( it == map->end() )
        it = map->insert( map->begin(), 
                          std::make_pair(  typeID<V>() , V::init() )) ;
      
      return  it->second  ;
    }

  private:
  
    static DPtrVec& cleaners() {
      static DPtrVec v ;
      return v ;
    }
  
    inline unsigned nextID(DeleteFPtr cp) const {
      static unsigned id(0) ;

      //     std::cout << " ---- nextID " << id+1  << " - delete Ptr  " 
      // <<  cp << std::endl ;
      
      cleaners().push_back( cp ) ;

      return id++ ;
    }
  
    template <class T>
    inline unsigned typeID() const {
      static const unsigned uid  = nextID( T::deletePtr() ) ;

      return uid ;
    } 
  
  
    //   PtrVec* _vec ; 
    mutable PtrMap _map ;
  
  } ;
  

  //----------------------- 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