DumpUtils.h

Go to the documentation of this file.

#ifndef LARCORE_COREUTILS_DUMPUTILS_H
#define LARCORE_COREUTILS_DUMPUTILS_H

// C++ libraries
#include <string>
#include <sstream>
#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