DumperBase.h

Go to the documentation of this file.

#ifndef LARDATAALG_DUMPERS_DUMPERBASE_H
#define LARDATAALG_DUMPERS_DUMPERBASE_H

// LArSoft includes
#include "lardataalg/Utilities/StatCollector.h" // lar::util::MinMaxCollector
#include "lardataobj/RawData/OpDetWaveform.h"

// C//C++ standard libraries
#include <algorithm> // std::min()
#include <cassert>
#include <iomanip> // std::setprecision(), std::setw()
#include <ios>     // std::fixed
#include <string>
#include <utility> // std::forward(), std::swap(), std::move()
#include <vector>

namespace dump {

  class DumperBase {

    struct IndentSettings {
      std::string indent = "";      
      std::string firstIndent = ""; 

      void set(std::string const& newIndent, std::string const& newFirstIndent)
      {
        indent = newIndent;
        firstIndent = newFirstIndent;
      }
      void set(std::string&& newIndent, std::string&& newFirstIndent)
      {
        indent = std::move(newIndent);
        firstIndent = std::move(newFirstIndent);
      }
      void set(std::string const& newIndent) { set(newIndent, newIndent); }

    }; // struct IndentSettings

    std::vector<IndentSettings> fIndentSettings; 

  public:
    DumperBase() : fIndentSettings{{}} {}

    DumperBase(std::string const& indent, std::string const& firstIndent)
      : fIndentSettings{{indent, firstIndent}}
    {}

    DumperBase(std::string const& indent) : DumperBase(indent, indent) {}


    std::string const& indent() const { return indentSettings().indent; }

    std::string const& firstIndent() const { return indentSettings().firstIndent; }

    void setIndent(std::string const& indent, std::string const& firstIndent)
    {
      indentSettings() = {indent, firstIndent};
    }

    void setIndent(std::string const& indent) { setIndent(indent, indent); }

    template <typename Stream>
    Stream& indented(Stream&& out, bool first = false) const
    {
      out << (first ? firstIndent() : indent());
      return out;
    }

    template <typename Stream>
    Stream& firstIndented(Stream&& out) const
    {
      return indented(std::forward<Stream>(out), true);
    }

    template <typename Stream>
    Stream& newline(Stream&& out) const
    {
      return indented(std::forward<Stream>(out));
    }


    template <typename Stream>
    class Indenter {
      Stream out;
      DumperBase const& dumper;

    public:
      using indenter_t = Indenter<Stream>; 

      Indenter(Stream out, DumperBase const& dumper)
        : out(std::forward<Stream>(out)), dumper(dumper)
      {}

      std::string const& indentString() const { return dumper.indent(); }

      std::string const& firstIndentString() const { return dumper.firstIndent(); }

      template <typename T>
      indenter_t& operator<<(T&& v)
      {
        out << std::forward<T>(v);
        return *this;
      }

      indenter_t& indent(bool first = false)
      {
        dumper.indented(out, first);
        return *this;
      }

      indenter_t& newline()
      {
        out << '\n';
        return indent();
      }

      indenter_t& start() { return indent(true); }

    }; // Indenter<>

    template <typename Stream>
    decltype(auto) indenter(Stream&& out) const
    {
      return Indenter<Stream>(std::forward<Stream>(out), *this);
    }

  protected:
    IndentSettings& indentSettings() { return fIndentSettings.back(); }
    IndentSettings const& indentSettings() const { return fIndentSettings.back(); }

    IndentSettings& saveIndentSettings()
    {
      auto oldSettings = indentSettings();
      fIndentSettings.push_back(std::move(oldSettings));
      return indentSettings();
    }

    IndentSettings& restoreIndentSettings()
    {
      if (fIndentSettings.size() > 1U) fIndentSettings.pop_back();
      assert(!fIndentSettings.empty());
      return indentSettings();
    }

  }; // DumperBase

  template <typename Dumper>
  auto withIndentation(Dumper&& dumper, std::string const& indent, std::string const& firstIndent)
  {
    dumper.setIndent(indent, firstIndent);
    return dumper;
  }

  template <typename Dumper>
  auto withIndentation(Dumper&& dumper, std::string const& indent)
  {
    return withIndentation(std::forward<Dumper>(dumper), indent, indent);
  }

} // namespace dump

//----------------------------------------------------------------------------

#endif // LARDATAALG_DUMPERS_DUMPERBASE_H