Class integer

include/boost/histogram/axis/types.hpp:392–445

 */
template <typename IntType, typename Allocator>
class integer : public labeled_base<Allocator>,
                public iterator_mixin<integer<IntType, Allocator>> {
  using base_type = labeled_base<Allocator>;

public:
  using allocator_type = typename base_type::allocator_type;
  using value_type = IntType;
  using bin_type = interval_view<integer>;

  /** Construct axis over a semi-open integer interval [lower, upper).
   *
   * \param lower smallest integer of the covered range.
   * \param upper largest integer of the covered range.
   * \param label description of the axis.
   * \param uoflow whether to add under-/overflow bins.
   */
  integer(value_type lower, value_type upper, string_view label = {},
          uoflow_type uo = uoflow_type::on, const allocator_type& a = allocator_type())
      : base_type(upper - lower, uo, label, a), min_(lower) {
    if (!(lower < upper)) { throw std::invalid_argument("lower < upper required"); }
  }

  integer() = default;
  integer(const integer&) = default;
  integer& operator=(const integer&) = default;
  integer(integer&&) = default;
  integer& operator=(integer&&) = default;

  /// Returns the bin index for the passed argument.
  int index(value_type x) const noexcept {
    const int z = x - min_;
    return z >= 0 ? (z > base_type::size() ? base_type::size() : z) : -1;
  }

  /// Returns lower edge of the integral bin.
  value_type lower(int i) const noexcept {
    if (i < 0) { return -std::numeric_limits<value_type>::max(); }
    if (i > base_type::size()) { return std::numeric_limits<value_type>::max(); }
    return min_ + i;
  }

  bin_type operator[](int idx) const noexcept { return bin_type(idx, *this); }

  bool operator==(const integer& o) const noexcept {
    return base_type::operator==(o) && min_ == o.min_;
  }

private:
  value_type min_ = 0;

  friend class ::boost::serialization::access;
  template <class Archive>
  void serialize(Archive&, unsigned);
};

/** Axis which maps unique values to bins (one on one).
 *