aterm_io.h

Go to the documentation of this file.

// Author(s): Jan Friso Groote
// Copyright: see the accompanying file COPYING or copy at
// https://github.com/mCRL2org/mCRL2/blob/master/COPYING
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
 
#ifndef MCRL2_ATERMPP_ATERM_IO_H
#define MCRL2_ATERMPP_ATERM_IO_H
 
#include "mcrl2/atermpp/aterm_list.h"
#include "mcrl2/atermpp/aterm_int.h"
#include "mcrl2/utilities/type_traits.h"
 
namespace atermpp
{
 
using aterm_transformer = aterm(const aterm&);
 
inline aterm identity(const aterm& x) { return x; }
 
class aterm_stream
{
public:
  virtual ~aterm_stream();
 
  void set_transformer(aterm_transformer transformer) { m_transformer = transformer; }
 
  aterm_transformer* get_transformer() const { return m_transformer; }
 
protected:
  aterm_transformer* m_transformer = identity;
};
 
class aterm_ostream : public aterm_stream
{
public:
  virtual ~aterm_ostream();
 
  virtual void put(const aterm& term) = 0;
};
 
class aterm_istream : public aterm_stream
{
public:
  virtual ~aterm_istream();
 
  virtual void get(aterm& t) = 0;
};
 
// These free functions provide input/output operators for these streams.
 
inline aterm_istream& operator>>(aterm_istream& stream, aterm_transformer transformer) { stream.set_transformer(transformer); return stream; }
inline aterm_ostream& operator<<(aterm_ostream& stream, aterm_transformer transformer) { stream.set_transformer(transformer); return stream; }
 
inline aterm_ostream& operator<<(aterm_ostream& stream, const aterm& term) { stream.put(term); return stream; }
 
inline aterm_istream& operator>>(aterm_istream& stream, aterm& term) { stream.get(term); return stream; }
 
// Utility functions
 
class aterm_stream_state
{
public:
  aterm_stream_state(aterm_stream& stream)
    : m_stream(stream)
  {
    m_transformer = stream.get_transformer();
  }
 
  ~aterm_stream_state()
  {
    m_stream.set_transformer(m_transformer);
  }
 
private:
  aterm_stream& m_stream;
  aterm_transformer* m_transformer;
};
 
template<typename T,
  typename std::enable_if_t<mcrl2::utilities::is_iterable_v<T>, int> = 0,
  typename std::enable_if_t<!std::is_base_of<aterm, T>::value, int> = 0>
inline aterm_ostream& operator<<(aterm_ostream& stream, const T& container)
{
  // Write the number of elements, followed by each element in the container.
  stream << aterm_int(std::distance(container.begin(), container.end()));
 
  for (const auto& element : container)
  {
    stream << element;
  }
 
  return stream;
}
 
template<typename T,
  typename std::enable_if_t<mcrl2::utilities::is_iterable_v<T>, int> = 0,
  typename std::enable_if_t<!std::is_base_of<aterm, T>::value, int> = 0>
inline aterm_istream& operator>>(aterm_istream& stream, T& container)
{
  // Insert the next nof_elements into the container.
  aterm_int nof_elements;
  stream >> nof_elements;
 
  auto it = std::inserter(container, container.end());
  for (std::size_t i = 0; i < nof_elements.value(); ++i)
  {
    typename T::value_type element;
    stream >> element;
    it = element;
  }
 
  return stream;
}
 
template<typename T>
inline aterm_ostream& operator<<(aterm_ostream&& stream, const T& t) { stream << t; return stream; }
 
template<typename T>
inline aterm_istream& operator>>(aterm_istream&& stream, T& t) { stream >> t; return stream; }
 
inline
std::ostream& operator<<(std::ostream& out, const function_symbol& f)
{
  return out << f.name();
}
 
inline const std::string& pp(const function_symbol& f)
{
  return f.name();
}
 
void write_term_to_binary_stream(const aterm& t, std::ostream& os);
 
void read_term_from_binary_stream(std::istream& is, aterm& t);
 
void write_term_to_text_stream(const aterm& t, std::ostream& os);
 
void read_term_from_text_stream(std::istream& is, aterm& t);
 
aterm read_term_from_string(const std::string& s);
 
inline aterm_list read_list_from_string(const std::string& s)
{
  const aterm_list l = down_cast<aterm_list>(read_term_from_string(s));
  assert(l.type_is_list());
  return l;
}
 
inline aterm_int read_int_from_string(const std::string& s)
{
  const aterm_int n = down_cast<aterm_int>(read_term_from_string(s));
  assert(n.type_is_int());
  return n;
}
 
inline aterm read_appl_from_string(const std::string& s)
{
  const aterm a = read_term_from_string(s);
  assert(a.type_is_appl());
  return a;
}
 
 
} // namespace atermpp
 
#endif // MCRL2_ATERMPP_ATERM_IO_H