io.hpp

Go to the documentation of this file.

// Copyright (c) 2019-2021 Simons Foundation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0.txt
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Authors: Olivier Parcollet, Nils Wentzell
 
#pragma once
 
#include "./clef.hpp"
 
#include <functional>
#include <iostream>
#include <tuple>
#include <type_traits>
#include <utility>
 
namespace nda::clef {
 
  template <int N>
  std::ostream &operator<<(std::ostream &sout, placeholder<N>) {
    return sout << "_" << N;
  }
 
  template <typename T>
  std::ostream &operator<<(std::ostream &sout, std::reference_wrapper<T> const &wrapper) {
    return sout << wrapper.get();
  }
 
  // Overload of nda::clef::variadic_print for the case of an empty list of arguments.
  inline std::ostream &variadic_print(std::ostream &sout) { return sout; }
 
  template <typename T0, typename... Ts>
  std::ostream &variadic_print(std::ostream &sout, T0 &&t0, Ts &&...ts) {
    sout << std::forward<T0>(t0) << (sizeof...(Ts) > 0 ? ", " : "");
    variadic_print(sout, std::forward<Ts>(ts)...);
    return sout;
  }
 
  namespace detail {
 
    // Helper struct to print a std::tuple recursively to std::ostream.
    template <int C, int N>
    struct print_tuple_impl {
      template <typename Tuple>
      void operator()(std::ostream &sout, Tuple const &t) {
        sout << std::get<C>(t) << (C != N - 1 ? ", " : "");
        print_tuple_impl<C + 1, N>()(sout, t);
      }
    };
 
    // Helper struct to print a std::tuple recursively to std::ostream (end of the recursion).
    template <int N>
    struct print_tuple_impl<N, N> {
      template <typename Tuple>
      void operator()(std::ostream &, Tuple const &) {}
    };
 
  } // namespace detail
 
  template <typename Tuple>
  std::ostream &print_tuple(std::ostream &sout, Tuple const &t) {
    detail::print_tuple_impl<1, std::tuple_size_v<Tuple>>()(sout, t);
    return sout;
  }
 
  template <typename Tag, typename L>
    requires std::is_base_of_v<tags::unary_op, Tag>
  std::ostream &operator<<(std::ostream &sout, expr<Tag, L> const &ex) {
    return sout << "(" << Tag::name() << " " << std::get<0>(ex.childs) << ")";
  }
 
  template <typename Tag, typename L, typename R>
    requires std::is_base_of_v<tags::binary_op, Tag>
  std::ostream &operator<<(std::ostream &sout, expr<Tag, L, R> const &ex) {
    return sout << "(" << std::get<0>(ex.childs) << " " << Tag::name() << " " << std::get<1>(ex.childs) << ")";
  }
 
  template <typename C, typename A, typename B>
  std::ostream &operator<<(std::ostream &sout, expr<tags::if_else, C, A, B> const &ex) {
    return sout << "(" << std::get<0>(ex.childs) << " ? " << std::get<1>(ex.childs) << " : " << std::get<2>(ex.childs) << ")";
  }
 
  template <typename... Ts>
  std::ostream &operator<<(std::ostream &sout, expr<tags::function, Ts...> const &ex) {
    sout << "lambda"
         << "(";
    print_tuple(sout, ex.childs);
    return sout << ")";
  }
 
  template <typename... Ts>
  std::ostream &operator<<(std::ostream &sout, expr<tags::subscript, Ts...> const &ex) {
    sout << "lambda"
         << "[";
    print_tuple(sout, ex.childs);
    return sout << "]";
  }
 
  template <typename T>
  std::ostream &operator<<(std::ostream &sout, expr<tags::terminal, T> const &ex) {
    return sout << std::get<0>(ex.childs);
  }
 
  template <typename T>
  std::ostream &operator<<(std::ostream &sout, expr<tags::subscript, T> const &ex) {
    return sout << std::get<0>(ex.childs) << "[" << std::get<1>(ex.childs) << "]";
  }
 
  template <typename T>
  std::ostream &operator<<(std::ostream &sout, expr<tags::negate, T> const &ex) {
    return sout << "-(" << std::get<0>(ex.childs) << ")";
  }
 
  template <typename Expr, int... Is>
  std::ostream &operator<<(std::ostream &sout, make_fun_impl<Expr, Is...> const &f) {
    sout << "lazy function : (";
    variadic_print(sout, placeholder<Is>()...);
    return sout << ") --> " << f.obj;
  }
 
} // namespace nda::clef