stream.hh

Go to the documentation of this file.

// This file is part of Awali.
// Copyright 2016-2022 Sylvain Lombardy, Victor Marsault, Jacques Sakarovitch
//
// Awali is a 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.
//
// This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
 
#ifndef AWALI_MISC_STREAM_HH
# define AWALI_MISC_STREAM_HH
 
# include <sstream>
# include <stdexcept>
# include <iostream> // cin
# include <memory> // shared_ptr
 
#include <awali/sttc/misc/escape.hh>
//#include <awali/sttc/misc/export.hh>
#include <awali/sttc/misc/raise.hh>
 
namespace awali { namespace sttc {
    //deprecated
  //LIBAWALI_API
  //extern std::ostream cnull;
  //extern std::wostream wcnull;
 
  std::string
  bracketed(std::istream& i, const char lbracket, const char rbracket);
 
  template <typename ValueSet, typename... Args>
  auto
  conv(const ValueSet& vs, const std::string& str, Args&&... args)
    -> decltype(vs.conv(std::declval<std::istream&>(),
                        std::forward<Args>(args)...))
  {
    std::istringstream i{str};
    auto res = vs.conv(i, std::forward<Args>(args)...);
    if (i.peek() != -1)
      throw std::domain_error(vs.sname() + ": invalid value: " + str
                              + ", unexpected "
                              + str_escape(i.peek()));
    return res;
  }
 
  void eat(std::istream& is, char c){
      require(is.peek() == c,
              "unexpected: ", str_escape(is.peek()),
              ": expected ", str_escape(c));
      is.ignore();
    }
 
  void eat(std::istream& is, const std::string& expect){
      std::string s;
      char c;
      size_t cnt = expect.size();
      while (cnt && is >> c)
        {
          s.append(1, c);
          --cnt;
        }
      require(s == expect,
              "unexpected: ", str_escape(s), ": expected ", str_escape(expect));
    }
 
  ATTRIBUTE_NORETURN
  void fail_reading(std::istream& is, std::string explanation)
  {
    is.clear();
    std::string buf;
    std::getline(is, buf, '\n');
    if (!is.good())
      // This shouldn't really happen; however it's best to fail cleanly.
      is.clear();
    if (!buf.empty())
      explanation += ": " + str_escape(buf);
    raise(explanation);
  }
 
  template <typename ValueSet, typename... Args>
  auto
  format(const ValueSet& vs,
         const typename ValueSet::value_t& v, Args&&... args)
    -> std::string
  {
    std::ostringstream o;
    vs.print(v, o, std::forward<Args>(args)...);
    return o.str();
  }
 
  std::string get_file_contents(const std::string& file);
 
  std::shared_ptr<std::istream> open_input_file(const std::string& file);
 
  std::shared_ptr<std::ostream> open_output_file(const std::string& file);
 
}}//end of ns awali::stc
 
#endif // !AWALI_MISC_STREAM_HH