format.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
----------------------------------------------------------------------/
*
* This file contains private API, this might break at any time between releases.
* You have been warned!
*
*/
#ifndef ZYPP_NG_LOG_FORMAT_H_INCLUDED
#define ZYPP_NG_LOG_FORMAT_H_INCLUDED
 
#include <ostream>
#include <sstream>
#include <type_traits>
 
#include <zypp-core/ng/base/zyppglobal.h>
#include <zypp-core/ng/meta/type_traits.h>
 
 
namespace zyppng{
 
  ZYPP_FWD_DECL_TYPE_WITH_REFS(Context);
 
  namespace log {

    template <typename T, typename Enable = void>
    struct formatter;
 
    namespace detail {

      template <typename T>
      struct view_proxy {
          const T& obj;
 
          operator std::string() const {
              std::ostringstream ss;
              ss << *this;
              return ss.str();
          }
 
          friend std::ostream& operator<<(std::ostream& os, const view_proxy& v) {
              return formatter<T>::stream(os, v.obj);
          }
      };

      template <typename T>
      struct ctx_bound_view_proxy {
          const ContextWeakRef ctx;
          const T& obj;
 
          operator std::string() const {
              std::ostringstream ss;
              ss << *this;
              return ss.str();
          }
 
          friend std::ostream& operator<<(std::ostream& os, const ctx_bound_view_proxy& v) {
            auto ctxLock = v.ctx.lock();
            if ( ctxLock )
              return formatter<T>::stream(os, ctxLock, v.obj);
            else {
              return os << "<<Error: Context Required for streaming " << typeid(T).name() << ">>";
            }
          }
      };

        template <typename T, typename = void>
        struct has_view_proxy : std::false_type {};
 
        template <typename T>
        struct has_view_proxy<T, std::void_t<decltype(formatter<T>::stream(std::declval<std::ostream&>(), std::declval<const T&>()))>>
            : std::true_type {};
    }

    template <typename T>
    auto view(const ContextRef& ctx, const T& obj) {
      return detail::ctx_bound_view_proxy<T>{ ctx, obj };
    }

    template <typename T >
    auto view(const T& obj) {
      return detail::view_proxy<T>{ obj };
    }
  }

  template <typename T>
  auto operator<<(std::ostream& os, const T& obj)
      -> std::enable_if_t<log::detail::has_view_proxy<T>::value, std::ostream&>
  {
      return os << log::view<T>(obj);
  }
}
 
#endif