In This Package:

GiGaCnvBase.h

Go to the documentation of this file.

// $Id: GiGaCnvBase.h,v 1.14 2007/11/08 15:29:04 gcorti Exp $ 
#ifndef GIGA_GIGACNVBASE_H 
#define GIGA_GIGACNVBASE_H  1 

// Include files
// from STL 
#include <string> 
#include <vector> 
#include <map> 
#include <exception> 

// from Gaudi 
#include "GaudiKernel/IDataProviderSvc.h" 
#include "GaudiKernel/IToolSvc.h" 
#include "GaudiKernel/Converter.h" 
#include "GaudiKernel/MsgStream.h" 
#include "GaudiKernel/SmartDataPtr.h" 
#include "GaudiKernel/System.h" 

// from GiGa
#include "GiGaCnv/IGiGaCnvSvc.h" 
#include "GiGaCnv/IGiGaCnvSvcLocation.h" 
#include "GiGaCnv/IGiGaKineCnvSvc.h" 
#include "GiGaCnv/GiGaLeaf.h" 

// forward declarations
class IDataProviderSvc     ;
class IMessageSvc          ; 
class IChronoStatSvc       ; 
class IToolSvc             ; 
class IParticlePropertySvc ; 
class IGiGaSvc             ;   
class IGiGaSetUpSvc        ;
//
class GaudiException       ; 
//
class IGiGaGeomCnvSvc      ;
class IGiGaHitsCnvSvc      ; 


class GiGaCnvBase: public Converter 
{
public:
  typedef std::vector<GiGaLeaf> Leaves;
  
protected: 
  
  GiGaCnvBase
  ( const long  StorageType , 
    const CLID&          ClassType   , 
    ISvcLocator*         Locator     );
  
  virtual ~GiGaCnvBase();
public: 
  long repSvcType() const
  { return i_repSvcType(); }
  
  virtual StatusCode initialize () ; 
  
  virtual StatusCode finalize   () ;
  
protected: 

  inline ISvcLocator*          svcLoc    () const 
  { return serviceLocator ()                          ; }
  
  inline IGiGaCnvSvc*          cnvSvc    () const 
  { return m_GiGaCnvSvc                               ; } 
  
  inline IGiGaGeomCnvSvc*      geoSvc    () const 
  { return m_GiGaGeomCnvSvc                           ; } 
  
  inline IGiGaKineCnvSvc*      kineSvc   () const 
  { return m_GiGaKineCnvSvc                           ; } 
  
  inline IGiGaHitsCnvSvc*      hitsSvc   () const 
  { return m_GiGaHitsCnvSvc                           ; }
  
  inline IDataProviderSvc*     evtSvc    () const 
  { return m_evtSvc                                   ; }   
  
  inline IDataProviderSvc*     detSvc    () const 
  { return m_detSvc                                   ; }
  
  
  inline IChronoStatSvc*       chronoSvc () const 
  { return m_chronoSvc                                ; } 

  inline IToolSvc*             toolSvc   () const 
  { return m_toolSvc                                  ; } 
  
  inline IGiGaSvc*             gigaSvc   () const 
  { return 0 != cnvSvc () ? cnvSvc ()->gigaSvc () : 0 ; }

  inline IGiGaSetUpSvc*        setupSvc  () const 
  { return 0 != cnvSvc () ? cnvSvc ()->setupSvc() : 0 ; } 
  
  inline IParticlePropertySvc* ppSvc     () const 
  { return 0 != kineSvc() ? kineSvc()->ppSvc   () : 0 ; }


  template<class TYPE>
  TYPE* 
  get
  ( IDataProviderSvc*  svc        , 
    const std::string& location   ,
    const TYPE*        /* type */ ) const 
  {
    // check the environment 
    Assert( 0 != svc   , "  get():: IDataProvider* points to NULL!"      );
    SmartDataPtr<TYPE> object( svc, location ) ;
    Assert( !(!object) ,  " get():: No valid data at '" + location + "'" );
    TYPE* aux = object ;
    Assert( 0 != aux   ,  " get():: No valid data at '" + location + "'" );
    const std::string type( System::typeinfoName( typeid( *aux ) ) );
    // debug printout 
    // return located valid data 
    Print( " The data from address '"     + location + 
           "' are retrieved from TS "     ,
           StatusCode::SUCCESS ,  MSG::DEBUG ) ;
    Print( " [ The actual data type is '" + type     + 
           "' ] "                         ,
           StatusCode::SUCCESS  , MSG::DEBUG ) ;
    return aux ;
  };
  
  template<class TOOL>
  TOOL* 
  tool
  ( const std::string& type           , 
    const std::string& name           , 
    TOOL*&             Tool           , 
    const IInterface*  parent  = 0    , 
    bool               create  = true ) const 
  {
    // for empty names delegate to another method 
    if( name.empty() ) { return tool( type , Tool , parent , create ) ; }
    Assert( 0 != toolSvc() , "IToolSvc* points toNULL!" );
    // get the tool from Tool Service 
    StatusCode sc = toolSvc () 
      -> retrieveTool ( type , name , Tool, parent , create );
    Assert( sc.isSuccess() , 
            "Could not retrieve Tool'" + type + "'/'" + name + "'", sc ) ;
    Assert( 0 != Tool      , 
            "Could not retrieve Tool'" + type + "'/'" + name + "'"     ) ;
    // debug printout 
    Print( " The Tool of type '" + Tool->type() + 
           "'/'"                 + Tool->name() + 
           "' is retrieved from IToolSvc " , MSG::DEBUG  , sc ) ;
    // return located tool 
    return Tool ;
  };

  template<class TOOL>
  TOOL* 
  tool
  ( const std::string& type          , 
    TOOL*&             Tool          , 
    const IInterface*  parent = 0    , 
    bool               create = true ) const
  {
    // check the environment 
    Assert( 0 != toolSvc() , "IToolSvc* points toNULL!" );
    // "type" or "type/name" ?
    std::string::const_iterator it = 
      std::find( type.begin() , type.end () , '/' );
    // "type" is compound!
    if( type.end() != it ) 
      {
        std::string::size_type pos = it - type.begin()   ;
        const std::string ntype( type , 0       , pos               );
        const std::string nname( type , pos + 1 , std::string::npos );
        return tool( ntype , // new type 
                     nname , // new name 
                     Tool , parent , create            ) ;
      }
    // retrieve the tool from Tool Service 
    StatusCode sc = toolSvc () 
      -> retrieveTool ( type , Tool, parent , create   );
    Assert( sc.isSuccess() , "Could not retrieve Tool'" + type + "'" , sc ) ;
    Assert( 0 != Tool      , "Could not retrieve Tool'" + type + "'"      ) ;
    // debug printout 
    Print( " The Tool of type '" + Tool->type() + 
           "'/'"                 + Tool->name() + 
           "' is retrieved from IToolSvc " , MSG::DEBUG , sc ) ;
    // return located tool 
    return Tool ;
  };

  StatusCode Error     
  ( const std::string& Message                       , 
    const StatusCode& status   = StatusCode::FAILURE , 
    const size_t      mx       = 10                  ) const ;
  
  StatusCode Warning     
  ( const std::string& Message                       , 
    const StatusCode&  status  = StatusCode::FAILURE , 
    const size_t       mx      = 10                  ) const ;
  
  StatusCode Print
  ( const std::string& Message                       , 
    const StatusCode & Status  = StatusCode::SUCCESS ,
    const MSG::Level & level   = MSG::INFO           ) const  ;
    
  StatusCode Exception 
  ( const std::string    & msg                       ,   
    const GaudiException & exc                       , 
    const MSG::Level     & lvl = MSG::FATAL          ,
    const StatusCode     & sc  = StatusCode::FAILURE ) const ;
  
  StatusCode Exception 
  ( const std::string    & msg                       ,  
    const std::exception & exc                       , 
    const MSG::Level     & lvl = MSG::FATAL          ,
    const StatusCode     & sc  = StatusCode::FAILURE ) const ;
  
  StatusCode Exception 
  ( const std::string    & msg                       ,  
    const MSG::Level     & lvl = MSG::FATAL          ,
    const StatusCode     & sc  = StatusCode::FAILURE ) const ;
  
  inline StatusCode Assert
  ( bool  assertion                                  , 
    const std::string& msg = "GiGaCnvBase::unknown"  , 
    const StatusCode&  sc  = StatusCode::FAILURE     ) const ;
  
  inline StatusCode Assert
  ( bool  assertion                              ,
    const char*        msg                       ,
    const StatusCode&  sc  = StatusCode::FAILURE ) const ;
  

  inline const std::string&  name     () const { return m_ConverterName; } 

  inline void setNameOfGiGaConversionService
  ( const std::string& CnvSvc ) 
  { m_NameOfGiGaConversionService = CnvSvc ; }                     
  
  void setConverterName 
  ( const std::string& ConverterName ) 
  { m_ConverterName  = ConverterName ; } 
  
  StatusCode declareObject ( const GiGaLeaf&   leaf );
protected: 
  std::string           m_NameOfGiGaConversionService ; 
  std::string           m_ConverterName               ;
  Leaves                m_leaves                      ;
private:
  IGiGaCnvSvc*          m_GiGaCnvSvc                  ; 
  IGiGaGeomCnvSvc*      m_GiGaGeomCnvSvc              ; 
  IGiGaKineCnvSvc*      m_GiGaKineCnvSvc              ; 
  IGiGaHitsCnvSvc*      m_GiGaHitsCnvSvc              ; 
  IDataProviderSvc*     m_evtSvc                      ; 
  IDataProviderSvc*     m_detSvc                      ; 
  IChronoStatSvc*       m_chronoSvc                   ; 
  IToolSvc*             m_toolSvc                     ; 
  CLID                  m_local ;
  typedef std::map<std::string,unsigned int> Counter;
  mutable Counter m_errors     ;
  mutable Counter m_warnings   ; 
  mutable Counter m_exceptions ;
  
  
};

// ============================================================================
// ============================================================================
inline StatusCode  GiGaCnvBase::Assert
( bool               assertion , 
  const std::string& msg       , 
  const StatusCode&  sc        ) const 
{  
  StatusCode status = StatusCode::SUCCESS ;
  return (assertion) ? status : Exception( msg , MSG::FATAL , sc ) ;
};
// ============================================================================

// ============================================================================
// ============================================================================
inline StatusCode  GiGaCnvBase::Assert
( bool               assertion , 
  const char*        msg       , 
  const StatusCode&  sc        ) const 
{ 
  StatusCode status = StatusCode::SUCCESS ;
  return (assertion) ? status : Exception( msg , MSG::FATAL , sc ) ;
};
// ============================================================================

// ============================================================================
// End 
// ============================================================================
#endif    //      GIGA_GIGACNVBASE_H 
// ============================================================================

---