stream.hh

Go to the documentation of this file.

#pragma once

#include <sstream>
#include <stdexcept>
#include <iostream> // cin
#include <memory> // shared_ptr

#include <vcsn/misc/escape.hh>
#include <vcsn/misc/export.hh>
#include <vcsn/misc/raise.hh>

namespace vcsn LIBVCSN_API
{
  extern std::ostream cnull;

  extern std::wostream wcnull;

  std::string
  bracketed(std::istream& i, char lbracket, char rbracket);

  template <typename ValueSet, typename... Args>
  inline 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)...);
    VCSN_REQUIRE(i.peek() == EOF,
                 vs.sname(), ": invalid value: ", str,
                 ", unexpected ", str_escape(i.peek()));
    return res;
  }

  char eat(std::istream& is, char c);

  const std::string& eat(std::istream& is, const std::string& s);

  template <typename... Args>
  ATTRIBUTE_NORETURN
  inline
  void fail_reading(std::istream& is, Args&&... args)
  {
    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())
      raise(std::forward<Args>(args)...);
    else
      raise(std::forward<Args>(args)..., ": ", str_escape(buf));
  }

  inline char get_char(std::istream& i)
  {
    int res = i.get();
    if (res == '\\')
      {
        int c = i.peek();
        // \(, \) and \- are used in setalpha::make, e.g.,
        // char_letters(\(\-\)), so strip the backslash.  Otherwise,
        // return the backslash itself.
        if (c == 'x')
          {
            i.ignore();
            // Handle hexadecimal escape.
            int c1 = i.get();
            require(c1 != EOF,
                    "get_char: unexpected end-of-file"
                    " after: \\x");
            require(isxdigit(c1),
                    "get_char: invalid escape: \\x", char(c1));
            int c2 = i.get();
            require(c2 != EOF,
                    "get_char: unexpected end-of-file"
                    " after: \\x", char(c1));
            require(isxdigit(c2),
                    "get_char: invalid escape: \\x",
                    char(c1), char(c2));
            res = std::stoi(std::string{char(c1), char(c2)}, nullptr, 16);
          }
        else if (std::isalnum(c))
          raise("get_char: invalid escape: \\", char(c), " in \\", i);
        else
          res = i.get();
      }
    require(res != EOF,
            "get_char: unexpected end-of-file");
    return res;
  }

  template <typename ValueSet, typename Value = typename ValueSet::value_t,
            typename... Args>
  inline auto
  to_string(const ValueSet& vs, const Value& 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);

}