bwf_base.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright Apache Software Foundation 2019
 
#pragma once
 
#include <cstdlib>
#include <utility>
#include <cstring>
#include <vector>
#include <unordered_map>
#include <string>
#include <iosfwd>
#include <string_view>
#include <functional>
#include <tuple>
#include <any>
#include <array>
 
#include "swoc/swoc_version.h"
#include "swoc/TextView.h"
#include "swoc/MemSpan.h"
#include "swoc/MemArena.h"
#include "swoc/BufferWriter.h"
#include "swoc/swoc_meta.h"
 
namespace swoc { inline namespace SWOC_VERSION_NS {
namespace bwf {
struct Spec {
  using self_type = Spec; 
 
  static constexpr char DEFAULT_TYPE = 'g'; 
  static constexpr char INVALID_TYPE = 0;   
  static constexpr char LITERAL_TYPE = '"'; 
  static constexpr char CAPTURE_TYPE = 1;   
 
  static constexpr char SIGN_ALWAYS = '+'; 
  static constexpr char SIGN_NEVER  = ' '; 
  static constexpr char SIGN_NEG    = '-'; 

  constexpr Spec() {}

  Spec(const TextView &fmt);

  bool parse(TextView fmt);
 
  char _fill = ' ';      
  char _sign = SIGN_NEG; 
  enum class Align : char {
    NONE,                            
    LEFT,                            
    RIGHT,                           
    CENTER,                          
    SIGN                             
  } _align           = Align::NONE;  
  char _type         = DEFAULT_TYPE; 
  bool _radix_lead_p = false;        
  // @a _min is unsigned because there's no point in an invalid default, 0 works fine.
  unsigned int _min = 0;                                        
  int _prec         = -1;                                       
  unsigned int _max = std::numeric_limits<unsigned int>::max(); 
  int _idx          = -1;                                       
  std::string_view _name;                                       
  std::string_view _ext;                                        

  static const self_type DEFAULT;

  static bool is_type(char c);

  static bool is_numeric_type(char c);

  static bool is_upper_case_type(char c);

  bool has_numeric_type() const;

  bool has_upper_case_type() const;

  bool has_pointer_type() const;

  bool has_valid_type() const;
 
protected:
  Align align_of(char c);

  bool is_sign(char c);

  struct Property {
    Property(); 
    uint8_t _data[0x100]{};
    static constexpr uint8_t ALIGN_MASK        = 0x0F; 
    static constexpr uint8_t TYPE_CHAR         = 0x10; 
    static constexpr uint8_t UPPER_TYPE_CHAR   = 0x20; 
    static constexpr uint8_t NUMERIC_TYPE_CHAR = 0x40; 
    static constexpr uint8_t SIGN_CHAR         = 0x80; 
  };
  static const Property &
  Get_Prop()
  {
    static const Property prop;
    return prop;
  } 
};

struct Format {
  using self_type = Format; 

  Format() = default;

  Format(TextView fmt);

  Format(self_type &&that) = default;
  Format(self_type const &) = delete;

  struct TextViewExtractor {
    TextView _fmt; 

    explicit operator bool() const;

    bool operator()(std::string_view &literal_v, Spec &spec);

    static bool parse(TextView &fmt, std::string_view &literal, std::string_view &specifier);
  };

  static TextViewExtractor bind(TextView fmt);

  struct FormatExtractor {
    MemSpan<Spec const> _fmt; 
    int _idx = 0;             
    explicit operator bool() const;

    bool operator()(std::string_view &literal_v, Spec &spec);
  };

  FormatExtractor bind() const;

  bool is_literal() const;
 
  using Container = std::vector<Spec>;
  Container _items; 
 
  using iterator       = Container::iterator;
  using const_iterator = Container::const_iterator;
 
  iterator
  begin() {
    return _items.begin();
  }
  iterator
  end() {
    return _items.end();
  }
  const_iterator
  begin() const {
    return _items.begin();
  }
  const_iterator
  end() const {
    return _items.end();
  }
};
 
// Name binding - support for having format specifier names.

using ExternalGeneratorSignature = BufferWriter &(BufferWriter &w, Spec const &spec);

class NameBinding {
public:
  virtual ~NameBinding(); 

  virtual BufferWriter &operator()(BufferWriter &w, Spec const &spec) const = 0;
 
protected:
  static BufferWriter &err_invalid_name(BufferWriter &w, Spec const &spec);
};

class NilBinding : public NameBinding {
public:
  BufferWriter &operator()(BufferWriter &, Spec const &) const override;
};

template <typename F> class NameMap {
public:
  using Generator = std::function<F>;
 
protected:
  using Map = std::unordered_map<std::string_view, Generator>;
 
private:
  using self_type = NameMap; 
public:
  NameMap();

  NameMap(std::initializer_list<std::tuple<std::string_view, Generator const &>> list);

  self_type &assign(std::string_view const &name, Generator const &generator);

  bool contains(std::string_view name);
 
protected:
  std::string_view localize(std::string_view const &name);

  Map _map;              
  MemArena _arena{1024}; 
};

class ExternalNames : public NameMap<ExternalGeneratorSignature>, public NameBinding {
  using self_type  = ExternalNames;                       
  using super_type = NameMap<ExternalGeneratorSignature>; 
  using Map        = super_type::Map;                     
 
public:
  using super_type::super_type; // import constructors.

  NameBinding const &bind() const;

  BufferWriter &operator()(BufferWriter &w, const Spec &spec) const override;

};

template <typename T> class ContextNames : public NameMap<BufferWriter &(BufferWriter &, const Spec &, T &)> {
private:
  using self_type  = ContextNames; 
  using super_type = NameMap<BufferWriter &(BufferWriter &, const Spec &, T &)>;
  using Map        = typename super_type::Map;
 
public:
  using context_type = T; 
  using Generator = typename super_type::Generator;
  using ExternalGenerator = std::function<ExternalGeneratorSignature>;
 
  using super_type::super_type; // inherit @c super_type constructors.

  class Binding : public NameBinding {
  public:
    BufferWriter &
    operator()(BufferWriter &w, const Spec &spec) const override {
      return _names(w, spec, _ctx);
    }
 
  protected:
    Binding(ContextNames const &names, context_type &ctx) : _ctx(ctx), _names(names) {}
 
    context_type &_ctx;         
    ContextNames const &_names; 
 
    friend class ContextNames;
  };

  self_type &assign(std::string_view const &name, const ExternalGenerator &bg);

  self_type &assign(std::string_view const &name, Generator const &generator);

  Binding bind(context_type &context);
 
protected:
  virtual BufferWriter &operator()(BufferWriter &w, const Spec &spec, context_type &ctx) const;
};

extern ExternalNames& Global_Names();
 
// --------------- Implementation --------------------
 
inline Spec::Align
Spec::align_of(char c) {
  return static_cast<Align>(Get_Prop()._data[static_cast<unsigned>(c)] & Property::ALIGN_MASK);
}
 
inline bool
Spec::is_sign(char c) {
  return Get_Prop()._data[static_cast<unsigned>(c)] & Property::SIGN_CHAR;
}
 
inline bool
Spec::is_type(char c) {
  return Get_Prop()._data[static_cast<unsigned>(c)] & Property::TYPE_CHAR;
}
 
inline bool
Spec::is_upper_case_type(char c) {
  return Get_Prop()._data[static_cast<unsigned>(c)] & Property::UPPER_TYPE_CHAR;
}
 
inline bool
Spec::is_numeric_type(char c) {
  return Get_Prop()._data[static_cast<unsigned>(c)] & Property::NUMERIC_TYPE_CHAR;
}
 
inline bool
Spec::has_numeric_type() const {
  return Get_Prop()._data[static_cast<unsigned>(_type)] & Property::NUMERIC_TYPE_CHAR;
}
 
inline bool
Spec::has_upper_case_type() const {
  return Get_Prop()._data[static_cast<unsigned>(_type)] & Property::UPPER_TYPE_CHAR;
}
 
inline bool
Spec::has_pointer_type() const {
  return _type == 'p' || _type == 'P';
}
 
inline bool
Spec::has_valid_type() const {
  return _type != INVALID_TYPE;
}
 
inline auto
Format::bind(swoc::TextView fmt) -> TextViewExtractor {
  return {fmt};
}
 
inline auto
Format::bind() const -> FormatExtractor {
  return {_items};
}
 
inline Format::TextViewExtractor::operator bool() const {
  return !_fmt.empty();
}
 
inline Format::FormatExtractor::operator bool() const {
  return _idx < static_cast<int>(_fmt.size());
}

 
inline BufferWriter &
NameBinding::err_invalid_name(BufferWriter &w, const Spec &spec) {
  return w.print("{{~{}~}}", spec._name);
}
 
inline BufferWriter &
NilBinding::operator()(BufferWriter &, bwf::Spec const &) const {
  throw std::runtime_error("Use of nil bound names in BW formatting");
}
 
template <typename T>
inline auto
ContextNames<T>::bind(context_type &ctx) -> Binding {
  return {*this, ctx};
}
 
template <typename T>
BufferWriter &
ContextNames<T>::operator()(BufferWriter &w, const Spec &spec, context_type &ctx) const {
  if (!spec._name.empty()) {
    if (auto spot = super_type::_map.find(spec._name); spot != super_type::_map.end()) {
      spot->second(w, spec, ctx);
    } else {
      Binding::err_invalid_name(w, spec);
    }
  }
  return w;
}
 
template <typename F> NameMap<F>::NameMap() {}
 
template <typename F> NameMap<F>::NameMap(std::initializer_list<std::tuple<std::string_view, const Generator &>> list) {
  for (auto &&[name, generator] : list) {
    this->assign(name, generator);
  }
}
 
template <typename F>
bool
NameMap<F>::contains(std::string_view name) {
  return _map.end() != _map.find(name);
}
 
template <typename F>
std::string_view
NameMap<F>::localize(std::string_view const &name) {
  auto span = _arena.alloc_span<char>(name.size());
  memcpy(span, name);
  return std::string_view(span.data(), span.size());
}
 
template <typename F>
auto
NameMap<F>::assign(std::string_view const &name, Generator const &generator) -> self_type & {
  _map[this->localize(name)] = generator;
  return *this;
}
 
inline BufferWriter &
ExternalNames::operator()(BufferWriter &w, const Spec &spec) const {
  if (!spec._name.empty()) {
    if (auto spot = _map.find(spec._name); spot != _map.end()) {
      spot->second(w, spec);
    } else {
      this->err_invalid_name(w, spec);
    }
  }
  return w;
}
 
inline NameBinding const &
ExternalNames::bind() const {
  return *this;
}
 
template <typename T>
auto
ContextNames<T>::assign(std::string_view const &name, ExternalGenerator const &bg) -> self_type & {
  // wrap @a bg in a shim that discards the context so it can be stored in the map.
  super_type::assign(name, [bg](BufferWriter &w, Spec const &spec, context_type &) -> BufferWriter & { return bg(w, spec); });
  return *this;
}
 
template <typename T>
auto
ContextNames<T>::assign(std::string_view const &name, Generator const &g) -> self_type & {
  super_type::assign(name, g);
  return *this;
}


template <typename TUPLE> using ArgFormatterSignature = BufferWriter &(*)(BufferWriter &w, Spec const &, TUPLE const &args);

void Err_Bad_Arg_Index(BufferWriter &w, int i, size_t n);
 
// MSVC will expand the parameter pack inside a lambda but not gcc, so this indirection is required.

template <typename TUPLE, size_t I>
BufferWriter &
Arg_Formatter(BufferWriter &w, Spec const &spec, TUPLE const &args) {
  return bwformat(w, spec, std::get<I>(args));
}

template <typename TUPLE, size_t... N>
ArgFormatterSignature<TUPLE> *
Get_Arg_Formatter_Array(std::index_sequence<N...>) {
  static ArgFormatterSignature<TUPLE> fa[sizeof...(N)] = {&bwf::Arg_Formatter<TUPLE, N>...};
  return fa;
}

void Adjust_Alignment(BufferWriter &aux, Spec const &spec);

BufferWriter &Format_Integer(BufferWriter &w, Spec const &spec, uintmax_t n, bool negative_p);

BufferWriter &Format_Float(BufferWriter &w, Spec const &spec, double f, bool negative_p);

void Format_As_Hex(BufferWriter &w, std::string_view view, const char *digits);
 
/* Capture support, which allows format extractors to capture arguments and consume them.
 * This was built in order to support C style formatting, which needs to capture arguments
 * to set the minimum width and/or the precision of other arguments.
 *
 * The key component is the ability to dynamically access an element of a tuple using
 * @c std::any.
 *
 * Note: Much of this was originally in the meta support but it caused problems in use if
 * the tuple header wasn't also included. I was unable to determine why, so this code doesn't
 * depend on tuple explicitly.
 */
template <typename T> using TupleAccessorSignature = std::any (*)(T const &t);

template <size_t IDX, typename T>
std::any
TupleAccessor(T const &t) {
  return std::any(&std::get<IDX>(t));
}

template <typename T, size_t... N>
std::array<TupleAccessorSignature<T>, sizeof...(N)> &
Tuple_Accessor_Array(std::index_sequence<N...>) {
  static std::array<TupleAccessorSignature<T>, sizeof...(N)> accessors = {&TupleAccessor<N>...};
  return accessors;
}

template <typename T>
std::any
Tuple_Nth(T const &t, size_t idx) {
  return Tuple_Accessor_Array<T>(std::make_index_sequence<std::tuple_size<T>::value>())[idx](t);
}

template <typename F>
auto
arg_capture(F &&, BufferWriter &, Spec const &, std::any &&, swoc::meta::CaseTag<0>) -> void {
  throw std::runtime_error("Capture specification used in format extractor that does not support capture");
}
 
template <typename F>
auto
arg_capture(F &&f, BufferWriter &w, Spec const &spec, std::any &&value, swoc::meta::CaseTag<1>)
  -> decltype(f.capture(w, spec, value)) {
  return f.capture(w, spec, value);
}

template <typename EXTRACTOR, typename VIEW, typename SPEC>
auto
extractor_spec_type(bool (EXTRACTOR::*)(VIEW, SPEC)) -> SPEC {}

class ArgPack {
public:
  virtual ~ArgPack() = default; 

  virtual std::any capture(unsigned idx) const = 0;

  virtual BufferWriter &print(BufferWriter &w, Spec const &spec, unsigned idx) const = 0;

  virtual unsigned count() const = 0;
};

template <typename... Args> class ArgTuple : public ArgPack {
public:
  ArgTuple(std::tuple<Args...> const &tuple) : _tuple(tuple) {}
 
protected:
  unsigned count() const override;

  BufferWriter &print(BufferWriter &w, Spec const &spec, unsigned idx) const override;

  std::any capture(unsigned idx) const override;

  std::tuple<Args...> const &_tuple;
};
 
template <typename... Args>
unsigned
ArgTuple<Args...>::count() const {
  return sizeof...(Args);
}
 
template <typename... Args>
BufferWriter &
ArgTuple<Args...>::print(BufferWriter &w, Spec const &spec, unsigned idx) const {
  static const auto _fa{bwf::Get_Arg_Formatter_Array<std::tuple<Args...>>(std::index_sequence_for<Args...>{})};
  return _fa[idx](w, spec, _tuple);
}
 
template <typename... Args>
std::any
ArgTuple<Args...>::capture(unsigned idx) const {
  return {Tuple_Nth(_tuple, idx)};
}
 
} // namespace bwf
 
template <typename Binding, typename Extractor>
BufferWriter &
BufferWriter::print_nfv(Binding &&names, Extractor &&ex, bwf::ArgPack const &args) {
  using namespace std::literals;
  // This gets the actual specifier type from the Extractor - it must be a subclass of @c bwf::Spec
  // but this enables format extractors to use a subclass if additional data needs to be passed
  // via the specifier.
  using spec_type =
    typename std::remove_reference<decltype(bwf::extractor_spec_type(&std::remove_reference<Extractor>::type::operator()))>::type;
  int N       = args.count();
  int arg_idx = 0; // the next argument index to be processed.
 
  // Parser is required to return @c false if there's no more data, @c true if something was parsed.
  while (ex) {
    std::string_view lit_v;
    spec_type spec;
    bool spec_p = ex(lit_v, spec);
 
    // If there's a literal, just ship it.
    if (lit_v.size()) {
      this->write(lit_v);
    }
 
    if (spec_p) {
      if (spec._name.size() == 0) {
        spec._idx = arg_idx++;
      }
 
      while (true) {
        size_t width = this->remaining();
        if (spec._max < width) {
          width = spec._max;
        }
 
        FixedBufferWriter lw{this->aux_data(), width};
 
        if (0 <= spec._idx) {
          if (spec._idx < N) {
            if (spec._type == bwf::Spec::CAPTURE_TYPE) {
              bwf::arg_capture(ex, lw, spec, args.capture(spec._idx), swoc::meta::CaseArg);
            } else {
              args.print(lw, spec, spec._idx);
            }
          } else {
            bwf::Err_Bad_Arg_Index(lw, spec._idx, N);
          }
        } else if (spec._name.size()) {
          names(lw, spec);
        }
        if (lw.extent()) {
          bwf::Adjust_Alignment(lw, spec);
          if (!this->commit(lw.extent())) {
            continue;
          }
        }
        break;
      }
    }
  }
  return *this;
}
 
template <typename... Args>
BufferWriter &
BufferWriter::print(const TextView &fmt, Args &&...args) {
  return this->print_nfv(bwf::Global_Names().bind(), bwf::Format::bind(fmt), bwf::ArgTuple{std::forward_as_tuple(args...)});
}
 
template <typename... Args>
BufferWriter &
BufferWriter::print(bwf::Format const &fmt, Args &&...args) {
  return this->print_nfv(bwf::Global_Names().bind(), fmt.bind(), bwf::ArgTuple{std::forward_as_tuple(args...)});
}
 
template <typename... Args>
BufferWriter &
BufferWriter::print_v(TextView const &fmt, std::tuple<Args...> const &args) {
  return this->print_nfv(bwf::Global_Names().bind(), bwf::Format::bind(fmt), bwf::ArgTuple{args});
}
 
template <typename... Args>
BufferWriter &
BufferWriter::print_v(const bwf::Format &fmt, const std::tuple<Args...> &args) {
  return this->print_nfv(bwf::Global_Names().bind(), fmt.bind(), bwf::ArgTuple{args});
}
 
template <typename Binding, typename Extractor>
BufferWriter &
BufferWriter::print_nfv(Binding const &names, Extractor &&f) {
  return print_nfv(names, f, bwf::ArgTuple{std::make_tuple()});
}
 
template <typename Binding>
BufferWriter &
BufferWriter::print_n(Binding const &names, TextView const &fmt) {
  return print_nfv(names, bwf::Format::bind(fmt), bwf::ArgTuple{std::make_tuple()});
}
 
inline MemSpan<char>
BufferWriter::aux_span() {
  return {this->aux_data(), this->remaining()};
}
 
// ---- Formatting for specific types.

BufferWriter &bwformat(BufferWriter &w, bwf::Spec const &spec, std::string_view sv);

BufferWriter &bwformat(BufferWriter &w, bwf::Spec const &spec, const void *ptr);

BufferWriter &bwformat(BufferWriter &w, bwf::Spec const &spec, MemSpan<void const> const &span);

inline BufferWriter &
bwformat(BufferWriter &w, bwf::Spec const &spec, MemSpan<void> const &span) {
  return bwformat(w, spec, span.rebind<void const>());
}
 
template <typename T>
BufferWriter &
bwformat(BufferWriter &w, bwf::Spec const &spec, MemSpan<T> const &span) {
  bwf::Spec s{spec};
  // If the precision isn't already specified, make it the size of the objects in the span.
  // This will break the output into blocks of that size.
  if (spec._prec <= 0) {
    s._prec = sizeof(T);
  }
  return bwformat(w, s, span.template rebind<void const>());
}
 
template <size_t N>
BufferWriter &
bwformat(BufferWriter &w, bwf::Spec const &spec, const char (&a)[N]) {
  return bwformat(w, spec, std::string_view(a, N - 1));
}
 
// Capture this explicitly so it doesn't go to any other pointer type.
inline BufferWriter &
bwformat(BufferWriter &w, bwf::Spec const &spec, std::nullptr_t) {
  return bwformat(w, spec, static_cast<void *>(nullptr));
}
 
// Char pointer formatting
inline BufferWriter &
bwformat(BufferWriter &w, bwf::Spec const &spec, const char *v) {
  if (spec._type == 'x' || spec._type == 'X' || spec._type == 'p' || spec._type == 'P') {
    bwformat(w, spec, static_cast<const void *>(v));
  } else if (v != nullptr) {
    bwformat(w, spec, std::string_view(v));
  } else {
    bwformat(w, spec, nullptr);
  }
  return w;
}
// doc end
 
inline BufferWriter &
bwformat(BufferWriter &w, bwf::Spec const &spec, std::string const &s) {
  return bwformat(w, spec, std::string_view{s});
}
 
inline BufferWriter &
bwformat(BufferWriter &w, bwf::Spec const &spec, TextView tv) {
  return bwformat(w, spec, static_cast<std::string_view>(tv));
}
 
template <typename X, typename V>
BufferWriter &
bwformat(BufferWriter &w, bwf::Spec const &, TransformView<X, V> &&view) {
  while (view)
    w.write(char(*(view++)));
  return w;
}
 
template <typename F>
auto
bwformat(BufferWriter &w, bwf::Spec const &spec, F &&f) ->
  typename std::enable_if<std::is_floating_point_v<typename std::remove_reference_t<F>>, BufferWriter &>::type {
  return f < 0 ? bwf::Format_Float(w, spec, -f, true) : bwf::Format_Float(w, spec, f, false);
}
 
/* Integer types.
 
   Due to some oddities for MacOS building, need a bit more template magic here. The underlying
   integer rendering is in @c Format_Integer which takes @c intmax_t or @c uintmax_t. For @c
   bwformat templates are defined, one for signed and one for unsigned. These forward their argument
   to the internal renderer. To avoid additional ambiguity the template argument is checked with @c
   std::enable_if to invalidate the overload if the argument type isn't a signed / unsigned
   integer. One exception to this is @c char which is handled by a previous overload in order to
   treat the value as a character and not an integer. The overall benefit is this works for any set
   of integer types, rather tuning and hoping to get just the right set of overloads.
 */
 
template <typename I>
auto
bwformat(BufferWriter &w, bwf::Spec const &spec, I &&i) ->
  typename std::enable_if<std::is_unsigned<typename std::remove_reference<I>::type>::value &&
                            std::is_integral<typename std::remove_reference<I>::type>::value,
                          BufferWriter &>::type {
  return bwf::Format_Integer(w, spec, i, false);
}
 
template <typename I>
auto
bwformat(BufferWriter &w, bwf::Spec const &spec, I &&i) ->
  typename std::enable_if<std::is_signed<typename std::remove_reference<I>::type>::value &&
                            std::is_integral<typename std::remove_reference<I>::type>::value,
                          BufferWriter &>::type {
  bool neg_p  = false;
  uintmax_t n = static_cast<uintmax_t>(i);
  if (i < 0) {
    n     = static_cast<uintmax_t>(-i);
    neg_p = true;
  }
  return bwf::Format_Integer(w, spec, n, neg_p);
}
 
inline BufferWriter &
bwformat(BufferWriter &w, bwf::Spec const &, char c) {
  return w.write(c);
}
 
inline BufferWriter &
bwformat(BufferWriter &w, bwf::Spec const &spec, bool f) {
  using namespace std::literals;
  if ('s' == spec._type) {
    w.write(f ? "true"sv : "false"sv);
  } else if ('S' == spec._type) {
    w.write(f ? "TRUE"sv : "FALSE"sv);
  } else {
    bwf::Format_Integer(w, spec, static_cast<uintmax_t>(f), false);
  }
  return w;
}
 
// std::string support
template <typename... Args>
std::string &
bwprint_v(std::string &s, TextView fmt, std::tuple<Args...> const &args) {
  auto const len = s.size(); // remember initial size
  auto printer   = [&]() { return FixedBufferWriter(s.data(), s.capacity()).print_v(fmt, args).extent(); };
  size_t n       = printer();
  s.resize(n);   // always need to resize - if shorter, must clip pre-existing text.
  if (n > len) { // dropped data, try again.
    printer();
  }
  return s;
}

template <typename... Args>
std::string &
bwprint(std::string &s, TextView fmt, Args &&...args) {
  return bwprint_v(s, fmt, std::forward_as_tuple(args...));
}

template <typename... Args>
std::string &
bwappend(std::string &s, TextView fmt, Args &&...args) {
  auto const len      = s.length();   // Text to preserve.
  auto const capacity = s.capacity(); // Working space.
  auto printer        = [&]() { return FixedBufferWriter(s.data() + len, s.capacity() - len).print(fmt, args...).extent(); };
  // Resize first, otherwise capacity past @a len is cleared on @c resize.
  s.resize(capacity);
  auto n = printer() + len; // Get the final length.
  s.resize(n);              // Adjust to correct string length.
  if (n > capacity) {       // dropped data, write it again.
    printer();
  }
  return s;
}

template <typename... Args>
auto
FixedBufferWriter::print(TextView fmt, Args &&...args) -> self_type & {
  return static_cast<self_type &>(this->super_type::print_v(fmt, std::forward_as_tuple(args...)));
}
 
template <typename... Args>
auto
FixedBufferWriter::print_v(TextView fmt, std::tuple<Args...> const &args) -> self_type & {
  return static_cast<self_type &>(this->super_type::print_v(fmt, args));
}
 
template <typename... Args>
auto
FixedBufferWriter::print(bwf::Format const &fmt, Args &&...args) -> self_type & {
  return static_cast<self_type &>(this->super_type::print_v(fmt, std::forward_as_tuple(args...)));
}
 
template <typename... Args>
auto
FixedBufferWriter::print_v(bwf::Format const &fmt, std::tuple<Args...> const &args) -> self_type & {
  return static_cast<self_type &>(this->super_type::print_v(fmt, args));
}
 
// Special case support for @c Scalar, because @c Scalar is a base utility for some other utilities
// there can be some unpleasant circularities if @c Scalar includes BufferWriter formatting. If the
// support is here then it's fine because anything using BWF for @c Scalar must include this header.
template <intmax_t N, typename C, typename T> class Scalar;
namespace detail {
template <typename T>
auto
tag_label(BufferWriter &, const bwf::Spec &, meta::CaseTag<0>) -> void {}
 
template <typename T>
auto
tag_label(BufferWriter &w, const bwf::Spec &, meta::CaseTag<1>) -> decltype(T::label, meta::TypeFunc<void>()) {
  w.print("{}", T::label);
}
} // namespace detail
 
template <intmax_t N, typename C, typename T>
BufferWriter &
bwformat(BufferWriter &w, bwf::Spec const &spec, Scalar<N, C, T> const &x) {
  bwformat(w, spec, x.value());
  if (!spec.has_numeric_type()) {
    detail::tag_label<T>(w, spec, meta::CaseArg);
  }
  return w;
}
 
// Generically a stream operator is a formatter with the default specification.
template <typename V>
BufferWriter &
operator<<(BufferWriter &w, V &&v) {
  return bwformat(w, bwf::Spec::DEFAULT, std::forward<V>(v));
}
 
// Basic format wrappers - these are here because they're used internally.
namespace bwf {
struct HexDump {
  std::string_view _view; 

  HexDump(void const *mem, size_t n) : _view(static_cast<char const *>(mem), n) {}
};

template <typename T>
HexDump
As_Hex(T const &t) {
  return HexDump(&t, sizeof(T));
}
 
} // namespace bwf

BufferWriter &bwformat(BufferWriter &w, bwf::Spec const &spec, bwf::HexDump const &hex);

inline BufferWriter &
bwformat(BufferWriter &w, bwf::Spec const &spec, BufferWriter const &ww) {
  return bwformat(w, spec, TextView(ww));
}
 
template <typename T>
BufferWriter &
BufferWriter::format(bwf::Spec const &spec, T const &t) {
  return bwformat(*this, spec, t);
}
 
template <typename T>
BufferWriter &
BufferWriter::format(bwf::Spec const &spec, T &&t) {
  return bwformat(*this, spec, t);
}
 
}} // namespace swoc::SWOC_VERSION_NS