gar::geo::BitFieldCoder Class Reference

Helper class for decoding and encoding a bit field of 64bits for convenient declaration. More...

#include <BitFieldCoder.h>

Public Types
typedef std::map< std::string, unsigned int >	IndexMap

Public Member Functions
	BitFieldCoder ()=default
	Default constructor. More...
	BitFieldCoder (const BitFieldCoder &)=default
	Copy constructor. More...
	BitFieldCoder (BitFieldCoder &&)=default
	Move constructor. More...
	~BitFieldCoder ()=default
	Default destructor. More...
BitFieldCoder &	operator= (const BitFieldCoder &)=default
	Assignment operator. More...
	BitFieldCoder (const std::string &initString)
long64	get (long64 bitfield, size_t index) const
long64	get (long64 bitfield, const std::string &name) const
void	set (long64 &bitfield, size_t index, ulong64 value) const
void	set (long64 &bitfield, const std::string &name, ulong64 value) const
unsigned	highestBit () const
size_t	size () const
size_t	index (const std::string &name) const
const BitFieldValue &	operator[] (const std::string &name) const
const BitFieldValue &	operator[] (unsigned index) const
std::string	fieldDescription () const
std::string	valueString (ulong64 bitfield) const
const std::vector< BitFieldValue > &	fields () const
ulong64	mask () const

Static Public Member Functions
static long64	toLong (unsigned low_Word, unsigned high_Word)
static unsigned	lowWord (long64 bitfield)
static unsigned	highWord (long64 bitfield)

Protected Member Functions
void	addField (const std::string &name, unsigned offset, int width)
void	init (const std::string &initString)

Protected Attributes
std::vector< BitFieldValue >	_fields {}
IndexMap	_map {}
long64	_joined {}

Detailed Description

Helper class for decoding and encoding a bit field of 64bits for convenient declaration.

and manipulation of sub fields of various widths.
This is a thread safe re-implementation of the functionality in the deprected BitField64.

Example:
BitFieldCoder bc("layer:7,system:-3,barrel:3,theta:32:11,phi:11" ) ;
bc.set( field, "layer" , 123 );
bc.set( field, "system" , -4 );
bc.set( field, "barrel" , 7 );
bc.set( field, "theta" , 180 );
bc.set( field, "phi" , 270 );
...
int theta = bc.get( field, "theta" ) ;
...
unsigned phiIndex = bc.index("phi") ;
int phi = bc.get( field, phiIndex ) ;

Author

F.Gaede, DESY

Date

2017-09

Definition at line 130 of file BitFieldCoder.h.

Member Typedef Documentation

typedef std::map<std::string, unsigned int> gar::geo::BitFieldCoder::IndexMap

Definition at line 134 of file BitFieldCoder.h.

Constructor & Destructor Documentation

gar::geo::BitFieldCoder::BitFieldCoder ( )

default

Default constructor.

gar::geo::BitFieldCoder::BitFieldCoder ( const BitFieldCoder &  )

default

Copy constructor.

gar::geo::BitFieldCoder::BitFieldCoder ( BitFieldCoder &&  )

default

Move constructor.

gar::geo::BitFieldCoder::~BitFieldCoder ( )

default

Default destructor.

gar::geo::BitFieldCoder::BitFieldCoder ( const std::string &  initString )

inline

The c'tor takes an initialization string of the form:
<fieldDesc>[,<fieldDesc>...]
fieldDesc = name:[start]:[-]length
where:
name: The name of the field
start: The start bit of the field. If omitted assumed to start immediately following previous field, or at the least significant bit if the first field.
length: The number of bits in the field. If preceeded by '-' the field is signed, otherwise unsigned.
Bit numbering is from the least significant bit (bit 0) to the most significant (bit 63).
Example: "layer:7,system:-3,barrel:3,theta:32:11,phi:11"

Definition at line 162 of file BitFieldCoder.h.

                                                             : _joined(0)
                {
                    init( initString ) ;
                }

Member Function Documentation

void gar::geo::BitFieldCoder::addField ( const std::string &  name, unsigned  offset, int  width  )

protected

Add an additional field to the list

Definition at line 141 of file BitFieldCoder.cxx.

                                                                                        {


            _fields.push_back( BitFieldValue( name, offset, width ) ) ;

            BitFieldValue& bfv = _fields.back() ;

            _map[ name ] = _fields.size()-1 ;

            if( _joined & bfv.mask()  ) {

                std::stringstream s ;
                s << " BitFieldValue::addField(" << name << "): bits already used " << std::hex << _joined
                << " for mask " <<  bfv.mask() ;

                throw( std::runtime_error( s.str() ) ) ;

            }

            _joined |= bfv.mask() ;

        }

std::string gar::geo::BitFieldCoder::fieldDescription

(

)

const

Return a valid description string of all fields

Definition at line 119 of file BitFieldCoder.cxx.

                                                        {

            std::stringstream  os ;

            for(unsigned i=0;i<_fields.size();i++){

                if( i != 0 )   os << "," ;

                os << _fields[i].name() <<  ":"
                << _fields[i].offset() << ":" ;

                if(  _fields[i].isSigned()  )
                os << "-" ;

                os  << _fields[i].width() ;

            }

            return os.str() ;
        }

const std::vector<BitFieldValue>& gar::geo::BitFieldCoder::fields ( ) const

inline

Definition at line 223 of file BitFieldCoder.h.

{ return _fields;}

long64 gar::geo::BitFieldCoder::get ( long64  bitfield, size_t  index  ) const

inline

get value of sub-field specified by index

Definition at line 181 of file BitFieldCoder.h.

{ return _fields.at(index).value( bitfield ); }

long64 gar::geo::BitFieldCoder::get ( long64  bitfield, const std::string &  name  ) const

inline

Access to field through name .

Definition at line 185 of file BitFieldCoder.h.

{ return _fields.at( index( name ) ).value( bitfield ); }

unsigned gar::geo::BitFieldCoder::highestBit

(

)

const

Highest bit used in fields [0-63]

Definition at line 91 of file BitFieldCoder.cxx.

                                                 {

            unsigned hb(0) ;

            for(unsigned i=0;i<_fields.size();i++){

                if( hb < ( _fields[i].offset() + _fields[i].width() ) )
                hb = _fields[i].offset() + _fields[i].width()  ;
            }
            return hb ;
        }

static unsigned gar::geo::BitFieldCoder::highWord ( long64  bitfield )

inlinestatic

The high word, bits 32-63

Definition at line 177 of file BitFieldCoder.h.

{ return unsigned( bitfield >> 32); }

size_t gar::geo::BitFieldCoder::index

(

const std::string &

name

)

const

Index for field named 'name'

Definition at line 78 of file BitFieldCoder.cxx.

                                                                {

            IndexMap::const_iterator it = _map.find( name ) ;

            if( it != _map.end() )

            return it->second  ;

            else
            throw std::runtime_error(" BitFieldValue: unknown name: " + name ) ;
        }

void gar::geo::BitFieldCoder::init ( const std::string &  initString )

protected

Decode the initialization string as described in the constructor.

See also

BitFieldCoder( const std::string& initString )

Definition at line 165 of file BitFieldCoder.cxx.

                                                             {

            unsigned offset = 0  ;

            // need to compute bit field masks and offsets ...
            std::vector<std::string> fieldDescriptors ;
            Tokenizer t( fieldDescriptors ,',') ;

            std::for_each( initString.begin(), initString.end(), t ) ;

            for(unsigned i=0; i< fieldDescriptors.size() ; i++ ){

                std::vector<std::string> subfields ;
                Tokenizer ts( subfields ,':') ;

                std::for_each( fieldDescriptors[i].begin(), fieldDescriptors[i].end(), ts );

                std::string name ;
                int  width ;
                unsigned thisOffset ;

                switch( subfields.size() ){

                case 2:

                    name = subfields[0] ;
                    width = atol( subfields[1].c_str()  ) ;
                    thisOffset = offset ;

                    offset += abs( width ) ;

                    break ;

                case 3:
                    name = subfields[0] ;
                    thisOffset = atol( subfields[1].c_str()  ) ;
                    width = atol( subfields[2].c_str()  ) ;

                    offset = thisOffset + abs( width ) ;

                    break ;

                default:

                    std::stringstream s ;
                    s << " BitFieldCoder: invalid number of subfields "
                    <<  fieldDescriptors[i] ;

                    throw( std::runtime_error( s.str() ) ) ;
                }

                addField( name , thisOffset, width ) ;
            }
        }

static unsigned gar::geo::BitFieldCoder::lowWord ( long64  bitfield )

inlinestatic

The low word, bits 0-31

Definition at line 173 of file BitFieldCoder.h.

{ return unsigned( bitfield &  0xffffFFFFUL ); }

ulong64 gar::geo::BitFieldCoder::mask ( ) const

inline

the mask of all the bits used in the description

Definition at line 226 of file BitFieldCoder.h.

{ return _joined ; }

BitFieldCoder& gar::geo::BitFieldCoder::operator= ( const BitFieldCoder &  )

default

Assignment operator.

const BitFieldValue& gar::geo::BitFieldCoder::operator[] ( const std::string &  name ) const

inline

Const Access to field through name .

Definition at line 209 of file BitFieldCoder.h.

{ return _fields[ index( name ) ] ;}

const BitFieldValue& gar::geo::BitFieldCoder::operator[] ( unsigned  index ) const

inline

Const Access to field through index .

Definition at line 213 of file BitFieldCoder.h.

{ return _fields[ index ] ;}

void gar::geo::BitFieldCoder::set ( long64 &  bitfield, size_t  index, ulong64  value  ) const

inline

set value of sub-field specified by index

Definition at line 189 of file BitFieldCoder.h.

{ _fields.at(index).set( bitfield , value ); }

void gar::geo::BitFieldCoder::set ( long64 &  bitfield, const std::string &  name, ulong64  value  ) const

inline

Access to field through name .

Definition at line 193 of file BitFieldCoder.h.

{ _fields.at( index( name ) ).set( bitfield, value ); }

size_t gar::geo::BitFieldCoder::size ( ) const

inline

Number of values

Definition at line 201 of file BitFieldCoder.h.

{ return _fields.size() ; }

static long64 gar::geo::BitFieldCoder::toLong ( unsigned  low_Word, unsigned  high_Word  )

inlinestatic

return a new 64bit value given as high and low 32bit words.

Definition at line 169 of file BitFieldCoder.h.

{ return (  ( low_Word & 0xffffffffULL ) |  ( ( high_Word & 0xffffffffULL ) << 32 ) ); }

std::string gar::geo::BitFieldCoder::valueString

(

ulong64

bitfield

)

const

Return a string with a comma separated list of the current sub field values

Definition at line 104 of file BitFieldCoder.cxx.

                                                                   {

            std::stringstream  os ;

            for(unsigned i=0;i<_fields.size();i++){

                if( i != 0 )   os << "," ;

                os << _fields[i].name() <<  ":" << _fields[i].value(bitfield) ;

            }
            return os.str() ;
        }

Member Data Documentation

std::vector<BitFieldValue> gar::geo::BitFieldCoder::_fields {}

protected

Definition at line 243 of file BitFieldCoder.h.

long64 gar::geo::BitFieldCoder::_joined {}

protected

Definition at line 245 of file BitFieldCoder.h.

IndexMap gar::geo::BitFieldCoder::_map {}

protected

Definition at line 244 of file BitFieldCoder.h.

---

The documentation for this class was generated from the following files:

• garsoft/Geometry/BitFieldCoder.h
• garsoft/Geometry/BitFieldCoder.cxx