BufferWriter.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 <string>
#include <iosfwd>
#include <string_view>
 
#include "swoc/swoc_version.h"
#include "swoc/TextView.h"
#include "swoc/MemSpan.h"
#include "swoc/bwf_fwd.h"
 
namespace swoc { inline namespace SWOC_VERSION_NS {

class BufferWriter {
public:
  virtual BufferWriter &write(char c) = 0;

  virtual BufferWriter &write(void const *data, size_t length);

  BufferWriter &write(MemSpan<void const> span);

  virtual const char *data() const = 0;

  virtual bool error() const = 0;

  virtual char *aux_data();

  virtual size_t capacity() const = 0;

  virtual size_t extent() const = 0;

  size_t size() const;

  size_t remaining() const;

  MemSpan<char> aux_span();

  virtual bool commit(size_t n) = 0;

  virtual BufferWriter &discard(size_t n) = 0;

  virtual BufferWriter &restrict(size_t n) = 0;

  virtual BufferWriter &restore(size_t n) = 0;

  virtual BufferWriter &copy(size_t dst, size_t src, size_t n) = 0;
 
  // Force virtual destructor.
  virtual ~BufferWriter();

  template <typename... Args> BufferWriter &print(const TextView &fmt, Args &&...args);

  template <typename... Args> BufferWriter &print_v(const TextView &fmt, const std::tuple<Args...> &args);

  template <typename... Args> BufferWriter &print(const bwf::Format &fmt, Args &&...args);

  template <typename... Args> BufferWriter &print_v(const bwf::Format &fmt, const std::tuple<Args...> &args);

  template <typename Binding, typename Extractor>
  BufferWriter &print_nfv(Binding &&names, Extractor &&ex, bwf::ArgPack const &args);

  template <typename Binding, typename Extractor> BufferWriter &print_nfv(Binding const &names, Extractor &&ex);

  template <typename Binding> BufferWriter &print_n(Binding const &names, TextView const &fmt);

  template <typename T> BufferWriter &format(bwf::Spec const &spec, T &&t);

  template <typename T> BufferWriter &format(bwf::Spec const &spec, T const &t);

  virtual std::ostream &operator>>(std::ostream &stream) const = 0;
};

class FixedBufferWriter : public BufferWriter {
  using super_type = BufferWriter;
  using self_type  = FixedBufferWriter;
 
public:
  FixedBufferWriter(char *buffer, size_t capacity);

  FixedBufferWriter(MemSpan<void> const &span);

  FixedBufferWriter(MemSpan<char> const &span);

  FixedBufferWriter(std::nullptr_t);
 
  FixedBufferWriter(const FixedBufferWriter &) = delete;
 
  FixedBufferWriter &operator=(const FixedBufferWriter &) = delete;

  FixedBufferWriter(FixedBufferWriter &&that);

  FixedBufferWriter &operator=(FixedBufferWriter &&that);

  self_type &assign(MemSpan<char> const &span);

  FixedBufferWriter &write(char c) override;

  FixedBufferWriter &write(const void *data, size_t length) override;
 
  // Bring in non-overridden methods.
  using super_type::write;

  const char *data() const override;

  bool error() const override;

  char *aux_data() override;

  size_t capacity() const override;

  size_t extent() const override;

  bool commit(size_t n) override;

  self_type &discard(size_t n) override;

  self_type &restrict(size_t n) override;

  self_type &restore(size_t n) override;

  FixedBufferWriter &copy(size_t dst, size_t src, size_t n) override;

  self_type &clear();
 
  self_type &detach();

  swoc::TextView view() const;

  operator std::string_view() const;

  operator swoc::TextView() const;

  std::ostream &operator>>(std::ostream &stream) const override;

  template <typename... Rest> self_type &print(TextView fmt, Rest &&...rest);
 
  template <typename... Args> self_type &print_v(TextView fmt, std::tuple<Args...> const &args);
 
  template <typename... Args> self_type &print(bwf::Format const &fmt, Args &&...args);
 
  template <typename... Args> self_type &print_v(bwf::Format const &fmt, std::tuple<Args...> const &args);
 
protected:
  // Used for derived classes where we don't want to throw exceptions.
  FixedBufferWriter(char *buffer, size_t capacity, bool noexcept_flag) noexcept;
 
  char *const _buffer;   
  size_t _capacity;      
  size_t _attempted = 0; 
};

template <size_t N> class LocalBufferWriter : public FixedBufferWriter {
  using self_type  = LocalBufferWriter;
  using super_type = FixedBufferWriter;
 
public:
  LocalBufferWriter() noexcept;
 
  LocalBufferWriter(const LocalBufferWriter &that) = delete;
 
  LocalBufferWriter &operator=(const LocalBufferWriter &that) = delete;
 
protected:
  char _arr[N]; 
};
 
// --------------- Implementation --------------------
 
inline BufferWriter::~BufferWriter() {}
 
inline BufferWriter &
BufferWriter::write(const void *data, size_t length) {
  const char *d = static_cast<const char *>(data);
 
  while (length--) {
    this->write(*(d++));
  }
  return *this;
}
 
#if 0
inline BufferWriter &
BufferWriter::write(const std::string_view &sv) {
  return this->write(sv.data(), sv.size());
}
#endif
 
inline BufferWriter &
BufferWriter::write(MemSpan<void const> span) {
  return this->write(span.data(), span.size());
}
 
inline char *
BufferWriter::aux_data() {
  return nullptr;
}
 
inline size_t
BufferWriter::size() const {
  return std::min(this->extent(), this->capacity());
}
 
inline size_t
BufferWriter::remaining() const {
  return this->capacity() - this->size();
}
 
// --- FixedBufferWriter ---
inline FixedBufferWriter::FixedBufferWriter(char *buffer, size_t capacity) : _buffer(buffer), _capacity(capacity) {
  if (_capacity != 0 && buffer == nullptr) {
    throw(std::invalid_argument{"FixedBufferWriter created with null buffer and non-zero size."});
  };
}
 
inline FixedBufferWriter::FixedBufferWriter(char *buffer, size_t capacity, bool /* noexcept_flag */) noexcept : _buffer(buffer), _capacity(capacity) {
}
 
inline FixedBufferWriter::FixedBufferWriter(MemSpan<void> const &span)
  : _buffer{static_cast<char *>(span.data())}, _capacity{span.size()} {}
 
inline FixedBufferWriter::FixedBufferWriter(MemSpan<char> const &span) : _buffer{span.begin()}, _capacity{span.size()} {}
 
inline FixedBufferWriter::FixedBufferWriter(std::nullptr_t) : _buffer(nullptr), _capacity(0) {}
 
inline FixedBufferWriter::self_type &
FixedBufferWriter::detach() {
  const_cast<char *&>(_buffer) = nullptr;
  _capacity                    = 0;
  _attempted                   = 0;
  return *this;
}
 
inline FixedBufferWriter::FixedBufferWriter(FixedBufferWriter &&that)
  : _buffer(that._buffer), _capacity(that._capacity), _attempted(that._attempted) {
  that.detach();
}
 
inline FixedBufferWriter::self_type &
FixedBufferWriter::assign(MemSpan<char> const &span) {
  const_cast<char *&>(_buffer) = span.data();
  _capacity                    = span.size();
  _attempted                   = 0;
  return *this;
}
 
inline FixedBufferWriter &
FixedBufferWriter::operator=(FixedBufferWriter &&that) {
  const_cast<char *&>(_buffer) = that._buffer;
  _capacity                    = that._capacity;
  _attempted                   = that._attempted;
  that.detach();
  return *this;
}
 
inline FixedBufferWriter &
FixedBufferWriter::write(char c) {
  if (_attempted < _capacity) {
    _buffer[_attempted] = c;
  }
  ++_attempted;
 
  return *this;
}
 
inline FixedBufferWriter &
FixedBufferWriter::write(const void *data, size_t length) {
  const size_t newSize = _attempted + length;
 
  if (_buffer) {
    if (newSize <= _capacity) {
      std::memcpy(_buffer + _attempted, data, length);
    } else if (_attempted < _capacity) {
      std::memcpy(_buffer + _attempted, data, _capacity - _attempted);
    }
  }
  _attempted = newSize;
 
  return *this;
}

inline const char *
FixedBufferWriter::data() const {
  return _buffer;
}
 
inline bool
FixedBufferWriter::error() const {
  return _attempted > _capacity;
}
 
inline char *
FixedBufferWriter::aux_data() {
  return error() ? nullptr : _buffer + _attempted;
}
 
inline bool
FixedBufferWriter::commit(size_t n) {
  _attempted += n;
 
  return true;
}
 
inline size_t
FixedBufferWriter::capacity() const {
  return _capacity;
}
 
inline size_t
FixedBufferWriter::extent() const {
  return _attempted;
}
 
inline auto FixedBufferWriter::restrict(size_t n) -> self_type & {
  if (n > _capacity) {
    throw(std::invalid_argument{"FixedBufferWriter restrict value more than capacity"});
  }
  _capacity -= n;
  return *this;
}
 
inline auto
FixedBufferWriter::restore(size_t n) -> self_type & {
  if (error()) {
    _attempted = _capacity;
  }
  _capacity += n;
  return *this;
}
 
inline auto
FixedBufferWriter::discard(size_t n) -> self_type & {
  _attempted -= std::min(_attempted, n);
  return *this;
}
 
inline auto
FixedBufferWriter::clear() -> self_type & {
  _attempted = 0;
  return *this;
}
 
inline auto
FixedBufferWriter::copy(size_t dst, size_t src, size_t n) -> self_type & {
  auto limit = std::min<size_t>(_capacity, _attempted); // max offset of region possible.
  MemSpan<char> src_span{_buffer + src, std::min(limit, src + n)};
  MemSpan<char> dst_span{_buffer + dst, std::min(limit, dst + n)};
  std::memmove(dst_span.data(), src_span.data(), std::min(dst_span.size(), src_span.size()));
  return *this;
}
 
inline swoc::TextView
FixedBufferWriter::view() const {
  return {_buffer, size()};
}
 
inline FixedBufferWriter::operator std::string_view() const {
  return this->view();
}
 
inline FixedBufferWriter::operator swoc::TextView() const {
  return this->view();
}
 
// --- LocalBufferWriter ---
template <size_t N> LocalBufferWriter<N>::LocalBufferWriter() noexcept : super_type(_arr, N, true) {}
 
}} // namespace swoc::SWOC_VERSION_NS

namespace std {
inline ostream &
operator<<(ostream &s, swoc::BufferWriter const &w) {
  return w >> s;
}
} // end namespace std