BitField64.h

Go to the documentation of this file.

#ifndef UTIL_BitField64_H
#define UTIL_BitField64_H 1

#include <iostream>

#include <string>
#include <vector>
#include <map>
#include <sstream>

#include "lcio.h"
#include "LCIOTypes.h"

namespace UTIL {
  
  class LCTokenizer{
    
    std::vector< std::string >& _tokens ;
    char _del ;
    char _last ;

  public:
    
    LCTokenizer( std::vector< std::string >& tokens, char del ) 
      : _tokens(tokens) 
    , _del(del), 
    _last(del) {
    }
    
    void operator()(const char& c) { 
      
      if( c != _del  ) {
    
    if( _last == _del  ) {
      _tokens.push_back("") ; 
    }
    _tokens.back() += c ;
      }
      _last = c ;
    } 
    
  };


  class BitFieldValue{
  
  public :
    virtual ~BitFieldValue() {}
  
    BitFieldValue( lcio::long64& bitfield, const std::string& name, 
           unsigned offset, int signedWidth ) ; 


    lcio::long64 value() const ;
  
    BitFieldValue& operator=(lcio::long64 in) ;

    operator lcio::long64() const { return value() ; } 
    
    //     operator int() const { return (int) value() ; } 
    
    const std::string& name() const { return _name ; }

    unsigned offset() const { return _offset ; }

    unsigned width() const { return _width ; }

    bool isSigned() const { return _isSigned ; }

    lcio::ulong64 mask() const { return _mask ; }


  protected:
  
    lcio::long64& _b  ;
    lcio::ulong64 _mask{0} ;
    std::string _name ;
    unsigned _offset{0} ;
    unsigned _width{0} ;
    int _minVal{0} ;
    int _maxVal{0} ;
    bool _isSigned{false} ;

  };

  class BitField64{

    friend std::ostream& operator<<(std::ostream& os, const BitField64& b) ;

  public :

    typedef std::map<std::string, unsigned int> IndexMap ;


    ~BitField64() {  // clean up
      for(unsigned i=0;i<_fields.size();i++){
    delete _fields[i] ;
      }
    }
  
    BitField64( const std::string& initString ) : _value(0), _joined(0){
    
      init( initString ) ;
    }

    lcio::long64 getValue() const { return _value ; }
    
    void  setValue(lcio::long64 value ) { _value = value ; }
    
    void  reset() { _value = 0 ; }

    BitFieldValue& operator[](size_t theIndex) { 
      return *_fields.at( theIndex )  ; 
    }
    
    const BitFieldValue& operator[](size_t theIndex) const { 
      return *_fields.at( theIndex )  ; 
    }

    unsigned highestBit() const ;
    
    size_t size() const { return _fields.size() ; }

    size_t index( const std::string& name) const ;

    BitFieldValue& operator[](const std::string& name) { 

      return *_fields[ index( name ) ] ;
    }
    const BitFieldValue& operator[](const std::string& name) const { 

      return *_fields[ index( name ) ] ;
    }


    unsigned lowWord() const { return unsigned( _value &  0xffffFFFF )  ; } 

    unsigned highWord() const { return unsigned( _value >> 32  ) ; } 


    std::string fieldDescription() const ;

    std::string valueString() const ;

  protected:

    void addField( const std::string& name,  unsigned offset, int width ); 

    void init( const std::string& initString) ;

    BitField64() : _value(0) , _joined(0) { }


    // -------------- data members:--------------

    std::vector<BitFieldValue*>  _fields{} ;
    lcio::long64 _value ;
    IndexMap _map{} ;
    lcio::long64 _joined ;


  };



  std::ostream& operator<<(std::ostream& os, const BitField64& b) ;


} // end namespace

#endif