BitField64.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_BITFIELD64_H
#define DDSEGMENTATION_BITFIELD64_H 1
 
#include <ostream>
 
#include <string>
 
#include <DDSegmentation/BitFieldCoder.h>
 
namespace dd4hep {
  
  namespace DDSegmentation {
    
 
    class BitFieldValue{
 
      CellID& _value ;
      const BitFieldElement& _bv ;
    
    public :
    
      BitFieldValue() = delete ;
    
      BitFieldValue( CellID& bitfield, const BitFieldElement& bv ) :
        _value( bitfield ), _bv( bv) {}
    
      FieldID value() const { return _bv.value( _value ) ; }
  
      FieldID value(CellID id) const { return _bv.value( id ) ; }
 
      BitFieldValue& operator=(FieldID in) {
        _bv.set( _value, in ) ;
        return *this ;
      } 
    
      operator FieldID() const { return value() ; } 
    
      const std::string& name() const { return _bv.name() ; }
 
      unsigned offset() const { return _bv.offset() ; }
 
      unsigned width() const  { return _bv.width() ; }
 
      bool isSigned() const   { return _bv.isSigned() ; }
 
      CellID mask() const     { return _bv.mask() ; }
 
      int  minValue()  const  { return _bv.minValue();  }
 
      int  maxValue()  const  { return _bv.maxValue();  }
 
    } ;
    
  
 
    class BitField64{
      
      friend std::ostream& operator<<(std::ostream& os, const BitField64& b) ;
 
    public :
 
      virtual ~BitField64() {
        if( _owner)
          delete _coder ;
      }; 
 
      BitField64() = delete ;
 
      BitField64( const std::string& initString ){
        _coder = new BitFieldCoder( initString ) ;
      }
 
      BitField64( const BitFieldCoder* coder ) : _owner(false), _coder( coder ) {
      }
 
 
      CellID getValue() const { return _value ; }
    
      void  setValue(CellID value ) { _value = ( _coder->mask() & value ) ; }
 
      void  setValue(unsigned low_Word, unsigned high_Word ) {
        setValue( ( low_Word & 0xffffffffULL ) |  ( ( high_Word & 0xffffffffULL ) << 32 ) ) ; 
      }
    
      BitField64& operator()(CellID val) { setValue( val ) ; return *this ; }
 
      void  reset() { _value = 0 ; }
 
      BitFieldValue operator[](size_t idx) {
        return BitFieldValue( _value,  _coder->operator[]( idx  ) ) ; 
      }
    
      // /** Const acces to field through index 
      //  */
      // const BitFieldValue& operator[](size_t idx) const { 
      
      //   return BitFieldValue( _value,  _coder->operator[]( idx  ) ) ; 
      // }
 
      unsigned highestBit() const { return _coder->highestBit() ; }
    
      size_t size() const { return _coder->size() ; }
 
      size_t index( const std::string& name) const { return _coder->index( name ) ; } 
 
      BitFieldValue operator[](const std::string& name) { 
        return BitFieldValue( _value,  _coder->operator[]( name ) ) ; 
      }
      // /** Const Access to field through name .
      //  */
      // const BitFieldValue& operator[](const std::string& name) const { 
 
      //   return BitFieldValue( _value,  _coder->operator[]( name )  ); 
      // }
 
 
      unsigned lowWord() const { return unsigned( _value &  0xffffFFFFUL )  ; } 
 
      unsigned highWord() const { return unsigned(_value >> 32) ; } 
 
 
      std::string fieldDescription() const { return _coder->fieldDescription() ; }
 
      std::string valueString() const ;
 
      // const std::vector<BitFieldValue*>& fields()  const  {
      //   return _coder->fields() ;
      // }
    
    protected:
 
      // -------------- data members:--------------
      bool      _owner{true} ;
      CellID    _value{} ;
      const BitFieldCoder* _coder{} ;
    
    };
  
  
    std::ostream& operator<<(std::ostream& os, const BitField64& b) ;
  
  
  
  } // end namespace
 
  using DDSegmentation::BitField64 ;
} // end namespace
 
#endif