Tuple.h

Go to the documentation of this file.

#ifndef GAUDIALG_TUPLE_H
#define GAUDIALG_TUPLE_H 1
// ============================================================================
// Include files
// ============================================================================
// STD & STL
// ============================================================================
#include <string>

// ============================================================================
// ============================================================================

// ============================================================================
// ============================================================================

#include "GaudiKernel/SmartIF.h"
#include "GaudiAlg/TupleObj.h"

namespace Tuples
{

  template <class ITEM> class TupleItem ;

  class GAUDI_API Tuple
  {

    // Tuple() = delete;
    Tuple();

  public :
    Tuple ( TupleObj* ) ;

    Tuple ( const Tuple&  ) = default;

    virtual ~Tuple() = default;

    Tuple&    operator=( const Tuple& )  = default;

    TupleObj* operator->  ()  const  { return tuple () ; }

    bool      valid       ()  const  { return tuple () ; }

  protected:

    TupleObj*  tuple() const { return m_tuple.get() ; }

  private:

    SmartIF<TupleObj> m_tuple;

  };

  template<class ITEM>
  class TupleColumn
  {
  public:
    TupleColumn() = delete;
    TupleColumn ( std::string  name   ,
                  ITEM         value  )
      : m_name ( std::move(name) ) , m_value  (  std::move(value)  ) {}

    const std::string& name  () const { return m_name  ; }
    const ITEM&        value () const { return m_value ; }
  private:
    std::string m_name   ; 
    ITEM       m_value  ; 
  };

  template<class ITEM>
  inline TupleColumn<ITEM>
  make_column ( std::string name , const ITEM& item )
  { return TupleColumn<ITEM> ( std::move(name) , item ) ; }

  template<class ITEM>
  inline TupleColumn<const ITEM*>
  make_column ( std::string name , const ITEM* item )
  { return TupleColumn<const ITEM*>( std::move(name) , item ) ; }

  template<class ITEM>
  inline TupleColumn<ITEM*>
  make_column ( std::string name ,       ITEM* item )
  { return TupleColumn<ITEM*>      ( std::move(name) , item ) ; }

  template<class ITEM>
  inline TupleColumn<ITEM>
  Column      ( std::string name , const ITEM& item )
  { return make_column             ( std::move(name) , item ) ; }

  template<class ITEM>
  inline TupleColumn<const ITEM*>
  Column      ( std::string name , const ITEM* item )
  { return make_column             ( std::move(name) , item ) ; }

  template<class ITEM>
  inline TupleColumn<ITEM*>
  Column      ( std::string name ,       ITEM* item )
  { return make_column             ( std::move(name) , item ) ; }

} // end of the namespace Tuples

// ============================================================================
// ============================================================================
template <class ITEM>
inline Tuples::Tuple& operator<<
  ( Tuples::Tuple&                   tuple ,
    const Tuples::TupleColumn<ITEM>& item )
{
  if ( !tuple.valid() ) { return tuple  ; } // no action for invalid tuple
  tuple->column( item.name() , item.value () ) ;
  return tuple ;
}
// ============================================================================



// ============================================================================
// THe END
// ============================================================================
#endif // GAUDIALG_TUPLE_H
// ============================================================================