GenVectorIO.h

Go to the documentation of this file.

// @(#)root/mathcore:$Id$
// Authors: W. Brown, M. Fischler, L. Moneta    2005
 
 /**********************************************************************
  *                                                                    *
  * Copyright (c) 2005 , LCG ROOT MathLib Team (FNAL component)        *
  *                                                                    *
  *                                                                    *
  **********************************************************************/
 
// Support templates (class and function) for stream i/o of vectors
//     This is a utuility to allow for control, via manipulators, of the
//     form of
//
// Created by: W. E. Brown and M. Fischler at Tue Jun 21 2005
//
// Last update: Tue Jun 21 2005
//
#ifndef ROOT_Math_GenVector_GenVectorIO
#define ROOT_Math_GenVector_GenVectorIO  1
 
#include <cctype>
#include <iostream>
 
 
namespace ROOT  {
namespace Math  {
 
namespace detail  {
 
 
// -------- Manipulator support ----------
 
 
enum manip_t { open, sep, close, bitforbit };
 
 
inline  int
  ios_data( int k )
{
  static int const  ios_data[4]  = { std::ios::xalloc()  // open
                                   , std::ios::xalloc()  // sep
                                   , std::ios::xalloc()  // close
                                   , std::ios::xalloc()  // bitforbit
                                   };
 
  return ios_data[k];
 
}  // ios_data()
 
 
template< class char_t, class traits_t >
  inline  char_t
  get_manip( std::basic_ios<char_t,traits_t> & ios
           , manip_t m
           )
{
  char_t  ch  = static_cast<char_t>( ios.iword( ios_data(m) ) );
  if( ch )  return ch;
 
  switch( m )
  { default        : return ios.widen( '?' );
    case open      : return ios.widen( '(' );
    case close     : return ios.widen( ')' );
    case sep       : return ios.widen( ',' );
    case bitforbit : return ch;
  }
 
}  // get_manip<>()
 
 
template< class char_t, class traits_t >
  inline  void
  set_manip( std::basic_ios<char_t,traits_t> & ios
           , manip_t m
           , char_t ch
           )
{
  ios.iword( ios_data(m) ) = static_cast<long>(ch);
 
}  // set_manip<>()
 
 
template< class char_t >
  class manipulator
{
public:
  explicit
    manipulator( manip_t m
               , char_t  ch = 0
               )
    : fMan(m)
    , fChar(ch)
  { }
 
  template< class traits_t >
    void
    set( std::basic_ios<char_t,traits_t> & ios ) const
  {
    set_manip<char_t>( ios, fMan, fChar );
  }
 
private:
  manip_t  fMan;
  char_t   fChar;
 
};  // manipulator<>
 
 
template< class char_t, class traits_t >
  inline
  std::basic_istream<char_t,traits_t> &
  require_delim( std::basic_istream<char_t,traits_t> & is
               , manip_t m
               )
{
  char_t delim = get_manip( is, m );
  if( std::isspace(delim) )  return is;
 
  char_t ch;
  is >> ch;
  if( ch != delim )
    is.setstate( std::ios::failbit );
 
  return is;
 
}  // require_delim<>()
 
 
template< class char_t, class traits_t >
  inline
  std::basic_ostream<char_t,traits_t> &
  operator << ( std::basic_ostream<char_t,traits_t> & os
              , detail::manipulator<char_t> const   & manip
              )
 
{
  manip.set(os);
  return os;
 
}  // op<< <>()
 
 
template< class char_t, class traits_t >
  inline
  std::basic_istream<char_t,traits_t> &
  operator >> ( std::basic_istream<char_t,traits_t> & is
              , detail::manipulator<char_t> const   & manip
              )
 
{
  manip.set(is);
  return is;
 
}  // op>> <>()
 
}  // namespace detail
 
 
// --------- Functions that allow a user to control vector I/O ----------
 
 
 
template< class char_t >
  inline
  detail::manipulator<char_t>
  set_open( char_t ch )
{
  return detail::manipulator<char_t>( detail::open, ch );
 
}  // set_open<>()
 
 
template< class char_t >
  inline
  detail::manipulator<char_t>
  set_separator( char_t ch )
{
  return detail::manipulator<char_t>( detail::sep, ch );
 
}  // set_separator<>()
 
 
template< class char_t >
  inline
  detail::manipulator<char_t>
  set_close( char_t ch )
{
  return detail::manipulator<char_t>( detail::close, ch );
 
}  // set_close<>()
 
 
template< class char_t, class traits_t >
  inline
  std::basic_ios<char_t,traits_t> &
  human_readable( std::basic_ios<char_t,traits_t> & ios )
{
  ios.iword( ios_data(detail::bitforbit) ) = 0L;
  return ios;
 
}  // human_readable<>()
 
 
template< class char_t, class traits_t >
  inline
  std::basic_ios<char_t,traits_t> &
  machine_readable( std::basic_ios<char_t,traits_t> & ios )
{
  ios.iword( ios_data(detail::bitforbit) ) = 1L;
  return ios;
 
}  // machine_readable<>()
 
 
 
}  // namespace ROOT
}  // namespace Math
 
 
#endif  // ROOT_Math_GenVector_GenVectorIO