IoFormat.h

/*
 * IoFormat.h - io formatting class.
 *
 * This file is part of the Rulbus Device Class Library (RDCL).
 *
 * Copyright (C) 2003-2004, Leiden University.
 *
 * This library 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 2 of the License, or
 * (at your option) any later version.
 *
 * The library 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 mngdriver; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * $Id: IoFormat.h 2 2004-10-12 11:54:15Z moene $
 */

#ifndef __IOFORMAT_H
#define __IOFORMAT_H

#ifndef __COMMON_H
#include "Common.h"
#endif

//#include <iosfwd>
#include <sstream>

namespace Rulbus
{
   template <typename T> class BoundIoFormat;

   template <typename T>
   class IoFormat
   {
   public:
      typedef std::ios_base::fmtflags fmtflags;


      explicit IoFormat( int precision = 6 ):
         thePrecision(precision), theFlags(0), theWidth(0), theFillChar(' ')
      {
         ; // do nothing
      }


      BoundIoFormat<T> operator()( const T& d ) const;


      int fill() const
      {
         return theFillChar;
      }

      int flags() const
      {
         return theFlags;
      }

      int width() const
      {
         return theWidth;
      }

      int precision() const
      {
         return thePrecision;
      }


      IoFormat<T>& left()
      {
         setf( std::ios_base::left, std::ios_base::adjustfield );
         return *this;
      }

      IoFormat<T>& right()
      {
         setf( std::ios_base::right, std::ios_base::adjustfield );
         return *this;
      }

      IoFormat<T>& internal()
      {
         setf( std::ios_base::internal, std::ios_base::adjustfield );
         return *this;
      }

      IoFormat<T>& boolalpha( bool alpha = true )
      {
         if ( alpha )   setf( std::ios_base::boolalpha );
         else         unsetf( std::ios_base::boolalpha );
         return *this;
      }

      IoFormat<T>& uppercase( bool upper = true )
      {
         if ( upper )   setf( std::ios_base::uppercase );
         else         unsetf( std::ios_base::uppercase );
         return *this;
      }

      IoFormat<T>& general()
      {
         setf( 0, std::ios_base::floatfield );
         return *this;
      }

      IoFormat<T>& fixed()
      {
         setf( std::ios_base::fixed, std::ios_base::floatfield );
         return *this;
      }

      IoFormat<T>& scientific()
      {
         setf( std::ios_base::scientific, std::ios_base::floatfield );
         return *this;
      }

      IoFormat<T>& oct()
      {
         setf( std::ios_base::oct, std::ios_base::basefield );
         return *this;
      }

      IoFormat<T>& dec()
      {
         setf( std::ios_base::dec, std::ios_base::basefield );
         return *this;
      }

      IoFormat<T>& hex()
      {
         setf( std::ios_base::hex, std::ios_base::basefield );
         return *this;
      }

      IoFormat<T>& showplus( bool show = true )
      {
         if ( show )   setf( std::ios_base::showpos );
         else        unsetf( std::ios_base::showpos );
         return *this;
      }

      IoFormat<T>& showbase( bool show = true )
      {
         if ( show )   setf( std::ios_base::showbase );
         else        unsetf( std::ios_base::showbase );
         return *this;
      }

      IoFormat<T>& showpoint( bool show = true )
      {
         if ( show )   setf( std::ios_base::showpoint );
         else        unsetf( std::ios_base::showpoint );
         return *this;
      }

      IoFormat<T>& fill( int c = ' ' )
      {
         theFillChar = c;
         return *this;
      }

      IoFormat<T>& width( int w )
      {
         theWidth = w;
         return *this;
      }

      IoFormat<T>& precision( int p )
      {
         thePrecision = p;
         return *this;
      }


   protected:
      void setf( fmtflags f )
      {
         theFlags = flags() | f;
      }

      void setf( fmtflags f, fmtflags msk )
      {
         theFlags = ( flags() & ~msk ) | f & msk ;
      }

      void unsetf( fmtflags msk = ~0 )
      {
         theFlags = flags() & ~msk;
      }

   private:

      int thePrecision;                         
      int theWidth;                             
      int theFillChar;                          
      fmtflags theFlags;                        

   };

   template <typename T>
   class BoundIoFormat
   {
   public:

      BoundIoFormat( const IoFormat<T>& f, const T& v ): theFormat(f), theValue(v)
      {
         ; // do nothing
      }

      const IoFormat<T>& theFormat;             
      T                  theValue;              
   };

   template <typename T>
   inline BoundIoFormat<T> IoFormat<T>::operator()( const T& v ) const
   {
      return BoundIoFormat<T>( *this, v );
   }

   template <typename T> std::ostream& operator<< ( std::ostream& os, const Rulbus::BoundIoFormat<T>& bf )
   {
      std::ostringstream s;

      s.fill     ( bf.theFormat.fill()      );
      s.width    ( bf.theFormat.width()     );
      s.precision( bf.theFormat.precision() );
      s.flags    ( bf.theFormat.flags()     );

      s << bf.theValue;

      return os << s.str();
   }

} // namespace Rulbus

#endif  // __IOFORMAT_H

/*
 * end of file
 */

---