BitFieldCoder.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
//==========================================================================
 
#ifndef DDSEGMENTATION_BITFIELDCODER_H
#define DDSEGMENTATION_BITFIELDCODER_H 1
 
#include <map>
#include <string>
#include <vector>
#include <sstream>
#include <cstdint>
 
namespace dd4hep {
 
  namespace DDSegmentation {
 
    typedef int64_t  FieldID;
    typedef uint64_t CellID;
    typedef uint64_t VolumeID;
 
    class StringTokenizer ; 
 
    class BitFieldElement   {
  
    public :
      BitFieldElement() = default ;
      BitFieldElement(const BitFieldElement&) = default ;
      BitFieldElement(BitFieldElement&&) = default ;
 
      BitFieldElement( const std::string& name, unsigned offset, int signedWidth ) ; 
      ~BitFieldElement() = default ;
 
      BitFieldElement& operator=(const BitFieldElement&) = default ;
 
      FieldID value(CellID bitfield) const;
 
      // assign the given value to the bit field
      void set(CellID& bitfield, FieldID value) const ;
 
      const std::string& name() const { return _name ; }
 
      unsigned offset() const { return _offset ; }
 
      unsigned width() const  { return _width ; }
 
      bool isSigned() const   { return _isSigned ; }
 
      CellID mask() const     { return _mask ; }
 
      int  minValue()  const  { return _minVal;  }
 
      int  maxValue()  const  { return _maxVal;  }
 
    protected:
  
      CellID _mask      {};
      unsigned _offset  {};
      unsigned _width   {};
      int _minVal       {};
      int _maxVal       {};
      bool _isSigned    {};
      std::string _name;
    };
 
 
  
 
    class BitFieldCoder{
    public :
      typedef std::map<std::string, unsigned int> IndexMap ;
 
    public :
      BitFieldCoder() = default ;
      BitFieldCoder(const BitFieldCoder&) = default ;
      BitFieldCoder(BitFieldCoder&&) = default ;
      ~BitFieldCoder() = default ;
 
      BitFieldCoder& operator=(const BitFieldCoder&) = default ;
    
      BitFieldCoder( const std::string& initString ) : _joined(0){
        init( initString ) ;
      }
 
      static CellID toLong(unsigned low_Word, unsigned high_Word ) {
        return (  ( low_Word & 0xffffffffULL ) |  ( ( high_Word & 0xffffffffULL ) << 32 ) ) ; 
      }
    
      static unsigned lowWord(CellID bitfield)  { return unsigned( bitfield &  0xffffFFFFUL ); } 
 
      static unsigned highWord(CellID bitfield) { return unsigned( bitfield >> 32); }
 
      FieldID get(CellID bitfield, size_t idx) const { 
        return _fields.at(idx).value( bitfield )  ;
      }
    
      FieldID get(CellID bitfield, const std::string& name) const {
        return _fields.at( index( name ) ).value( bitfield ) ;
      }
 
      void set(CellID& bitfield, size_t idx, FieldID value) const { 
        _fields.at(idx).set( bitfield , value )  ;
      }
    
      void set(CellID& bitfield, const std::string& name, FieldID value) const {
        _fields.at( index( name ) ).set( bitfield, value ) ;
      }
 
      unsigned highestBit() const ;
 
      size_t size() const { return _fields.size() ; }
 
      size_t index( const std::string& name) const ;
 
      const BitFieldElement& operator[](const std::string& name) const { 
        return _fields[ index( name ) ] ;
      }
 
      const BitFieldElement& operator[](unsigned idx) const { 
        return _fields[ idx ] ;
      }
 
      std::string fieldDescription() const ;
 
      std::string valueString(CellID bitfield) const ;
 
      const std::vector<BitFieldElement>& fields()  const  {
        return _fields;
      }
    
      CellID mask() const { return _joined ; }
 
    protected:
 
      void addField( const std::string& name,  unsigned offset, int width ); 
 
      void init( const std::string& initString) ;
 
    protected:
      // -------------- data members:--------------
      std::vector<BitFieldElement> _fields{} ;
      IndexMap  _map{} ;
      CellID    _joined{} ;
    };
 
 
 
    class StringTokenizer{
      std::vector< std::string >& _tokens ;
      char _del ;
      char _last ;
 
    public:
    
      StringTokenizer( 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.emplace_back("") ; 
          }
          _tokens.back() += c ;
        }
        _last = c ;
      } 
    };
 
  } // end namespace
} // end namespace
#endif