NestedContainer.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 

 
// $Id: NestedContainer.h,v 1.6 2009-02-11 13:46:55 dwhittin Exp $
 
 
#ifndef TRTConditionsData_NestedContainer_h
#define TRTConditionsData_NestedContainer_h
 
#include <vector>
#include <map>
#include <functional>
#include <algorithm>
#include "TRT_ConditionsData/ExpandedIdentifier.h"
#include "AthenaKernel/getMessageSvc.h"
#include "GaudiKernel/MsgStream.h"
 
 
namespace TRTCond
{
  
  template <class Daughter, class T, class Trait>
  struct NestedContainerDaughterAccessor
  {
    static const T& get(const Daughter& d, const ExpandedIdentifier& id) { return d.get(id) ; }
    static const T& get(const Daughter& d, const ExpandedIdentifier& id , size_t& resolvelevel) { return d.get(id,resolvelevel) ; }
    static const T& get(const Daughter& d) { return d.get() ; }
    static void set(Daughter& d, const ExpandedIdentifier& id, const T& t) { d.set(id,t) ; }
    static bool empty(Daughter& d) { return d.daughters().empty() ; }
    static void clear(Daughter& d, const ExpandedIdentifier& id) { d.clear(id) ; } ;
    static void clear(Daughter& d) { d.clear() ; } ;
    static void print(const Daughter& d) { d.print() ; }
    static void getall(const Daughter& d, std::vector< std::pair<ExpandedIdentifier, const T*> >& entries) { 
      d.getall(entries) ; }

    static Daughter initialvalue() { return Daughter() ; }
    static void copy(Daughter& out, const Daughter& in) { out = in ; }
    static size_t footprint(const Daughter& d) { return d.footprint() ; }
    static void crunch(Daughter& d) { return d.crunch() ; }
    static bool isequal(const Daughter& lhs, const Daughter& rhs) { return lhs==rhs ; }
    static size_t numObjects(const Daughter& d) { return d.numObjects() ; }
  } ;
  
  template <class T, class Trait>
  struct NestedContainerDaughterAccessor<T,T,Trait>
  {
    static const T& get(const T& d, const ExpandedIdentifier&) { return d ; }
    static const T& get(const T& d, const ExpandedIdentifier& , size_t& ) { return d ; }
    static const T& get(const T& d) { return d ; }
    static void set(T& d, const ExpandedIdentifier&, const T& t) { Trait::copy(d,t) ; }
    static bool empty(T&) { return true ; }
    static void clear(T& d, const ExpandedIdentifier&) { Trait::erase(d) ; }
    static void clear(T& d) { Trait::erase(d) ; }
    static void print(const T& d) { Trait::print(d) ; }
    static void getall(const T& d, std::vector< std::pair<ExpandedIdentifier, const T*> >& entries) { 
      if(Trait::isvalid(d) ) {
    ExpandedIdentifier id(0,0,0,0,0,ExpandedIdentifier::STRAW) ;
    entries.push_back(std::pair<ExpandedIdentifier, const T*>(id,&d)) ; 
      }
    }
    static T initialvalue() { return Trait::initialvalue() ; }
    static void copy(T& out, const T& in) { Trait::copy(out,in) ; }
    static size_t footprint(const T& d) { return Trait::footprint(d) ; }
    static void crunch(T&) {}
    static bool isequal(const T& lhs, const T& rhs) { return Trait::isequal(lhs,rhs) ; }
    static size_t numObjects(const T& d) { return Trait::isvalid(d) ? 1 : 0 ; }
  } ;
  
 

  template <int NestingLevel, class Daughter, class T, class Trait>
  class NestedContainerBase
  {
  private:
 
    typedef std::vector<Daughter> DaughterContainer ;   
    //typedef std::vector<Daughter>::const_iterator ConstIterator ;
    DaughterContainer m_daughters ; 
    T m_default ; 
    
  public:
    typedef T value_type ;  
    typedef const T const_value_type ;  
    typedef Trait trait_type ;  

    NestedContainerBase()  : m_daughters(0), m_default(Trait::initialvalue()) {}
    //    NestedContainerBase(const NestedContainerBase& rhs) 
    //       : m_daughters(0), m_default(Trait::initialvalue()) { *this = rhs ; }

    ~NestedContainerBase() = default;
    //{ 
      //cannot delete the daughter here, because of copy constructors
      //std::cout << "in ~NestedContainerBase(): " << std::flush ;
      //Trait::print(m_default) ;
      //Trait::erase(m_default) ; 
      //std::cout << "done." << std::endl ;
    //}
 
    //     NestedContainerBase& operator=(const NestedContainerBase& rhs) {
    //       std::cout << "operator=" << m_daughters.size() << " " << rhs.m_daughters.size() << std::endl ;
    //       clear() ;
    //       Trait::copy(m_default,rhs.m_default) ;
    //       m_daughters.resize(rhs.m_daughters.size(),NestedContainerDaughterAccessor<Daughter,T,Trait>::initialvalue()) ;
    //       for(unsigned int i=0; i<m_daughters.size(); ++i) 
    //  NestedContainerDaughterAccessor<Daughter,T,Trait>::copy( m_daughters[i], rhs.m_daughters[i] ) ;
    //       std::cout << "done with operator=" << std::endl ;
    //       return *this ;
    //     }
    
    void set( const ExpandedIdentifier& id, const T& t) {
      if( NestingLevel == id.level() ) {
    // set the default value
    Trait::copy(m_default,t) ;
      } else {
    unsigned int thisindex = id.index(NestingLevel+1) ;
    // expand daughter array if necessary
    if(thisindex>=m_daughters.size()) 
      m_daughters.resize( thisindex+1, NestedContainerDaughterAccessor<Daughter,T,Trait>::initialvalue() ) ; 
    NestedContainerDaughterAccessor<Daughter,T,Trait>::set(m_daughters[thisindex], id, t ) ;
      }
    }
    
    const T& get( const ExpandedIdentifier& id ) const {
      if( NestingLevel < id.level() ) {
    unsigned int thisindex = id.index(NestingLevel+1) ;
    if(thisindex<m_daughters.size()) {
      const T& rc = NestedContainerDaughterAccessor<Daughter,T,Trait>::get(m_daughters[thisindex],id) ;
      // only return this value if it is valid. otherwise, return the default.
      if( Trait::isvalid(rc) ) return rc ;
    }
      }
      return m_default ;
    }
 
   const T& get( const ExpandedIdentifier& id, size_t& resolvelevel) const 
   {
     if( NestingLevel < id.level() ) {
       unsigned int thisindex = id.index(NestingLevel+1) ;
       if(thisindex<m_daughters.size()) {
          const T& rc = NestedContainerDaughterAccessor<Daughter,T,Trait>::get(m_daughters[thisindex],id,resolvelevel) ;
           if( Trait::isvalid(rc) ) return rc ;   
         }
      }
      resolvelevel = NestingLevel ; 
      return m_default ;
    }
 

    const T& get() const { return m_default ; }

    void set(const T& t) { Trait::copy(m_default,t) ; }

    void clear() {
      for( typename DaughterContainer::iterator it = m_daughters.begin() ; it != m_daughters.end(); ++it ) 
    NestedContainerDaughterAccessor<Daughter,T,Trait>::clear(*it) ;
      m_daughters.clear() ;
      Trait::erase(m_default) ;
    }

    void clear( const ExpandedIdentifier& id )  {
      if( NestingLevel == id.level() ) clear() ;
      else {
    unsigned int thisindex = id.index(NestingLevel+1) ;
    if(thisindex<m_daughters.size()) 
      NestedContainerDaughterAccessor<Daughter,T,Trait>::clear(m_daughters[thisindex],id ) ;
      }
    }

    const DaughterContainer& daughters() const { return m_daughters ; }
 

    size_t numObjects() const { 
      size_t rc(0) ;
      assert( std::distance(m_daughters.begin(),m_daughters.end())==(int)m_daughters.size()) ;
      assert( m_daughters.size() < 1000 ) ;
      for( typename DaughterContainer::const_iterator it = m_daughters.begin() ; it != m_daughters.end(); ++it ) 
    rc += NestedContainerDaughterAccessor<Daughter,T,Trait>::numObjects(*it) ;
      if( Trait::isvalid(m_default) ) ++rc ;
      return rc ;
    }
 
    
    bool operator==(const NestedContainerBase& rhs) const {
      return m_daughters.size()==0 && rhs.m_daughters.size()==0 && Trait::isequal(m_default,rhs.m_default) ;
    }
    
    bool operator==(const T& rhs) const {
      return m_daughters.size()==0 && Trait::isequal(m_default,rhs) ;
    }
    
    size_t footprint() const {
      size_t total = Trait::footprint(m_default) + (m_daughters.capacity()-m_daughters.size())*sizeof(Daughter) ;
      for( typename DaughterContainer::const_iterator it = m_daughters.begin() ; it != m_daughters.end(); ++it ) 
    total += NestedContainerDaughterAccessor<Daughter,T,Trait>::footprint(*it) ;
      return total ;
    }
    
    void crunch() {
      // first the daughters 
      for( typename DaughterContainer::iterator it = m_daughters.begin() ; it != m_daughters.end(); ++it ) 
    NestedContainerDaughterAccessor<Daughter,T,Trait>::crunch(*it) ;
      // now use, if anything is there
      if( m_daughters.size()>0 ) {
    // find the first daughter that is valid
    size_t firstvaliddaughter(0);
    bool allequal(true) ;
    for(size_t idau=0; idau<m_daughters.size() && allequal; ++idau) {
      allequal = NestedContainerDaughterAccessor<Daughter,T,Trait>::empty(m_daughters[idau]) ;
      if( allequal ) {
        bool isvalid = Trait::isvalid( NestedContainerDaughterAccessor<Daughter,T,Trait>::get(m_daughters[idau])) ;
        if( isvalid ) {
          if( firstvaliddaughter==0 ) firstvaliddaughter = idau ;
        } else {
          allequal = NestedContainerDaughterAccessor<Daughter,T,Trait>::isequal(m_daughters[idau],m_daughters[firstvaliddaughter]) ;
        }
      }
    }
    if(allequal) {
      // set the default value to the value form the first daughter
      T defaultvalue(Trait::initialvalue()) ;
      if( firstvaliddaughter < m_daughters.size() ) 
        Trait::copy(defaultvalue,NestedContainerDaughterAccessor<Daughter,T,Trait>::get(m_daughters[firstvaliddaughter])) ;
      clear() ; // this clears pointers in the daughters. would rather replace that with destructors.
      m_daughters = DaughterContainer(0) ;
      m_default = defaultvalue ;
    } else if(m_daughters.size()<m_daughters.capacity())  {
      DaughterContainer newdaughters(0) ;
      newdaughters.reserve( m_daughters.size() ) ;
      newdaughters.insert( newdaughters.end(), m_daughters.begin(), m_daughters.end() ) ;
      newdaughters.swap(m_daughters) ;
    }
      }
    }
    
    void printindent() const {
      for(int i=0; i<NestingLevel; ++i) 
    std::cout << '\t' ;
    }
    void print() const {
      printindent() ;
      ExpandedIdentifier id;
      std::cout << "level = " << id.name(NestingLevel) << " (" << NestingLevel << ")"  << std::endl ;
      for(unsigned int i=0; i< m_daughters.size(); ++i) {
    printindent() ;
    std::cout << "daughter " << i << std::endl ;
    NestedContainerDaughterAccessor<Daughter,T,Trait>::print(m_daughters[i]) ;
      }
    }

    typedef std::vector< std::pair<ExpandedIdentifier, const T*> > FlatContainer ;
    void getall( FlatContainer& entries ) const {
      // add the daughters
      for(unsigned int idau = 0; idau<m_daughters.size(); ++idau) {
    FlatContainer dauentries ;
    // first get them
    NestedContainerDaughterAccessor<Daughter,T,Trait>::getall(m_daughters[idau], dauentries) ;
    // now update the identifiers to have the dauhgter index  set correctly
    for(unsigned int j=0; j< dauentries.size(); ++j ) 
      dauentries[j].first.index(NestingLevel+1) = idau ;
    // and append
    entries.insert(entries.end(),dauentries.begin(),dauentries.end()) ;
      }
      // add the default value
      if( Trait::isvalid(m_default) ) {
    ExpandedIdentifier id(0,0,0,0,0,NestingLevel) ;
    entries.push_back( std::pair<ExpandedIdentifier, const T*>(id,&m_default)) ; 
      }
    }
  } ;
 

  template <int NestingLevel, class T, class Trait>
  class NestedContainer 
    : public NestedContainerBase<NestingLevel, NestedContainer<NestingLevel+1,T,Trait>, T, Trait>
  {
  } ;
  

  template <class T, class Trait>
  class NestedContainer<ExpandedIdentifier::STRAWLAYER,T,Trait>
    : public NestedContainerBase<ExpandedIdentifier::STRAWLAYER,T,T,Trait>
  {
  } ;
 

  template <class T>
  class NestedContainerPointerTrait
  {
  public:
    using pointer = T;
    using base_type = std::remove_pointer_t<pointer>;
    using const_pointer = const base_type*;
    static void erase( pointer& x) { delete x ; x = 0 ; }
    static void copy( pointer& out, const_pointer in) { if(out) erase(out) ; if(in) out = in->clone() ; }
    static bool isvalid( const_pointer x ) { return x!=0 ; }
    static void initialize( pointer& x) { x = 0 ; }
    static size_t footprint( const_pointer x) { return sizeof(pointer) + (x ? x->footprint() : 0) ; }
    static void print(const_pointer x) { std::cout << x << std::endl ; }
    static pointer initialvalue() { return 0 ; }
    static bool isequal(const_pointer lhs, const_pointer rhs) { return lhs==rhs || (lhs && rhs && *lhs==*rhs) ; }
  } ;
}
 
 
#endif