TupleDetail.h

Go to the documentation of this file.

#ifndef GAUDIALG_TUPLEDETAIL_H
#define GAUDIALG_TUPLEDETAIL_H 1
// ============================================================================
// Include files
// ============================================================================
#include "GaudiAlg/Tuple.h"
#include "GaudiAlg/TupleObj.h"
#include "GaudiAlg/Tuples.h"
// ============================================================================

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

namespace Tuples
{
  namespace detail
  {
    template <class HANDLER1, class HANDLER2>
    class TupleObjImp : public TupleObj
    {
    public:
      TupleObjImp( HANDLER1 handler1, HANDLER2 handler2, const std::string& name, NTuple::Tuple* tuple,
                   const CLID& clid = CLID_ColumnWiseTuple, const Tuples::Type type = Tuples::NTUPLE )
          : TupleObj( name, tuple, clid, type ), m_handler1( handler1 ), m_handler2( handler2 )
      {
      }

    public:
      StatusCode Error( const std::string& msg, const StatusCode sc = StatusCode::FAILURE ) const override
      {
        m_handler1( name() + " " + msg, sc );
        return sc;
      }

      StatusCode Warning( const std::string& msg, const StatusCode sc = StatusCode::FAILURE ) const override
      {
        m_handler2( name() + " " + msg, sc );
        return sc;
      }

    protected:
      ~TupleObjImp() override = default;

    private:
      HANDLER1 m_handler1;
      HANDLER2 m_handler2;
    };

    template <class HANDLER1, class HANDLER2>
    inline TupleObj* createTupleObj( HANDLER1 handler1, HANDLER2 handler2, const std::string& name,
                                     NTuple::Tuple* tuple, const CLID& clid = CLID_ColumnWiseTuple,
                                     const Tuples::Type type = Tuples::NTUPLE )
    {
      return new TupleObjImp<HANDLER1, HANDLER2>( handler1, handler2, name, tuple, clid, type );
    }

    template <class OBJECT, class FUNCTION>
    class ErrorHandler
    {
    public:
      ErrorHandler( const OBJECT* obj, FUNCTION fun ) : m_obj( obj ), m_fun( fun ) {}

    public:
      StatusCode operator()( const std::string& msg, const StatusCode sc, const size_t mp = 10 ) const
      {
        return ( m_obj->*m_fun )( msg, sc, mp );
      }

    private:
      // default constructor is private
      ErrorHandler();

    private:
      const OBJECT* m_obj = nullptr;
      FUNCTION m_fun;
    };

    template <class OBJECT, class FUNCTION>
    inline ErrorHandler<OBJECT, FUNCTION> make_handler( const OBJECT* object, FUNCTION function )
    {
      return ErrorHandler<OBJECT, FUNCTION>( object, function );
    }
  }

  template <class OWNER>
  inline TupleObj* createTupleObj( const OWNER* owner, const std::string& name, NTuple::Tuple* tuple,
                                   const CLID& clid = CLID_ColumnWiseTuple, const Tuples::Type type = Tuples::NTUPLE )
  {
    return detail::createTupleObj( detail::make_handler( owner, &OWNER::Error ),
                                   detail::make_handler( owner, &OWNER::Warning ), name, tuple, clid, type );
  }

} // end of namespace Tuples

// ============================================================================
// The END
// ============================================================================
#endif // GAUDIALG_TUPLEDETAIL_H
// ============================================================================