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_MathX_GenVectorX_GenVectorIO
#define ROOT_MathX_GenVectorX_GenVectorIO 1
 
#include "MathX/GenVectorX/AccHeaders.h"
 
#include <cctype>
#include <iostream>
 
#if !defined(ROOT_MATH_SYCL) && !defined(ROOT_MATH_CUDA)
 
namespace ROOT {
namespace ROOT_MATH_ARCH {
 
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_MATH_ARCH
} // namespace ROOT
 
#endif
 
#endif // ROOT_MathX_GenVectorX_GenVectorIO