In This Package:

GiGaCnvSvcBase.h

Go to the documentation of this file.

// $Id: GiGaCnvSvcBase.h,v 1.15 2008/05/30 13:13:17 gcorti Exp $ 
#ifndef      GIGA_GIGACNVSVCBASE_H 
#define      GIGA_GIGACNVSVCBASE_H  1 

// Include files
// from STL 
#include <string> 
#include <vector> 
#include <exception> 
#include <map> 
// from Gaudi - base class and interafces 
#include "GaudiKernel/IIncidentListener.h" 
#include "GaudiKernel/IDataProviderSvc.h" 
#include "GaudiKernel/IToolSvc.h" 
#include "GaudiKernel/System.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/ConversionSvc.h"
// from GiGa 
#include "GiGaCnv/IGiGaCnvSvc.h" 
#include "GiGaCnv/GiGaLeaf.h" 
#include "GiGa/IGiGaSvc.h"
#include "GiGa/IGiGaSetUpSvc.h"
#include "GaudiKernel/GaudiException.h"

// Forward declarations
class IDataProviderSvc     ; 
class IParticlePropertySvc ; 
class IMagneticFieldSvc    ; 
class IChronoStatSvc       ; 
class IToolSvc             ; 
class IIncidentSvc         ; 
class ISvcLocator          ;
//class GaudiException       ;


class GiGaCnvSvcBase: virtual public  IGiGaCnvSvc       ,
                      virtual public  IIncidentListener ,       
                      public          ConversionSvc
{
public:

  typedef std::vector<GiGaLeaf> Leaves;

protected:
  
  GiGaCnvSvcBase( const std::string&   ServiceName       , 
                  ISvcLocator*         ServiceLocator    ,
                  const unsigned int   StorageType       ) ;

  virtual ~GiGaCnvSvcBase();

public: 

  virtual StatusCode initialize     (); 

  virtual StatusCode finalize       ();
  virtual StatusCode queryInterface ( const InterfaceID& , void**  );
  virtual StatusCode declareObject  ( const GiGaLeaf& Leaf );
  virtual void       handle         ( const Incident&      );
  virtual IGiGaSvc* gigaSvc   ()  const {
    if( m_gigaSvc == 0 ) {
      StatusCode status = serviceLocator()->service( m_gigaName, m_gigaSvc, 
                                                     true );
      if( status.isFailure() ) { 
        //FIXME Throw exception
        Error("Initialize::Could not locate IGiGaSvc=" + m_gigaName, status );
      }       
      if( 0 == gigaSvc() ) {
        Error("Initialize::Could not locate IGiGaSvc=" + m_gigaName );
      }
      Print( " Located GiGa Service="+m_gigaName, MSG::VERBOSE ); 
    } 
    return m_gigaSvc; 
  }  
  
  virtual IGiGaSetUpSvc*    setupSvc  ()  const {
    
    if( m_setupSvc == 0 ) {
      StatusCode status = serviceLocator()->service( m_setupName, m_setupSvc, 
                                                     true );
      if( status.isFailure() ){ 
        Error("Initialize::Could not locate IGiGaSetUpSvc=" + 
              m_setupName, status );
      }      
      if( 0 == setupSvc() ) { 
        Error("Initialize::Could not locate IGiGaSetUpSvc=" + 
              m_setupName );
      }
      Print( " Located GiGa SetUp Service="+m_setupName, MSG::VERBOSE ); 
    } 
    return m_setupSvc;
  } 
  
  virtual StatusCode registerGiGaLeaves() ;
  
  virtual StatusCode createAddress
  ( long                  svc_type ,
    const CLID&           clid     ,
    const std::string*    par      , 
    const unsigned long*  ip       ,
    IOpaqueAddress*&      address  ) ;
  
protected:
  inline IDataProviderSvc* dpSvc     ()  const { return m_dpSvc       ; }  
  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 IIncidentSvc*     incSvc    ()  const { return m_incSvc      ; } 
  inline ISvcLocator*      svcLoc    ()  const { return serviceLocator() ; } 
  StatusCode    setNameOfDataProviderSvc( const std::string& Name ) 
  { m_dpName = Name ; return StatusCode::SUCCESS ; } 
//   StatusCode locateOwnCnvs();

  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 "     , 
           MSG::DEBUG     ,     StatusCode::SUCCESS  ) ;
    Print( " [ The actual data type is '" + type     + 
           "' ] "                         ,
           MSG::VERBOSE   ,     StatusCode::SUCCESS  ) ;
    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    & msg                       ,  
    const StatusCode     & sc  = StatusCode::FAILURE ) const ;

  StatusCode Warning   
  ( const std::string    & msg                       ,  
    const StatusCode     & sc  = StatusCode::FAILURE ) const ;
  
  StatusCode Print     
  ( const std::string    & msg                       ,  
    const MSG::Level     & lvl = MSG::INFO           ,
    const StatusCode     & sc  = StatusCode::FAILURE ) const ;
  
  inline StatusCode Assert
  ( bool  assertion                                    , 
    const std::string& msg = "GiGaCnvSvcBase::unknown" , 
    const StatusCode&  sc  = StatusCode::FAILURE       ) const ;
  
  inline StatusCode Assert
  ( bool  assertion                              ,
    const char*        msg                       ,
    const StatusCode&  sc  = StatusCode::FAILURE ) 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 ;
private: 
  GiGaCnvSvcBase() ; 
  GiGaCnvSvcBase           ( const GiGaCnvSvcBase& ) ; //< no copy
  GiGaCnvSvcBase& operator=( const GiGaCnvSvcBase& ) ; //< no assignment 
protected:
  Leaves                               m_leaves     ; 
private: 
  std::string                          m_dpName     ; 
  IDataProviderSvc*                    m_dpSvc      ; 
  std::string                          m_evtName    ; 
  IDataProviderSvc*                    m_evtSvc     ; 
  std::string                          m_detName    ; 
  IDataProviderSvc*                    m_detSvc     ; 
  std::string                          m_gigaName   ; 
  mutable IGiGaSvc*                    m_gigaSvc    ; 
  std::string                          m_setupName  ; 
  mutable IGiGaSetUpSvc*               m_setupSvc   ; 
  std::string                          m_chronoName ; 
  IChronoStatSvc*                      m_chronoSvc  ;
  std::string                          m_toolName   ; 
  IToolSvc*                            m_toolSvc    ;
  std::string                          m_inName     ; 
  IIncidentSvc*                        m_incSvc     ;
  typedef std::map<std::string,unsigned int> Counter;
  mutable Counter m_errors     ;
  mutable Counter m_warnings   ; 
  mutable Counter m_exceptions ;
};        

// ============================================================================
// ============================================================================
inline StatusCode  GiGaCnvSvcBase::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  GiGaCnvSvcBase::Assert
( bool               assertion , 
  const char*        msg       , 
  const StatusCode&  sc        ) const 
{ 
  StatusCode status = StatusCode::SUCCESS ;
  return (assertion) ? status : Exception( msg , MSG::FATAL , sc ) ;
};
// ============================================================================

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

---