Binary_t.h

Go to the documentation of this file.

 
#ifndef __BINARY_T__
#define __BINARY_T__
 
#include "Rtypes.h"
#include "Riostream.h"
#include "TString.h"
 
class Hexa_t;
 
template < class T > class Binary_t {
private:
   UChar_t fNBitsRep;           //number of bits used to represent value
   UChar_t fNBits;              //number of bits used to store value = kBitsPerByte*sizeof(T)
   T fVal;                      //decimal used to store value
 
   TString fDumString;  
   TString fDumString2;  
 
   void init();
 
public:
   Binary_t();
   Binary_t(const T);
   Binary_t(const Char_t*);
   Binary_t(const Binary_t&);
   virtual ~ Binary_t()
   {
   };
   void Set(const T);
   void Set(const Char_t*);
   T Value() const;
   const Char_t* String(UChar_t nbits = 0);
 
   Long64_t Max() const;
 
   void SetBit(UChar_t);
   void SetBit(UChar_t, T);
   void ResetBit(UChar_t);
   Bool_t TestBit(UChar_t);
 
   void WriteSubvalue(const T, UChar_t msb, UChar_t nbits);
   T Subvalue(UChar_t msb, UChar_t nbits);
   Binary_t < T >& operator=(const Binary_t < T >&);
   Binary_t < T >& operator=(const T);
   Binary_t < T >& operator=(const Char_t*);
   operator       Int_t() const
   {
      return (Int_t) Value();
   };
   operator       T() const
   {
      return Value();
   };
   operator       Float_t() const
   {
      return (Float_t) Value();
   };
   operator       Double_t() const
   {
      return (Double_t) Value();
   };
   operator       const char* ()
   {
      return String();
   };
 
   Hexa_t Hexa() const;
 
   void SetNBits(UChar_t nbits)
   {
      fNBitsRep = nbits;
   };
   UChar_t GetNBits() const
   {
      return (fNBitsRep);
   };
 
   Binary_t<T> operator|(const Binary_t<T>& b1);
   Binary_t<T> operator&(const Binary_t<T>& b1);
 
   Bool_t operator==(const Binary_t < T >&);
   Bool_t operator!=(const Binary_t < T >&);
   Bool_t operator!=(const Char_t*);
 
   void Print(Option_t* opt = "") const;
 
   ClassDef(Binary_t, 1)        //a binary number
};
 
 
#include "Riostream.h"
#include "TMath.h"
#include "Hexa_t.h"
#include "TString.h"
 
template < class T > void Binary_t < T >::init()
{
   fNBits = (UChar_t)(kBitsPerByte * sizeof(T));
}
 
template < class T > Binary_t < T >::Binary_t()
{
   fNBitsRep = 0;
   fVal = 0;
   init();
}
 
template < class T > Binary_t < T >::Binary_t(const Binary_t < T >& b)
{
   init();
   fNBitsRep = b.GetNBits();
   fVal = b.Value();
}
 
template < class T > Binary_t < T >::Binary_t(const T val)
{
   fNBitsRep = 0;
   fVal = val;
   init();
}
 
template < class T > Binary_t < T >::Binary_t(const Char_t* val)
{
   Set(val);
   fNBitsRep = 0;
   init();
}
 
template < class T > void Binary_t < T >::Set(const T val)
{
   fVal = val;
}
 
template < class T > T Binary_t < T >::Value() const
{
   return (fVal);
}
 
template < class T > void Binary_t < T >::Set(const Char_t* val)
{
 
   fVal = 0;
   Int_t nbits = (Int_t) strlen(val);
   Int_t ibit = 0;
   Int_t idx_min = nbits - fNBits;
   idx_min = idx_min * (idx_min > 0);
   for (Int_t i = nbits - 1; i >= idx_min; i--) {
      if (val[i] - '0') {       //if a '1' is present here...
         fVal += (T)(1 << ibit);
      }
      ibit++;
   }
}
 
template < class T > const Char_t* Binary_t < T >::String(UChar_t nbits)
{
   UChar_t setbits = 0;
   if (!Value()) {
      fDumString = "0";
      setbits = 1;
   }
   else {
      fDumString = "";
      T cont = Value();
      while (cont) {
         if (cont % 2)
            fDumString.Prepend('1');
         else
            fDumString.Prepend('0');
         setbits++;
         cont /= 2;
      }
   }
   Int_t lzos =
      (nbits ? (Int_t) nbits -
       (Int_t) setbits : (GetNBits() ? (Int_t) GetNBits() -
                          (Int_t) setbits : 0));
   if (lzos > 0) {
      fDumString.Prepend('0', lzos);
   }
   else if (lzos < 0) {
      fDumString.Remove(0, -lzos);
   }
   return fDumString.Data();
}
 
template < class T > Binary_t < T >& Binary_t < T >::operator=(const T val)
{
   Set(val);
   return (*this);
}
 
template < class T > Binary_t < T >& Binary_t <
T >::operator=(const Char_t* val)
{
   Set(val);
   return (*this);
}
 
 
template < class T > Binary_t < T >& Binary_t <
T >::operator=(const Binary_t& val)
{
   Set(val.Value());
   return (*this);
}
 
template <class T> Bool_t Binary_t<T>::operator==(const Binary_t < T >& b2)
{
   return (fVal == b2.fVal);
}
 
template <class T> Bool_t Binary_t<T>::operator!=(const Binary_t < T >& b2)
{
   return (fVal != b2.fVal);
}
 
template <class T> Bool_t Binary_t<T>::operator!=(const Char_t* b2)
{
   Binary_t<T> Bb2(b2);
   return ((*this) != Bb2);
}
 
 
 
template <class T> Binary_t<T> Binary_t<T>::operator|(const Binary_t<T>& b1)
{
   Binary_t<T> tmp(fVal | b1.Value());
   return tmp;
}
 
template <class T> Binary_t<T> Binary_t<T>::operator&(const Binary_t<T>& b1)
{
   Binary_t<T> tmp(fVal & b1.Value());
   return tmp;
}
 
 
template < class T > void Binary_t < T >::SetBit(UChar_t nbit)
{
 
   SETBIT(fVal, nbit);
}
 
template < class T > void Binary_t < T >::SetBit(UChar_t nbit, T val)
{
 
   if (TESTBIT(val, nbit))
      SetBit(nbit);
   else
      ResetBit(nbit);
}
 
template < class T > void Binary_t < T >::ResetBit(UChar_t nbit)
{
 
   CLRBIT(fVal, nbit);
}
 
template < class T > Bool_t Binary_t < T >::TestBit(UChar_t nbit)
{
 
   return TESTBIT(fVal, nbit);
}
 
template < class T > Hexa_t Binary_t < T >::Hexa() const
{
   return Hexa_t((Long64_t) Value());
}
 
template < class T > void Binary_t < T >::WriteSubvalue(const T val,
      UChar_t msb,
      UChar_t nbits)
{
 
   Int_t _fNBits, _msb, _nbits;
   _fNBits = (Int_t) fNBits;
   _msb = (Int_t) msb;
   _nbits = (Int_t) nbits;
   if (_nbits < 1 || _nbits > _fNBits || _msb > (_fNBits - 1)
         || (_msb - _nbits + 1) < 0) {
      std::cout << "Error in <Binary_t<T>::WriteSubvalue> : ";
      if (_nbits < 1)
         std::cout << "nbits<1";
      if (_nbits > _fNBits)
         std::cout << "nbits(" << _nbits << ")>fNBits(" << _fNBits << ")";
      if (_msb > (_fNBits - 1))
         std::cout << "msb(" << _msb << ") > fNBits-1(" << _fNBits - 1 << ")";
      if ((_msb - _nbits + 1) < 0)
         std::cout << "(msb-nbits+1) < 0 : msb=" << _msb << " nbits=" << _nbits;
      std::cout << std::endl;
      return;
   }
   Binary_t < T > tmp(val);
   String(fNBits); //NB result is in fDumString !!
   fDumString.Replace((_fNBits - _msb - 1), nbits, tmp.String(nbits));
   Set(fDumString.Data());
}
 
template < class T > void Binary_t < T >::Print(Option_t*) const
{
   std::cout << "Binary number : " << const_cast<Binary_t<T>*>(this)->String() << " : fNBits=" << (int) fNBits
             << " fNBitsRep=" << (int) fNBitsRep << " fVal=" << (Long64_t)
             Value() << std::endl;
}
 
template < class T > T Binary_t < T >::Subvalue(UChar_t firstbit,
      UChar_t nbits)
{
 
   Int_t _firstbit, _nbits;
   _firstbit = (Int_t) firstbit;
   _nbits = (Int_t) nbits;
   _nbits = ((_firstbit - _nbits + 1) < 0 ? _firstbit + 1 : _nbits);
 
   String(_firstbit + 1); //result is in fDumString!!
   fDumString2 = fDumString(0, _nbits);
 
   Binary_t < T > tmp;
   tmp.Set(fDumString2.Data());
   return (tmp.Value());
}
 
template < class T > Long64_t Binary_t < T >::Max() const
{
   return (Long64_t)pow(2.0, (int)fNBits) - 1;
}
 
typedef Binary_t < UChar_t > Binary8_t;
typedef Binary_t < UShort_t > Binary16_t;
typedef Binary_t < UInt_t > Binary32_t;
typedef Binary_t < Long64_t > Binary64_t;
#endif