Errata.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright Network Geographics 2014
 
#pragma once
 
#include <vector>
#include <string_view>
#include <functional>
#include <atomic>
#include <optional>
 
#include "swoc/swoc_version.h"
#include "swoc/MemSpan.h"
#include "swoc/MemArena.h"
#include "swoc/bwf_base.h"
#include "swoc/bwf_std.h"
#include "swoc/IntrusiveDList.h"
 
namespace swoc { inline namespace SWOC_VERSION_NS {

class Errata {
public:
  using code_type     = std::error_code; 
  using severity_type = uint8_t;         

  struct Severity {
    severity_type _raw; 
 
    explicit constexpr Severity(severity_type n) : _raw(n) {} 
 
    Severity(Severity const &that)            = default;
    Severity &operator=(Severity const &that) = default;
 
    operator severity_type() const { return _raw; } 
  };

  static inline const code_type DEFAULT_CODE;
  static Severity DEFAULT_SEVERITY;
  static Severity FAILURE_SEVERITY;
  static Severity FILTER_SEVERITY;
 
  static inline TextView AUTOTEXT_SEVERITY      = "{}";     
  static inline TextView AUTOTEXT_CODE          = "{}";     
  static inline TextView AUTOTEXT_SEVERITY_CODE = "{}: {}"; 

  static MemSpan<TextView const> SEVERITY_NAMES;

  class Annotation {
    using self_type = Annotation; 
 
  public:
    self_type &clear();

    swoc::TextView text() const;

    unsigned short level() const;

    bool has_severity() const;

    Severity severity(Severity default_severity = DEFAULT_SEVERITY) const;

    self_type &assign(Severity severity);
 
  protected:
    std::string_view _text;            
    unsigned short _level{0};          
    std::optional<Severity> _severity; 

    self_type *_next{nullptr};
    self_type *_prev{nullptr};
    using Linkage = swoc::IntrusiveLinkage<self_type, &self_type::_next, &self_type::_prev>;

    Annotation();

    explicit Annotation(std::string_view text, std::optional<Severity> severity = std::optional<Severity>{},
                        unsigned short level = 0);
 
    friend class Errata;
    friend class swoc::MemArena; // needed for @c MemArena::make
  };
 
protected:
  using self_type = Errata; 
  using Container = IntrusiveDList<Annotation::Linkage>;

  struct Data {
    using self_type = Data; 

    Data(swoc::MemArena &&arena);

    bool empty() const;

    std::string_view localize(std::string_view src);

    swoc::MemSpan<char> remnant();

    swoc::MemSpan<char> alloc(size_t n);
 
    TextView _annotation_glue_text          = DEFAULT_ANNOTATION_GLUE_TEXT;
    TextView _annotation_severity_glue_text = DEFAULT_SEVERITY_GLUE_TEXT;
    TextView _severity_glue_text            = DEFAULT_SEVERITY_GLUE_TEXT;
    TextView _indent_text                   = DEFAULT_INDENT_TEXT;
    bool _glue_final_p                      = true; 
 
    std::optional<Severity> _severity; 
    code_type _code{DEFAULT_CODE};     
    Container _notes;                  
    swoc::MemArena _arena;             
  };
 
public:
  static constexpr struct AutoText {
  } AUTO{};

  Errata()                      = default;
  Errata(self_type const &that) = delete;               
  Errata(self_type &&that) noexcept;                    
  self_type &operator=(self_type const &that) = delete; // no copy assignment.
  self_type &operator=(self_type &&that);               
  ~Errata();                                            

  explicit Errata(code_type const &ec);

  explicit Errata(code_type const &ec, AutoText);

  explicit Errata(Severity severity);

  explicit Errata(Severity severity, AutoText);

  Errata(code_type const &ec, Severity severity);

  explicit Errata(code_type const &ec, Severity severity, AutoText auto_text);

  Errata(code_type const &code, Severity severity, std::string_view const &text);

  Errata(Severity severity, std::string_view const &text);

  Errata(code_type const &code, std::string_view const &text);

  explicit Errata(std::string_view const &text);

  template <typename... Args> Errata(code_type const &code, Severity severity, std::string_view fmt, Args &&...args);
 
  template <typename... Args> Errata(code_type const &type, std::string_view fmt, Args &&...args);
  template <typename... Args> Errata(Severity severity, std::string_view fmt, Args &&...args);
  template <typename... Args> explicit Errata(std::string_view fmt, Args &&...args);

  self_type &note(std::string_view text);

  self_type &note(Severity severity, std::string_view text);

  self_type &note(Severity severity);

  self_type &note(code_type const &ec);

  self_type &note(code_type const &code, Severity severity);

  self_type &note_s(std::optional<Severity> severity, std::string_view text);

  template <typename... Args> self_type &note(std::string_view fmt, Args &&...args);

  template <typename... Args> self_type &note_v(std::string_view fmt, std::tuple<Args...> const &args);

  template <typename... Args> self_type &note(Severity severity, std::string_view fmt, Args &&...args);

  template <typename... Args> self_type &note_v(Severity severity, std::string_view fmt, std::tuple<Args...> const &args);

  template <typename... Args>
  self_type &note_sv(std::optional<Severity> severity, std::string_view fmt, std::tuple<Args...> const &args);

  self_type &note(self_type const &that);

  self_type &note(self_type &&that);

  self_type &clear();

  self_type &sink();
 
  friend std::ostream &operator<<(std::ostream &, self_type const &);

  static inline TextView DEFAULT_ANNOTATION_GLUE_TEXT = "\n";
  static inline TextView DEFAULT_SEVERITY_GLUE_TEXT = ": ";
  // Text used for each level of indent.
  static inline TextView DEFAULT_INDENT_TEXT = "  ";

 
  explicit operator bool() const;

  bool operator!() const;

  bool is_ok() const;

  bool has_severity() const;

  Severity severity() const;

  self_type &assign(Severity severity);

  self_type &update(Severity severity);

  code_type const &code() const;

  self_type &assign(code_type code);

  size_t length() const;

  bool empty() const;
 
  using iterator       = Container::iterator;
  using const_iterator = Container::const_iterator;

  iterator begin();
  const_iterator begin() const;
  iterator end();
  const_iterator end() const;

  const Annotation &front() const;

  const Annotation &back() const;
 
  // Logging support.

  TextView annotation_glue_text() const;

  self_type &assign_annotation_glue_text(TextView text, bool final_glue_p = false);

  TextView annotation_severity_glue_text() const;

  self_type &assign_annotation_severity_glue_text(TextView text);

  TextView severity_glue_text() const;

  self_type &assign_severity_glue_text(TextView text);

  TextView indent_text() const;

  self_type &assign_indent_text(TextView text);

  class Sink {
    using self_type = Sink;
 
  public:
    using Handle = std::shared_ptr<self_type>; 

    virtual void operator()(Errata const &) const = 0;
    virtual ~Sink() {}
  };

  static void register_sink(Sink::Handle const &s);

  using SinkHandler = std::function<void(Errata const &)>;

  struct SinkWrapper : public Sink {
    SinkWrapper(SinkHandler const &f) : _f(f) {}
    SinkWrapper(SinkHandler &&f) : _f(std::move(f)) {}
    void operator()(Errata const &e) const override;
    SinkHandler _f; 
  };

  static void
  register_sink(SinkHandler const &f) {
    register_sink(Sink::Handle(new SinkWrapper(f)));
  }

  static void
  register_sink(SinkHandler &&f) {
    register_sink(Sink::Handle(new SinkWrapper(std::move(f))));
  }

  std::ostream &write(std::ostream &out) const;
 
protected:
  Data *_data = nullptr;

  Data *data();

  MemSpan<char> alloc(size_t n);

  self_type &note_localized(std::string_view const &text, std::optional<Severity> severity = std::optional<Severity>{});

  static Annotation const NIL_NOTE;
 
  friend struct Data;
  friend class Item;
  friend BufferWriter &bwformat(BufferWriter &bw, bwf::Spec const &, Errata const &errata);
};
 
extern std::ostream &operator<<(std::ostream &os, Errata const &stat);

template <typename R> class Rv {
public:
  using result_type = R; 
  using code_type   = Errata::code_type;
  using Severity    = Errata::Severity;
 
protected:
  using self_type = Rv; 
 
  result_type _r; 
  Errata _errata; 
 
public:
  Rv();

  Rv(result_type const &result);

  Rv(result_type const &result, Errata &&errata);

  Rv(result_type &&result);

  Rv(result_type &&result, Errata &&errata);

  Rv(Errata &&errata);

  self_type &note(std::string_view text);

  self_type &note(Severity severity, std::string_view text);

  self_type &note(code_type const &code);

  self_type &note(code_type const &code, Severity severity);

  template <typename... Args> self_type &note(std::string_view fmt, Args &&...args);

  template <typename... Args> self_type &note(Severity severity, std::string_view fmt, Args &&...args);

  self_type &note(Errata const &that);

  self_type &note(Errata &&that);

  operator result_type const &() const;

  result_type &operator=(result_type const &r);

  result_type &operator=(result_type &&r);

  self_type &assign(result_type const &result);

  self_type &assign(result_type &&result);

  result_type &result();

  result_type const &result() const;

  Errata &errata();

  Errata const &errata() const;

  operator Errata &();

  self_type &operator=(Errata &&status);

  bool is_ok() const;

  self_type &clear();
};

template <typename R>
Rv<typename std::remove_reference<R>::type>
MakeRv(R &&r,           
       Errata &&erratum 
) {
  return Rv<typename std::remove_reference<R>::type>(std::forward<R>(r), std::move(erratum));
}
/* ----------------------------------------------------------------------- */
// Inline methods for Annotation
 
inline Errata::Annotation::Annotation() = default;
 
inline Errata::Annotation::Annotation(std::string_view text, std::optional<Severity> severity, unsigned short level)
  : _text(text), _level(level), _severity(severity) {}
 
inline Errata::Annotation &
Errata::Annotation::clear() {
  _text = std::string_view{};
  return *this;
}
 
inline swoc::TextView
Errata::Annotation::text() const {
  return _text;
}
 
inline unsigned short
Errata::Annotation::level() const {
  return _level;
}
 
inline bool
Errata::Annotation::has_severity() const {
  return _severity.has_value();
}
inline auto
Errata::Annotation::severity(Errata::Severity default_severity) const -> Severity {
  return _severity.value_or(default_severity);
}
inline auto
Errata::Annotation::assign(Errata::Severity severity) -> self_type & {
  _severity = severity;
  return *this;
}
 
/* ----------------------------------------------------------------------- */
// Inline methods for Errata::Data
 
inline Errata::Data::Data(MemArena &&arena) {
  _arena = std::move(arena);
}
 
inline swoc::MemSpan<char>
Errata::Data::remnant() {
  return _arena.remnant().rebind<char>();
}
 
inline swoc::MemSpan<char>
Errata::Data::alloc(size_t n) {
  return _arena.alloc(n).rebind<char>();
}
 
inline bool
Errata::Data::empty() const {
  return _notes.empty();
}
 
/* ----------------------------------------------------------------------- */
// Inline methods for Errata
 
inline Errata::Errata(self_type &&that) noexcept {
  std::swap(_data, that._data);
}
 
inline Errata::Errata(code_type const &ec) {
  this->data()->_code = ec;
}
 
inline Errata::Errata(Severity severity) {
  this->data()->_severity = severity;
}
 
inline Errata::Errata(const code_type &ec, Severity severity) {
  auto d       = this->data();
  d->_severity = severity;
  d->_code     = ec;
}
 
inline Errata::Errata(code_type const &ec, AutoText) {
  this->data()->_code = ec;
  this->note(AUTOTEXT_CODE, ec);
}
 
inline Errata::Errata(Severity severity, AutoText) {
  this->data()->_severity = severity;
  this->note(AUTOTEXT_SEVERITY, severity);
}
 
inline Errata::Errata(const code_type &ec, Severity severity, AutoText) : Errata(ec, severity) {
  this->note(AUTOTEXT_SEVERITY_CODE, severity, ec);
}
 
inline Errata::Errata(const code_type &code, Severity severity, const std::string_view &text) : Errata(code, severity) {
  this->note(text);
}
 
inline Errata::Errata(const std::string_view &text) : Errata(DEFAULT_CODE, DEFAULT_SEVERITY, text) {}
inline Errata::Errata(code_type const &code, const std::string_view &text) : Errata(code, DEFAULT_SEVERITY, text) {}
inline Errata::Errata(Severity severity, const std::string_view &text) : Errata(DEFAULT_CODE, severity, text) {}
 
template <typename... Args>
Errata::Errata(code_type const &code, Severity severity, std::string_view fmt, Args &&...args) : Errata(code, severity) {
  this->note_v(fmt, std::forward_as_tuple(args...));
}
 
template <typename... Args>
Errata::Errata(code_type const &code, std::string_view fmt, Args &&...args)
  : Errata(code, DEFAULT_SEVERITY, fmt, std::forward<Args>(args)...) {}
template <typename... Args>
Errata::Errata(Severity severity, std::string_view fmt, Args &&...args)
  : Errata(DEFAULT_CODE, severity, fmt, std::forward<Args>(args)...) {}
template <typename... Args>
Errata::Errata(std::string_view fmt, Args &&...args) : Errata(DEFAULT_CODE, DEFAULT_SEVERITY, fmt, std::forward<Args>(args)...) {}
 
inline Errata &
Errata::clear() {
  if (_data) {
    _data->~Data(); // destructs the @c MemArena in @a _data which releases memory.
    _data = nullptr;
  }
  return *this;
}
 
inline auto
Errata::operator=(self_type &&that) -> self_type & {
  if (this != &that) {
    this->clear();
    std::swap(_data, that._data);
  }
  return *this;
}
 
inline Errata::operator bool() const {
  return this->is_ok();
}
 
inline bool
Errata::operator!() const {
  return !this->is_ok();
}
 
inline bool
Errata::empty() const {
  return _data == nullptr || _data->_notes.count() == 0;
}
 
inline auto
Errata::code() const -> code_type const & {
  return this->empty() ? DEFAULT_CODE : _data->_code;
}
 
inline auto
Errata::assign(code_type code) -> self_type & {
  this->data()->_code = code;
  return *this;
}
 
inline bool
Errata::has_severity() const {
  return _data && _data->_severity.has_value();
}
inline auto
Errata::severity() const -> Severity {
  return this->has_severity() ? _data->_severity.value() : DEFAULT_SEVERITY;
}
 
inline auto
Errata::assign(Severity severity) -> self_type & {
  this->data()->_severity = severity;
  return *this;
}
 
inline size_t
Errata::length() const {
  return _data ? _data->_notes.count() : 0;
}
 
inline bool
Errata::is_ok() const {
  return nullptr == _data || this->severity() < FAILURE_SEVERITY;
}
 
inline const Errata::Annotation &
Errata::front() const {
  return *(_data->_notes.head());
}
 
inline const Errata::Annotation &
Errata::back() const {
  return *(_data->_notes.tail());
}
 
inline Errata &
Errata::note(self_type &&that) {
  this->note(that); // no longer an rvalue reference, so no recursion.
  that.clear();
  return *this;
}
 
inline Errata &
Errata::note(std::string_view text) {
  return this->note_s({}, text);
}
 
inline Errata &
Errata::note(Severity severity, std::string_view text) {
  return this->note_s(severity, text);
}
 
inline Errata &
Errata::note(Severity severity) {
  return this->note(severity, AUTOTEXT_SEVERITY, severity);
}
 
inline Errata &
Errata::note(code_type const &code) {
  return this->note(AUTOTEXT_CODE, code);
}
 
inline Errata &
Errata::note(code_type const &ec, Severity severity) {
  return this->note(severity, AUTOTEXT_SEVERITY_CODE, severity, ec);
}
 
template <typename... Args>
Errata &
Errata::note_sv(std::optional<Severity> severity, std::string_view fmt, std::tuple<Args...> const &args) {
  if (severity.has_value()) {
    this->update(*severity);
  }
 
  if (!severity.has_value() || *severity >= FILTER_SEVERITY) {
    Data *data = this->data();
    auto span  = data->remnant();
    FixedBufferWriter bw{span};
    if (!bw.print_v(fmt, args).error()) {
      span = span.prefix(bw.extent());
      data->alloc(bw.extent()); // require the part of the remnant actually used.
    } else {
      // Not enough space, get a big enough chunk and do it again.
      span = this->alloc(bw.extent());
      FixedBufferWriter{span}.print_v(fmt, args);
    }
    this->note_localized(TextView(span), severity);
  }
  return *this;
}
 
template <typename... Args>
Errata &
Errata::note_v(std::string_view fmt, std::tuple<Args...> const &args) {
  return this->note_sv({}, fmt, args);
}
 
template <typename... Args>
Errata &
Errata::note_v(Severity severity, std::string_view fmt, std::tuple<Args...> const &args) {
  return this->note_sv(severity, fmt, args);
}
 
template <typename... Args>
Errata &
Errata::note(std::string_view fmt, Args &&...args) {
  return this->note_sv({}, fmt, std::forward_as_tuple(args...));
}
 
template <typename... Args>
Errata &
Errata::note(Severity severity, std::string_view fmt, Args &&...args) {
  return this->note_sv(severity, fmt, std::forward_as_tuple(args...));
}
 
inline Errata::iterator
Errata::begin() {
  return _data ? _data->_notes.begin() : iterator();
}
 
inline Errata::const_iterator
Errata::begin() const {
  return _data ? _data->_notes.begin() : const_iterator();
}
 
inline Errata::iterator
Errata::end() {
  return _data ? _data->_notes.end() : iterator();
}
 
inline Errata::const_iterator
Errata::end() const {
  return _data ? _data->_notes.end() : const_iterator();
}
 
inline TextView
Errata::annotation_glue_text() const {
  return _data ? _data->_annotation_glue_text : DEFAULT_ANNOTATION_GLUE_TEXT;
}
 
inline auto
Errata::assign_annotation_glue_text(TextView text, bool final_glue_p) -> self_type & {
  this->data()->_annotation_glue_text = this->data()->localize(text);
  this->data()->_glue_final_p         = final_glue_p;
  return *this;
}
 
inline TextView
Errata::annotation_severity_glue_text() const {
  return _data ? _data->_annotation_severity_glue_text : DEFAULT_SEVERITY_GLUE_TEXT;
}
 
inline auto
Errata::assign_annotation_severity_glue_text(TextView text) -> self_type & {
  this->data()->_annotation_severity_glue_text = this->data()->localize(text);
  return *this;
}
 
inline TextView
Errata::severity_glue_text() const {
  return _data ? _data->_severity_glue_text : DEFAULT_SEVERITY_GLUE_TEXT;
}
 
inline auto
Errata::assign_severity_glue_text(TextView text) -> self_type & {
  this->data()->_severity_glue_text = this->data()->localize(text);
  return *this;
}
 
inline TextView
Errata::indent_text() const {
  return _data ? _data->_indent_text : DEFAULT_INDENT_TEXT;
}
 
inline auto
Errata::assign_indent_text(TextView text) -> self_type & {
  this->data()->_indent_text = this->data()->localize(text);
  return *this;
}
 
inline void
Errata::SinkWrapper::operator()(Errata const &e) const {
  _f(e);
}
/* ----------------------------------------------------------------------- */
// Inline methods for Rv
 
template <typename R>
inline auto
Rv<R>::note(std::string_view text) -> self_type & {
  _errata.note(text);
  return *this;
}
 
template <typename R>
inline auto
Rv<R>::note(Severity severity, std::string_view text) -> self_type & {
  _errata.note(severity, text);
  return *this;
}
 
template <typename R>
auto
Rv<R>::note(const code_type &code) -> self_type & {
  _errata.note(code);
  return *this;
}
 
template <typename R>
auto
Rv<R>::note(const code_type &code, Severity severity) -> self_type & {
  _errata.note(code, severity);
  return *this;
}
 
template <typename R>
template <typename... Args>
auto
Rv<R>::note(std::string_view fmt, Args &&...args) -> self_type & {
  _errata.note(fmt, std::forward<Args>(args)...);
  return *this;
}
 
template <typename R>
template <typename... Args>
auto
Rv<R>::note(Severity severity, std::string_view fmt, Args &&...args) -> self_type & {
  _errata.note(severity, fmt, std::forward<Args>(args)...);
  return *this;
}
 
template <typename R>
bool
Rv<R>::is_ok() const {
  return _errata.is_ok();
}
 
template <typename R>
auto
Rv<R>::clear() -> self_type & {
  errata().clear();
  return *this;
}
 
template <typename T> Rv<T>::Rv() {}
 
template <typename T> Rv<T>::Rv(result_type const &r) : _r(r) {}
 
template <typename T> Rv<T>::Rv(result_type const &r, Errata &&errata) : _r(r), _errata(std::move(errata)) {}
 
template <typename R> Rv<R>::Rv(R &&r) : _r(std::move(r)) {}
 
template <typename R> Rv<R>::Rv(R &&r, Errata &&errata) : _r(std::move(r)), _errata(std::move(errata)) {}
 
template <typename R> Rv<R>::Rv(Errata &&errata) : _errata{std::move(errata)} {}
 
template <typename T> Rv<T>::operator result_type const &() const {
  return _r;
}
 
template <typename R>
R const &
Rv<R>::result() const {
  return _r;
}
 
template <typename R>
R &
Rv<R>::result() {
  return _r;
}
 
template <typename R>
Errata const &
Rv<R>::errata() const {
  return _errata;
}
 
template <typename R>
Errata &
Rv<R>::errata() {
  return _errata;
}
 
template <typename R> Rv<R>::operator Errata &() {
  return _errata;
}
 
template <typename R>
Rv<R> &
Rv<R>::assign(result_type const &r) {
  _r = r;
  return *this;
}
 
template <typename R>
Rv<R> &
Rv<R>::assign(R &&r) {
  _r = std::move(r);
  return *this;
}
 
template <typename R>
auto
Rv<R>::operator=(Errata &&errata) -> self_type & {
  _errata = std::move(errata);
  return *this;
}
 
template <typename R>
inline Rv<R> &
Rv<R>::note(Errata const &that) {
  this->_errata.note(that);
  return *this;
}
 
template <typename R>
inline Rv<R> &
Rv<R>::note(Errata &&that) {
  this->_errata.note(std::move(that));
  that.clear();
  return *this;
}
 
template <typename R>
auto
Rv<R>::operator=(result_type const &r) -> result_type & {
  _r = r;
  return _r;
}
 
template <typename R>
auto
Rv<R>::operator=(result_type &&r) -> result_type & {
  _r = std::move(r);
  return _r;
}
 
BufferWriter &bwformat(BufferWriter &w, bwf::Spec const &spec, Errata::Severity);
 
BufferWriter &bwformat(BufferWriter &w, bwf::Spec const &spec, Errata::Annotation const &);
 
BufferWriter &bwformat(BufferWriter &w, bwf::Spec const &spec, Errata const &);
 
}} // namespace swoc::SWOC_VERSION_NS
 
// Tuple / structured binding support.
namespace std {
template <size_t IDX, typename R> class tuple_element<IDX, swoc::Rv<R>> {
  static_assert("swoc:Rv tuple index out of range");
};
 
template <typename R> class tuple_element<0, swoc::Rv<R>> {
public:
  using type = typename swoc::Rv<R>::result_type;
};
 
template <typename R> class tuple_element<1, swoc::Rv<R>> {
public:
  using type = swoc::Errata;
};
 
template <typename R> class tuple_size<swoc::Rv<R>> : public std::integral_constant<size_t, 2> {};
} // namespace std
 
namespace swoc { inline namespace SWOC_VERSION_NS {
// Not sure how much of this is needed, but experimentally all of these were needed in one
// use case or another of structured binding. I wasn't able to make this work if this was
// defined in namespace @c std. Also, because functions can't be partially specialized, it is
// necessary to use @c constexpr @c if to handle the cases. This should roll up nicely when
// compiled.

template <size_t IDX, typename R>
typename std::tuple_element<IDX, swoc::Rv<R>>::type &
get(swoc::Rv<R> &&rv) {
  if constexpr (IDX == 0) {
    return rv.result();
  } else if constexpr (IDX == 1) {
    return rv.errata();
  }
}
 
template <size_t IDX, typename R>
typename std::tuple_element<IDX, swoc::Rv<R>>::type &
get(swoc::Rv<R> &rv) {
  static_assert(0 <= IDX && IDX <= 1, "Errata tuple index out of range (0..1)");
  if constexpr (IDX == 0) {
    return rv.result();
  } else if constexpr (IDX == 1) {
    return rv.errata();
  }
  // Shouldn't need this due to the @c static_assert but the Intel compiler requires it.
  throw std::domain_error("Errata index value out of bounds");
}
 
template <size_t IDX, typename R>
typename std::tuple_element<IDX, swoc::Rv<R>>::type const &
get(swoc::Rv<R> const &rv) {
  static_assert(0 <= IDX && IDX <= 1, "Errata tuple index out of range (0..1)");
  if constexpr (IDX == 0) {
    return rv.result();
  } else if constexpr (IDX == 1) {
    return rv.errata();
  }
  // Shouldn't need this due to the @c static_assert but the Intel compiler requires it.
  throw std::domain_error("Errata index value out of bounds");
}
 
}} // namespace swoc::SWOC_VERSION_NS