IPRange.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright Network Geographics 2014
 
#pragma once
 
#include <string_view>
#include <variant> // for std::monostate
#include <tuple>
 
#include <swoc/DiscreteRange.h>
#include <swoc/IPAddr.h>
 
namespace swoc { inline namespace SWOC_VERSION_NS {
 
using std::string_view;
 
class IP4Net;
class IP6Net;
class IPNet;

class IP4Range : public DiscreteRange<IP4Addr> {
  using self_type   = IP4Range;
  using super_type  = DiscreteRange<IP4Addr>;
  using metric_type = IP4Addr;
 
public:
  constexpr IP4Range() = default;

  IP4Range(IP4Addr const &addr, IPMask const &mask);

  IP4Range(super_type const &r) : super_type(r) {}

  IP4Range(string_view const &text);
 
  using super_type::super_type; 

  self_type &assign(IP4Addr const &addr, IPMask const &mask);
 
  using super_type::assign; 

  bool load(string_view text);

  IPMask network_mask() const;

  sa_family_t
  family() const {
    return AF_INET;
  }
 
  class NetSource;

  NetSource networks() const;
};

class IP4Range::NetSource {
  using self_type = NetSource; 
public:
  using range_type = IP4Range; 

  explicit NetSource(range_type const &range);

  NetSource(self_type const &that) = default;

  using iterator = self_type;
  using const_iterator = iterator;
 
  iterator begin() const; 
  static iterator end();  

  bool empty() const;

  IP4Net operator*() const;

  self_type *operator->();

  IP4Addr const &addr() const;

  IPMask mask() const;

  self_type &operator++();

  self_type operator++(int);

  bool operator==(self_type const &that) const;

  bool operator!=(self_type const &that) const;
 
protected:
  IP4Range _range; 
  IP4Addr _mask{~static_cast<in_addr_t>(0)};
  IPMask::raw_type _cidr = IP4Addr::WIDTH; 
 
  void search_wider();
 
  void search_narrower();
 
  bool is_valid(IP4Addr mask) const;
};

class IP6Range : public DiscreteRange<IP6Addr> {
  using self_type  = IP6Range;
  using super_type = DiscreteRange<IP6Addr>;
 
public:
  IP6Range(super_type const &r) : super_type(r) {}

  IP6Range(string_view const &text);
 
  using super_type::super_type; 

  self_type &assign(IP6Addr const &addr, IPMask const &mask);
 
  using super_type::assign; 

  bool load(string_view text);

  IPMask network_mask() const;

  sa_family_t
  family() const {
    return AF_INET6;
  }
 
  class NetSource;

  NetSource networks() const;
};

class IP6Range::NetSource {
  using self_type = NetSource; 
public:
  using range_type = IP6Range; 

  explicit NetSource(range_type const &range);

  NetSource(self_type const &that) = default;

  using iterator = self_type;
  using const_iterator = iterator;
 
  iterator begin() const; 
  iterator end() const;   

  bool empty() const;

  IP6Net operator*() const;

  self_type *operator->();

  IP6Addr const &addr() const;

  IPMask mask() const;

  self_type &operator++();

  self_type operator++(int);

  bool operator==(self_type const &that) const;

  bool operator!=(self_type const &that) const;
 
protected:
  IP6Range _range;              
  IPMask _mask{IP6Addr::WIDTH}; 
 
  void search_wider();
 
  void search_narrower();
 
  bool is_valid(IPMask const &mask);
};
 
class IPRangeView; // Forward declare.

class IPRange {
  using self_type = IPRange;
 
public:
  IPRange() = default;

  IPRange(IPAddr const &min, IPAddr const &max);

  IPRange(IP4Addr const &min, IP4Addr const &max);

  IPRange(IP6Addr const &min, IP6Addr const &max);

  IPRange(IPAddr const &addr) : IPRange(addr, addr) {}

  IPRange(IP4Addr addr) : IPRange(addr, addr) {}

  IPRange(IP6Addr const &addr) : IPRange(addr, addr) {}

  IPRange(IP4Range const &range);

  IPRange(IP6Range const &range);

  IPRange(IPRangeView const &view);

  IPRange(string_view const &text);

  self_type &assign(IP4Addr const &min, IP4Addr const &max);

  self_type &assign(IP6Addr const &min, IP6Addr const &max);

  self_type &operator=(IPRangeView const &rv);

  bool operator==(self_type const &that) const;
  bool operator!=(self_type const &that) const;

  bool is_ip4() const;

  bool is_ip6() const;

  bool is(sa_family_t family) const;

  bool load(std::string_view const &text);

  bool contains(IPAddr const& addr) const;

  bool contains(IP6Addr const& addr) const;

  bool contains(IP4Addr const& addr) const;

  IPAddr min() const;

  IPAddr max() const;

  bool empty() const;

  self_type &clear();

  IP4Range const & ip4() const;

  IP6Range const & ip6() const;

  sa_family_t family() const;

  IPMask network_mask() const;

  class NetSource;

  NetSource networks() const;
 
protected:
  union {
    std::monostate _nil; 
    IP4Range _ip4;       
    IP6Range _ip6;       
  } _range{std::monostate{}};

  sa_family_t _family{AF_UNSPEC};
};

class IPRange::NetSource {
  using self_type = NetSource; 
public:
  using range_type = IPRange; 

  explicit NetSource(range_type const &range);

  explicit NetSource(IPRangeView const &rv);

  NetSource(self_type const &that) = default;

  using iterator = self_type;
  using const_iterator = iterator;
 
  iterator begin() const; 
  iterator end() const;   

  IPNet operator*() const;

  self_type *operator->();

  IPAddr addr() const;

  IPMask mask() const;

  self_type &operator++();

  self_type operator++(int);

  bool operator==(self_type const &that) const;

  bool operator!=(self_type const &that) const;
 
protected:
  union {
    std::monostate _nil;      
    IP4Range::NetSource _ip4; 
    IP6Range::NetSource _ip6; 
  };
 
  sa_family_t _family = AF_UNSPEC; 
};

class IPRangeView {
  using self_type = IPRangeView;
  friend IPRange;
  union storage_type {
    std::monostate _nil; 
    IP4Range const *_4;  
    IP6Range const *_6;  
  };
 
public:
  IPRangeView() = default;

  bool operator==(IPRange const &r) const;

  bool valid() const;
 
  // @return @c true if the range is empty (invalid views are empty)
  bool empty() const;

  self_type &clear();

  self_type &assign(IP4Range const &r);

  self_type &assign(IP6Range const &r);

  bool is_ip4() const;

  bool is_ip6() const;

  bool is(sa_family_t family) const;

  bool contains(IPAddr const& addr) const;

  bool contains(IP6Addr const& addr) const;

  bool contains(IP4Addr const& addr) const;

  IP4Range const &ip4() const;

  IP6Range const &ip6() const;


  IPAddr min() const;

  IPAddr max() const;

  bool operator==(self_type const &that) const;

  bool operator!=(self_type const &that) const;

  IPRange::NetSource
  networks() const {
    return IPRange::NetSource(*this);
  }

 
protected:
  storage_type _raw   = {std::monostate()}; 
  sa_family_t _family = AF_UNSPEC;          
};

class IP4Net {
  using self_type = IP4Net; 
public:
  IP4Net()                      = default; 
  IP4Net(self_type const &that) = default; 

  IP4Net(IP4Addr addr, IPMask mask);
 
  IP4Net(swoc::TextView text) { this->load(text); }

  bool load(swoc::TextView text);

  bool empty() const;

  IP4Addr min() const;

  IP4Addr max() const;

  IPMask const &mask() const;

  IP4Range as_range() const;

  self_type &assign(IP4Addr const &addr, IPMask const &mask);

  self_type &
  clear() {
    _mask.clear();
    return *this;
  }

  bool operator==(self_type const &that) const;

  bool operator!=(self_type const &that) const;
 
protected:
  IP4Addr _addr; 
  IPMask _mask;  
};

class IP6Net {
  using self_type = IP6Net; 
public:
  IP6Net()                      = default; 
  IP6Net(self_type const &that) = default; 

  IP6Net(IP6Addr addr, IPMask mask);

  IP6Net(TextView text) { this->load(text); }

  bool load(swoc::TextView text);

  bool empty() const;

  IP6Addr min() const;

  IP6Addr max() const;

  IPMask const &mask() const;

  IP6Range as_range() const;

  self_type &assign(IP6Addr const &addr, IPMask const &mask);

  self_type &
  clear() {
    _mask.clear();
    return *this;
  }

  bool operator==(self_type const &that) const;

  bool operator!=(self_type const &that) const;
 
protected:
  IP6Addr _addr; 
  IPMask _mask;  
};

class IPNet {
  using self_type = IPNet; 
public:
  IPNet()                      = default; 
  IPNet(self_type const &that) = default; 

  IPNet(IPAddr const &addr, IPMask const &mask);

  IPNet(TextView text);

  bool load(swoc::TextView text);

  bool empty() const;

  IPAddr min() const;

  IPAddr max() const;

  IPMask::raw_type width() const;

  IPMask const &mask() const;

  IPRange as_range() const;

  bool
  is_ip4() const {
    return _addr.is_ip4();
  }

  bool
  is_ip6() const {
    return _addr.is_ip6();
  }

  sa_family_t
  family() const {
    return _addr.family();
  }

  IP4Net ip4() const;

  IP6Net ip6() const;

  self_type &assign(IPAddr const &addr, IPMask const &mask);

  self_type &clear();

  bool operator==(self_type const &that) const;

  bool operator!=(self_type const &that) const;
 
protected:
  IPAddr _addr; 
  IPMask _mask; 
};
 
// --------------------------------------------------------------------------
namespace detail {
template <typename PAYLOAD> struct ip_space_const_value_type {
  using self_type = ip_space_const_value_type;
 
  IPRangeView _rv;             
  PAYLOAD *_payload = nullptr; 
 
  ip_space_const_value_type() = default;

  self_type &clear();

  self_type &assign(IP4Range const &r, PAYLOAD &payload);

  self_type &assign(IP6Range const &r, PAYLOAD &payload);

  self_type &assign(self_type const &that);

  std::tuple<IPRangeView, PAYLOAD &>
  tuple() const {
    return {_rv, *_payload};
  }

  bool operator==(std::tuple<swoc::IPRange, PAYLOAD> const &t) const;

  IPRange
  range() const {
    return _rv;
  }

  IPRangeView
  range_view() const {
    return _rv;
  }

  PAYLOAD const &
  payload() const {
    return *_payload;
  }
};

template <typename PAYLOAD> struct ip_space_value_type : ip_space_const_value_type<PAYLOAD> {
  using self_type  = ip_space_value_type;
  using super_type = ip_space_const_value_type<PAYLOAD>;

  PAYLOAD &
  payload() {
    return *super_type::_payload;
  }
};
 
template <typename PAYLOAD>
auto
ip_space_const_value_type<PAYLOAD>::clear() -> self_type & {
  _rv.clear();
  _payload = nullptr;
  return *this;
}
 
template <typename PAYLOAD>
auto
ip_space_const_value_type<PAYLOAD>::assign(IP4Range const &r, PAYLOAD &payload) -> self_type & {
  _rv.assign(r);
  _payload = &payload;
  return *this;
}
 
template <typename PAYLOAD>
auto
ip_space_const_value_type<PAYLOAD>::assign(IP6Range const &r, PAYLOAD &payload) -> self_type & {
  _rv.assign(r);
  _payload = &payload;
  return *this;
}
 
template <typename PAYLOAD>
auto
ip_space_const_value_type<PAYLOAD>::assign(ip_space_const_value_type::self_type const &that) -> self_type & {
  _rv      = that._rv;
  _payload = that._payload;
  return *this;
}
 
template <typename PAYLOAD>
bool
ip_space_const_value_type<PAYLOAD>::operator==(std::tuple<swoc::IPRange, PAYLOAD> const &t) const {
  return _rv == std::get<0>(t) && std::get<1>(t) == *_payload;
}
 
} // namespace detail

template <typename PAYLOAD> class IPSpace {
  using self_type = IPSpace;
  using IP4Space  = DiscreteSpace<IP4Addr, PAYLOAD>;
  using IP6Space  = DiscreteSpace<IP6Addr, PAYLOAD>;
 
public:
  using payload_t = PAYLOAD; 
  using value_type = detail::ip_space_value_type<PAYLOAD>;

  IPSpace() = default;

  self_type &mark(IPRange const &range, PAYLOAD const &payload);

   self_type &mark_bulk(std::pair<DiscreteRange<IP4Addr>, PAYLOAD>* range_payloads, size_t size, bool is_sorted = false);

   self_type &mark_bulk(std::vector<std::pair<DiscreteRange<IP4Addr>, PAYLOAD>>& range_payloads, bool is_sorted = false);

   self_type &mark_bulk(std::pair<DiscreteRange<IP6Addr>, PAYLOAD>* range_payloads, size_t size, bool is_sorted = false);

   self_type &mark_bulk(std::vector<std::pair<DiscreteRange<IP6Addr>, PAYLOAD>>& range_payloads, bool is_sorted = false);

  self_type &fill(IPRange const &range, PAYLOAD const &payload);

  self_type &erase(IPRange const &range);

  template <typename F, typename U = PAYLOAD> self_type &blend(IPRange const &range, U const &color, F &&blender);
 
  template <typename F, typename U = PAYLOAD> self_type &blend(IP4Range const &range, U const &color, F &&blender);
 
  template <typename F, typename U = PAYLOAD> self_type &blend(IP6Range const &range, U const &color, F &&blender);

  size_t count() const;

  size_t count_ip4() const;

  size_t count_ip6() const;

  size_t count(sa_family_t f) const;

  bool empty() const;

  void clear();

  class const_iterator {
    using self_type = const_iterator; 
    friend class IPSpace;
 
  public:
    using value_type = detail::ip_space_const_value_type<PAYLOAD>; 
    // STL algorithm compliance.
    using iterator_category = std::bidirectional_iterator_tag;
    using pointer           = value_type const *;
    using reference         = value_type const &;
    using difference_type   = int;

    const_iterator() = default;

    const_iterator(self_type const &that) = default;

    self_type &operator=(self_type const &that);

    self_type &operator++();

    self_type &operator--();

    self_type operator++(int);

    self_type operator--(int);

    reference operator*() const;

    pointer operator->() const;

    bool operator==(self_type const &that) const;

    bool operator!=(self_type const &that) const;
 
  protected:
    // These are stored non-const to make implementing @c iterator easier. The containing class provides the
    // required @c const protection. Internally a tuple of iterators is stored for forward iteration. If
    // the primary (ipv4) iterator is at the end, then use the secondary (ipv6) iterator. The reverse
    // is done for reverse iteration. This depends on the extra support @c IntrusiveDList iterators
    // provide.
    typename IP4Space::iterator _iter_4; 
    typename IP6Space::iterator _iter_6; 
    value_type _value;

    const_iterator(typename IP4Space::const_iterator const &iter4, typename IP6Space::const_iterator const &iter6);
 
    // These are required because the actual range type for the subspaces is @c DiscreteRange<T>
    // and returning that type without a cast creates a temporary which causes some nasty side effects.

    IP4Range const &
    r4() {
      return static_cast<IP4Range const &>(_iter_4->range());
    }

    IP6Range const &
    r6() {
      return static_cast<IP6Range const &>(_iter_6->range());
    }
  };

  class iterator : public const_iterator {
    using self_type  = iterator;
    using super_type = const_iterator;
 
    friend class IPSpace;
 
  protected:
    using super_type::super_type; 
    iterator(const_iterator const &that) : const_iterator(that) {}
 
  public:
    using value_type = detail::ip_space_value_type<PAYLOAD>;
    using pointer    = value_type *;
    using reference  = value_type &;

    iterator() = default;

    iterator(self_type const &that) = default;

    self_type &operator=(self_type const &that);

    self_type &operator++();

    self_type &operator--();

    self_type operator++(int);

    self_type operator--(int);

    reference operator*() const;

    pointer operator->() const;
 
  protected:
    // Retrieve the value and convert from the super (const) type value to the value for iterator.
    value_type &value() const;
  };

  iterator find(IPAddr const &addr);

  const_iterator find(IPAddr const &addr) const;

  iterator find(IP4Addr const &addr);

  const_iterator find(IP4Addr const &addr) const;

  iterator find(IP6Addr const &addr);

  const_iterator find(IP6Addr const &addr) const;

  iterator begin();

  const_iterator begin() const;

  iterator end();

  const_iterator end() const;

  iterator begin_ip4();
  const_iterator begin_ip4() const;

  iterator end_ip4();
  const_iterator end_ip4() const;

  iterator begin_ip6();
  const_iterator begin_ip6() const;
  iterator end_ip6();
  const_iterator end_ip6() const;

  const_iterator begin(sa_family_t family) const;

  const_iterator end(sa_family_t family) const;

  std::pair<iterator, iterator>
  intersection(IP4Range const &r) {
    auto &&[begin, end] = _ip4.intersection(r);
    return {this->iterator_at(begin), this->iterator_at(end)};
  }

  std::pair<iterator, iterator>
  intersection(IP6Range const &r) {
    auto &&[begin, end] = _ip6.intersection(r);
    return {this->iterator_at(begin), this->iterator_at(end)};
  }

  std::pair<iterator, iterator>
  intersection(IPRange const &r) {
    if (r.is_ip4()) {
      return this->intersection(r.ip4());
    } else if (r.is_ip6()) {
      return this->intersection(r.ip6());
    }
    return {this->end(), this->end()};
  }
 
protected:
  IP4Space _ip4; 
  IP6Space _ip6; 
 
  iterator
  iterator_at(typename IP4Space::const_iterator const &spot) {
    return iterator(spot, _ip6.begin());
  }
  iterator
  iterator_at(typename IP6Space::const_iterator const &spot) {
    return iterator(_ip4.end(), spot);
  }
 
  friend class IPRangeSet;
};

class IPRangeSet {
  using self_type = IPRangeSet;

  static inline constexpr struct Mark {
    using self_type = Mark;
    bool operator==(self_type const &that);
    bool operator!=(self_type const &that);
  } MARK{};

  using Space = swoc::IPSpace<Mark>;
 
public:
  IPRangeSet() = default;

  self_type &mark(swoc::IPRange const &r);

  self_type &fill(swoc::IPRange const &r);

  self_type &erase(swoc::IPRange const &r);

  bool contains(swoc::IPAddr const &addr) const;

  size_t count() const;
 
  bool empty() const;

  void clear();

  class const_iterator {
    using self_type  = const_iterator; 
    using super_type = Space::const_iterator;
    friend class IPRangeSet;
 
  public:
    using value_type = IPRangeView;
    // STL algorithm compliance.
    using iterator_category = std::bidirectional_iterator_tag;
    using pointer           = value_type const *;
    using reference         = value_type const &;
    using difference_type   = int;

    const_iterator() = default;

    const_iterator(self_type const &that) = default;

    self_type &operator=(self_type const &that) = default;

    self_type &operator++();

    self_type &operator--();

    self_type operator++(int);

    self_type operator--(int);

    reference operator*() const;

    pointer operator->() const;

    bool operator==(self_type const &that) const;

    bool operator!=(self_type const &that) const;
 
  protected:
    const_iterator(super_type const &spot) : _iter(spot) {}
 
    super_type _iter; 
    IPRange _r;       
  };
 
  using iterator = const_iterator;

  const_iterator
  begin() const {
    return _addrs.begin();
  }

  const_iterator
  end() const {
    return _addrs.end();
  }
 
protected:
  Space _addrs;
};
 
inline auto
IPRangeSet::mark(swoc::IPRange const &r) -> self_type & {
  _addrs.mark(r, MARK);
  return *this;
}
 
inline auto
IPRangeSet::fill(swoc::IPRange const &r) -> self_type & {
  _addrs.mark(r, MARK);
  return *this;
}
 
inline auto
IPRangeSet::erase(swoc::IPRange const &r) -> self_type & {
  _addrs.erase(r);
  return *this;
}
 
inline bool
IPRangeSet::contains(swoc::IPAddr const &addr) const {
  return _addrs.find(addr) != _addrs.end();
}
 
inline size_t
IPRangeSet::count() const {
  return _addrs.count();
}
 
inline bool
IPRangeSet::empty() const {
  return _addrs.empty();
}
 
inline void
IPRangeSet::clear() {
  _addrs.clear();
}
 
inline bool
IPRangeSet::Mark::operator==(IPRangeSet::Mark::self_type const &) {
  return true;
}
 
inline bool
IPRangeSet::Mark::operator!=(IPRangeSet::Mark::self_type const &) {
  return false;
}
 
template <typename PAYLOAD>
IPSpace<PAYLOAD>::const_iterator::const_iterator(typename IP4Space::const_iterator const &iter4,
                                                 typename IP6Space::const_iterator const &iter6)
  : _iter_4(static_cast<typename IP4Space::iterator const &>(iter4)),
    _iter_6(static_cast<typename IP6Space::iterator const &>(iter6)) {
  if (_iter_4.has_next()) {
    _value.assign(this->r4(), _iter_4->payload());
  } else if (_iter_6.has_next()) {
    _value.assign(this->r6(), _iter_6->payload());
  }
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::const_iterator::operator=(self_type const &that) -> self_type & {
  _iter_4 = that._iter_4;
  _iter_6 = that._iter_6;
  _value.assign(that._value);
  return *this;
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::const_iterator::operator++() -> self_type & {
  bool incr_p = false;
  if (_iter_4.has_next()) {
    ++_iter_4;
    incr_p = true;
    if (_iter_4.has_next()) {
      _value.assign(this->r4(), _iter_4->payload());
      return *this;
    }
  }
 
  if (_iter_6.has_next()) {
    if (incr_p || (++_iter_6).has_next()) {
      _value.assign(this->r6(), _iter_6->payload());
      return *this;
    }
  }
  _value.clear();
  return *this;
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::const_iterator::operator++(int) -> self_type {
  self_type zret(*this);
  ++*this;
  return zret;
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::const_iterator::operator--() -> self_type & {
  if (_iter_6.has_prev()) {
    --_iter_6;
    _value.assign(this->r6(), _iter_6->payload());
    return *this;
  }
  if (_iter_4.has_prev()) {
    --_iter_4;
    _value.assign(this->r4(), _iter_4->payload());
    return *this;
  }
  _value.clear();
  return *this;
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::const_iterator::operator--(int) -> self_type {
  self_type zret(*this);
  --*this;
  return zret;
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::const_iterator::operator*() const -> reference {
  return _value;
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::const_iterator::operator->() const -> pointer {
  return &_value;
}
 
/* Bit of subtlety with equality - although it seems that if @a _iter_4 is valid, it doesn't matter
 * where @a _iter6 is (because it is really the iterator location that's being checked), it's
 * necessary to do the @a _iter_4 validity on both iterators to avoid the case of a false positive
 * where different internal iterators are valid. However, in practice the other (non-active)
 * iterator won't have an arbitrary value, it will be either @c begin or @c end in step with the
 * active iterator therefore it's effective and cheaper to just check both values.
 */
 
template <typename PAYLOAD>
bool
IPSpace<PAYLOAD>::const_iterator::operator==(self_type const &that) const {
  return _iter_4 == that._iter_4 && _iter_6 == that._iter_6;
}
 
template <typename PAYLOAD>
bool
IPSpace<PAYLOAD>::const_iterator::operator!=(self_type const &that) const {
  return _iter_4 != that._iter_4 || _iter_6 != that._iter_6;
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::iterator::operator=(self_type const &that) -> self_type & {
  this->super_type::operator=(that);
  return *this;
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::iterator::value() const -> value_type & {
  return reinterpret_cast<value_type &>(const_cast<self_type *>(this)->_value);
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::iterator::operator->() const -> pointer {
  return &(this->value());
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::iterator::operator*() const -> reference {
  return this->value();
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::iterator::operator++() -> self_type & {
  this->super_type::operator++();
  return *this;
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::iterator::operator++(int) -> self_type {
  self_type zret{*this};
  ++*this;
  return zret;
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::iterator::operator--() -> self_type & {
  this->super_type::operator--();
  return *this;
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::iterator::operator--(int) -> self_type {
  self_type zret{*this};
  --*this;
  return zret;
}

 
// +++ IPRange +++
 
inline IP4Range::IP4Range(string_view const &text) {
  this->load(text);
}
 
inline auto
IP4Range::networks() const -> NetSource {
  return {NetSource{*this}};
}
 
inline IP6Range::IP6Range(string_view const &text) {
  this->load(text);
}
 
inline auto
IP6Range::networks() const -> NetSource {
  return {NetSource{*this}};
}
 
inline IPRange::IPRange(IP4Range const &range) : _family(AF_INET) {
  _range._ip4 = range;
}
 
inline IPRange::IPRange(IP6Range const &range) : _family(AF_INET6) {
  _range._ip6 = range;
}
 
inline IPRange::IPRange(IP4Addr const &min, IP4Addr const &max) {
  this->assign(min, max);
}
 
inline IPRange::IPRange(IP6Addr const &min, IP6Addr const &max) {
  this->assign(min, max);
}
 
inline IPRange::IPRange(string_view const &text) {
  this->load(text);
}
 
inline IPRange::IPRange(IPRangeView const &view) {
  if (AF_INET == view._family) {
    *this = *view._raw._4;
  } else if (AF_INET6 == view._family) {
    *this = *view._raw._6;
  }
}
 
inline auto
IPRange::assign(IP4Addr const &min, IP4Addr const &max) -> self_type & {
  _range._ip4.assign(min, max);
  _family = AF_INET;
  return *this;
}
 
inline auto
IPRange::assign(IP6Addr const &min, IP6Addr const &max) -> self_type & {
  _range._ip6.assign(min, max);
  _family = AF_INET6;
  return *this;
}
 
inline auto
IPRange::operator=(const IPRangeView &rv) -> self_type & {
  if (AF_INET == rv._family) {
    *this = *rv._raw._4;
  } else if (AF_INET6 == rv._family) {
    *this = *rv._raw._6;
  }
  return *this;
}
 
inline auto
IPRange::clear() -> self_type & {
  _family = AF_UNSPEC;
  return *this;
}
 
inline auto
IPRange::networks() const -> NetSource {
  return {NetSource{*this}};
}
 
inline bool
IPRange::is(sa_family_t family) const {
  return family == _family;
}
 
inline bool
IPRange::operator!=(const self_type &that) const {
  return !(*this == that);
}
 
inline bool
IPRange::is_ip4() const {
  return AF_INET == _family;
}
 
inline bool
IPRange::is_ip6() const {
  return AF_INET6 == _family;
}
 
inline sa_family_t IPRange::family() const {
  return _family;
}
inline IP4Range const& IPRange::ip4() const {
  return _range._ip4;
}
 
inline IP6Range const& IPRange::ip6() const {
  return _range._ip6;
}
 
inline auto
IPRangeView::clear() -> self_type & {
  _family = AF_UNSPEC;
  return *this;
}
 
inline bool
IPRangeView::empty() const {
  if (AF_INET6 == _family) {
    return _raw._6->empty();
  } else if (AF_INET == _family) {
    return _raw._4->empty();
  } else {
    return true;
  }
}
 
inline bool
IPRangeView::is_ip4() const {
  return AF_INET == _family;
}
 
inline bool
IPRangeView::is_ip6() const {
  return AF_INET6 == _family;
}
 
inline bool
IPRangeView::is(sa_family_t f) const {
  return f == _family;
}
 
inline bool IPRange::contains(IPAddr const & addr) const {
  if (addr.family() != _family) {
    return false;
  }
  if (this->ip4()) {
    return _range._ip4.contains(addr.ip4());
  } else if (this->is_ip6()) {
    return _range._ip6.contains(addr.ip6());
  }
  return false;
}
 
inline bool IPRange::contains(IP6Addr const & addr) const {
  return this->is_ip6() && _range._ip6.contains(addr);
}
 
inline bool IPRange::contains(IP4Addr const & addr) const {
  return this->is_ip4() && _range._ip4.contains(addr);
}
 
inline IP4Range const &
IPRangeView::ip4() const {
  return *_raw._4;
}
 
inline IP6Range const &
IPRangeView::ip6() const {
  return *_raw._6;
}
 
inline bool
IPRangeView::valid() const {
  return AF_INET == _family || AF_INET6 == _family;
}
 
inline auto
IPRangeView::assign(IP4Range const &r) -> self_type & {
  _family = r.family();
  _raw._4 = &r;
  return *this;
}
 
inline auto
IPRangeView::assign(IP6Range const &r) -> self_type & {
  _family = r.family();
  _raw._6 = &r;
  return *this;
}
 
inline bool
IPRangeView::operator!=(IPRangeView::self_type const &that) const {
  return !(*this == that);
}
 
inline IPAddr
IPRangeView::min() const {
  return AF_INET == _family ? _raw._4->min() : AF_INET6 == _family ? _raw._6->min() : IPAddr::INVALID;
}
 
inline IPAddr
IPRangeView::max() const {
  return AF_INET == _family ? _raw._4->max() : AF_INET6 == _family ? _raw._6->max() : IPAddr::INVALID;
}
 
inline bool IPRangeView::contains(IPAddr const& addr) const {
  if (_family != addr.family()) {
    return false;
  }
  return (_family == addr.family() ) &&
         ( ( this->is_ip4() && _raw._4->contains(addr.ip4()) ) ||
           ( this->is_ip6() && _raw._6->contains(addr.ip6()) )
         );
}
 
inline bool IPRangeView::contains(IP6Addr const& addr) const {
  return this->is_ip6() && _raw._6->contains(addr);
}
 
inline bool IPRangeView::contains(IP4Addr const& addr) const {
  return this->is_ip4() && _raw._4->contains(addr);
}
 
// +++ IPNet +++
 
inline IP4Net::IP4Net(swoc::IP4Addr addr, swoc::IPMask mask) : _addr(addr & mask), _mask(mask) {}
 
inline IPMask const &
IP4Net::mask() const {
  return _mask;
}
 
inline bool
IP4Net::empty() const {
  return !_mask.is_valid();
}
 
inline IP4Addr
IP4Net::min() const {
  return _addr;
}
 
inline IP4Addr
IP4Net::max() const {
  return _addr | _mask;
}
 
inline IP4Range
IP4Net::as_range() const {
  return {this->min(), this->max()};
}
 
inline bool
IP4Net::operator==(self_type const &that) const {
  return _mask == that._mask && _addr == that._addr;
}
 
inline bool
IP4Net::operator!=(self_type const &that) const {
  return _mask != that._mask || _addr != that._addr;
}
 
inline IP4Net::self_type &
IP4Net::assign(IP4Addr const &addr, IPMask const &mask) {
  _addr = addr & mask;
  _mask = mask;
  return *this;
}
 
inline IP6Net::IP6Net(swoc::IP6Addr addr, swoc::IPMask mask) : _addr(addr & mask), _mask(mask) {}
 
inline IPMask const &
IP6Net::mask() const {
  return _mask;
}
 
inline bool
IP6Net::empty() const {
  return !_mask.is_valid();
}
 
inline IP6Addr
IP6Net::min() const {
  return _addr;
}
 
inline IP6Addr
IP6Net::max() const {
  return _addr | _mask;
}
 
inline IP6Range
IP6Net::as_range() const {
  return {this->min(), this->max()};
}
 
inline bool
IP6Net::operator==(self_type const &that) const {
  return _mask == that._mask && _addr == that._addr;
}
 
inline bool
IP6Net::operator!=(self_type const &that) const {
  return _mask != that._mask || _addr != that._addr;
}
 
inline IP6Net::self_type &
IP6Net::assign(IP6Addr const &addr, IPMask const &mask) {
  _addr = addr & mask;
  _mask = mask;
  return *this;
}
 
inline IPNet::IPNet(IPAddr const &addr, IPMask const &mask) : _addr(addr & mask), _mask(mask) {}
 
inline IPNet::IPNet(TextView text) {
  this->load(text);
}
 
inline bool
IPNet::empty() const {
  return !_mask.is_valid();
}
 
inline IPAddr
IPNet::min() const {
  return _addr;
}
 
inline IPAddr
IPNet::max() const {
  return _addr | _mask;
}
 
inline IPMask::raw_type
IPNet::width() const {
  return _mask.width();
}
 
inline IPMask const &
IPNet::mask() const {
  return _mask;
}
 
inline IPRange
IPNet::as_range() const {
  return {this->min(), this->max()};
}
 
inline IPNet::self_type &
IPNet::assign(IPAddr const &addr, IPMask const &mask) {
  _addr = addr & mask;
  _mask = mask;
  return *this;
}
 
inline bool
IPNet::operator==(IPNet::self_type const &that) const {
  return _mask == that._mask && _addr == that._addr;
}
 
inline bool
IPNet::operator!=(IPNet::self_type const &that) const {
  return _mask != that._mask || _addr != that._addr;
}
 
inline bool
operator==(IPNet const &lhs, IP4Net const &rhs) {
  return lhs.is_ip4() && lhs.ip4() == rhs;
}
 
inline bool
operator==(IP4Net const &lhs, IPNet const &rhs) {
  return rhs.is_ip4() && rhs.ip4() == lhs;
}
 
inline bool
operator==(IPNet const &lhs, IP6Net const &rhs) {
  return lhs.is_ip6() && lhs.ip6() == rhs;
}
 
inline bool
operator==(IP6Net const &lhs, IPNet const &rhs) {
  return rhs.is_ip6() && rhs.ip6() == lhs;
}
 
inline IP4Net
IPNet::ip4() const {
  return IP4Net{_addr.ip4(), _mask};
}
 
inline IP6Net
IPNet::ip6() const {
  return IP6Net{_addr.ip6(), _mask};
}
 
inline auto
IPNet::clear() -> self_type & {
  _mask.clear();
  return *this;
}
 
// +++ Range -> Network classes +++
 
inline bool
IP4Range::NetSource::is_valid(swoc::IP4Addr mask) const {
  return ((mask._addr & _range._min._addr) == _range._min._addr) && ((_range._min._addr | ~mask._addr) <= _range._max._addr);
}
 
inline IP4Net
IP4Range::NetSource::operator*() const {
  return IP4Net{_range.min(), IPMask{_cidr}};
}
 
inline IP4Range::NetSource::iterator
IP4Range::NetSource::begin() const {
  return *this;
}
 
inline IP4Range::NetSource::iterator
IP4Range::NetSource::end() {
  return self_type{range_type{}};
}
 
inline bool
IP4Range::NetSource::empty() const {
  return _range.empty();
}
 
inline IPMask
IP4Range::NetSource::mask() const {
  return IPMask{_cidr};
}
 
inline auto
IP4Range::NetSource::operator->() -> self_type * {
  return this;
}
 
inline IP4Addr const &
IP4Range::NetSource::addr() const {
  return _range.min();
}
 
inline bool
IP4Range::NetSource::operator==(IP4Range::NetSource::self_type const &that) const {
  return ((_cidr == that._cidr) && (_range == that._range)) || (_range.empty() && that._range.empty());
}
 
inline bool
IP4Range::NetSource::operator!=(IP4Range::NetSource::self_type const &that) const {
  return !(*this == that);
}
 
inline auto
IP6Range::NetSource::begin() const -> iterator {
  return *this;
}
 
inline auto
IP6Range::NetSource::end() const -> iterator {
  return self_type{range_type{}};
}
 
inline bool
IP6Range::NetSource::empty() const {
  return _range.empty();
}
 
inline IP6Net
IP6Range::NetSource::operator*() const {
  return IP6Net{_range.min(), _mask};
}
 
inline auto
IP6Range::NetSource::operator->() -> self_type * {
  return this;
}
 
inline bool
IP6Range::NetSource::is_valid(IPMask const &mask) {
  return ((_range.min() & mask) == _range.min()) && ((_range.min() | mask) <= _range.max());
}
 
inline bool
IP6Range::NetSource::operator==(IP6Range::NetSource::self_type const &that) const {
  return ((_mask == that._mask) && (_range == that._range)) || (_range.empty() && that._range.empty());
}
 
inline bool
IP6Range::NetSource::operator!=(IP6Range::NetSource::self_type const &that) const {
  return !(*this == that);
}
 
inline IP6Addr const &
IP6Range::NetSource::addr() const {
  return _range.min();
}
 
inline IPMask
IP6Range::NetSource::mask() const {
  return _mask;
}
 
inline IPRange::NetSource::NetSource(IPRange::NetSource::range_type const &range) {
  if (range.is_ip4()) {
    new (&_ip4) decltype(_ip4)(range.ip4());
    _family = AF_INET;
  } else if (range.is_ip6()) {
    new (&_ip6) decltype(_ip6)(range.ip6());
    _family = AF_INET6;
  }
}
 
inline IPRange::NetSource::NetSource(IPRangeView const &rv) {
  if (rv.is_ip4()) {
    new (&_ip4) decltype(_ip4)(rv.ip4());
    _family = AF_INET;
  } else if (rv.is_ip6()) {
    new (&_ip6) decltype(_ip6)(rv.ip6());
    _family = AF_INET6;
  }
}
 
inline auto
IPRange::NetSource::begin() const -> iterator {
  return *this;
}
 
inline auto
IPRange::NetSource::end() const -> iterator {
  return AF_INET == _family ? self_type{IP4Range{}} : AF_INET6 == _family ? self_type{IP6Range{}} : self_type{IPRange{}};
}
 
inline IPAddr
IPRange::NetSource::addr() const {
  if (AF_INET == _family) {
    return _ip4.addr();
  } else if (AF_INET6 == _family) {
    return _ip6.addr();
  }
  return {};
}
 
inline IPMask
IPRange::NetSource::mask() const {
  if (AF_INET == _family) {
    return _ip4.mask();
  } else if (AF_INET6 == _family) {
    return _ip6.mask();
  }
  return {};
}
 
inline IPNet
IPRange::NetSource::operator*() const {
  return {this->addr(), this->mask()};
}
 
inline auto
IPRange::NetSource::operator++() -> self_type & {
  if (AF_INET == _family) {
    ++_ip4;
  } else if (AF_INET6 == _family) {
    ++_ip6;
  }
  return *this;
}
 
inline auto
IPRange::NetSource::operator->() -> self_type * {
  return this;
}
 
inline bool
IPRange::NetSource::operator==(self_type const &that) const {
  if (_family != that._family) {
    return false;
  }
  if (AF_INET == _family) {
    return _ip4 == that._ip4;
  } else if (AF_INET6 == _family) {
    return _ip6 == that._ip6;
  } else if (AF_UNSPEC == _family) {
    return true;
  }
  return false;
}
 
inline bool
IPRange::NetSource::operator!=(self_type const &that) const {
  return !(*this == that);
}
 
// --- IPSpace
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::mark_bulk(std::pair<DiscreteRange<IP4Addr>, PAYLOAD>* range_payloads, size_t size, bool is_sorted) -> self_type & {
  _ip4.mark_bulk(range_payloads, size, is_sorted);
  return *this;
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::mark_bulk(std::pair<DiscreteRange<IP6Addr>, PAYLOAD>* range_payloads, size_t size, bool is_sorted) -> self_type & {
  _ip6.mark_bulk(range_payloads, size, is_sorted);
  return *this;
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::mark_bulk(std::vector<std::pair<DiscreteRange<IP4Addr>, PAYLOAD>>& range_payloads, bool is_sorted) -> self_type & {
  _ip4.mark_bulk(range_payloads, is_sorted);
  return *this;
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::mark_bulk(std::vector<std::pair<DiscreteRange<IP6Addr>, PAYLOAD>>& range_payloads, bool is_sorted) -> self_type & {
  _ip6.mark_bulk(range_payloads, is_sorted);
  return *this;
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::mark(IPRange const &range, PAYLOAD const &payload) -> self_type & {
  if (range.is(AF_INET)) {
    _ip4.mark(range.ip4(), payload);
  } else if (range.is(AF_INET6)) {
    _ip6.mark(range.ip6(), payload);
  }
  return *this;
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::fill(IPRange const &range, PAYLOAD const &payload) -> self_type & {
  if (range.is(AF_INET6)) {
    _ip6.fill(range.ip6(), payload);
  } else if (range.is(AF_INET)) {
    _ip4.fill(range.ip4(), payload);
  }
  return *this;
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::erase(IPRange const &range) -> self_type & {
  if (range.is(AF_INET)) {
    _ip4.erase(range.ip4());
  } else if (range.is(AF_INET6)) {
    _ip6.erase(range.ip6());
  }
  return *this;
}
 
template <typename PAYLOAD>
template <typename F, typename U>
auto
IPSpace<PAYLOAD>::blend(IPRange const &range, U const &color, F &&blender) -> self_type & {
  if (range.is(AF_INET)) {
    _ip4.blend(range.ip4(), color, blender);
  } else if (range.is(AF_INET6)) {
    _ip6.blend(range.ip6(), color, blender);
  }
  return *this;
}
 
template <typename PAYLOAD>
template <typename F, typename U>
auto
IPSpace<PAYLOAD>::blend(IP4Range const &range, U const &color, F &&blender) -> self_type & {
  _ip4.blend(range, color, std::forward<F>(blender));
  return *this;
}
 
template <typename PAYLOAD>
template <typename F, typename U>
auto
IPSpace<PAYLOAD>::blend(IP6Range const &range, U const &color, F &&blender) -> self_type & {
  _ip6.blend(range, color, std::forward<F>(blender));
  return *this;
}
 
template <typename PAYLOAD>
void
IPSpace<PAYLOAD>::clear() {
  _ip4.clear();
  _ip6.clear();
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::begin() -> iterator {
  return iterator{_ip4.begin(), _ip6.begin()};
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::begin() const -> const_iterator {
  return const_cast<self_type *>(this)->begin();
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::end() -> iterator {
  return iterator{_ip4.end(), _ip6.end()};
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::end() const -> const_iterator {
  return const_cast<self_type *>(this)->end();
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::begin_ip4() -> iterator {
  return this->begin();
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::begin_ip4() const -> const_iterator {
  return this->begin();
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::end_ip4() -> iterator {
  return {_ip4.end(), _ip6.begin()};
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::end_ip4() const -> const_iterator {
  return const_cast<self_type *>(this)->end_ip4();
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::begin_ip6() -> iterator {
  return {_ip4.end(), _ip6.begin()};
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::begin_ip6() const -> const_iterator {
  return const_cast<self_type *>(this)->begin_ip6();
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::end_ip6() -> iterator {
  return this->end();
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::end_ip6() const -> const_iterator {
  return this->end();
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::find(IPAddr const &addr) -> iterator {
  if (addr.is_ip4()) {
    return this->find(addr.ip4());
  } else if (addr.is_ip6()) {
    return this->find(addr.ip6());
  }
  return this->end();
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::find(IPAddr const &addr) const -> const_iterator {
  if (addr.is_ip4()) {
    return this->find(addr.ip4());
  } else if (addr.is_ip6()) {
    return this->find(addr.ip6());
  }
  return this->end();
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::find(IP4Addr const &addr) -> iterator {
  if (auto spot = _ip4.find(addr); spot != _ip4.end()) {
    return {spot, _ip6.begin()};
  }
  return this->end();
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::find(IP4Addr const &addr) const -> const_iterator {
  if (auto spot = _ip4.find(addr); spot != _ip4.end()) {
    return {spot, _ip6.begin()};
  }
  return this->end();
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::find(IP6Addr const &addr) -> iterator {
  return {_ip4.end(), _ip6.find(addr)};
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::find(IP6Addr const &addr) const -> const_iterator {
  return const_iterator{_ip4.end(), _ip6.find(addr)};
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::begin(sa_family_t family) const -> const_iterator {
  if (AF_INET == family) {
    return this->begin_ip4();
  } else if (AF_INET6 == family) {
    return this->begin_ip6();
  }
  return this->end();
}
 
template <typename PAYLOAD>
auto
IPSpace<PAYLOAD>::end(sa_family_t family) const -> const_iterator {
  if (AF_INET == family) {
    return this->end_ip4();
  } else if (AF_INET6 == family) {
    return this->end_ip6();
  }
  return this->end();
}
 
template <typename PAYLOAD>
size_t
IPSpace<PAYLOAD>::count_ip4() const {
  return _ip4.count();
}
 
template <typename PAYLOAD>
size_t
IPSpace<PAYLOAD>::count_ip6() const {
  return _ip6.count();
}
 
template <typename PAYLOAD>
size_t
IPSpace<PAYLOAD>::count() const {
  return _ip4.count() + _ip6.count();
}
 
template <typename PAYLOAD>
size_t
IPSpace<PAYLOAD>::count(sa_family_t f) const {
  return IP4Addr::AF_value == f ? _ip4.count() : IP6Addr::AF_value == f ? _ip6.count() : 0;
}
 
template <typename PAYLOAD>
bool
IPSpace<PAYLOAD>::empty() const {
  return _ip4.empty() && _ip6.empty();
}
 
inline auto
IPRangeSet::const_iterator::operator++() -> self_type & {
  ++_iter;
  return *this;
}
 
inline auto
IPRangeSet::const_iterator::operator--() -> self_type & {
  --_iter;
  return *this;
}
 
inline auto
IPRangeSet::const_iterator::operator++(int) -> self_type {
  self_type zret{*this};
  ++_iter;
  return zret;
}
 
inline auto
IPRangeSet::const_iterator::operator--(int) -> self_type {
  self_type zret{*this};
  --_iter;
  return zret;
}
 
inline auto
IPRangeSet::const_iterator::operator*() const -> reference {
  return _iter->_rv;
}
 
inline auto
IPRangeSet::const_iterator::operator->() const -> pointer {
  return &(_iter->_rv);
}
 
inline bool
IPRangeSet::const_iterator::operator==(IPRangeSet::const_iterator::self_type const &that) const {
  return _iter == that._iter;
}
 
inline bool
IPRangeSet::const_iterator::operator!=(IPRangeSet::const_iterator::self_type const &that) const {
  return _iter != that._iter;
}
 
}} // namespace swoc::SWOC_VERSION_NS

namespace std {
 
// -- Tuple support for IP4Net --
template <> class tuple_size<swoc::IP4Net> : public std::integral_constant<size_t, 2> {};
 
template <size_t IDX> class tuple_element<IDX, swoc::IP4Net> {
  static_assert("swoc::IP4Net tuple index out of range");
};
 
template <> class tuple_element<0, swoc::IP4Net> {
public:
  using type = swoc::IP4Addr;
};
 
template <> class tuple_element<1, swoc::IP4Net> {
public:
  using type = swoc::IPMask;
};
 
// -- Tuple support for IP6Net --
template <> class tuple_size<swoc::IP6Net> : public std::integral_constant<size_t, 2> {};
 
template <size_t IDX> class tuple_element<IDX, swoc::IP6Net> {
  static_assert("swoc::IP6Net tuple index out of range");
};
 
template <> class tuple_element<0, swoc::IP6Net> {
public:
  using type = swoc::IP6Addr;
};
 
template <> class tuple_element<1, swoc::IP6Net> {
public:
  using type = swoc::IPMask;
};
 
// -- Tuple support for IPNet --
template <> class tuple_size<swoc::IPNet> : public std::integral_constant<size_t, 2> {};
 
template <size_t IDX> class tuple_element<IDX, swoc::IPNet> {
  static_assert("swoc::IPNet tuple index out of range");
};
 
template <> class tuple_element<0, swoc::IPNet> {
public:
  using type = swoc::IPAddr;
};
 
template <> class tuple_element<1, swoc::IPNet> {
public:
  using type = swoc::IPMask;
};
 
} // namespace std
 
namespace swoc { inline namespace SWOC_VERSION_NS {
 
template <size_t IDX>
typename std::tuple_element<IDX, IP4Net>::type
get(swoc::IP4Net const &net) {
  if constexpr (IDX == 0) {
    return net.min();
  } else if constexpr (IDX == 1) {
    return net.mask();
  }
}
 
template <size_t IDX>
typename std::tuple_element<IDX, IP6Net>::type
get(swoc::IP6Net const &net) {
  if constexpr (IDX == 0) {
    return net.min();
  } else if constexpr (IDX == 1) {
    return net.mask();
  }
}
 
template <size_t IDX>
typename std::tuple_element<IDX, IPNet>::type
get(swoc::IPNet const &net) {
  if constexpr (IDX == 0) {
    return net.min();
  } else if constexpr (IDX == 1) {
    return net.mask();
  }
}
 
}} // namespace swoc::SWOC_VERSION_NS
 
// Tuple support for IPSpace values.
 
namespace std {
 
template <typename P> class tuple_size<swoc::detail::ip_space_value_type<P>> : public integral_constant<size_t, 2> {};
template <typename P> class tuple_size<swoc::detail::ip_space_const_value_type<P>> : public integral_constant<size_t, 2> {};
 
template <size_t IDX, typename P> class tuple_element<IDX, swoc::detail::ip_space_value_type<P>> {
  static_assert("swoc::IPSpace::value_type tuple index out of range");
};
template <size_t IDX, typename P> class tuple_element<IDX, swoc::detail::ip_space_const_value_type<P>> {
  static_assert("swoc::IPSpace::value_type tuple index out of range");
};
 
template <typename P> class tuple_element<0, swoc::detail::ip_space_value_type<P>> {
public:
  using type = swoc::IPRangeView const &;
};
 
template <typename P> class tuple_element<1, swoc::detail::ip_space_value_type<P>> {
public:
  using type = P &;
};
 
template <typename P> class tuple_element<0, swoc::detail::ip_space_const_value_type<P>> {
public:
  using type = swoc::IPRangeView const &;
};
 
template <typename P> class tuple_element<1, swoc::detail::ip_space_const_value_type<P>> {
public:
  using type = P const &;
};
 
} // namespace std
 
namespace swoc { inline namespace SWOC_VERSION_NS { namespace detail {
template <size_t IDX, typename P>
auto
get(ip_space_const_value_type<P> const &p) -> typename std::tuple_element<IDX, ip_space_const_value_type<P>>::type {
  if constexpr (IDX == 0) {
    return p._rv;
  } else if constexpr (IDX == 1) {
    return *(p._payload);
  }
}
 
template <size_t IDX, typename P>
auto
get(ip_space_value_type<P> const &p) -> typename std::tuple_element<IDX, ip_space_value_type<P>>::type {
  if constexpr (IDX == 0) {
    return p._rv;
  } else if constexpr (IDX == 1) {
    return *(p._payload);
  }
}
}}} // namespace swoc::SWOC_VERSION_NS::detail
 
// Support unqualified @c get because ADL doesn't seem to work.
using swoc::detail::get;
// Support @c std::get
namespace std {
using swoc::detail::get;
}