cpp17: set axis compile-time options via deduction guide (#340)

Author: HDembinski

include/boost/histogram/axis/boolean.hpp

@@ -40,7 +40,7 @@ class boolean : public iterator_mixin<boolean<MetaData>>,
 public:
   /** Construct a boolean axis.
    *
-   * \param meta     description of the axis.
+   * @param meta description of the axis.
    */
   explicit boolean(metadata_type meta = {}) : metadata_base(std::move(meta)) {}
 

include/boost/histogram/axis/category.hpp

@@ -67,47 +67,69 @@ class category : public iterator_mixin<category<Value, MetaData, Options, Alloca
 
   /** Construct from iterator range of unique values.
    *
-   * \param begin     begin of category range of unique values.
-   * \param end       end of category range of unique values.
-   * \param meta      description of the axis.
-   * \param alloc     allocator instance to use.
+   * @param begin    begin of category range of unique values.
+   * @param end      end of category range of unique values.
+   * @param meta     description of the axis (optional).
+   * @param options  see boost::histogram::axis::option (optional).
+   * @param alloc    allocator instance to use (optional).
    */
   template <class It, class = detail::requires_iterator<It>>
-  category(It begin, It end, metadata_type meta = {}, allocator_type alloc = {})
+  category(It begin, It end, metadata_type meta = {}, options_type options = {},
+           allocator_type alloc = {})
       : metadata_base(std::move(meta)), vec_(alloc) {
+    (void)options;
     if (std::distance(begin, end) < 0)
       BOOST_THROW_EXCEPTION(
           std::invalid_argument("end must be reachable by incrementing begin"));
     vec_.reserve(std::distance(begin, end));
     while (begin != end) vec_.emplace_back(*begin++);
   }
 
+  // kept for backward compatibility
+  template <class It, class = detail::requires_iterator<It>>
+  category(It begin, It end, metadata_type meta, allocator_type alloc)
+      : category(begin, end, std::move(meta), {}, std::move(alloc)) {}
+
   /** Construct axis from iterable sequence of unique values.
    *
-   * \param iterable sequence of unique values.
-   * \param meta     description of the axis.
-   * \param alloc    allocator instance to use.
+   * @param iterable sequence of unique values.
+   * @param meta     description of the axis.
+   * @param options  see boost::histogram::axis::option (optional).
+   * @param alloc    allocator instance to use.
    */
   template <class C, class = detail::requires_iterable<C>>
-  category(const C& iterable, metadata_type meta = {}, allocator_type alloc = {})
-      : category(std::begin(iterable), std::end(iterable), std::move(meta),
+  category(const C& iterable, metadata_type meta = {}, options_type options = {},
+           allocator_type alloc = {})
+      : category(std::begin(iterable), std::end(iterable), std::move(meta), options,
+                 std::move(alloc)) {}
+
+  // kept for backward compatibility
+  template <class C, class = detail::requires_iterable<C>>
+  category(const C& iterable, metadata_type meta, allocator_type alloc)
+      : category(std::begin(iterable), std::end(iterable), std::move(meta), {},
                  std::move(alloc)) {}
 
   /** Construct axis from an initializer list of unique values.
    *
-   * \param list   `std::initializer_list` of unique values.
-   * \param meta   description of the axis.
-   * \param alloc  allocator instance to use.
+   * @param list     `std::initializer_list` of unique values.
+   * @param meta     description of the axis.
+   * @param options  see boost::histogram::axis::option (optional).
+   * @param alloc    allocator instance to use.
    */
   template <class U>
   category(std::initializer_list<U> list, metadata_type meta = {},
-           allocator_type alloc = {})
-      : category(list.begin(), list.end(), std::move(meta), std::move(alloc)) {}
+           options_type options = {}, allocator_type alloc = {})
+      : category(list.begin(), list.end(), std::move(meta), options, std::move(alloc)) {}
+
+  // kept for backward compatibility
+  template <class U>
+  category(std::initializer_list<U> list, metadata_type meta, allocator_type alloc)
+      : category(list.begin(), list.end(), std::move(meta), {}, std::move(alloc)) {}
 
   /// Constructor used by algorithm::reduce to shrink and rebin (not for users).
   category(const category& src, index_type begin, index_type end, unsigned merge)
       // LCOV_EXCL_START: gcc-8 is missing the delegated ctor for no reason
-      : category(src.vec_.begin() + begin, src.vec_.begin() + end, src.metadata(),
+      : category(src.vec_.begin() + begin, src.vec_.begin() + end, src.metadata(), {},
                  src.get_allocator())
   // LCOV_EXCL_STOP
   {
@@ -189,12 +211,17 @@ class category : public iterator_mixin<category<Value, MetaData, Options, Alloca
 
 template <class T>
 category(std::initializer_list<T>)
-    ->category<detail::replace_cstring<std::decay_t<T>>, null_type>;
+    -> category<detail::replace_cstring<std::decay_t<T>>, null_type>;
 
 template <class T, class M>
 category(std::initializer_list<T>, M)
-    ->category<detail::replace_cstring<std::decay_t<T>>,
-               detail::replace_cstring<std::decay_t<M>>>;
+    -> category<detail::replace_cstring<std::decay_t<T>>,
+                detail::replace_cstring<std::decay_t<M>>>;
+
+template <class T, class M, unsigned B>
+category(std::initializer_list<T>, M, const option::bitset<B>&)
+    -> category<detail::replace_cstring<std::decay_t<T>>,
+                detail::replace_cstring<std::decay_t<M>>, option::bitset<B>>;
 
 #endif
 

include/boost/histogram/axis/integer.hpp

@@ -34,9 +34,9 @@ namespace axis {
 
   Binning is a O(1) operation. This axis bins faster than a regular axis.
 
-  @tparam Value input value type. Must be integer or floating point.
-  @tparam MetaData type to store meta data.
-  @tparam Options see boost::histogram::axis::option (all values allowed).
+  @tparam Value     input value type. Must be integer or floating point.
+  @tparam MetaData  type to store meta data.
+  @tparam Options   see boost::histogram::axis::option.
  */
 template <class Value, class MetaData, class Options>
 class integer : public iterator_mixin<integer<Value, MetaData, Options>>,
@@ -73,14 +73,17 @@ class integer : public iterator_mixin<integer<Value, MetaData, Options>>,
 
   /** Construct over semi-open integer interval [start, stop).
    *
-   * \param start    first integer of covered range.
-   * \param stop     one past last integer of covered range.
-   * \param meta     description of the axis.
+   * @param start    first integer of covered range.
+   * @param stop     one past last integer of covered range.
+   * @param meta     description of the axis (optional).
+   * @param options  see boost::histogram::axis::option (optional).
    */
-  integer(value_type start, value_type stop, metadata_type meta = {})
+  integer(value_type start, value_type stop, metadata_type meta = {},
+          options_type options = {})
       : metadata_base(std::move(meta))
       , size_(static_cast<index_type>(stop - start))
       , min_(start) {
+    (void)options;
     if (!(stop >= start))
       BOOST_THROW_EXCEPTION(std::invalid_argument("stop >= start required"));
   }
@@ -217,6 +220,12 @@ integer(T, T, M)
     -> integer<detail::convert_integer<T, index_type>,
                detail::replace_type<std::decay_t<M>, const char*, std::string>>;
 
+template <class T, class M, unsigned B>
+integer(T, T, M, const option::bitset<B>&)
+    -> integer<detail::convert_integer<T, index_type>,
+               detail::replace_type<std::decay_t<M>, const char*, std::string>,
+               option::bitset<B>>;
+
 #endif
 
 } // namespace axis

include/boost/histogram/axis/option.hpp

@@ -57,7 +57,7 @@ constexpr auto operator-(bitset<B1>, bitset<B2>) {
   @tparam Pos position of the bit in the set.
 */
 template <unsigned Pos>
-struct bit : bitset<(1 << Pos)> {};
+using bit = bitset<(1 << Pos)>;
 
 /// All options off.
 using none_t = bitset<0>;

include/boost/histogram/axis/regular.hpp

@@ -173,7 +173,7 @@ step_type<T> step(T t) {
   @tparam Value input value type, must be floating point.
   @tparam Transform builtin or user-defined transform type.
   @tparam MetaData type to store meta data.
-  @tparam Options see boost::histogram::axis::option (all values allowed).
+  @tparam Options see boost::histogram::axis::option.
  */
 template <class Value, class Transform, class MetaData, class Options>
 class regular : public iterator_mixin<regular<Value, Transform, MetaData, Options>>,
@@ -213,14 +213,16 @@ class regular : public iterator_mixin<regular<Value, Transform, MetaData, Option
    * @param start    low edge of first bin.
    * @param stop     high edge of last bin.
    * @param meta     description of the axis (optional).
+   * @param options  see boost::histogram::axis::option (optional).
    */
   regular(transform_type trans, unsigned n, value_type start, value_type stop,
-          metadata_type meta = {})
+          metadata_type meta = {}, options_type options = {})
       : transform_type(std::move(trans))
       , metadata_base(std::move(meta))
       , size_(static_cast<index_type>(n))
       , min_(this->forward(detail::get_scale(start)))
       , delta_(this->forward(detail::get_scale(stop)) - min_) {
+    (void)options;
     if (size() == 0) BOOST_THROW_EXCEPTION(std::invalid_argument("bins > 0 required"));
     if (!std::isfinite(min_) || !std::isfinite(delta_))
       BOOST_THROW_EXCEPTION(
@@ -235,46 +237,51 @@ class regular : public iterator_mixin<regular<Value, Transform, MetaData, Option
    * @param start    low edge of first bin.
    * @param stop     high edge of last bin.
    * @param meta     description of the axis (optional).
+   * @param options  see boost::histogram::axis::option (optional).
    */
-  regular(unsigned n, value_type start, value_type stop, metadata_type meta = {})
-      : regular({}, n, start, stop, std::move(meta)) {}
+  regular(unsigned n, value_type start, value_type stop, metadata_type meta = {},
+          options_type options = {})
+      : regular({}, n, start, stop, std::move(meta), options) {}
 
   /** Construct bins with the given step size over real transformed range
    * [start, stop).
    *
-   * @param trans   transform instance to use.
-   * @param step    width of a single bin.
-   * @param start   low edge of first bin.
-   * @param stop    upper limit of high edge of last bin (see below).
-   * @param meta    description of the axis (optional).
+   * @param trans    transform instance to use.
+   * @param step     width of a single bin.
+   * @param start    low edge of first bin.
+   * @param stop     upper limit of high edge of last bin (see below).
+   * @param meta     description of the axis (optional).
+   * @param options  see boost::histogram::axis::option (optional).
    *
    * The axis computes the number of bins as n = abs(stop - start) / step,
    * rounded down. This means that stop is an upper limit to the actual value
    * (start + n * step).
    */
   template <class T>
   regular(transform_type trans, step_type<T> step, value_type start, value_type stop,
-          metadata_type meta = {})
+          metadata_type meta = {}, options_type options = {})
       : regular(trans, static_cast<index_type>(std::abs(stop - start) / step.value),
                 start,
                 start + static_cast<index_type>(std::abs(stop - start) / step.value) *
                             step.value,
-                std::move(meta)) {}
+                std::move(meta), options) {}
 
   /** Construct bins with the given step size over real range [start, stop).
    *
-   * @param step    width of a single bin.
-   * @param start   low edge of first bin.
-   * @param stop    upper limit of high edge of last bin (see below).
-   * @param meta    description of the axis (optional).
+   * @param step     width of a single bin.
+   * @param start    low edge of first bin.
+   * @param stop     upper limit of high edge of last bin (see below).
+   * @param meta     description of the axis (optional).
+   * @param options  see boost::histogram::axis::option (optional).
    *
    * The axis computes the number of bins as n = abs(stop - start) / step,
    * rounded down. This means that stop is an upper limit to the actual value
    * (start + n * step).
    */
   template <class T>
-  regular(step_type<T> step, value_type start, value_type stop, metadata_type meta = {})
-      : regular({}, step, start, stop, std::move(meta)) {}
+  regular(step_type<T> step, value_type start, value_type stop, metadata_type meta = {},
+          options_type options = {})
+      : regular({}, step, start, stop, std::move(meta), options) {}
 
   /// Constructor used by algorithm::reduce to shrink and rebin (not for users).
   regular(const regular& src, index_type begin, index_type end, unsigned merge)
@@ -397,20 +404,28 @@ class regular : public iterator_mixin<regular<Value, Transform, MetaData, Option
 
 template <class T>
 regular(unsigned, T, T)
-    ->regular<detail::convert_integer<T, double>, transform::id, null_type>;
+    -> regular<detail::convert_integer<T, double>, transform::id, null_type>;
 
 template <class T, class M>
-regular(unsigned, T, T, M)
-    ->regular<detail::convert_integer<T, double>, transform::id,
-              detail::replace_cstring<std::decay_t<M>>>;
+regular(unsigned, T, T, M) -> regular<detail::convert_integer<T, double>, transform::id,
+                                      detail::replace_cstring<std::decay_t<M>>>;
+
+template <class T, class M, unsigned B>
+regular(unsigned, T, T, M, const option::bitset<B>&)
+    -> regular<detail::convert_integer<T, double>, transform::id,
+               detail::replace_cstring<std::decay_t<M>>, option::bitset<B>>;
 
 template <class Tr, class T, class = detail::requires_transform<Tr, T>>
-regular(Tr, unsigned, T, T)->regular<detail::convert_integer<T, double>, Tr, null_type>;
+regular(Tr, unsigned, T, T) -> regular<detail::convert_integer<T, double>, Tr, null_type>;
 
 template <class Tr, class T, class M>
-regular(Tr, unsigned, T, T, M)
-    ->regular<detail::convert_integer<T, double>, Tr,
-              detail::replace_cstring<std::decay_t<M>>>;
+regular(Tr, unsigned, T, T, M) -> regular<detail::convert_integer<T, double>, Tr,
+                                          detail::replace_cstring<std::decay_t<M>>>;
+
+template <class Tr, class T, class M, unsigned B>
+regular(Tr, unsigned, T, T, M, const option::bitset<B>&)
+    -> regular<detail::convert_integer<T, double>, Tr,
+               detail::replace_cstring<std::decay_t<M>>, option::bitset<B>>;
 
 #endif