log_inserters.integer.hxx

Go to the documentation of this file.

/*
---------------------------------------------------------------------------

    This file is part of uHAL.

    uHAL is a hardware access library and programming framework
    originally developed for upgrades of the Level-1 trigger of the CMS
    experiment at CERN.

    uHAL is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    uHAL is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with uHAL.  If not, see <http://www.gnu.org/licenses/>.


      Andrew Rose, Imperial College, London
      email: awr01 <AT> imperial.ac.uk

      Marc Magrans de Abril, CERN
      email: marc.magrans.de.abril <AT> cern.ch

---------------------------------------------------------------------------
*/


#include <stdint.h>                          // for uint32_t, uint8_t, uint16_t, int32_t, ...
#include <ostream>                           // for ostream, basic_ostream::put
#include "uhal/log/log_inserter_helper.hpp"  // for RefWrapper


namespace uhal
{


  template< typename T >
  _Integer< T , IntFmt<> > Integer ( const T& aT )
  {
    return _Integer< T , IntFmt<> > ( aT );
  }

  template< typename T , integer_base BASE , integer_format FORMAT , uint32_t WIDTH > _Integer< T , IntFmt<BASE , FORMAT , WIDTH> > Integer ( const T& aT , const IntFmt<BASE , FORMAT , WIDTH>& aFmt )
  {
    return _Integer< T , IntFmt<BASE , FORMAT , WIDTH> > ( aT );
  }


  template< typename T >
  void sign_helper ( std::ostream& aStr, const T& aInt ) {}





  template< typename T , uint32_t WIDTH >
  void _Integer< T , IntFmt<bin , fixed , WIDTH> >::print ( std::ostream& aStr ) const
  {
    uint32_t lSize ( sizeof ( T ) << 3 ); //number of characters
    aStr.write ( "0b" , 2 );
    int32_t i ( WIDTH-lSize );

    if ( i > 0 )
    {
      for ( ; i!=0 ; --i )
      {
        aStr.put ( '0' );
      }
    }

    T lValue ( RefWrapper<T>::value() );
    T lMask ( 0x1 );
    lMask <<= ( lSize-1 );

    for ( uint32_t i=0 ; i!=lSize ; ++i )
    {
      aStr.put ( ( lValue & lMask ) ?'1':'0' );
      lValue <<= 1;
    }
  }


  template< typename T , uint32_t WIDTH >
  void _Integer< T , IntFmt<dec , fixed , WIDTH> >::print ( std::ostream& aStr ) const
  {
    static const char* lCharacterMapping ( "9876543210123456789" );
    static const char* lCharacterMappingCenter ( lCharacterMapping + 9 );
    char lBuffer[24]; //greater than the size of a 64bit decimal number
    char* lPtr = lBuffer;
    T value ( RefWrapper<T>::value() );
    T tmp_value;
    sign_helper ( aStr , value );

    do
    {
      tmp_value = value;
      value /= 10;
      *lPtr++ = * ( lCharacterMappingCenter + tmp_value - ( value * 10 ) );
    }
    while ( value );

    int32_t i ( WIDTH- ( lPtr-lBuffer ) );

    if ( i > 0 )
    {
      for ( ; i!=0 ; --i )
      {
        aStr.put ( '0' );
      }
    }

    do
    {
      aStr.put ( * ( --lPtr ) );
    }
    while ( lPtr!=lBuffer );
  }


  template< typename T , uint32_t WIDTH >
  void _Integer< T , IntFmt<hex , fixed , WIDTH> >::print ( std::ostream& aStr ) const
  {
    uint32_t lSize ( sizeof ( T ) << 1 ); //number of characters
    static const char* lCharacterMapping ( "0123456789ABCDEF" );
    aStr.write ( "0x" , 2 );
    int32_t i ( WIDTH-lSize );

    if ( i > 0 )
    {
      for ( ; i!=0 ; --i )
      {
        aStr.put ( '0' );
      }
    }

    uint8_t* lStart ( ( uint8_t* ) ( & RefWrapper<T>::value() ) );
    uint8_t* lPtr ( lStart + sizeof ( T ) );

    do
    {
      --lPtr;
      aStr.put ( * ( lCharacterMapping + ( ( ( *lPtr ) &0xF0 ) >>4 ) ) );
      aStr.put ( * ( lCharacterMapping + ( ( ( *lPtr ) &0x0F ) ) ) );
    }
    while ( lPtr!=lStart );
  }




  template< typename T , uint32_t WIDTH >
  void _Integer< T , IntFmt<bin , variable , WIDTH> >::print ( std::ostream& aStr ) const
  {
    if ( RefWrapper<T>::value() == T ( 0 ) )
    {
      aStr.write ( "0b0" , 3 );
    }
    else
    {
      uint32_t lSize ( sizeof ( T ) <<3 );
      aStr.write ( "0b" , 2 );
      T lValue ( RefWrapper<T>::value() );
      T lMask ( 0x1 );
      lMask <<= ( lSize-1 );
      bool lPrint ( false );
      bool lCurrent ( false );

      for ( uint32_t i=0 ; i!=lSize ; ++i )
      {
        lCurrent = lValue & lMask;

        if ( (lPrint |= lCurrent) )
        {
          aStr.put ( lCurrent?'1':'0' );
        }

        lValue <<= 1;
      }
    }
  }



  template< typename T , uint32_t WIDTH >
  void _Integer< T , IntFmt<dec , variable , WIDTH> >::print ( std::ostream& aStr ) const
  {
    static const char* lCharacterMapping ( "9876543210123456789" );
    static const char* lCharacterMappingCenter ( lCharacterMapping + 9 );
    char lBuffer[24]; //greater than the size of a 64bit decimal number
    char* lPtr = lBuffer;
    T value ( RefWrapper<T>::value() );
    T tmp_value;
    sign_helper ( aStr , value );

    do
    {
      tmp_value = value;
      value /= 10;
      *lPtr++ = * ( lCharacterMappingCenter + tmp_value - ( value * 10 ) );
    }
    while ( value );

    do
    {
      aStr.put ( * ( --lPtr ) );
    }
    while ( lPtr!=lBuffer );
  }



  template< typename T , uint32_t WIDTH >
  void _Integer< T , IntFmt<hex , variable , WIDTH> >::print ( std::ostream& aStr ) const
  {
    static const char* lCharacterMapping ( "0123456789ABCDEF" );

    if ( RefWrapper<T>::value() == T ( 0 ) )
    {
      aStr.write ( "0x0" , 3 );
    }
    else
    {
      uint32_t lSize ( sizeof ( T ) );
      aStr.write ( "0x" , 2 );
      bool lPrint ( false );
      uint32_t lPos ( 0 );
      uint8_t* lStart ( ( uint8_t* ) ( & RefWrapper<T>::value() ) );
      uint8_t* lPtr ( lStart + lSize );

      do
      {
        --lPtr;
        lPos = ( ( ( *lPtr ) &0xF0 ) >>4 );

        if ( (lPrint |= ( bool ) ( lPos )) )
        {
          aStr.put ( * ( lCharacterMapping + lPos ) );
        }

        lPos = ( ( *lPtr ) &0x0F );

        if ( (lPrint |= ( bool ) ( lPos )) )
        {
          aStr.put ( * ( lCharacterMapping + lPos ) );
        }
      }
      while ( lPtr!=lStart );
    }
  }



  template< typename FORMAT >
  std::ostream& operator<< ( std::ostream& aStr , const uhal::_Integer< uint8_t , FORMAT >& aInt )
  {
    aInt.print ( aStr );
    return aStr;
  }

  template< typename FORMAT >
  std::ostream& operator<< ( std::ostream& aStr , const uhal::_Integer< int8_t , FORMAT >& aInt )
  {
    aInt.print ( aStr );
    return aStr;
  }

  template< typename FORMAT >
  std::ostream& operator<< ( std::ostream& aStr , const uhal::_Integer< uint16_t , FORMAT >& aInt )
  {
    aInt.print ( aStr );
    return aStr;
  }

  template< typename FORMAT >
  std::ostream& operator<< ( std::ostream& aStr , const uhal::_Integer< int16_t , FORMAT >& aInt )
  {
    aInt.print ( aStr );
    return aStr;
  }

  template< typename FORMAT >
  std::ostream& operator<< ( std::ostream& aStr , const uhal::_Integer< uint32_t , FORMAT >& aInt )
  {
    aInt.print ( aStr );
    return aStr;
  }

  template< typename FORMAT >
  std::ostream& operator<< ( std::ostream& aStr , const uhal::_Integer< int32_t , FORMAT >& aInt )
  {
    aInt.print ( aStr );
    return aStr;
  }

  template< typename FORMAT >
  std::ostream& operator<< ( std::ostream& aStr , const uhal::_Integer< uint64_t , FORMAT >& aInt )
  {
    aInt.print ( aStr );
    return aStr;
  }

  template< typename FORMAT >
  std::ostream& operator<< ( std::ostream& aStr , const uhal::_Integer< int64_t , FORMAT >& aInt )
  {
    aInt.print ( aStr );
    return aStr;
  }

#ifdef __APPLE__ 
  template< typename FORMAT > 
  std::ostream& operator<< ( std::ostream& aStr , const uhal::_Integer< size_t , FORMAT >& aInt ) 
  { 
    aInt.print ( aStr ); 
    return aStr; 
  }
#endif

}