text: /*
      pybind11/iostream.h -- Tools to assist with redirecting cout and cerr to Python
  
      Copyright (c) 2017 Henry F. Schreiner
  
      All rights reserved. Use of this source code is governed by a
      BSD-style license that can be found in the LICENSE file.
  */
  
  #pragma once
  
  #include <streambuf>
  #include <ostream>
  #include <string>
  #include <memory>
  #include <iostream>
  #include "../../../nms/include/pybind11/pybind11.h"
  
  NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  NAMESPACE_BEGIN(detail)
  
  // Buffer that writes to Python instead of C++
  class pythonbuf : public std::streambuf {
  private:
      using traits_type = std::streambuf::traits_type;
  
      char d_buffer[1024];
      object pywrite;
      object pyflush;
  
      int overflow(int c) {
          if (!traits_type::eq_int_type(c, traits_type::eof())) {
              *pptr() = traits_type::to_char_type(c);
              pbump(1);
          }
          return sync() ? traits_type::not_eof(c) : traits_type::eof();
      }
  
      int sync() {
          if (pbase() != pptr()) {
              // This subtraction cannot be negative, so dropping the sign
              str line(pbase(), static_cast<size_t>(pptr() - pbase()));
  
              pywrite(line);
              pyflush();
  
              setp(pbase(), epptr());
          }
          return 0;
      }
  
  public:
      pythonbuf(object pyostream)
          : pywrite(pyostream.attr("write")),
            pyflush(pyostream.attr("flush")) {
          setp(d_buffer, d_buffer + sizeof(d_buffer) - 1);
      }
  
      /// Sync before destroy
      ~pythonbuf() {
          sync();
      }
  };
  
  NAMESPACE_END(detail)
  
  
  /** \rst
      This a move-only guard that redirects output.
  
      .. code-block:: cpp
  
          #include <pybind11/iostream.h>
  
          ...
  
          {
              py::scoped_ostream_redirect output;
              std::cout << "Hello, World!"; // Python stdout
          } // <-- return std::cout to normal
  
      You can explicitly pass the c++ stream and the python object,
      for example to guard stderr instead.
  
      .. code-block:: cpp
  
          {
              py::scoped_ostream_redirect output{std::cerr, py::module::import("sys").attr("stderr")};
              std::cerr << "Hello, World!";
          }
   \endrst */
  class scoped_ostream_redirect {
  protected:
      std::streambuf *old;
      std::ostream &costream;
      detail::pythonbuf buffer;
  
  public:
      scoped_ostream_redirect(
              std::ostream &costream = std::cout,
              object pyostream = module::import("sys").attr("stdout"))
          : costream(costream), buffer(pyostream) {
          old = costream.rdbuf(&buffer);
      }
  
      ~scoped_ostream_redirect() {
          costream.rdbuf(old);
      }
  
      scoped_ostream_redirect(const scoped_ostream_redirect &) = delete;
      scoped_ostream_redirect(scoped_ostream_redirect &&other) = default;
      scoped_ostream_redirect &operator=(const scoped_ostream_redirect &) = delete;
      scoped_ostream_redirect &operator=(scoped_ostream_redirect &&) = delete;
  };
  
  
  /** \rst
      Like `scoped_ostream_redirect`, but redirects cerr by default. This class
      is provided primary to make ``py::call_guard`` easier to make.
  
      .. code-block:: cpp
  
       m.def("noisy_func", &noisy_func,
             py::call_guard<scoped_ostream_redirect,
                            scoped_estream_redirect>());
  
  \endrst */
  class scoped_estream_redirect : public scoped_ostream_redirect {
  public:
      scoped_estream_redirect(
              std::ostream &costream = std::cerr,
              object pyostream = module::import("sys").attr("stderr"))
          : scoped_ostream_redirect(costream,pyostream) {}
  };
  
  
  NAMESPACE_BEGIN(detail)
  
  // Class to redirect output as a context manager. C++ backend.
  class OstreamRedirect {
      bool do_stdout_;
      bool do_stderr_;
      std::unique_ptr<scoped_ostream_redirect> redirect_stdout;
      std::unique_ptr<scoped_estream_redirect> redirect_stderr;
  
  public:
      OstreamRedirect(bool do_stdout = true, bool do_stderr = true)
          : do_stdout_(do_stdout), do_stderr_(do_stderr) {}
  
      void enter() {
          if (do_stdout_)
              redirect_stdout.reset(new scoped_ostream_redirect());
          if (do_stderr_)
              redirect_stderr.reset(new scoped_estream_redirect());
      }
  
      void exit() {
          redirect_stdout.reset();
          redirect_stderr.reset();
      }
  };
  
  NAMESPACE_END(detail)
  
  /** \rst
      This is a helper function to add a C++ redirect context manager to Python
      instead of using a C++ guard. To use it, add the following to your binding code:
  
      .. code-block:: cpp
  
          #include <pybind11/iostream.h>
  
          ...
  
          py::add_ostream_redirect(m, "ostream_redirect");
  
      You now have a Python context manager that redirects your output:
  
      .. code-block:: python
  
          with m.ostream_redirect():
              m.print_to_cout_function()
  
      This manager can optionally be told which streams to operate on:
  
      .. code-block:: python
  
          with m.ostream_redirect(stdout=true, stderr=true):
              m.noisy_function_with_error_printing()
  
   \endrst */
  inline class_<detail::OstreamRedirect> add_ostream_redirect(module m, std::string name = "ostream_redirect") {
      return class_<detail::OstreamRedirect>(m, name.c_str(), module_local())
          .def(init<bool,bool>(), arg("stdout")=true, arg("stderr")=true)
          .def("__enter__", &detail::OstreamRedirect::enter)
          .def("__exit__", [](detail::OstreamRedirect &self, args) { self.exit(); });
  }
  
  NAMESPACE_END(PYBIND11_NAMESPACE)
  