d0/d7c/_tuple_obj_8h_source.html

 // ============================================================================
 #ifndef GAUDIALG_TUPLEOBJ_H
 #define GAUDIALG_TUPLEOBJ_H 1
 // ============================================================================
 // Include files
 // ============================================================================
 // STD&STL
 // ============================================================================
 #include <cstddef>
 #include <set>
 #include <string>
 #include <limits>
 #include <array>
 #include <functional>
 #include <numeric>
 #include <sstream>
 // ============================================================================
 // GaudiKernel
 // ============================================================================
 #include "GaudiKernel/NTuple.h"
 #include "GaudiKernel/VectorMap.h"
 #include "GaudiKernel/SerializeSTL.h"
 #include "GaudiKernel/invoke.h"
 // ============================================================================
 // GaudiAlg
 // ============================================================================
 #include "GaudiAlg/Tuples.h"
 #include "GaudiAlg/Maps.h"
 // ============================================================================
 // ROOT
 // ============================================================================
 #include "Math/Point3D.h"
 #include "Math/Vector3D.h"
 #include "Math/Vector4D.h"
 #include "Math/SVector.h"
 #include "Math/SMatrix.h"
 // ============================================================================
 // forward declaration
 // ============================================================================
 // GaudiKernel
 // ============================================================================
 class IOpaqueAddress   ;
 // ============================================================================
 // ============================================================================
 namespace Tuples
 {
     namespace detail {
       template <typename T> struct to_ {
           template <typename Arg>
           T operator()(Arg&& i) const
           { return T(std::forward<Arg>(i)); }
       };
       constexpr struct to_<float> to_float {};

       template <typename Iterator>
       using const_ref_t = typename std::add_const<typename std::iterator_traits<Iterator>::reference>::type;

     }
   // ==========================================================================
   enum Type
     {
       NTUPLE  , // Analysis nTuple
       EVTCOL    // Event Collection
     };
   // ==========================================================================
   enum ErrorCodes
     {
       InvalidTuple      = 100 ,
       InvalidColumn           ,
       InvalidOperation        ,
       InvalidObject           ,
       InvalidItem             ,
       TruncateValue     = 200
     };
   // ==========================================================================
   class GAUDI_API TupleObj
   {
   public:
     // ========================================================================
     typedef NTuple::Item<bool>                  Bool      ;
     // ========================================================================
     typedef NTuple::Item<char>                  Char      ;
     // ========================================================================
     typedef NTuple::Item<unsigned char>         UChar     ;
     // ========================================================================
     typedef NTuple::Item<short>                 Short     ;
     // ========================================================================
     typedef NTuple::Item<unsigned short>        UShort    ;
     // ========================================================================
     typedef NTuple::Item<int>                   Int       ;
     // ========================================================================
     typedef NTuple::Item<unsigned int>          UInt      ;
     // ========================================================================
     typedef NTuple::Item<long long>             LongLong  ;
     // ========================================================================
     typedef NTuple::Item<unsigned long long>    ULongLong ;
     // ========================================================================
     typedef NTuple::Item<float>                 Float     ;
     // ========================================================================
     typedef NTuple::Item<double>                Double    ;
     // ========================================================================
     typedef NTuple::Item<IOpaqueAddress*>       Address   ;
     // ========================================================================
     typedef NTuple::Array<float>                FArray    ;
     // ========================================================================
     typedef NTuple::Matrix<float>               FMatrix   ;
     // ========================================================================
     // the actual type for variable size matrix indices
     typedef unsigned short                      MIndex    ;
     // ========================================================================
     // the map of all items
     typedef std::map<std::string,std::string>   ItemMap   ;
     // ========================================================================
   protected:
     // ========================================================================
     TupleObj ( std::string           name                          ,
                NTuple::Tuple*        tuple                         ,
                const CLID&           clid = CLID_ColumnWiseTuple   ,
                const Tuples::Type    type = Tuples::NTUPLE         ) ;
     // ========================================================================
   protected:
     // ========================================================================
     virtual ~TupleObj();
     // ========================================================================
   public:
     // ========================================================================
     StatusCode column ( const std::string& name   , float  value  );
     // ========================================================================
   public:
     // ========================================================================
     StatusCode column ( const std::string& name   , double  value  );
     // ========================================================================
   public:
     // ========================================================================
     StatusCode column ( const std::string&   name  , short value );
     // ========================================================================
     StatusCode column ( const std::string&  name  ,
                         short         value ,
                         short         minv  ,
                         short         maxv  );
     // ========================================================================
   public:
     // ========================================================================
     StatusCode column ( const std::string& name  , unsigned short     value );
     // ========================================================================
     StatusCode column ( const std::string& name  ,
                         unsigned short     value ,
                         unsigned short     minv  ,
                         unsigned short     maxv  );
     // ========================================================================
   public:
     // ========================================================================
     StatusCode column ( const std::string& name  , char               value );
     // ========================================================================
     StatusCode column ( const std::string& name  ,
                         char               value ,
                         char               minv  ,
                         char               maxv  );
     // ========================================================================
   public:
     // ========================================================================
     StatusCode column ( const std::string& name  , unsigned char      value );
     // ========================================================================
     StatusCode column ( const std::string& name  ,
                         unsigned char      value ,
                         unsigned char      minv  ,
                         unsigned char      maxv  );
     // ========================================================================
   public:
     // ========================================================================
     StatusCode column ( const std::string& name  , int                value );
     // ========================================================================
     StatusCode column ( const std::string& name  ,
                         int                value ,
                         int                minv  ,
                         int                maxv  );
     // ========================================================================
   public:
     // ========================================================================
     StatusCode column ( const std::string& name  , unsigned int       value );
     // ========================================================================
     StatusCode column ( const std::string& name  ,
                         unsigned int       value ,
                         unsigned int       minv  ,
                         unsigned int       maxv  );
     // ========================================================================
   public:
     // ========================================================================
     StatusCode column ( const std::string& name  , long               value );
     // ========================================================================
     StatusCode column ( const std::string& name  ,
                         long               value ,
                         long               minv  ,
                         long               maxv  );
     // ========================================================================
   public:
     // ========================================================================
     StatusCode column ( const std::string& name  , unsigned long      value );
     // ========================================================================
     StatusCode column ( const std::string& name  ,
                         unsigned long      value ,
                         unsigned long      minv  ,
                         unsigned long      maxv  );
     // ========================================================================
   public:
     // ========================================================================
     StatusCode column ( const std::string& name  , long long          value );
     // ========================================================================
     StatusCode column ( const std::string& name  ,
                         long long          value ,
                         long long          minv  ,
                         long long          maxv  );
     // ========================================================================
   public:
     // ========================================================================
     StatusCode column ( const std::string& name  , unsigned long long value );
     // ========================================================================
     StatusCode column ( const std::string& name  ,
                         unsigned long long value ,
                         unsigned long long minv  ,
                         unsigned long long maxv  );
     // ========================================================================
   public:
     // ========================================================================
     StatusCode column ( const std::string& name, signed char value )
     {
       return column ( name  , value ,
                       std::numeric_limits<signed char>::min() ,
                       std::numeric_limits<signed char>::max() ) ;
     }
     // ========================================================================
   public:
     // ========================================================================
     StatusCode column ( const std::string& name  ,
                         bool               value );
     // ========================================================================
   public:
     // ========================================================================
     StatusCode column ( const std::string& name    ,
                         IOpaqueAddress*    address ) ;
     // ========================================================================
     StatusCode column ( IOpaqueAddress* address ) ;
     // ========================================================================
   public:
     // ========================================================================
 private:
     template <typename Tuple, typename Value, std::size_t... I>
     StatusCode columns_helper( const Value& value, const Tuple& tup, std::index_sequence<I...>) {
         auto scs = std::initializer_list<StatusCode>{
             this->column(std::get<I>(tup).first, Gaudi::invoke(std::get<I>(tup).second,value))...
         };
         auto is_ok = [](const StatusCode& sc) -> bool { return sc; };
         auto i = std::find_if_not(begin(scs), end(scs), is_ok );
         if (i!=end(scs)) {
             // avoid unchecked StatusCodes...
             std::for_each(std::next(i),end(scs),is_ok);
             return *i;
         }
         return StatusCode::SUCCESS;
     }

 public:
     template <typename Value, typename... Args>
     StatusCode columns(Value&& value, Args&&... args ) {
         return columns_helper(std::forward<Value>(value),
                               std::forward_as_tuple(std::forward<Args>(args)...),
                               std::index_sequence_for<Args...>{});
     }
     // ========================================================================
   public:
     // ========================================================================
     StatusCode fill( const char* format ... ) ;
     // =======================================================================
   public:
     // =======================================================================
     template <typename ITERATOR1,typename ITERATOR2>
     StatusCode farray ( const std::string& name          ,
                         ITERATOR1&&        first         ,
                         ITERATOR2&&        last          ,
                         const std::string& length        ,
                         size_t             maxv          )
     {
       return farray( name, detail::to_float,
                      std::forward<ITERATOR1>(first), std::forward<ITERATOR2>(last),
                      length, maxv );
     }
     // =======================================================================
     template <class DATA>
     StatusCode farray ( const std::string& name          ,
                         const DATA&        data          ,
                         const std::string& length        ,
                         const size_t       maxv          )
     { return farray ( name , std::begin(data) , std::end(data) , length , maxv  ) ; }
     // =======================================================================
     template <class FUNCTION, class ITERATOR>
     StatusCode farray ( const std::string& name          ,
                         const FUNCTION&    function      ,
                         ITERATOR           first         ,
                         ITERATOR           last          ,
                         const std::string& length        ,
                         size_t             maxv          )
     {
       if ( invalid () ) { return InvalidTuple     ; }
       if ( rowWise () ) { return InvalidOperation ; }

       // adjust the length
       if( std::distance(first,last) > static_cast<std::ptrdiff_t>(maxv) ) {
         Warning("farray('"
                 + name  + "'): array is overflow, skip extra entries") ;
         last = std::next(first,maxv);
       }

       // get the length item
       Int* len  = ints( length , 0 , maxv ) ;
       if( !len  ) { return InvalidColumn ; }

       // adjust the length
       *len = std::distance(first,last);

       // get the array itself
       FArray*  var  = fArray ( name , len ) ;
       if( !var ) { return InvalidColumn ; }

       // fill the array
       std::transform( first, last, std::begin(*var), std::cref(function) );

       return StatusCode::SUCCESS ;
     }
     // =======================================================================
     template <typename Iterator, template <typename,typename...> class Container = std::initializer_list,
               typename Fun  = std::function<float(detail::const_ref_t<Iterator>)>,
               typename Item = std::pair<std::string,Fun>,
               typename = std::enable_if_t<!std::is_same<std::string,Container<Item>>::value >>
     StatusCode farray ( const Container<Item>&    items ,
                         Iterator                  first ,
                         Iterator                  last  ,
                         const std::string&        length,
                         size_t                    maxv  )
     {
       if ( invalid () ) { return InvalidTuple     ; }
       if ( rowWise () ) { return InvalidOperation ; }

       // adjust the lenfth
       if( std::distance(first,last) > static_cast<std::ptrdiff_t>(maxv) ) {
         using GaudiUtils::details::ostream_joiner;
         std::ostringstream os;
         ostream_joiner( os, items, ",",
                         [](std::ostream& os, const auto& i) -> std::ostream&
                         { return os << i.first; } );
         Warning( "farray('" + os.str()
                + "'): array overflow, skipping extra entries").ignore() ;
         last = std::next(first, maxv) ;
       }

       // get the length item
       Int* len  = ints ( length , 0 , maxv ) ;
       if ( !len  ) { return InvalidColumn ; }

       // adjust the length
       *len = std::distance(first,last);

       // get the arrays themselves
       std::vector<FArray*> vars; vars.reserve(items.size());
       std::transform( items.begin(), items.end(), std::back_inserter(vars),
                       [&](const auto& item) { return this->fArray(item.first,len); } );
       if ( std::any_of( vars.begin(), vars.end(), [](const FArray* f) { return !f; } ) ) {
         return InvalidColumn ;
       }

       // fill the array
       for(size_t index = 0; first != last; ++first,++index ) {
         auto item = items.begin();
         for( auto& var : vars ) {
           (*var)[index] = (item++)->second(*first);
         }
       }

       return StatusCode::SUCCESS ;
     }
     // =======================================================================
     template <class FUNC1, class FUNC2, class Iterator>
     StatusCode farray ( const std::string&   name1         ,
                         const FUNC1&         func1         ,
                         const std::string&   name2         ,
                         const FUNC2&         func2         ,
                         Iterator&&           first         ,
                         Iterator&&           last          ,
                         const std::string&   length        ,
                         size_t               maxv          )
     {
         return farray( { { name1, std::cref(func1) },
                          { name2, std::cref(func2) } },
                        std::forward<Iterator>(first), std::forward<Iterator>(last),
                        length, maxv );
     }
     // =======================================================================
     template <class FUNC1, class FUNC2, class FUNC3, class Iterator>
     StatusCode farray ( const std::string& name1         ,
                         const FUNC1&       func1         ,
                         const std::string& name2         ,
                         const FUNC2&       func2         ,
                         const std::string& name3         ,
                         const FUNC3&       func3         ,
                         Iterator&&         first         ,
                         Iterator&&         last          ,
                         const std::string& length        ,
                         size_t             maxv          )
     {
         return farray( {{name1,std::cref(func1)},
                         {name2,std::cref(func2)},
                         {name3,std::cref(func3)}},
                         std::forward<Iterator>(first), std::forward<Iterator>(last),
                         length, maxv );
     }
     // =======================================================================
     template <class FUNC1, class FUNC2, class FUNC3, class FUNC4, class Iterator>
     StatusCode farray ( const std::string& name1         ,
                         const FUNC1&       func1         ,
                         const std::string& name2         ,
                         const FUNC2&       func2         ,
                         const std::string& name3         ,
                         const FUNC3&       func3         ,
                         const std::string& name4         ,
                         const FUNC4&       func4         ,
                         Iterator&&         first         ,
                         Iterator&&         last          ,
                         const std::string& length        ,
                         size_t             maxv          )
     {
         return farray( {{name1,std::cref(func1)},
                         {name2,std::cref(func2)},
                         {name3,std::cref(func3)},
                         {name4,std::cref(func4)}},
                         std::forward<Iterator>(first), std::forward<Iterator>(last),
                         length, maxv );
     }
     // =======================================================================
   public:
     // =======================================================================
     template <class MATRIX>
     StatusCode fmatrix ( const std::string& name    ,
                          const MATRIX&      data    ,
                          size_t             rows    ,
                          const MIndex&      cols    ,
                          const std::string& length  ,
                          size_t             maxv    )
     {
       if ( invalid () ) { return InvalidTuple     ; }
       if ( rowWise () ) { return InvalidOperation ; }

       // adjust the length
       if ( rows >= maxv )
       {
         Warning ( "fmatrix('"+name+"'): matrix is overflow, skip extra items").ignore() ;
         rows = ( 0 < maxv ) ? ( maxv - 1 ) : 0 ;
       }

       // get the length item
       Int* len  = ints( length , 0 , maxv ) ;
       if ( !len  ) { return InvalidColumn; }

       // adjust the length item
       *len = rows ;

       // get the array itself
       FMatrix* var  = fMatrix ( name , len  , cols ) ;
       if ( !var ) { return InvalidColumn ; }

       for ( size_t iCol = 0 ; iCol < cols ; ++iCol )
       {
         for ( MIndex iRow = 0 ; iRow < rows ; ++iRow )
         { (*var)[ iRow ] [ iCol ] = data[ iRow ][ iCol ] ; }
       }

       return StatusCode::SUCCESS ;
     }
     // =======================================================================
     template <class DATA>
     StatusCode fmatrix ( const std::string& name   ,
                          DATA               first  ,
                          DATA               last   ,
                          const MIndex&      cols   ,
                          const std::string& length ,
                          size_t             maxv   )
     {
       if ( invalid () ) { return InvalidTuple     ; }
       if ( rowWise () ) { return InvalidOperation ; }

       // adjust the length
       if ( first + maxv < last )
       {
         Warning("fmatrix('"+name+"'): matrix is overflow, skip extra items").ignore() ;
         last = first + maxv ;
       }

       // get the length item
       Int* len  = ints( length , 0 , maxv ) ;
       if ( !len  ) { return InvalidColumn; }

       // adjust the length item
       *len = last - first ;

       // get the array itself
       FMatrix* var  = fMatrix ( name , len , cols ) ;
       if ( !var ) { return InvalidColumn ; }

       size_t iRow = 0 ;
       for ( ; first != last ; ++first )
       {
         //
         for ( MIndex iCol = 0 ; iCol < cols ; ++iCol )
         { (*var)[ iRow ] [ iCol ] = (float)((*first)[ iCol ]) ; }
         //
         ++iRow ;
       }

       return StatusCode::SUCCESS ;
     }
     // =======================================================================
     template <class FUN,class DATA>
     StatusCode fmatrix ( const std::string& name   ,
                          FUN                funF   ,
                          FUN                funL   ,
                          DATA               first  ,
                          DATA               last   ,
                          const std::string& length ,
                          size_t             maxv   )
     {
       if ( invalid () ) { return InvalidTuple     ; }
       if ( rowWise () ) { return InvalidOperation ; }

       // adjust the length
       if ( std::distance(first,last) > static_cast<std::ptrdiff_t>(maxv) )
       {
         Warning("fmatrix('"+name+"'): matrix is overflow, skip extra items").ignore() ;
         last = std::next(first, maxv) ;
       }

       // get the length item
       Int* len  = ints( length , 0 , maxv ) ;
       if ( !len  ) { return InvalidColumn; }

       // adjust the length item
       *len = std::distance(first,last);

       // get the array itself
       auto cols = std::distance(funF,funL);
       FMatrix* var  = fMatrix ( name , len , cols ) ;
       if ( !var ) { return InvalidColumn ; }

       size_t iRow = 0 ;
       for ( ; first != last ; ++first )
       {
         //
         for ( FUN fun = funF ; fun < funL ; ++fun )
         { (*var)[ iRow ] [ fun - funF ] = (*fun) ( *first ) ; }
         //
         ++iRow;
       }

       return StatusCode::SUCCESS ;
     }
     // =======================================================================
   public:
     // =======================================================================
     template <class DATA>
     StatusCode array ( const std::string& name          ,
                        DATA               first         ,
                        DATA               last          )

     {
       if ( invalid () ) { return InvalidTuple     ; }
       if ( rowWise () ) { return InvalidOperation ; }

       // get the length (fixed!)
       auto length = std::distance(first,last);

       // get the array itself
       FArray* var  = fArray ( name , length ) ;
       if ( !var ) { return InvalidColumn ; }

       std::copy( first, last, std::begin(*var) );

       return StatusCode::SUCCESS ;
     }
     // =======================================================================
     template <class ARRAY>
     StatusCode array ( const std::string& name   ,
                        const ARRAY&       data   ,
                        const MIndex&      length )
     {
       using std::begin; // allow data to be eg. CLHEP::HepVector (which does not define HepVector::begin()!,
                         // in which case ADL prefers CLHEP::begin (yah! at least they (now) use a namespace)
                         // so one just to insure  double* CLHEP::begin(CLHEP::HepVector& v) { return &v[0]; }
                         // is visible when this function gets instantiated for CLHEP::HepVector...
       auto first = begin(data);
       return array( name, first, std::next( first, length ) );
     }
     // =======================================================================
     template <class ARRAY>
     StatusCode array ( const std::string& name  ,
                        const ARRAY&       data  )
     {
         using std::begin; using std::end;
         return array ( name , begin(data) , end(data) ) ;
     }
     // =======================================================================
   public:
     // =======================================================================
     template <class MATRIX>
     StatusCode matrix ( const std::string& name  ,
                         const MATRIX&      data  ,
                         const MIndex&      rows  ,
                         const MIndex&      cols  )
     {
       if ( invalid () ) { return InvalidTuple     ; }
       if ( rowWise () ) { return InvalidOperation ; }

       // get the matrix itself
       FMatrix* var  = fMatrix ( name , rows , cols ) ;
       if ( !var ) { return InvalidColumn ; }

       for ( size_t iCol = 0 ; iCol < cols ; ++iCol )
       {
         for ( size_t iRow = 0 ; iRow < rows ; ++iRow )
         { (*var)[iRow][iCol] = data[iRow][iCol]; }
       };
       return StatusCode::SUCCESS ;
     }
     // =======================================================================
   public:
     // =======================================================================
     template <class TYPE>
     StatusCode column ( const std::string& name , const ROOT::Math::LorentzVector<TYPE>& v )
     {
       return columns( v, std::make_pair( name + "E", &ROOT::Math::LorentzVector<TYPE>::E ),
                          std::make_pair( name + "X", &ROOT::Math::LorentzVector<TYPE>::Px),
                          std::make_pair( name + "Y", &ROOT::Math::LorentzVector<TYPE>::Py),
                          std::make_pair( name + "Z", &ROOT::Math::LorentzVector<TYPE>::Pz) );
     }
     // =======================================================================
     template <class TYPE,class TAG>
     StatusCode column ( const std::string& name ,
                         const ROOT::Math::DisplacementVector3D<TYPE,TAG>& v )
     {
       return this->columns( v, std::make_pair( name + "X", &ROOT::Math::DisplacementVector3D<TYPE,TAG>::X ),
                                std::make_pair( name + "Y", &ROOT::Math::DisplacementVector3D<TYPE,TAG>::Y ),
                                std::make_pair( name + "Z", &ROOT::Math::DisplacementVector3D<TYPE,TAG>::Z ) );
     }
     // =======================================================================
     template <class TYPE,class TAG>
     StatusCode column
     ( const std::string& name ,
       const ROOT::Math::PositionVector3D<TYPE,TAG>& v )
     {
       return this->columns( v,
                         std::make_pair( name + "X", &ROOT::Math::PositionVector3D<TYPE,TAG>::X ),
                         std::make_pair( name + "Y", &ROOT::Math::PositionVector3D<TYPE,TAG>::Y ),
                         std::make_pair( name + "Z", &ROOT::Math::PositionVector3D<TYPE,TAG>::Z ) );
     }
     // =======================================================================
     template <class TYPE,unsigned int D1,unsigned int D2,class REP>
     StatusCode matrix
     ( const std::string&                         name ,
       const ROOT::Math::SMatrix<TYPE,D1,D2,REP>& mtrx )
     {
       if ( invalid () ) { return InvalidTuple     ; }
       if ( rowWise () ) { return InvalidOperation ; }

       // get the matrix itself
       FMatrix* var  = fMatrix ( name , (MIndex)D1 , (MIndex)D2 ) ;
       if ( !var   ) { return InvalidColumn ; }

       for ( size_t iCol = 0 ; iCol < D2 ; ++iCol )
       {
         for ( size_t iRow = 0 ; iRow < D1 ; ++iRow )
         { (*var)[iRow][iCol] = mtrx(iRow,iCol) ; }
       };

       return StatusCode::SUCCESS ;
     }
     // =======================================================================
     template <class KEY, class VALUE>
     StatusCode fmatrix
     ( const std::string&                      name       ,
       const GaudiUtils::VectorMap<KEY,VALUE>& info       ,
       const std::string&                      length     ,
       const size_t                            maxv = 100 )
     {
       using Info = std::pair<KEY,VALUE>;
       static const std::array< std::function<float(const Info&)>, 2>
          fns = { { [](const Info& i) { return i.first;  } ,
                    [](const Info& i) { return i.second; } } };
       return fmatrix( name,
                       std::begin(fns), std::end(fns),
                       std::begin(info), std::end(info),
                       length,maxv );
     }
     // =======================================================================
   public:
     // =======================================================================
     template <class TYPE>
     StatusCode put
     ( const std::string& name , const TYPE*  obj ) ;
     // =======================================================================
   public:
     // =======================================================================
     StatusCode write () ;
     // =======================================================================
     const std::string&  name() const { return m_name ; }
     // =======================================================================
     const NTuple::Tuple* tuple() const  { return m_tuple ; }
     // =======================================================================
     NTuple::Tuple* tuple() { return m_tuple ; }
     // =======================================================================
     unsigned long refCount() const { return   m_refCount ; }
     // =======================================================================
     unsigned long addRef  ()       { return ++m_refCount ; }
     // =======================================================================
     void          release () ;
     // =======================================================================
     const CLID&        clid() const { return m_clid ; }
     // =======================================================================
     Tuples::Type       type() const { return m_type ; }
     // =======================================================================
     bool columnWise() const { return CLID_ColumnWiseTuple == clid() ; }
     // =======================================================================
     bool rowWise   () const { return CLID_RowWiseTuple    == clid() ; }
     // =======================================================================
     bool evtColType() const { return Tuples::EVTCOL       == type()  ; }
     // =======================================================================
     bool valid     () const { return 0 != tuple() ; }
     // =======================================================================
     bool invalid   () const { return ! valid()    ; }
     // =======================================================================
   public:
     // =======================================================================
     bool addItem ( std::string name ,
                    std::string type )
     { return m_items.emplace ( std::move(name) , std::move(type) ).second ; }
     // =======================================================================
     bool goodItem  ( const std::string& name ) const
     { return m_items.end() == m_items.find ( name ) ; }
     // =======================================================================
     const ItemMap& items() const { return m_items ; }
     // =======================================================================
   public:
     // =======================================================================
     virtual StatusCode Error
     ( const std::string& msg ,
       const StatusCode   sc  = StatusCode::FAILURE ) const = 0 ;
     // =======================================================================
     virtual StatusCode Warning
     ( const std::string& msg ,
       const StatusCode   sc  = StatusCode::FAILURE ) const = 0 ;
     // =======================================================================
   private:
     // =======================================================================
     Int*     ints       ( const std::string& name ,
                           int                minv ,
                           int                maxv ) ;
     // =======================================================================
     FArray*  fArray     ( const std::string& name ,
                           Int*               item ) ;
     // =======================================================================
     FArray*  fArray     ( const std::string& name ,
                           const MIndex&      rows ) ;
     // =======================================================================
     Address* addresses  ( const std::string& name ) ;
     // =======================================================================
     FMatrix* fMatrix    ( const std::string& name ,
                           Int*               item ,
                           const MIndex&      cols ) ;
     // =======================================================================
     FMatrix* fMatrix    ( const std::string& name ,
                           const MIndex&      rows ,
                           const MIndex&      cols ) ;
     // =======================================================================
   private:
     // =======================================================================
     TupleObj () = delete;
     TupleObj            ( const TupleObj& ) = delete;
     TupleObj& operator= ( const TupleObj& ) = delete;
     // =======================================================================
   private:
     // =======================================================================
     typedef GaudiUtils::HashMap<std::string,std::unique_ptr<Bool>>   Bools;
     // =======================================================================
     typedef GaudiUtils::HashMap<std::string,std::unique_ptr<Char>>   Chars;
     // =======================================================================
     typedef GaudiUtils::HashMap<std::string,std::unique_ptr<UChar>>  UChars;
     // =======================================================================
     typedef GaudiUtils::HashMap<std::string,std::unique_ptr<Short>>  Shorts;
     // =======================================================================
     typedef GaudiUtils::HashMap<std::string,std::unique_ptr<UShort>> UShorts;
     // =======================================================================
     typedef GaudiUtils::HashMap<std::string,std::unique_ptr<Int>>    Ints;
     // =======================================================================
     typedef GaudiUtils::HashMap<std::string,std::unique_ptr<UInt>>   UInts;
     // =======================================================================
     typedef GaudiUtils::HashMap<std::string,std::unique_ptr<LongLong>> LongLongs;
     // =======================================================================
     typedef GaudiUtils::HashMap<std::string,std::unique_ptr<ULongLong>> ULongLongs;
     // =======================================================================
     typedef GaudiUtils::HashMap<std::string,std::unique_ptr<Float>>   Floats;
     // =======================================================================
     typedef GaudiUtils::HashMap<std::string,std::unique_ptr<Double>>  Doubles;
     // =======================================================================
     typedef GaudiUtils::HashMap<std::string,std::unique_ptr<Address>> Addresses;
     // =======================================================================
     typedef GaudiUtils::HashMap<std::string,std::unique_ptr<FArray>>  FArrays;
     // =======================================================================
     typedef GaudiUtils::HashMap<std::string,std::unique_ptr<FMatrix>> FMatrices;
     // =======================================================================
   private:

     // =======================================================================
     std::string            m_name       ;
     // =======================================================================
     NTuple::Tuple*         m_tuple      ;
     // =======================================================================
     CLID                   m_clid       ;
     // =======================================================================
     Tuples::Type           m_type       ;
     // =======================================================================
     size_t                 m_refCount   = 0;
     // =======================================================================
     mutable Bools          m_bools      ;
     // =======================================================================
     mutable Chars          m_chars      ;
     // =======================================================================
     mutable UChars         m_uchars     ;
     // =======================================================================
     mutable Shorts         m_shorts     ;
     // =======================================================================
     mutable UShorts        m_ushorts    ;
     // =======================================================================
     mutable Ints           m_ints       ;
     // =======================================================================
     mutable UInts          m_uints      ;
     // =======================================================================
     mutable LongLongs      m_longlongs  ;
     // =======================================================================
     mutable ULongLongs     m_ulonglongs ;
     // =======================================================================
     mutable Floats         m_floats     ;
     // =======================================================================
     mutable Doubles        m_doubles    ;
     // =======================================================================
     mutable Addresses      m_addresses  ;
     // =======================================================================
     mutable FArrays        m_farrays    ;
     // =======================================================================
     mutable FArrays        m_arraysf    ;
     // =======================================================================
     mutable FMatrices      m_fmatrices  ;
     // =======================================================================
     mutable FMatrices      m_matricesf  ;
     // =======================================================================
     ItemMap                m_items      ;
     // =======================================================================
   } ;
   // ==========================================================================
 } // end of namespace Tuples
 // ============================================================================
 // GaudiAlg
 // ============================================================================
 #include "GaudiAlg/TuplePut.h"
 // ============================================================================
 // The END
 // ============================================================================
 #endif // GAUDIALG_TUPLEOBJ_H
 // ============================================================================
std::ptrdiff_t

Tuples::TupleObj::column
StatusCode column(const std::string &name, const ROOT::Math::DisplacementVector3D< TYPE, TAG > &v)
Useful shortcut to put 3D-Vector directly into N-Tuple:
Definition: TupleObj.h:1866

Tuples::TupleObj::m_ushorts
UShorts m_ushorts
the actual storage of all &#39;unsigned int&#39; columns
Definition: TupleObj.h:2176

Tuples::TupleObj::m_fmatrices
FMatrices m_fmatrices
the actual storage of all &#39;FArray&#39; columns
Definition: TupleObj.h:2206

GaudiUtils::VectorMap
A bit modified version of &#39;Loki::AssocVector&#39; associative vector from Loki library by Andrei Alexandr...
Definition: VectorMap.h:108

StatusCode::SUCCESS
Definition: StatusCode.h:30

Tuples::TupleObj::m_clid
CLID m_clid
tuple CLID
Definition: TupleObj.h:2155

Tuples::TupleObj::tuple
const NTuple::Tuple * tuple() const
provide the access to underlying Gaudi N-tuple
Definition: TupleObj.h:1991

std::copy
T copy(T...args)

Tuples::TupleObj::matrix
StatusCode matrix(const std::string &name, const MATRIX &data, const MIndex &rows, const MIndex &cols)
fill N-Tuple with fixed-size matrix
Definition: TupleObj.h:1801

Tuples::TupleObj::FMatrices
GaudiUtils::HashMap< std::string, std::unique_ptr< FMatrix > > FMatrices
the actual storage type for matrix columns
Definition: TupleObj.h:2143

std::forward_as_tuple
T forward_as_tuple(T...args)

std::distance
T distance(T...args)

format
GAUDI_API std::string format(const char *,...)
MsgStream format utility "a la sprintf(...)".
Definition: MsgStream.cpp:121

Tuples::TupleObj::Float
NTuple::Item< float > Float
basic type for float items
Definition: TupleObj.h:229

gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:28

StatusCode::FAILURE
Definition: StatusCode.h:29

Tuples::TupleObj::goodItem
bool goodItem(const std::string &name) const
check the uniqueness of the name
Definition: TupleObj.h:2050

Tuples::TupleObj::evtColType
bool evtColType() const
Event collection ?
Definition: TupleObj.h:2027

std::function

Tuples::InvalidTuple
Definition: TupleObj.h:95

gaudirun.args
args
Definition: gaudirun.py:236

Tuples::TupleObj::m_doubles
Doubles m_doubles
the actual storage of all &#39;Double&#39; columns
Definition: TupleObj.h:2194

Tuples::TupleObj::m_type
Tuples::Type m_type
tuple &#39;type&#39;
Definition: TupleObj.h:2158

Tuples::TupleObj::columns_helper
StatusCode columns_helper(const Value &value, const Tuple &tup, std::index_sequence< I... >)
Set the values for several columns simultaneously, for the same object Non-existing columns will be a...
Definition: TupleObj.h:825

NTuple::Matrix
Class acting as a smart pointer holding a N tuple _Item.
Definition: NTuple.h:44

GaudiPython.GaudiAlgs.fmatrix
fmatrix
Definition: GaudiAlgs.py:1151

Tuples::TupleObj::Address
NTuple::Item< IOpaqueAddress * > Address
basic type for address items
Definition: TupleObj.h:235

NTuple.h

Tuples::TupleObj::m_matricesf
FMatrices m_matricesf
the actual storage of all &#39;FMatrix&#39; columns (fixed)
Definition: TupleObj.h:2209

std::is_same

Tuples::TupleObj::m_floats
Floats m_floats
the actual storage of all &#39;Float&#39; columns
Definition: TupleObj.h:2191

Gaudi::Utils::Histos::fill
GAUDI_API void fill(AIDA::IHistogram1D *histo, const double value, const double weight=1.0)
simple function to fill AIDA::IHistogram1D objects
Definition: Fill.cpp:36

Tuples::TupleObj::ULongLong
NTuple::Item< unsigned long long > ULongLong
basic type for unsigned long long items
Definition: TupleObj.h:226

Tuples::TupleObj::m_farrays
FArrays m_farrays
the actual storage of all &#39;FArray&#39; columns
Definition: TupleObj.h:2200

Tuples::TupleObj::UShort
NTuple::Item< unsigned short > UShort
basic type for unsigned int items
Definition: TupleObj.h:214

std::end
T end(T...args)

Tuples::TupleObj::fmatrix
StatusCode fmatrix(const std::string &name, const MATRIX &data, size_t rows, const MIndex &cols, const std::string &length, size_t maxv)
Fill N-Tuple with data from variable-size matrix.
Definition: TupleObj.h:1375

Tuples::detail::to_float
Definition: TupleObj.h:68

Tuples::InvalidItem
Definition: TupleObj.h:99

Tuples::TupleObj::MIndex
unsigned short MIndex
Definition: TupleObj.h:244

std::size_t

ROOT::Math::PositionVector3D
Definition: IMagneticFieldSvc.h:16

invoke.h

std::map< std::string, std::string >

Tuples::TupleObj::m_name
std::string m_name
name
Definition: TupleObj.h:2149

Tuples::TupleObj::LongLongs
GaudiUtils::HashMap< std::string, std::unique_ptr< LongLong > > LongLongs
the actual storage type for longlong columns
Definition: TupleObj.h:2125

Tuples::TruncateValue
Definition: TupleObj.h:100

Tuples::TupleObj::tuple
NTuple::Tuple * tuple()
provide the access to underlying Gaudi N-tuple
Definition: TupleObj.h:1996

Tuples::TupleObj::m_arraysf
FArrays m_arraysf
the actual storage of all &#39;FArray&#39; columns (fixed)
Definition: TupleObj.h:2203

Tuples::TupleObj::Addresses
GaudiUtils::HashMap< std::string, std::unique_ptr< Address > > Addresses
the actual storage type for address columns
Definition: TupleObj.h:2137

Tuples::TupleObj::farray
StatusCode farray(const std::string &name, ITERATOR1 &&first, ITERATOR2 &&last, const std::string &length, size_t maxv)
Add an indexed array (of type float) to N-tuple.
Definition: TupleObj.h:925

Tuples::InvalidOperation
Definition: TupleObj.h:97

Tuples::TupleObj::UChar
NTuple::Item< unsigned char > UChar
basic type for unsigned int items
Definition: TupleObj.h:208

Tuples::TupleObj::m_bools
Bools m_bools
the actual storage of all &#39;bool&#39; columns
Definition: TupleObj.h:2164

SerializeSTL.h
Provide serialization function (output only) for some common STL classes (vectors, lists, pairs, maps) plus GaudiUtils::Map and GaudiUtils::HashMap.

begin
auto begin(reverse_wrapper< T > &w)
Definition: reverse.h:48

Tuples::TupleObj::columnWise
bool columnWise() const
column wise NTuple ?
Definition: TupleObj.h:2021

operator=
PropertyMgr & operator=(const PropertyMgr &)=delete

Gaudi::Units::second
constexpr double second
Definition: SystemOfUnits.h:122

std::string
STL class.

GaudiPython.GaudiAlgs.farray
farray
Definition: GaudiAlgs.py:1150

Tuples::TupleObj::Short
NTuple::Item< short > Short
basic type for int items
Definition: TupleObj.h:211

Tuples::TupleObj::m_chars
Chars m_chars
the actual storage of all &#39;Int&#39; columns
Definition: TupleObj.h:2167

Tuples::Tuple
A simple wrapper class over standard Gaudi NTuple::Tuple facility.
Definition: Tuple.h:116

Tuples::TupleObj::addItem
bool addItem(std::string name, std::string type)
add the item name into the list of known items
Definition: TupleObj.h:2042

Tuples::TupleObj::fmatrix
StatusCode fmatrix(const std::string &name, FUN funF, FUN funL, DATA first, DATA last, const std::string &length, size_t maxv)
fill N-Tuple with matrix of "direct-product" of "data-vector" [first,last) and "function-vector" [fun...
Definition: TupleObj.h:1571

Tuples::TupleObj::m_ulonglongs
ULongLongs m_ulonglongs
the actual storage of all &#39;ulonglong&#39; columns
Definition: TupleObj.h:2188

detail
TupleObj.h GaudiAlg/TupleObj.h namespace with few technical implementations.

VectorMap.h

Tuples::TupleObj
A simple wrapper class over standard Gaudi NTuple::Tuple facility.
Definition: TupleObj.h:197

std::next
T next(T...args)

Tuples::TupleObj::array
StatusCode array(const std::string &name, const ARRAY &data)
fill N-Tuple with fixed-size array
Definition: TupleObj.h:1743

StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26

Tuples::TupleObj::farray
StatusCode farray(const std::string &name1, const FUNC1 &func1, const std::string &name2, const FUNC2 &func2, const std::string &name3, const FUNC3 &func3, Iterator &&first, Iterator &&last, const std::string &length, size_t maxv)
Put three functions from one data array into LoKi-style N-Tuple simultaneously (effective!) ...
Definition: TupleObj.h:1243

Tuples::TupleObj::farray
StatusCode farray(const std::string &name, const DATA &data, const std::string &length, const size_t maxv)
Add an indexed array (of type float) to N-tuple.
Definition: TupleObj.h:979

Tuples::TupleObj::FMatrix
NTuple::Matrix< float > FMatrix
basic type for matrix of floats
Definition: TupleObj.h:241

std::ostringstream
STL class.

gaudirun.type
type
Definition: gaudirun.py:125

Tuples::TupleObj::m_uints
UInts m_uints
the actual storage of all &#39;unsigned int&#39; columns
Definition: TupleObj.h:2182

Tuples::detail::to_::operator()
T operator()(Arg &&i) const
Definition: TupleObj.h:65

std::make_pair
T make_pair(T...args)

Tuples::TupleObj::m_items
ItemMap m_items
all booked types:
Definition: TupleObj.h:2212

Tuples::TupleObj::Bool
NTuple::Item< bool > Bool
basic type for int items
Definition: TupleObj.h:202

end
auto end(reverse_wrapper< T > &w)
Definition: reverse.h:50

Tuples::TupleObj::Double
NTuple::Item< double > Double
basic type for double items
Definition: TupleObj.h:232

Tuples::TupleObj::farray
StatusCode farray(const std::string &name1, const FUNC1 &func1, const std::string &name2, const FUNC2 &func2, Iterator &&first, Iterator &&last, const std::string &length, size_t maxv)
Put two functions from one data array into LoKi-style N-Tuple simultaneously (effective!) ...
Definition: TupleObj.h:1191

NTuple::Item< bool >
Specialization acting as a smart pointer holding a N tuple _Item.
Definition: NTuple.h:297

Tuples::TupleObj::m_ints
Ints m_ints
the actual storage of all &#39;Int&#39; columns
Definition: TupleObj.h:2179

CLID
unsigned int CLID
Class ID definition.
Definition: ClassID.h:8

Tuples::TupleObj::UShorts
GaudiUtils::HashMap< std::string, std::unique_ptr< UShort > > UShorts
the actual storage type for unsigned short columns
Definition: TupleObj.h:2116

Tuples::TupleObj::m_longlongs
LongLongs m_longlongs
the actual storage of all &#39;longlong&#39; columns
Definition: TupleObj.h:2185

Tuples::TupleObj::valid
bool valid() const
valid pointer to tuple ?
Definition: TupleObj.h:2030

std::move
T move(T...args)

Tuples::InvalidColumn
Definition: TupleObj.h:96

ROOT::Math::DisplacementVector3D
Definition: IMagneticFieldSvc.h:18

Tuples::TupleObj::fmatrix
StatusCode fmatrix(const std::string &name, DATA first, DATA last, const MIndex &cols, const std::string &length, size_t maxv)
Fill N-Tuple with data from variable-size matrix.
Definition: TupleObj.h:1450

Tuples::TupleObj::addRef
unsigned long addRef()
add the reference to TupleObj
Definition: TupleObj.h:2006

Tuples::TupleObj::refCount
unsigned long refCount() const
return the reference counter
Definition: TupleObj.h:2001

Tuples::TupleObj::rowWise
bool rowWise() const
row wise NTuple ?
Definition: TupleObj.h:2024

GaudiUtils::details::ostream_joiner
Stream & ostream_joiner(Stream &os, Iterator first, Iterator last, Separator sep, OutputElement output=OutputElement{})
Definition: SerializeSTL.h:35

GaudiPython.GaudiAlgs.matrix
matrix
Definition: GaudiAlgs.py:1149

NTuple::Tuple
Abstract base class which allows the user to interact with the actual N tuple implementation.
Definition: NTuple.h:370

Tuples::detail::const_ref_t
typename std::add_const< typename std::iterator_traits< Iterator >::reference >::type const_ref_t
Definition: TupleObj.h:71

Tuples::TupleObj::column
StatusCode column(const std::string &name, signed char value)
Set the value for the selected tuple column.
Definition: TupleObj.h:736

std::add_const

std::pair

Tuples::ErrorCodes
ErrorCodes
Tuple error codes.
Definition: TupleObj.h:93

Tuples::TupleObj::LongLong
NTuple::Item< long long > LongLong
basic type for unsigned long long items
Definition: TupleObj.h:223

Tuples::TupleObj::m_addresses
Addresses m_addresses
the actual storage of all &#39;Address&#39; columns
Definition: TupleObj.h:2197

Tuples::TupleObj::FArrays
GaudiUtils::HashMap< std::string, std::unique_ptr< FArray > > FArrays
the actual storage type for array columns
Definition: TupleObj.h:2140

Tuples::EVTCOL
Definition: TupleObj.h:83

Tuples::TupleObj::Floats
GaudiUtils::HashMap< std::string, std::unique_ptr< Float > > Floats
the actual storage type for float columns
Definition: TupleObj.h:2131

std::find_if_not
T find_if_not(T...args)

Maps.h

Tuples::TupleObj::farray
StatusCode farray(const std::string &name1, const FUNC1 &func1, const std::string &name2, const FUNC2 &func2, const std::string &name3, const FUNC3 &func3, const std::string &name4, const FUNC4 &func4, Iterator &&first, Iterator &&last, const std::string &length, size_t maxv)
Put four functions from one data array into LoKi-style N-Tuple simultaneously (effective!) ...
Definition: TupleObj.h:1301

Tuples::TupleObj::array
StatusCode array(const std::string &name, DATA first, DATA last)
fill N-Tuple with fixed-size array
Definition: TupleObj.h:1640

Containers::array
struct GAUDI_API array
Parametrisation class for redirection array - like implementation.
Definition: KeyedObjectManager.h:27

std::vector
STL class.

Tuples::TupleObj::m_tuple
NTuple::Tuple * m_tuple
tuple itself
Definition: TupleObj.h:2152

Tuples::TupleObj::Doubles
GaudiUtils::HashMap< std::string, std::unique_ptr< Double > > Doubles
the actual storage type for float columns
Definition: TupleObj.h:2134

std::cref
T cref(T...args)

Tuples::TupleObj::type
Tuples::Type type() const
accessor to the N-Tuple type
Definition: TupleObj.h:2018

Iterator
boost::spirit::classic::position_iterator2< ForwardIterator > Iterator
Definition: Iterator.h:18

std::begin
T begin(T...args)

Tuples::TupleObj::farray
StatusCode farray(const std::string &name, const FUNCTION &function, ITERATOR first, ITERATOR last, const std::string &length, size_t maxv)
Put an indexed array into LoKi-style N-Tuple.
Definition: TupleObj.h:1048

std::back_inserter
T back_inserter(T...args)

std::any_of
T any_of(T...args)

fun
double fun(const std::vector< double > &x)
Definition: PFuncTest.cpp:26

Tuples::TupleObj::Char
NTuple::Item< char > Char
basic type for int items
Definition: TupleObj.h:205

GaudiPython.GaudiAlgs.write
write
Definition: GaudiAlgs.py:1144

GaudiUtils::HashMap
Common class providing an architecture-independent hash map.
Definition: HashMap.h:77

GaudiMP.FdsRegistry.msg
msg
Definition: FdsRegistry.py:8

std::array
STL class.

Tuples::TupleObj::Int
NTuple::Item< int > Int
basic type for int items
Definition: TupleObj.h:217

Tuples.h

Tuples::TupleObj::Chars
GaudiUtils::HashMap< std::string, std::unique_ptr< Char > > Chars
the actual storage type for short columns
Definition: TupleObj.h:2107

GaudiPython.GaudiAlgs.valid
valid
Definition: GaudiAlgs.py:1143

Tuples::TupleObj::column
StatusCode column(const std::string &name, const ROOT::Math::LorentzVector< TYPE > &v)
Useful shortcut to put LorentzVector directly into N-Tuple:
Definition: TupleObj.h:1841

Tuples::TupleObj::m_shorts
Shorts m_shorts
the actual storage of all &#39;Int&#39; columns
Definition: TupleObj.h:2173

Tuples::TupleObj::invalid
bool invalid() const
invalid pointer to tuple ?
Definition: TupleObj.h:2033

std::transform
T transform(T...args)

Tuples::NTUPLE
Definition: TupleObj.h:82

Tuples::TupleObj::items
const ItemMap & items() const
get the full list of booked items
Definition: TupleObj.h:2054

Tuples::TupleObj::FArray
NTuple::Array< float > FArray
basic type for array of floats
Definition: TupleObj.h:238

Gaudi::invoke
auto invoke(F &&f, ArgTypes &&...args) noexcept(noexcept(detail2::INVOKE(std::forward< F >(f), std::forward< ArgTypes >(args)...))) -> decltype(detail2::INVOKE(std::forward< F >(f), std::forward< ArgTypes >(args)...))
Definition: invoke.h:89

TuplePut.h
Implementation file for Tuple::TupleObj::put method.

IOpaqueAddress
Opaque address interface definition.
Definition: IOpaqueAddress.h:23

Tuples::InvalidObject
Definition: TupleObj.h:98

Tuples::TupleObj::UInts
GaudiUtils::HashMap< std::string, std::unique_ptr< UInt > > UInts
the actual storage type for unsigned integer columns
Definition: TupleObj.h:2122

NTuple::Item
Class acting as a smart pointer holding a N tuple _Item.
Definition: NTuple.h:42

Tuples::TupleObj::clid
const CLID & clid() const
accessor to the N-Tuple CLID
Definition: TupleObj.h:2015

Tuples::TupleObj::Ints
GaudiUtils::HashMap< std::string, std::unique_ptr< Int > > Ints
the actual storage type for integer columns
Definition: TupleObj.h:2119

Tuples::TupleObj::array
StatusCode array(const std::string &name, const ARRAY &data, const MIndex &length)
fill N-Tuple with fixed-size array
Definition: TupleObj.h:1700

Tuples::TupleObj::Shorts
GaudiUtils::HashMap< std::string, std::unique_ptr< Short > > Shorts
the actual storage type for short columns
Definition: TupleObj.h:2113

std::for_each
T for_each(T...args)

NTuple::Array
Class acting as a smart pointer holding a N tuple _Item.
Definition: NTuple.h:43

Tuples::TupleObj::ItemMap
std::map< std::string, std::string > ItemMap
Definition: TupleObj.h:247

GAUDI_API
#define GAUDI_API
Definition: Kernel.h:107

Tuples::detail::to_
Definition: TupleObj.h:63

Tuples::Type
Type
the list of available types for ntuples
Definition: TupleObj.h:80

std::ostream
STL class.

Tuples::TupleObj::name
const std::string & name() const
get the name
Definition: TupleObj.h:1986

Tuples::TupleObj::UInt
NTuple::Item< unsigned int > UInt
basic type for unsigned int items
Definition: TupleObj.h:220

Tuples::TupleObj::columns
StatusCode columns(Value &&value, Args &&...args)
Definition: TupleObj.h:841

Tuples::TupleObj::ULongLongs
GaudiUtils::HashMap< std::string, std::unique_ptr< ULongLong > > ULongLongs
the actual storage type for ulonglong columns
Definition: TupleObj.h:2128

Tuples::TupleObj::m_uchars
UChars m_uchars
the actual storage of all &#39;unsigned int&#39; columns
Definition: TupleObj.h:2170

std::initializer_list

Tuples::TupleObj::Bools
GaudiUtils::HashMap< std::string, std::unique_ptr< Bool > > Bools
the actual storage type for short columns
Definition: TupleObj.h:2104

Gaudi::Functional::details::put
Out1 * put(DataObjectHandle< Out1 > &out_handle, Out2 &&out)
Definition: FunctionalDetails.h:109

GaudiPython.GaudiAlgs.Tuple
Tuple
Definition: GaudiAlgs.py:1041

std::vector::reserve
T reserve(T...args)

GaudiPython.GaudiAlgs.column
column
Definition: GaudiAlgs.py:1071

Tuples::TupleObj::UChars
GaudiUtils::HashMap< std::string, std::unique_ptr< UChar > > UChars
the actual storage type for unsigned short columns
Definition: TupleObj.h:2110

std::numeric_limits

Tuples
General namespace for Tuple properties.
Definition: Maps.h:34