bwf_ex.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright Apache Software Foundation 2019
 
#pragma once
 
#include <array>
#include <string_view>
 
#include "swoc/swoc_version.h"
#include "swoc/bwf_base.h"
#include "swoc/swoc_meta.h"
 
namespace swoc { inline namespace SWOC_VERSION_NS {
namespace bwf {
using namespace swoc::literals; // enable ""sv

struct Pattern {
  int _n;                 
  std::string_view _text; 
};

struct Errno {
  int _e; 

  explicit Errno(int e = errno) : _e(e) {}
};

struct Date {
  static constexpr std::string_view DEFAULT_FORMAT{"%Y %b %d %H:%M:%S"_sv};
  time_t _epoch;         
  std::string_view _fmt; 

  Date(time_t t, std::string_view fmt = DEFAULT_FORMAT) : _epoch(t), _fmt(fmt) {}

  Date(std::string_view fmt = DEFAULT_FORMAT);
};
 
namespace detail {
// Special case conversions - these handle nullptr because the @c std::string_view spec is stupid.
inline std::string_view
FirstOfConverter(std::nullptr_t) {
  return std::string_view{};
}
 
inline std::string_view
FirstOfConverter(char const *s) {
  return std::string_view{s ? s : ""};
}
 
// Otherwise do any compliant conversion.
template <typename T>
std::string_view
FirstOfConverter(T &&t) {
  return t;
}
} // namespace detail

template <typename... Args>
std::string_view
FirstOf(Args &&...args) {
  std::array<std::string_view, sizeof...(args)> strings{{detail::FirstOfConverter(args)...}};
  for (auto &s : strings) {
    if (!s.empty())
      return s;
  }
  return std::string_view{};
}

template <typename... Args> struct SubText {
  using arg_pack = std::tuple<Args...>; 
  TextView _fmt;                        
  arg_pack _args;                       

  SubText(TextView const &fmt, arg_pack const &args) : _fmt(fmt), _args(args){};

  bool operator!() const;

  explicit operator bool() const;
};
 
template <typename... Args> SubText<Args...>::operator bool() const {
  return !_fmt.empty();
}
 
template <typename... Args>
bool
SubText<Args...>::operator!() const {
  return _fmt.empty();
}

template <typename... Args>
SubText<Args...>
If(bool flag, TextView const &fmt, Args &&...args) {
  return SubText<Args...>(flag ? fmt : TextView{}, std::forward_as_tuple(args...));
}
 
namespace detail {
// @a T has the @c empty() method.
template <typename T>
auto
Optional(meta::CaseTag<2>, TextView fmt, T &&t) -> decltype(void(t.empty()), meta::TypeFunc<SubText<T>>()) {
  return SubText<T>(t.empty() ? TextView{} : fmt, std::forward_as_tuple(t));
}
 
// @a T is convertible to @c bool.
template <typename T>
auto
Optional(meta::CaseTag<1>, TextView fmt, T &&t) -> decltype(bool(t), meta::TypeFunc<SubText<T>>()) {
  return SubText<T>(bool(t) ? fmt : TextView{}, std::forward_as_tuple(t));
}
 
// @a T is not optional, always print.
template <typename T>
auto
Optional(meta::CaseTag<0>, TextView fmt, T &&t) -> SubText<T> {
  return SubText<T>(fmt, std::forward_as_tuple(t));
}
} // namespace detail

template <typename ARG>
SubText<ARG>
Optional(TextView fmt, ARG &&arg) {
  return detail::Optional(meta::CaseArg, fmt, std::forward<ARG>(arg));
}

struct UnHex {
  UnHex(MemSpan<void const> const &span) : _span(span) {}
  MemSpan<void const> _span; 
};
} // namespace bwf

BufferWriter &bwformat(BufferWriter &w, bwf::Spec const &spec, bwf::Pattern const &pattern);

BufferWriter &bwformat(BufferWriter &w, bwf::Spec const &spec, bwf::Errno const &e);

BufferWriter &bwformat(BufferWriter &w, bwf::Spec const &spec, bwf::Date const &date);
 
BufferWriter &bwformat(BufferWriter &w, bwf::Spec const &spec, bwf::UnHex const &obj);

template <typename... Args>
BufferWriter &
bwformat(BufferWriter &w, bwf::Spec const &, bwf::SubText<Args...> const &subtext) {
  if (!subtext._fmt.empty()) {
    w.print_v(subtext._fmt, subtext._args);
  }
  return w;
}
 
}} // namespace swoc::SWOC_VERSION_NS