EIC code displayed by LXR master/​include/​GaudiAlg/​TupleDetail.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:57:34

 /***********************************************************************************\
 * (c) Copyright 1998-2019 CERN for the benefit of the LHCb and ATLAS collaborations *
 *                                                                                   *
 * This software is distributed under the terms of the Apache version 2 licence,     *
 * copied verbatim in the file "LICENSE".                                            *
 *                                                                                   *
 * In applying this licence, CERN does not waive the privileges and immunities       *
 * granted to it by virtue of its status as an Intergovernmental Organization        *
 * or submit itself to any jurisdiction.                                             *
 \***********************************************************************************/
 #ifndef GAUDIALG_TUPLEDETAIL_H
 #define GAUDIALG_TUPLEDETAIL_H 1
 // ============================================================================
 // Include files
 // ============================================================================
 #include "GaudiAlg/Tuple.h"
 #include "GaudiAlg/TupleObj.h"
 #include "GaudiAlg/Tuples.h"
 // ============================================================================
 
 // ============================================================================
 /** @file
  *  Collection of few 'technical' methods for instantiation of tuples
  *  @author Ivan BELYAEV
  *  @date   2004-01-27
  */
 // ============================================================================
 
 namespace Tuples {
   /** @namespace detail TupleObj.h GaudiAlg/TupleObj.h
    *  namespace with few technical implementations
    *
    *  @author Vanya BELYAEV Ivan.Belyaev@itep.ru
    *  @date   2004-01-23
    */
   namespace detail {
     /** @class TupleObjImp
      *
      *  The simplest concrete implementation of class TupleObj
      *  with 3 arbitrary error handlers
      *  Any types (classes, functions, etc.) which supports the
      *  semantics
      *
      *  @code
      *
      *     HANDLER obj = .. ;
      *
      *     StatusCode obj( msg , sc )
      *
      *  @endcode
      *
      *  can be used as error handler, e.g.
      *
      *  @code
      *
      *   void print_error   ( const std::string& msg , StatusCode sc )
      *    { std::cout <<
      *      "Error"   << msg << " code " << sc.getCode() << std::endl ; }
      *   void print_warning ( const std::string& msg , StatusCode sc )
      *    { std::cout <<
      *      "Warning" << msg << " code " << sc.getCode() << std::endl ; }
      *   void print_print   ( const std::string& msg , StatusCode sc )
      *    { std::cout << msg << " code " << sc.getCode() << std::endl ; }
      *
      *   NTuple::Tuple* tuple = ... ;
      *   TupleObj* obj =
      *    createTupleObj( print_errror   ,
      *                    print_warning  ,
      *                    print_print    ,
      *                    " my tuple "   , ntuple ) ;
      *
      *  @endcode
      *
      *  Templated helper functions allow to avoid heavy semantics of
      *  dealing with explicit type
      *
      *  Few concrete error handlers for dealing with classes,
      *  which supports member functions Error and Warning
      *   ( e.g. class GaudiAlgorithm or class GaudiTool )
      *  are provided
      *
      * @author Vanya BELYAEV Ivan.Belyaev@itep.ru
      * @date   2004-1-24
      */
     template <class HANDLER1, class HANDLER2>
     class TupleObjImp : public TupleObj {
     public:
       /** constructor
        *  @param  handler1 error   handler
        *  @param  handler2 warning handler
        *  @param  name  Name of the NTuple
        *  @param  tuple NTuple itself
        *  @param  clid  NTuple CLID
        *  @param  type  NTuple type
        */
       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 {
         return m_handler1( name() + " " + msg, sc );
       }
 
       StatusCode Warning( const std::string& msg, const StatusCode sc = StatusCode::FAILURE ) const override {
         return m_handler2( name() + " " + msg, sc );
       }
 
     private:
       HANDLER1 m_handler1;
       HANDLER2 m_handler2;
     };
 
     /** Templated helper functions allow to avoid heavy semantics of
      *  dealing with explicit type of class TupleObjImp
      *
      *  @code
      *
      *   void print_error   ( const std::string& msg , StatusCode sc )
      *    { std::cout <<
      *      "Error"   << msg << " code " << sc.getCode() << std::endl ; }
      *   void print_warning ( const std::string& msg , StatusCode sc )
      *    { std::cout <<
      *      "Warning" << msg << " code " << sc.getCode() << std::endl ; }
      *
      *   NTuple::Tuple* tuple = ... ;
      *   TupleObj* obj =
      *    createTupleObj( print_errror   ,
      *                    print_warning  ,
      *                    " my tuple "   , ntuple ) ;
      *
      *  @endcode
      *
      *  Few concrete error handlers for dealing with classes,
      *  which supports member functions Error,Warning and Print
      *   ( e.g. class GaudiAlgorithm or class GaudiTool )
      *  are provided
      *
      * @author Vanya BELYAEV Ivan.Belyaev@itep.ru
      * @date   2004-1-24
      */
     template <class HANDLER1, class HANDLER2>
     auto createTupleObj( HANDLER1 handler1, HANDLER2 handler2, const std::string& name, NTuple::Tuple* tuple,
                          const CLID& clid = CLID_ColumnWiseTuple, const Tuples::Type type = Tuples::NTUPLE ) {
       return std::make_unique<TupleObjImp<HANDLER1, HANDLER2>>( handler1, handler2, name, tuple, clid, type );
     }
 
     /** @class ErrorHandler
      *
      *  Concrete error handlers for dealing with classes,
      *  which supports member functions Error,Warning and Print
      *   ( e.g. class GaudiAlgorithm or class GaudiTool )
      *  are provided
      *
      * @author Vanya BELYAEV Ivan.Belyaev@itep.ru
      * @date   2004-1-24
      */
     template <class OBJECT, class FUNCTION>
     class ErrorHandler {
     public:
       /// constructor
       ErrorHandler( const OBJECT* obj, FUNCTION fun ) : m_obj( obj ), m_fun( fun ) {}
 
       /// the only one 'useful' method
       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;
     };
 
     /** Templated helper functions allow to avoid heavy semantics of
      *  dealing with explicit type of class ErrorHandler
      *
      * @code
      *
      * const GaudiAlgorithm* algo =  ... ;
      *
      * // error handler using GaudiAlgorithm::Error member function
      * make_handler( algo , &GaudiAlgorithm::Error ) ;
      *
      *  const GaudiTool* tool = .... ;
      * // error handler using GaudiTool::Print member function
      * make_handler( tool , &GaudiTool::Print ) ;
      *
      * @endcode
      *
      * @author Vanya BELYAEV Ivan.Belyaev@itep.ru
      * @date   2004-1-24
      */
     template <class OBJECT, class FUNCTION>
     ErrorHandler<OBJECT, FUNCTION> make_handler( const OBJECT* object, FUNCTION function ) {
       return ErrorHandler( object, function );
     }
   } // namespace detail
 
   /** Templated helper functions allow to avoid heavy semantics of
    *  dealing with explicit type of class TupleObjImp
    *
    *  @code
    *
    *   const GaudiAlgorithm* algo  = ... ;
    *   NTuple::Tuple*        tuple = ... ;
    *   TupleObj* obj = createTupleObj( algo , " my tuple 1 "   , ntuple ) ;
    *
    *   const GaudiTool* tool   = ... ;
    *   NTuple::Tuple*   tuple2 = ... ;
    *   TupleObj* obj2 = createTupleObj( tool , " my tuple 2 " , ntuple2 ) ;
    *
    *  @endcode
    *
    * @author Vanya BELYAEV Ivan.Belyaev@itep.ru
    * @date   2004-1-24
    */
   template <class OWNER>
   auto 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

This page was automatically generated by the 2.3.7 LXR engine. The LXR team