CellIDDecoder.h

#ifndef CellIDDecoder_h
#define CellIDDecoder_h 1

//#include <vector>
//#include "EVENT/LCObject.h"
#include "EVENT/LCCollection.h"
//#include "EVENT/SimTrackerHit.h"
#include "UTIL/BitField64.h"
#include "lcio.h"
#include <string>

// fixes problem in gcc 4.0.3
#include "EVENT/LCParameters.h"

//#include <sstream>
//#include <typeinfo>

using namespace lcio ;

namespace UTIL{


  template <class T> 
  class CellIDDecoder {
    
  public:  

  CellIDDecoder( const std::string& encoder_str ) : _oldHit(0) {
      
      if( encoder_str.length() == 0 ){
        throw( lcio::Exception( "CellIDDecoder : string of length zero provided as encoder string" ) ) ;
      }
      _b = new BitField64( encoder_str ) ; 
      
    }
    
    CellIDDecoder( const EVENT::LCCollection* col ) : _oldHit(0) {
      
      std::string initString("") ; 

      if( col !=0 ) 
        initString = col->getParameters().getStringVal(  lcio::LCIO::CellIDEncoding ) ;
      
      if( initString.size() == 0 ) {
        
        initString = *_defaultEncoding ;

        std::cout << "    ----------------------------------------- " << std::endl  
                  << "       WARNING: CellIDDecoder - no CellIDEncoding parameter in collection ! " 
                  << std::endl 
                  << "         -> using default : \"" << initString << "\"" 
                  << std::endl 
                  << "    ------------------------------------------ "  
                  << std::endl ;
      }
      
      _b = new BitField64(  initString ) ; 
    }
    
    ~CellIDDecoder(){ 
      
      delete _b ;
    } 
    
    
    inline const BitField64 & operator()( const T* hit ){  
      
      if( hit != _oldHit && hit ) {
        

        lcio::long64 val = lcio::long64( hit->getCellID0() & 0xffffffff ) 
          |        ( lcio::long64( hit->getCellID1() ) << 32      ) ;
        
        _b->setValue( val ) ;

        _oldHit = hit ;
      }
      
      return  *_b ;
    }
    

    static void setDefaultEncoding(const std::string& defaultEncoding ) {
      
      delete _defaultEncoding ;
      
      _defaultEncoding = new std::string( defaultEncoding ) ;
    }
    
  protected:
    BitField64* _b ;
    const T* _oldHit ;
    
    static std::string*  _defaultEncoding ;
  } ; 
  
  template <class T>
  std::string* CellIDDecoder<T>::_defaultEncoding 
  = new std::string("byte0:8,byte1:8,byte2:8,byte3:8,byte4:8,byte5:8,byte6:8,byte7:8") ;

  

//  /** Provides access to the bit fields, e.g. <br>
//   *   int layer =  myCellIDEncoding( hit )[ "layer" ] ;
//   * Specialization for SimTrackerHits that have only one cellID.
//   */
//  template<>
//  inline const BitField64 & CellIDDecoder<SimTrackerHit>::operator()(const SimTrackerHit* hit ){  
//    
//    if( hit != _oldHit && hit ) {
//      
//      long64 val = long64( hit->getCellID() & 0xffffffff )  ;
//      
//      _b->setValue( val ) ;
//      
//      _oldHit = hit ;
//    }
//    
//    return  *_b ;
//  }
//  
//  
//  template <>
//  std::string* CellIDDecoder<SimTrackerHit>::_defaultEncoding  ;

} // namespace
#endif