DumpUtils.h

Go to the documentation of this file.

#ifndef LARCORE_COREUTILS_DUMPUTILS_H
#define LARCORE_COREUTILS_DUMPUTILS_H

// C++ libraries
#include <sstream>
#include <string>
#include <type_traits>

namespace lar {

  namespace dump {

    namespace details {

      template <typename Coll>
      auto ptr_cbegin(Coll const& v)
      {
        using std::cbegin;
        return cbegin(v);
      }

      template <typename T>
      std::add_const_t<T>* ptr_cbegin(T* ptr)
      {
        return ptr;
      }

      template <typename Stream, typename Array>
      void dumpArray(Stream&& out, Array&& a, size_t n)
      {
        out << "{";
        if (n == 0) {
          out << "}";
          return;
        }
        auto it = ptr_cbegin(a);
        out << " " << *it;
        std::size_t i = 0;
        while (++i < n)
          out << "; " << (*++it);
        out << " }";
      } // dumpArray()

    } // namespace details

    template <typename Array>
    struct ArrayDumper {
      using Array_t = Array;
      using This_t = ArrayDumper<Array_t>;

      Array_t const& a; 
      size_t n;         

      ArrayDumper(Array_t const& a, size_t n) : a(a), n(n) {}

      // constructors ahead
      ArrayDumper(This_t const& from) = default;
      ArrayDumper(This_t&& from) = default;
      ArrayDumper& operator=(This_t const& from) = delete;
      ArrayDumper& operator=(This_t&& from) = delete;

      template <typename Stream>
      void operator()(Stream&& out) const
      {
        details::dumpArray(std::forward<Stream>(out), a, n);
      }

      explicit operator std::string() const
      {
        std::ostringstream sstr;
        this->operator()(sstr);
        return sstr.str();
      }

    }; // struct ArrayDumper

    template <typename T>
    struct ArrayDumper<T*> {
      using Array_t = T*;
      using This_t = ArrayDumper<Array_t>;

      Array_t a; 
      size_t n;  

      ArrayDumper(Array_t a, size_t n) : a(a), n(n) {}

      template <typename Stream>
      void operator()(Stream&& out) const
      {
        details::dumpArray(std::forward<Stream>(out), a, n);
      }

      explicit operator std::string() const
      {
        std::ostringstream sstr;
        this->operator()(sstr);
        return sstr.str();
      }

    }; // struct ArrayDumper<T*>

    template <typename Vector>
    struct VectorDumper {
      using Vector_t = Vector;
      using This_t = VectorDumper<Vector_t>;

      Vector_t const& v; 

      explicit VectorDumper(Vector_t const& v) : v(v) {}

      // constructors ahead
      VectorDumper(This_t const& from) = default;
      VectorDumper(This_t&& from) = default;
      VectorDumper& operator=(This_t const& from) = delete;
      VectorDumper& operator=(This_t&& from) = delete;

      template <typename Stream>
      void operator()(Stream&& out) const
      {
        out << "{ " << v.X() << "; " << v.Y() << "; " << v.Z() << " }";
      }

      explicit operator std::string() const
      {
        std::ostringstream sstr;
        this->operator()(sstr);
        return sstr.str();
      }

    }; // struct VectorDumper<>

    // Specialization for bare pointers.
    template <typename T>
    struct VectorDumper<T*> : public ArrayDumper<T const*> {
      explicit VectorDumper(T* v) : ArrayDumper<T const*>(v, 3U) {}
    }; // VectorDumper<T*>

    // Specialization for C-style arrays.
    template <typename T>
    struct VectorDumper<T[3]> : public ArrayDumper<T const*> {
      explicit VectorDumper(T const* v) : ArrayDumper<T const*>(v, 3U) {}
    }; // VectorDumper<T*>

    template <size_t N, typename Array>
    auto array(Array const& a)
    {
      return ArrayDumper<Array>(a, N);
    }

    template <typename Vector>
    auto vector(Vector const& v)
    {
      return ArrayDumper<Vector>(v, v.size());
    }

    template <typename Vector3D>
    auto vector3D(Vector3D const& v)
    {
      return VectorDumper<Vector3D>(v);
    }

    template <typename Stream, typename Array>
    Stream& operator<<(Stream&& out, ArrayDumper<Array>&& manip)
    {
      manip(std::forward<Stream>(out));
      return out;
    }

    template <typename Stream, typename Vector>
    Stream& operator<<(Stream&& out, VectorDumper<Vector>&& manip)
    {
      manip(std::forward<Stream>(out));
      return out;
    }

    template <typename String, typename Vector>
    String operator+(String const& s, VectorDumper<Vector> const& manip)
    {
      return s + std::string(manip);
    }

    template <typename Vector>
    std::string operator+(const char* s, VectorDumper<Vector> const& manip)
    {
      return std::string(s) + manip;
    }

    template <typename String, typename Vector>
    String operator+(VectorDumper<Vector> const& manip, String const& s)
    {
      return std::string(manip) + s;
    }

    template <typename Vector>
    std::string operator+(VectorDumper<Vector> const& manip, const char* s)
    {
      return manip + std::string(s);
    }

    template <typename String, typename Vector>
    String& operator+=(String& s, VectorDumper<Vector> const& manip)
    {
      return s += std::string(manip);
    }

  } // namespace dump

} // namespace lar

#endif // LARCORE_COREUTILS_DUMPUTILS_H