GEAR.h

// -*- C++ -*-
#ifndef GEAR_GEAR_H
#define GEAR_GEAR_H 1

#include <map>
#include <vector>
#include <string>
#include <exception> 

#include "gear/GearConfig.h"

// version macros are now defined with cmake
//#define GEAR_MAJOR_VERSION 0
//#define GEAR_MINOR_VERSION 14
//#define GEAR_VERSION_GE( MAJV , MINV )  ( (  GEAR_MAJOR_VERSION  > MAJV ) || ( (GEAR_MAJOR_VERSION==MAJV) && ( GEAR_MINOR_VERSION >= MINV ) ) )

#include "gearimpl/Vectors.h"


namespace gear {


  typedef Vector2D Point2D ;
  typedef Vector3D Point3D ;
  
  typedef std::vector<int> IntVec ;
  typedef std::vector<double> DoubleVec ;
  typedef std::vector<std::string> StringVec ;
  
  
   typedef long long long64 ;
   // FIXME: needs to be only long on 64bit machines ->  flags??


  class Exception : public std::exception {

    
  protected:
    std::string message ;
    
    Exception(){  /*no_op*/ ; } 
    
  public: 
    virtual ~Exception() throw() { /*no_op*/; } 
    
    Exception( const std::string& text ){
      message = "gear::Exception: " + text ;
    }

    virtual const char* what() const  throw() { return  message.c_str() ; } 

  };


  class ParseException : public Exception{
    
  protected:
    ParseException() {  /*no_op*/ ; } 
  public: 
    virtual ~ParseException() throw() { /*no_op*/; } 

    ParseException( std::string text ){
      message = "gear::ParseException: " + text ;
    }
  }; 

  class NotImplementedException : public Exception{

  protected:
    NotImplementedException() {  /*no_op*/ ; } 

  public: 
    NotImplementedException( std::string text ){
      message = "gear::NotImplementedException: " + text ;
    }
    virtual ~NotImplementedException() throw() { /*no_op*/; } 

  }; 

   class UnknownParameterException : public Exception{

  protected:
    UnknownParameterException() {  /*no_op*/ ; } 

  public: 
    UnknownParameterException( std::string text ){
      message = "gear::UnknownParameterException: " + text ;
    }
    virtual ~UnknownParameterException() throw() { /*no_op*/; } 

  }; 

   class OutsideGeometryException : public Exception{

  protected:
    OutsideGeometryException() {  /*no_op*/ ; } 

  public: 
    OutsideGeometryException( std::string text ){
      message = "gear::OutsideGeometryException: " + text ;
    }
    virtual ~OutsideGeometryException() throw() { /*no_op*/; } 

  }; 


  struct SensorID{
    SensorID() : layer(0), side(0), module(0), sensor(0) {}
    int layer ;
    int side ;
    int module ;
    int sensor ;
  } ;
  

}

namespace gear {

// namespace
class GEAR {

public: 
    virtual ~GEAR() { /* nop */; }



  public:
   static const char*  GEARPARAMETERS  ;
   static const char*  TPCPARAMETERS  ;
   static const char*  CALORIMETERPARAMETERS  ;
   static const char*  ZPLANARPARAMETERS  ;
   static const char*  FTDPARAMETERS  ;
   static const char*  SIPLANESPARAMETERS  ;
   static const char*  TRACKERPLANESPARAMETERS  ;


}; // class
} // namespace gear
#endif /* ifndef GEAR_GEAR_H */