boost_mirror/histogram
1
0
Fork 0
mirror of https://github.com/boostorg/histogram.git synced 2025-05-11 13:14:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

remove boost.assert and cleanup boost.config

Browse Source
This commit is contained in:
Hans Dembinski 2020-06-08 00:41:12 +02:00 committed by GitHub
parent 8ecaf89c3a
commit a819ef53bf
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
42 changed files with 192 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.appveyor.yml
View File

@ -54,5 +54,5 @@ test_script:
## Uncomment the following to stop VM and enable interactive login. ## Uncomment the following to stop VM and enable interactive login.
## Instructions how to log into the Appveyor VM are automatically printed. ## Instructions how to log into the Appveyor VM are automatically printed.
on_failure: # on_failure:
- ps: $blockRdp = $true; iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-rdp.ps1')) # - ps: $blockRdp = $true; iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-rdp.ps1'))

3
CMakeLists.txt
View File

@ -14,7 +14,6 @@ target_include_directories(boost_histogram INTERFACE include)
target_compile_features(boost_histogram INTERFACE cxx_std_14) target_compile_features(boost_histogram INTERFACE cxx_std_14)
target_link_libraries(boost_histogram target_link_libraries(boost_histogram
INTERFACE INTERFACE
Boost::assert
Boost::config Boost::config
Boost::core Boost::core
Boost::mp11 Boost::mp11
@ -50,7 +49,7 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
set(BUILD_TESTING OFF) # do not build tests of dependencies set(BUILD_TESTING OFF) # do not build tests of dependencies
boost_fetch(boostorg/assert TAG develop EXCLUDE_FROM_ALL) boost_fetch(boostorg/assert TAG develop EXCLUDE_FROM_ALL) # needed by core
boost_fetch(boostorg/config TAG develop EXCLUDE_FROM_ALL) boost_fetch(boostorg/config TAG develop EXCLUDE_FROM_ALL)
boost_fetch(boostorg/core TAG develop EXCLUDE_FROM_ALL) boost_fetch(boostorg/core TAG develop EXCLUDE_FROM_ALL)
boost_fetch(boostorg/mp11 TAG develop EXCLUDE_FROM_ALL) boost_fetch(boostorg/mp11 TAG develop EXCLUDE_FROM_ALL)

4
benchmark/axis_index.cpp
View File

@ -10,10 +10,10 @@
#include "../test/throw_exception.hpp" #include "../test/throw_exception.hpp"
#include "generator.hpp" #include "generator.hpp"
#include <boost/assert.hpp> #include <cassert>
struct assert_check { struct assert_check {
assert_check() { assert_check() {
BOOST_ASSERT(false); // don't run with asserts enabled assert(false); // don't run with asserts enabled
} }
} _; } _;

4
benchmark/histogram_filling.cpp
View File

@ -12,10 +12,10 @@
#include "../test/utility_histogram.hpp" #include "../test/utility_histogram.hpp"
#include "generator.hpp" #include "generator.hpp"
#include <boost/assert.hpp> #include <cassert>
struct assert_check { struct assert_check {
assert_check() { assert_check() {
BOOST_ASSERT(false); // don't run with asserts enabled assert(false); // don't run with asserts enabled
} }
} _; } _;

4
benchmark/histogram_filling_gsl.cpp
View File

@ -10,10 +10,10 @@
#include "../test/throw_exception.hpp" #include "../test/throw_exception.hpp"
#include "generator.hpp" #include "generator.hpp"
#include <boost/assert.hpp> #include <cassert>
struct assert_check { struct assert_check {
assert_check() { assert_check() {
BOOST_ASSERT(false); // don't run with asserts enabled assert(false); // don't run with asserts enabled
} }
} _; } _;

4
benchmark/histogram_filling_root.cpp
View File

@ -11,10 +11,10 @@
#include <benchmark/benchmark.h> #include <benchmark/benchmark.h>
#include "generator.hpp" #include "generator.hpp"
#include <boost/assert.hpp> #include <cassert>
struct assert_check { struct assert_check {
assert_check() { assert_check() {
BOOST_ASSERT(false); // don't run with asserts enabled assert(false); // don't run with asserts enabled
} }
} _; } _;

4
benchmark/histogram_iteration.cpp
View File

@ -15,10 +15,10 @@
#include <vector> #include <vector>
#include "../test/throw_exception.hpp" #include "../test/throw_exception.hpp"
#include <boost/assert.hpp> #include <cassert>
struct assert_check { struct assert_check {
assert_check() { assert_check() {
BOOST_ASSERT(false); // don't run with asserts enabled assert(false); // don't run with asserts enabled
} }
} _; } _;

4
benchmark/histogram_parallel_filling.cpp
View File

@ -18,10 +18,10 @@
#include <vector> #include <vector>
#include "../test/throw_exception.hpp" #include "../test/throw_exception.hpp"
#include <boost/assert.hpp> #include <cassert>
struct assert_check { struct assert_check {
assert_check() { assert_check() {
BOOST_ASSERT(false); // don't run with asserts enabled assert(false); // don't run with asserts enabled
} }
} _; } _;

2
include/boost/histogram/accumulators/mean.hpp
View File

@ -7,10 +7,10 @@
#ifndef BOOST_HISTOGRAM_ACCUMULATORS_MEAN_HPP #ifndef BOOST_HISTOGRAM_ACCUMULATORS_MEAN_HPP
#define BOOST_HISTOGRAM_ACCUMULATORS_MEAN_HPP #define BOOST_HISTOGRAM_ACCUMULATORS_MEAN_HPP
#include <boost/assert.hpp>
#include <boost/core/nvp.hpp> #include <boost/core/nvp.hpp>
#include <boost/histogram/fwd.hpp> // for mean<> #include <boost/histogram/fwd.hpp> // for mean<>
#include <boost/throw_exception.hpp> #include <boost/throw_exception.hpp>
#include <cassert>
#include <stdexcept> #include <stdexcept>
#include <type_traits> #include <type_traits>

2
include/boost/histogram/accumulators/weighted_mean.hpp
View File

@ -7,10 +7,10 @@
#ifndef BOOST_HISTOGRAM_ACCUMULATORS_WEIGHTED_MEAN_HPP #ifndef BOOST_HISTOGRAM_ACCUMULATORS_WEIGHTED_MEAN_HPP
#define BOOST_HISTOGRAM_ACCUMULATORS_WEIGHTED_MEAN_HPP #define BOOST_HISTOGRAM_ACCUMULATORS_WEIGHTED_MEAN_HPP
#include <boost/assert.hpp>
#include <boost/core/nvp.hpp> #include <boost/core/nvp.hpp>
#include <boost/histogram/fwd.hpp> // for weighted_mean<> #include <boost/histogram/fwd.hpp> // for weighted_mean<>
#include <boost/histogram/weight.hpp> #include <boost/histogram/weight.hpp>
#include <cassert>
#include <type_traits> #include <type_traits>
namespace boost { namespace boost {

2
include/boost/histogram/algorithm/reduce.hpp
View File

@ -7,7 +7,6 @@
#ifndef BOOST_HISTOGRAM_ALGORITHM_REDUCE_HPP #ifndef BOOST_HISTOGRAM_ALGORITHM_REDUCE_HPP
#define BOOST_HISTOGRAM_ALGORITHM_REDUCE_HPP #define BOOST_HISTOGRAM_ALGORITHM_REDUCE_HPP
#include <boost/assert.hpp>
#include <boost/histogram/axis/traits.hpp> #include <boost/histogram/axis/traits.hpp>
#include <boost/histogram/detail/axes.hpp> #include <boost/histogram/detail/axes.hpp>
#include <boost/histogram/detail/make_default.hpp> #include <boost/histogram/detail/make_default.hpp>
@ -17,6 +16,7 @@
#include <boost/histogram/indexed.hpp> #include <boost/histogram/indexed.hpp>
#include <boost/histogram/unsafe_access.hpp> #include <boost/histogram/unsafe_access.hpp>
#include <boost/throw_exception.hpp> #include <boost/throw_exception.hpp>
#include <cassert>
#include <cmath> #include <cmath>
#include <initializer_list> #include <initializer_list>
#include <stdexcept> #include <stdexcept>

2
include/boost/histogram/axis/ostream.hpp
View File

@ -9,13 +9,13 @@
#ifndef BOOST_HISTOGRAM_AXIS_OSTREAM_HPP #ifndef BOOST_HISTOGRAM_AXIS_OSTREAM_HPP
#define BOOST_HISTOGRAM_AXIS_OSTREAM_HPP #define BOOST_HISTOGRAM_AXIS_OSTREAM_HPP
#include <boost/assert.hpp>
#include <boost/histogram/axis/regular.hpp> #include <boost/histogram/axis/regular.hpp>
#include <boost/histogram/detail/counting_streambuf.hpp> #include <boost/histogram/detail/counting_streambuf.hpp>
#include <boost/histogram/detail/priority.hpp> #include <boost/histogram/detail/priority.hpp>
#include <boost/histogram/detail/type_name.hpp> #include <boost/histogram/detail/type_name.hpp>
#include <boost/histogram/fwd.hpp> #include <boost/histogram/fwd.hpp>
#include <boost/throw_exception.hpp> #include <boost/throw_exception.hpp>
#include <cassert>
#include <iomanip> #include <iomanip>
#include <iosfwd> #include <iosfwd>
#include <sstream> #include <sstream>

6
include/boost/histogram/axis/regular.hpp
View File

@ -7,7 +7,6 @@
#ifndef BOOST_HISTOGRAM_AXIS_REGULAR_HPP #ifndef BOOST_HISTOGRAM_AXIS_REGULAR_HPP
#define BOOST_HISTOGRAM_AXIS_REGULAR_HPP #define BOOST_HISTOGRAM_AXIS_REGULAR_HPP
#include <boost/assert.hpp>
#include <boost/core/nvp.hpp> #include <boost/core/nvp.hpp>
#include <boost/histogram/axis/interval_view.hpp> #include <boost/histogram/axis/interval_view.hpp>
#include <boost/histogram/axis/iterator.hpp> #include <boost/histogram/axis/iterator.hpp>
@ -19,6 +18,7 @@
#include <boost/histogram/fwd.hpp> #include <boost/histogram/fwd.hpp>
#include <boost/mp11/utility.hpp> #include <boost/mp11/utility.hpp>
#include <boost/throw_exception.hpp> #include <boost/throw_exception.hpp>
#include <cassert>
#include <cmath> #include <cmath>
#include <limits> #include <limits>
#include <stdexcept> #include <stdexcept>
@ -280,7 +280,7 @@ public:
regular(const regular& src, index_type begin, index_type end, unsigned merge) regular(const regular& src, index_type begin, index_type end, unsigned merge)
: regular(src.transform(), (end - begin) / merge, src.value(begin), src.value(end), : regular(src.transform(), (end - begin) / merge, src.value(begin), src.value(end),
src.metadata()) { src.metadata()) {
BOOST_ASSERT((end - begin) % merge == 0); assert((end - begin) % merge == 0);
if (options_type::test(option::circular) && !(begin == 0 && end == src.size())) if (options_type::test(option::circular) && !(begin == 0 && end == src.size()))
BOOST_THROW_EXCEPTION(std::invalid_argument("cannot shrink circular axis")); BOOST_THROW_EXCEPTION(std::invalid_argument("cannot shrink circular axis"));
} }
@ -310,7 +310,7 @@ public:
/// Returns index and shift (if axis has grown) for the passed argument. /// Returns index and shift (if axis has grown) for the passed argument.
std::pair<index_type, index_type> update(value_type x) noexcept { std::pair<index_type, index_type> update(value_type x) noexcept {
BOOST_ASSERT(options_type::test(option::growth)); assert(options_type::test(option::growth));
const auto z = (this->forward(x / unit_type{}) - min_) / delta_; const auto z = (this->forward(x / unit_type{}) - min_) / delta_;
if (z < 1) { // don't use i here! if (z < 1) { // don't use i here!
if (z >= 0) { if (z >= 0) {

13
include/boost/histogram/axis/traits.hpp
View File

@ -7,7 +7,6 @@
#ifndef BOOST_HISTOGRAM_AXIS_TRAITS_HPP #ifndef BOOST_HISTOGRAM_AXIS_TRAITS_HPP
#define BOOST_HISTOGRAM_AXIS_TRAITS_HPP #define BOOST_HISTOGRAM_AXIS_TRAITS_HPP
#include <boost/core/ignore_unused.hpp>
#include <boost/histogram/axis/option.hpp> #include <boost/histogram/axis/option.hpp>
#include <boost/histogram/detail/args_type.hpp> #include <boost/histogram/detail/args_type.hpp>
#include <boost/histogram/detail/detect.hpp> #include <boost/histogram/detail/detect.hpp>
@ -254,7 +253,7 @@ struct is_ordered;
*/ */
template <class Axis> template <class Axis>
constexpr unsigned options(const Axis& axis) noexcept { constexpr unsigned options(const Axis& axis) noexcept {
boost::ignore_unused(axis); (void)axis;
return get_options<Axis>::value; return get_options<Axis>::value;
} }
@ -272,7 +271,7 @@ unsigned options(const variant<Ts...>& axis) noexcept {
*/ */
template <class Axis> template <class Axis>
constexpr bool inclusive(const Axis& axis) noexcept { constexpr bool inclusive(const Axis& axis) noexcept {
boost::ignore_unused(axis); (void)axis;
return is_inclusive<Axis>::value; return is_inclusive<Axis>::value;
} }
@ -290,7 +289,7 @@ bool inclusive(const variant<Ts...>& axis) noexcept {
*/ */
template <class Axis> template <class Axis>
constexpr bool ordered(const Axis& axis) noexcept { constexpr bool ordered(const Axis& axis) noexcept {
boost::ignore_unused(axis); (void)axis;
return is_ordered<Axis>::value; return is_ordered<Axis>::value;
} }
@ -308,7 +307,7 @@ bool ordered(const variant<Ts...>& axis) noexcept {
*/ */
template <class Axis> template <class Axis>
constexpr bool continuous(const Axis& axis) noexcept { constexpr bool continuous(const Axis& axis) noexcept {
boost::ignore_unused(axis); (void)axis;
return is_continuous<Axis>::value; return is_continuous<Axis>::value;
} }
@ -341,7 +340,7 @@ template <class Axis>
decltype(auto) metadata(Axis&& axis) noexcept { decltype(auto) metadata(Axis&& axis) noexcept {
return detail::static_if<detail::has_method_metadata<std::decay_t<Axis>>>( return detail::static_if<detail::has_method_metadata<std::decay_t<Axis>>>(
[](auto&& a) -> decltype(auto) { return a.metadata(); }, [](auto&& a) -> decltype(auto) { return a.metadata(); },
[](auto &&) -> axis::null_type& { return detail::null_value; }, [](auto&&) -> axis::null_type& { return detail::null_value; },
std::forward<Axis>(axis)); std::forward<Axis>(axis));
} }
@ -403,7 +402,7 @@ axis::index_type index(const variant<Ts...>& axis, const U& value) {
*/ */
template <class Axis> template <class Axis>
constexpr unsigned rank(const Axis& axis) { constexpr unsigned rank(const Axis& axis) {
boost::ignore_unused(axis); (void)axis;
using T = value_type<Axis>; using T = value_type<Axis>;
// cannot use mp_eval_or since T could be a fixed-sized sequence // cannot use mp_eval_or since T could be a fixed-sized sequence
return mp11::mp_eval_if_not<detail::is_tuple<T>, mp11::mp_size_t<1>, mp11::mp_size, return mp11::mp_eval_if_not<detail::is_tuple<T>, mp11::mp_size_t<1>, mp11::mp_size,

4
include/boost/histogram/axis/variable.hpp
View File

@ -8,7 +8,6 @@
#define BOOST_HISTOGRAM_AXIS_VARIABLE_HPP #define BOOST_HISTOGRAM_AXIS_VARIABLE_HPP
#include <algorithm> #include <algorithm>
#include <boost/assert.hpp>
#include <boost/core/nvp.hpp> #include <boost/core/nvp.hpp>
#include <boost/histogram/axis/interval_view.hpp> #include <boost/histogram/axis/interval_view.hpp>
#include <boost/histogram/axis/iterator.hpp> #include <boost/histogram/axis/iterator.hpp>
@ -21,6 +20,7 @@
#include <boost/histogram/detail/replace_type.hpp> #include <boost/histogram/detail/replace_type.hpp>
#include <boost/histogram/fwd.hpp> #include <boost/histogram/fwd.hpp>
#include <boost/throw_exception.hpp> #include <boost/throw_exception.hpp>
#include <cassert>
#include <cmath> #include <cmath>
#include <limits> #include <limits>
#include <memory> #include <memory>
@ -121,7 +121,7 @@ public:
/// Constructor used by algorithm::reduce to shrink and rebin (not for users). /// Constructor used by algorithm::reduce to shrink and rebin (not for users).
variable(const variable& src, index_type begin, index_type end, unsigned merge) variable(const variable& src, index_type begin, index_type end, unsigned merge)
: metadata_base(src), vec_(src.get_allocator()) { : metadata_base(src), vec_(src.get_allocator()) {
BOOST_ASSERT((end - begin) % merge == 0); assert((end - begin) % merge == 0);
if (options_type::test(option::circular) && !(begin == 0 && end == src.size())) if (options_type::test(option::circular) && !(begin == 0 && end == src.size()))
BOOST_THROW_EXCEPTION(std::invalid_argument("cannot shrink circular axis")); BOOST_THROW_EXCEPTION(std::invalid_argument("cannot shrink circular axis"));
vec_.reserve((end - begin) / merge); vec_.reserve((end - begin) / merge);

28
include/boost/histogram/detail/axes.hpp
View File

@ -8,9 +8,6 @@
#define BOOST_HISTOGRAM_DETAIL_AXES_HPP #define BOOST_HISTOGRAM_DETAIL_AXES_HPP
#include <array> #include <array>
#include <boost/assert.hpp>
#include <boost/config/workaround.hpp>
#include <boost/core/ignore_unused.hpp>
#include <boost/core/nvp.hpp> #include <boost/core/nvp.hpp>
#include <boost/histogram/axis/traits.hpp> #include <boost/histogram/axis/traits.hpp>
#include <boost/histogram/axis/variant.hpp> #include <boost/histogram/axis/variant.hpp>
@ -21,6 +18,7 @@
#include <boost/histogram/detail/relaxed_tuple_size.hpp> #include <boost/histogram/detail/relaxed_tuple_size.hpp>
#include <boost/histogram/detail/static_if.hpp> #include <boost/histogram/detail/static_if.hpp>
#include <boost/histogram/detail/sub_array.hpp> #include <boost/histogram/detail/sub_array.hpp>
#include <boost/histogram/detail/try_cast.hpp>
#include <boost/histogram/fwd.hpp> #include <boost/histogram/fwd.hpp>
#include <boost/mp11/algorithm.hpp> #include <boost/mp11/algorithm.hpp>
#include <boost/mp11/integer_sequence.hpp> #include <boost/mp11/integer_sequence.hpp>
@ -28,6 +26,7 @@
#include <boost/mp11/tuple.hpp> #include <boost/mp11/tuple.hpp>
#include <boost/mp11/utility.hpp> #include <boost/mp11/utility.hpp>
#include <boost/throw_exception.hpp> #include <boost/throw_exception.hpp>
#include <cassert>
#include <initializer_list> #include <initializer_list>
#include <iterator> #include <iterator>
#include <stdexcept> #include <stdexcept>
@ -58,25 +57,16 @@ void for_each_axis(T&& t, Unary&& p) {
// merge if a and b are discrete and growing // merge if a and b are discrete and growing
struct axis_merger { struct axis_merger {
template <class T> template <class T, class U>
T operator()(const T& a, const T& b) { T operator()(const T& a, const U& u) {
const T* bp = ptr_cast<T>(&u);
if (!bp) BOOST_THROW_EXCEPTION(std::invalid_argument("axes not mergable"));
using O = axis::traits::get_options<T>; using O = axis::traits::get_options<T>;
constexpr bool discrete_and_growing = constexpr bool discrete_and_growing =
axis::traits::is_continuous<T>::value == false && O::test(axis::option::growth); axis::traits::is_continuous<T>::value == false && O::test(axis::option::growth);
return impl(mp11::mp_bool<discrete_and_growing>{}, a, b); return impl(mp11::mp_bool<discrete_and_growing>{}, a, *bp);
} }
#if BOOST_WORKAROUND(BOOST_MSVC, >= 0)
#pragma warning(disable : 4702) // fixing warning would reduce code readability a lot
#endif
template <class T, class U>
T operator()(const T& a, const U&) {
return BOOST_THROW_EXCEPTION(std::invalid_argument("axes not mergable")), a;
}
#if BOOST_WORKAROUND(BOOST_MSVC, >= 0)
#pragma warning(default : 4702)
#endif
template <class T> template <class T>
T impl(std::false_type, const T& a, const T& b) { T impl(std::false_type, const T& a, const T& b) {
if (!relaxed_equal{}(a, b)) if (!relaxed_equal{}(a, b))
@ -238,8 +228,8 @@ template <class T, class U, std::size_t... Is>
bool axes_equal_impl(const T& t, const U& u, mp11::index_sequence<Is...>) noexcept { bool axes_equal_impl(const T& t, const U& u, mp11::index_sequence<Is...>) noexcept {
bool result = true; bool result = true;
// operator folding emulation // operator folding emulation
ignore_unused(std::initializer_list<bool>{ (void)std::initializer_list<bool>{
(result &= relaxed_equal{}(std::get<Is>(t), std::get<Is>(u)))...}); (result &= relaxed_equal{}(std::get<Is>(t), std::get<Is>(u)))...};
return result; return result;
} }

4
include/boost/histogram/detail/fill.hpp
View File

@ -8,7 +8,6 @@
#define BOOST_HISTOGRAM_DETAIL_FILL_HPP #define BOOST_HISTOGRAM_DETAIL_FILL_HPP
#include <algorithm> #include <algorithm>
#include <boost/assert.hpp>
#include <boost/config/workaround.hpp> #include <boost/config/workaround.hpp>
#include <boost/histogram/axis/traits.hpp> #include <boost/histogram/axis/traits.hpp>
#include <boost/histogram/axis/variant.hpp> #include <boost/histogram/axis/variant.hpp>
@ -24,6 +23,7 @@
#include <boost/mp11/integral.hpp> #include <boost/mp11/integral.hpp>
#include <boost/mp11/tuple.hpp> #include <boost/mp11/tuple.hpp>
#include <boost/mp11/utility.hpp> #include <boost/mp11/utility.hpp>
#include <cassert>
#include <mutex> #include <mutex>
#include <tuple> #include <tuple>
#include <type_traits> #include <type_traits>
@ -195,7 +195,7 @@ void fill_storage_2(mp11::mp_int<-1>, mp11::mp_int<-1>, T&& t, const U&) noexcep
template <class IW, class IS, class Storage, class Index, class Args> template <class IW, class IS, class Storage, class Index, class Args>
auto fill_storage(IW, IS, Storage& s, const Index idx, const Args& a) noexcept { auto fill_storage(IW, IS, Storage& s, const Index idx, const Args& a) noexcept {
if (is_valid(idx)) { if (is_valid(idx)) {
BOOST_ASSERT(idx < s.size()); assert(idx < s.size());
fill_storage_2(IW{}, IS{}, s[idx], a); fill_storage_2(IW{}, IS{}, s[idx], a);
return s.begin() + idx; return s.begin() + idx;
} }

13
include/boost/histogram/detail/fill_n.hpp
View File

@ -8,8 +8,6 @@
#define BOOST_HISTOGRAM_DETAIL_FILL_N_HPP #define BOOST_HISTOGRAM_DETAIL_FILL_N_HPP
#include <algorithm> #include <algorithm>
#include <boost/assert.hpp>
#include <boost/core/ignore_unused.hpp>
#include <boost/histogram/axis/option.hpp> #include <boost/histogram/axis/option.hpp>
#include <boost/histogram/axis/traits.hpp> #include <boost/histogram/axis/traits.hpp>
#include <boost/histogram/detail/axes.hpp> #include <boost/histogram/detail/axes.hpp>
@ -26,6 +24,7 @@
#include <boost/mp11/utility.hpp> #include <boost/mp11/utility.hpp>
#include <boost/throw_exception.hpp> #include <boost/throw_exception.hpp>
#include <boost/variant2/variant.hpp> #include <boost/variant2/variant.hpp>
#include <cassert>
#include <initializer_list> #include <initializer_list>
#include <stdexcept> #include <stdexcept>
#include <type_traits> #include <type_traits>
@ -157,22 +156,22 @@ void fill_n_indices(Index* indices, const std::size_t start, const std::size_t s
template <class S, class Index, class... Ts> template <class S, class Index, class... Ts>
void fill_n_storage(S& s, const Index idx, Ts&&... p) noexcept { void fill_n_storage(S& s, const Index idx, Ts&&... p) noexcept {
if (is_valid(idx)) { if (is_valid(idx)) {
BOOST_ASSERT(idx < s.size()); assert(idx < s.size());
fill_storage_element(s[idx], *p.first...); fill_storage_element(s[idx], *p.first...);
} }
// operator folding emulation // operator folding emulation
ignore_unused(std::initializer_list<int>{(p.second ? (++p.first, 0) : 0)...}); (void)std::initializer_list<int>{(p.second ? (++p.first, 0) : 0)...};
} }
template <class S, class Index, class T, class... Ts> template <class S, class Index, class T, class... Ts>
void fill_n_storage(S& s, const Index idx, weight_type<T>&& w, Ts&&... ps) noexcept { void fill_n_storage(S& s, const Index idx, weight_type<T>&& w, Ts&&... ps) noexcept {
if (is_valid(idx)) { if (is_valid(idx)) {
BOOST_ASSERT(idx < s.size()); assert(idx < s.size());
fill_storage_element(s[idx], weight(*w.value.first), *ps.first...); fill_storage_element(s[idx], weight(*w.value.first), *ps.first...);
} }
if (w.value.second) ++w.value.first; if (w.value.second) ++w.value.first;
// operator folding emulation // operator folding emulation
ignore_unused(std::initializer_list<int>{(ps.second ? (++ps.first, 0) : 0)...}); (void)std::initializer_list<int>{(ps.second ? (++ps.first, 0) : 0)...};
} }
// general Nd treatment // general Nd treatment
@ -256,7 +255,7 @@ std::size_t get_total_size(const A& axes, const dtl::span<const T, N>& values) {
// supported cases (T = value type; CT = containter of T; V<T, CT, ...> = variant): // supported cases (T = value type; CT = containter of T; V<T, CT, ...> = variant):
// - span<CT, N>: for any histogram, N == rank // - span<CT, N>: for any histogram, N == rank
// - span<V<T, CT>, N>: for any histogram, N == rank // - span<V<T, CT>, N>: for any histogram, N == rank
BOOST_ASSERT(axes_rank(axes) == values.size()); assert(axes_rank(axes) == values.size());
constexpr auto unset = static_cast<std::size_t>(-1); constexpr auto unset = static_cast<std::size_t>(-1);
std::size_t size = unset; std::size_t size = unset;
for_each_axis(axes, [&size, vit = values.begin()](const auto& ax) mutable { for_each_axis(axes, [&size, vit = values.begin()](const auto& ax) mutable {

5
include/boost/histogram/detail/index_translator.hpp
View File

@ -8,8 +8,6 @@
#define BOOST_HISTOGRAM_DETAIL_INDEX_TRANSLATOR_HPP #define BOOST_HISTOGRAM_DETAIL_INDEX_TRANSLATOR_HPP
#include <algorithm> #include <algorithm>
#include <boost/assert.hpp>
#include <boost/core/ignore_unused.hpp>
#include <boost/histogram/axis/traits.hpp> #include <boost/histogram/axis/traits.hpp>
#include <boost/histogram/axis/variant.hpp> #include <boost/histogram/axis/variant.hpp>
#include <boost/histogram/detail/relaxed_equal.hpp> #include <boost/histogram/detail/relaxed_equal.hpp>
@ -18,6 +16,7 @@
#include <boost/histogram/multi_index.hpp> #include <boost/histogram/multi_index.hpp>
#include <boost/mp11/algorithm.hpp> #include <boost/mp11/algorithm.hpp>
#include <boost/mp11/integer_sequence.hpp> #include <boost/mp11/integer_sequence.hpp>
#include <cassert>
#include <initializer_list> #include <initializer_list>
#include <tuple> #include <tuple>
#include <vector> #include <vector>
@ -60,7 +59,7 @@ struct index_translator {
template <class T> template <class T>
static index_type translate(const T& dst, const T& src, index_type i) noexcept { static index_type translate(const T& dst, const T& src, index_type i) noexcept {
BOOST_ASSERT(axis::traits::is_continuous<T>::value == false); // LCOV_EXCL_LINE: unreachable assert(axis::traits::is_continuous<T>::value == false); // LCOV_EXCL_LINE: unreachable
return dst.index(src.value(i)); return dst.index(src.value(i));
} }

34
include/boost/histogram/detail/large_int.hpp
View File

@ -7,13 +7,13 @@
#ifndef BOOST_HISTOGRAM_DETAIL_LARGE_INT_HPP #ifndef BOOST_HISTOGRAM_DETAIL_LARGE_INT_HPP
#define BOOST_HISTOGRAM_DETAIL_LARGE_INT_HPP #define BOOST_HISTOGRAM_DETAIL_LARGE_INT_HPP
#include <boost/assert.hpp>
#include <boost/histogram/detail/operators.hpp> #include <boost/histogram/detail/operators.hpp>
#include <boost/histogram/detail/safe_comparison.hpp> #include <boost/histogram/detail/safe_comparison.hpp>
#include <boost/mp11/algorithm.hpp> #include <boost/mp11/algorithm.hpp>
#include <boost/mp11/function.hpp> #include <boost/mp11/function.hpp>
#include <boost/mp11/list.hpp> #include <boost/mp11/list.hpp>
#include <boost/mp11/utility.hpp> #include <boost/mp11/utility.hpp>
#include <cassert>
#include <cmath> #include <cmath>
#include <cstdint> #include <cstdint>
#include <limits> #include <limits>
@ -68,7 +68,7 @@ struct large_int : totally_ordered<large_int<Allocator>, large_int<Allocator>>,
} }
large_int& operator++() { large_int& operator++() {
BOOST_ASSERT(data.size() > 0u); assert(data.size() > 0u);
std::size_t i = 0; std::size_t i = 0;
while (!safe_increment(data[i])) { while (!safe_increment(data[i])) {
data[i] = 0; data[i] = 0;
@ -114,7 +114,7 @@ struct large_int : totally_ordered<large_int<Allocator>, large_int<Allocator>>,
} }
large_int& operator+=(std::uint64_t o) { large_int& operator+=(std::uint64_t o) {
BOOST_ASSERT(data.size() > 0u); assert(data.size() > 0u);
if (safe_radd(data[0], o)) return *this; if (safe_radd(data[0], o)) return *this;
add_remainder(data[0], o); add_remainder(data[0], o);
// carry the one, data may grow several times // carry the one, data may grow several times
@ -129,7 +129,7 @@ struct large_int : totally_ordered<large_int<Allocator>, large_int<Allocator>>,
} }
explicit operator double() const noexcept { explicit operator double() const noexcept {
BOOST_ASSERT(data.size() > 0u); assert(data.size() > 0u);
double result = static_cast<double>(data[0]); double result = static_cast<double>(data[0]);
std::size_t i = 0; std::size_t i = 0;
while (++i < data.size()) while (++i < data.size())
@ -138,11 +138,11 @@ struct large_int : totally_ordered<large_int<Allocator>, large_int<Allocator>>,
} }
bool operator<(const large_int& o) const noexcept { bool operator<(const large_int& o) const noexcept {
BOOST_ASSERT(data.size() > 0u); assert(data.size() > 0u);
BOOST_ASSERT(o.data.size() > 0u); assert(o.data.size() > 0u);
// no leading zeros allowed // no leading zeros allowed
BOOST_ASSERT(data.size() == 1 || data.back() > 0u); assert(data.size() == 1 || data.back() > 0u);
BOOST_ASSERT(o.data.size() == 1 || o.data.back() > 0u); assert(o.data.size() == 1 || o.data.back() > 0u);
if (data.size() < o.data.size()) return true; if (data.size() < o.data.size()) return true;
if (data.size() > o.data.size()) return false; if (data.size() > o.data.size()) return false;
auto s = data.size(); auto s = data.size();
@ -155,11 +155,11 @@ struct large_int : totally_ordered<large_int<Allocator>, large_int<Allocator>>,
} }
bool operator==(const large_int& o) const noexcept { bool operator==(const large_int& o) const noexcept {
BOOST_ASSERT(data.size() > 0u); assert(data.size() > 0u);
BOOST_ASSERT(o.data.size() > 0u); assert(o.data.size() > 0u);
// no leading zeros allowed // no leading zeros allowed
BOOST_ASSERT(data.size() == 1 || data.back() > 0u); assert(data.size() == 1 || data.back() > 0u);
BOOST_ASSERT(o.data.size() == 1 || o.data.back() > 0u); assert(o.data.size() == 1 || o.data.back() > 0u);
if (data.size() != o.data.size()) return false; if (data.size() != o.data.size()) return false;
return std::equal(data.begin(), data.end(), o.data.begin()); return std::equal(data.begin(), data.end(), o.data.begin());
} }
@ -167,22 +167,22 @@ struct large_int : totally_ordered<large_int<Allocator>, large_int<Allocator>>,
template <class U> template <class U>
std::enable_if_t<std::is_integral<U>::value, bool> operator<(const U& o) const std::enable_if_t<std::is_integral<U>::value, bool> operator<(const U& o) const
noexcept { noexcept {
BOOST_ASSERT(data.size() > 0u); assert(data.size() > 0u);
return data.size() == 1 && safe_less()(data[0], o); return data.size() == 1 && safe_less()(data[0], o);
} }
template <class U> template <class U>
std::enable_if_t<std::is_integral<U>::value, bool> operator>(const U& o) const std::enable_if_t<std::is_integral<U>::value, bool> operator>(const U& o) const
noexcept { noexcept {
BOOST_ASSERT(data.size() > 0u); assert(data.size() > 0u);
BOOST_ASSERT(data.size() == 1 || data.back() > 0u); // no leading zeros allowed assert(data.size() == 1 || data.back() > 0u); // no leading zeros allowed
return data.size() > 1 || safe_less()(o, data[0]); return data.size() > 1 || safe_less()(o, data[0]);
} }
template <class U> template <class U>
std::enable_if_t<std::is_integral<U>::value, bool> operator==(const U& o) const std::enable_if_t<std::is_integral<U>::value, bool> operator==(const U& o) const
noexcept { noexcept {
BOOST_ASSERT(data.size() > 0u); assert(data.size() > 0u);
return data.size() == 1 && safe_equal()(data[0], o); return data.size() == 1 && safe_equal()(data[0], o);
} }
@ -208,7 +208,7 @@ struct large_int : totally_ordered<large_int<Allocator>, large_int<Allocator>>,
} }
static void add_remainder(std::uint64_t& d, const std::uint64_t o) noexcept { static void add_remainder(std::uint64_t& d, const std::uint64_t o) noexcept {
BOOST_ASSERT(d > 0u); assert(d > 0u);
// in decimal system it would look like this: // in decimal system it would look like this:
// 8 + 8 = 6 = 8 - (9 - 8) - 1 // 8 + 8 = 6 = 8 - (9 - 8) - 1
// 9 + 1 = 0 = 9 - (9 - 1) - 1 // 9 + 1 = 0 = 9 - (9 - 1) - 1

32
include/boost/histogram/detail/linearize.hpp
View File

@ -7,14 +7,13 @@
#ifndef BOOST_HISTOGRAM_DETAIL_LINEARIZE_HPP #ifndef BOOST_HISTOGRAM_DETAIL_LINEARIZE_HPP
#define BOOST_HISTOGRAM_DETAIL_LINEARIZE_HPP #define BOOST_HISTOGRAM_DETAIL_LINEARIZE_HPP
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/histogram/axis/option.hpp> #include <boost/histogram/axis/option.hpp>
#include <boost/histogram/axis/traits.hpp> #include <boost/histogram/axis/traits.hpp>
#include <boost/histogram/axis/variant.hpp> #include <boost/histogram/axis/variant.hpp>
#include <boost/histogram/detail/optional_index.hpp> #include <boost/histogram/detail/optional_index.hpp>
#include <boost/histogram/fwd.hpp> #include <boost/histogram/fwd.hpp>
#include <boost/histogram/multi_index.hpp> #include <boost/histogram/multi_index.hpp>
#include <cassert>
namespace boost { namespace boost {
namespace histogram { namespace histogram {
@ -26,20 +25,20 @@ std::size_t linearize(Opts, Index& out, const std::size_t stride,
const axis::index_type size, const axis::index_type idx) { const axis::index_type size, const axis::index_type idx) {
constexpr bool u = Opts::test(axis::option::underflow); constexpr bool u = Opts::test(axis::option::underflow);
constexpr bool o = Opts::test(axis::option::overflow); constexpr bool o = Opts::test(axis::option::overflow);
#ifdef BOOST_NO_CXX17_IF_CONSTEXPR
if // must be non-const to avoid if constexpr warning from msvc
#else bool fast_track = std::is_same<Index, std::size_t>::value || (u && o);
if constexpr if (fast_track) {
#endif assert(idx >= (u ? -1 : 0));
(std::is_same<Index, std::size_t>::value || (u && o)) { assert(idx < (o ? size + 1 : size));
BOOST_ASSERT(idx >= (u ? -1 : 0)); assert(idx >= 0 || static_cast<std::size_t>(-idx * stride) <= out);
BOOST_ASSERT(idx < (o ? size + 1 : size));
BOOST_ASSERT(idx >= 0 || static_cast<std::size_t>(-idx * stride) <= out);
out += idx * stride; out += idx * stride;
} else { } else {
BOOST_ASSERT(idx >= -1); assert(idx >= -1);
BOOST_ASSERT(idx < size + 1); assert(idx < size + 1);
if ((u || idx >= 0) && (o || idx < size)) // must be non-const to avoid if constexpr warning from msvc
bool is_valid = (u || idx >= 0) && (o || idx < size);
if (is_valid)
out += idx * stride; out += idx * stride;
else else
out = invalid_index; out = invalid_index;
@ -65,7 +64,7 @@ std::size_t linearize_growth(Index& out, axis::index_type& shift,
constexpr bool u = axis::traits::get_options<Axis>::test(axis::option::underflow); constexpr bool u = axis::traits::get_options<Axis>::test(axis::option::underflow);
if (u) ++idx; if (u) ++idx;
if (std::is_same<Index, std::size_t>::value) { if (std::is_same<Index, std::size_t>::value) {
BOOST_ASSERT(idx < axis::traits::extent(a)); assert(idx < axis::traits::extent(a));
out += idx * stride; out += idx * stride;
} else { } else {
if (0 <= idx && idx < axis::traits::extent(a)) if (0 <= idx && idx < axis::traits::extent(a))
@ -94,8 +93,7 @@ std::size_t linearize_index(optional_index& out, const std::size_t stride, const
template <class A, std::size_t N> template <class A, std::size_t N>
optional_index linearize_indices(const A& axes, const multi_index<N>& indices) noexcept { optional_index linearize_indices(const A& axes, const multi_index<N>& indices) noexcept {
BOOST_ASSERT_MSG(axes_rank(axes) == detail::size(indices), assert(axes_rank(axes) == detail::size(indices));
"axes and indices must have equal lengths");
optional_index idx{0}; // offset not used by linearize_index optional_index idx{0}; // offset not used by linearize_index
auto stride = static_cast<std::size_t>(1); auto stride = static_cast<std::size_t>(1);

4
include/boost/histogram/detail/optional_index.hpp
View File

@ -7,7 +7,7 @@
#ifndef BOOST_HISTOGRAM_DETAIL_OPTIONAL_INDEX_HPP #ifndef BOOST_HISTOGRAM_DETAIL_OPTIONAL_INDEX_HPP
#define BOOST_HISTOGRAM_DETAIL_OPTIONAL_INDEX_HPP #define BOOST_HISTOGRAM_DETAIL_OPTIONAL_INDEX_HPP
#include <boost/assert.hpp> #include <cassert>
#include <cstdint> #include <cstdint>
namespace boost { namespace boost {
@ -26,7 +26,7 @@ struct optional_index {
} }
optional_index& operator+=(std::intptr_t x) noexcept { optional_index& operator+=(std::intptr_t x) noexcept {
BOOST_ASSERT(x >= 0 || static_cast<std::size_t>(-x) <= value); assert(x >= 0 || static_cast<std::size_t>(-x) <= value);
if (value != invalid_index) { value += x; } if (value != invalid_index) { value += x; }
return *this; return *this;
} }

4
include/boost/histogram/detail/reduce_command.hpp
View File

@ -7,10 +7,10 @@
#ifndef BOOST_HISTOGRAM_DETAIL_REDUCE_COMMAND_HPP #ifndef BOOST_HISTOGRAM_DETAIL_REDUCE_COMMAND_HPP
#define BOOST_HISTOGRAM_DETAIL_REDUCE_COMMAND_HPP #define BOOST_HISTOGRAM_DETAIL_REDUCE_COMMAND_HPP
#include <boost/assert.hpp>
#include <boost/histogram/detail/span.hpp> #include <boost/histogram/detail/span.hpp>
#include <boost/histogram/fwd.hpp> #include <boost/histogram/fwd.hpp>
#include <boost/throw_exception.hpp> #include <boost/throw_exception.hpp>
#include <cassert>
#include <stdexcept> #include <stdexcept>
#include <string> #include <string>
@ -46,7 +46,7 @@ inline void normalize_reduce_commands(span<reduce_command> out,
span<const reduce_command> in) { span<const reduce_command> in) {
unsigned iaxis = 0; unsigned iaxis = 0;
for (const auto& o_in : in) { for (const auto& o_in : in) {
BOOST_ASSERT(o_in.merge > 0); assert(o_in.merge > 0);
if (o_in.iaxis != reduce_command::unset && o_in.iaxis >= out.size()) if (o_in.iaxis != reduce_command::unset && o_in.iaxis >= out.size())
BOOST_THROW_EXCEPTION(std::invalid_argument("invalid axis index")); BOOST_THROW_EXCEPTION(std::invalid_argument("invalid axis index"));
auto& o_out = out.begin()[o_in.iaxis == reduce_command::unset ? iaxis : o_in.iaxis]; auto& o_out = out.begin()[o_in.iaxis == reduce_command::unset ? iaxis : o_in.iaxis];

30
include/boost/histogram/detail/span.hpp
View File

@ -35,8 +35,8 @@ using std::span;
// to be replaced by boost::span // to be replaced by boost::span
#include <array> #include <array>
#include <boost/assert.hpp>
#include <boost/histogram/detail/nonmember_container_access.hpp> #include <boost/histogram/detail/nonmember_container_access.hpp>
#include <cassert>
#include <initializer_list> #include <initializer_list>
#include <iterator> #include <iterator>
#include <type_traits> #include <type_traits>
@ -57,10 +57,14 @@ public:
constexpr std::size_t size() const noexcept { return N; } constexpr std::size_t size() const noexcept { return N; }
protected: protected:
constexpr span_base(T* b, std::size_t s) noexcept : begin_(b) { BOOST_ASSERT(N == s); } constexpr span_base(T* b, std::size_t s) noexcept : begin_(b) {
(void)s;
assert(N == s);
}
constexpr void set(T* b, std::size_t s) noexcept { constexpr void set(T* b, std::size_t s) noexcept {
(void)s;
begin_ = b; begin_ = b;
BOOST_ASSERT(N == s); assert(N == s);
} }
private: private:
@ -112,8 +116,8 @@ public:
constexpr span(pointer first, pointer last) constexpr span(pointer first, pointer last)
: span(first, static_cast<std::size_t>(last - first)) { : span(first, static_cast<std::size_t>(last - first)) {
BOOST_ASSERT(extent == dynamic_extent || assert(extent == dynamic_extent ||
static_cast<difference_type>(extent) == (last - first)); static_cast<difference_type>(extent) == (last - first));
} }
constexpr span(pointer ptr, index_type count) : base(ptr, count) {} constexpr span(pointer ptr, index_type count) : base(ptr, count) {}
@ -185,23 +189,23 @@ public:
template <std::size_t Count> template <std::size_t Count>
constexpr span<element_type, Count> first() const { constexpr span<element_type, Count> first() const {
BOOST_ASSERT(Count <= base::size()); assert(Count <= base::size());
return span<element_type, Count>(base::data(), Count); return span<element_type, Count>(base::data(), Count);
} }
constexpr span<element_type, dynamic_extent> first(std::size_t count) const { constexpr span<element_type, dynamic_extent> first(std::size_t count) const {
BOOST_ASSERT(count <= base::size()); assert(count <= base::size());
return span<element_type, dynamic_extent>(base::data(), count); return span<element_type, dynamic_extent>(base::data(), count);
} }
template <std::size_t Count> template <std::size_t Count>
constexpr span<element_type, Count> last() const { constexpr span<element_type, Count> last() const {
BOOST_ASSERT(Count <= base::size()); assert(Count <= base::size());
return span<element_type, Count>(base::data() + base::size() - Count, Count); return span<element_type, Count>(base::data() + base::size() - Count, Count);
} }
constexpr span<element_type, dynamic_extent> last(std::size_t count) const { constexpr span<element_type, dynamic_extent> last(std::size_t count) const {
BOOST_ASSERT(count <= base::size()); assert(count <= base::size());
return span<element_type, dynamic_extent>(base::data() + base::size() - count, count); return span<element_type, dynamic_extent>(base::data() + base::size() - count, count);
} }
@ -211,21 +215,21 @@ public:
? Count ? Count
: (extent != dynamic_extent ? extent - Offset : dynamic_extent))> : (extent != dynamic_extent ? extent - Offset : dynamic_extent))>
subspan() const { subspan() const {
BOOST_ASSERT(Offset <= base::size()); assert(Offset <= base::size());
constexpr std::size_t E = constexpr std::size_t E =
(Count != dynamic_extent (Count != dynamic_extent
? Count ? Count
: (extent != dynamic_extent ? extent - Offset : dynamic_extent)); : (extent != dynamic_extent ? extent - Offset : dynamic_extent));
BOOST_ASSERT(E == dynamic_extent || E <= base::size()); assert(E == dynamic_extent || E <= base::size());
return span<element_type, E>(base::data() + Offset, return span<element_type, E>(base::data() + Offset,
Count == dynamic_extent ? base::size() - Offset : Count); Count == dynamic_extent ? base::size() - Offset : Count);
} }
constexpr span<element_type, dynamic_extent> subspan( constexpr span<element_type, dynamic_extent> subspan(
std::size_t offset, std::size_t count = dynamic_extent) const { std::size_t offset, std::size_t count = dynamic_extent) const {
BOOST_ASSERT(offset <= base::size()); assert(offset <= base::size());
const std::size_t s = count == dynamic_extent ? base::size() - offset : count; const std::size_t s = count == dynamic_extent ? base::size() - offset : count;
BOOST_ASSERT(s <= base::size()); assert(s <= base::size());
return span<element_type, dynamic_extent>(base::data() + offset, s); return span<element_type, dynamic_extent>(base::data() + offset, s);
} }
}; };

4
include/boost/histogram/detail/sub_array.hpp
View File

@ -33,9 +33,7 @@ public:
sub_array() = default; sub_array() = default;
explicit sub_array(std::size_t s) noexcept : size_(s) { explicit sub_array(std::size_t s) noexcept : size_(s) { assert(size_ <= N); }
BOOST_ASSERT_MSG(size_ <= N, "requested size exceeds size of static buffer");
}
sub_array(std::size_t s, const T& value) noexcept( sub_array(std::size_t s, const T& value) noexcept(
std::is_nothrow_assignable<T, const_reference>::value) std::is_nothrow_assignable<T, const_reference>::value)

44
include/boost/histogram/detail/try_cast.hpp
View File

@ -7,38 +7,50 @@
#ifndef BOOST_HISTOGRAM_DETAIL_TRY_CAST_HPP #ifndef BOOST_HISTOGRAM_DETAIL_TRY_CAST_HPP
#define BOOST_HISTOGRAM_DETAIL_TRY_CAST_HPP #define BOOST_HISTOGRAM_DETAIL_TRY_CAST_HPP
#include <boost/config.hpp> #include <boost/config.hpp> // BOOST_NORETURN
#include <boost/core/demangle.hpp>
#include <boost/histogram/detail/type_name.hpp>
#include <boost/mp11/integral.hpp>
#include <boost/throw_exception.hpp> #include <boost/throw_exception.hpp>
#include <stdexcept>
#include <string>
#include <type_traits> #include <type_traits>
namespace boost { namespace boost {
namespace histogram { namespace histogram {
namespace detail { namespace detail {
template <class T, class E, class U>
BOOST_NORETURN T try_cast_impl(mp11::mp_int<0>, U&&) { template <class T, class U>
BOOST_THROW_EXCEPTION(E("cannot cast " + type_name<T>() + " to " + type_name<U>())); constexpr T* ptr_cast(U*) noexcept {
return nullptr;
}
template <class T>
constexpr T* ptr_cast(T* p) noexcept {
return p;
}
template <class T>
constexpr const T* ptr_cast(const T* p) noexcept {
return p;
} }
template <class T, class E, class U> template <class T, class E, class U>
T try_cast_impl(mp11::mp_int<1>, U&& u) noexcept { BOOST_NORETURN T try_cast_impl(std::false_type, std::false_type, U&&) {
return static_cast<T>(u); BOOST_THROW_EXCEPTION(E("type cast error"));
} }
// converting cast
template <class T, class E, class U> template <class T, class E, class U>
decltype(auto) try_cast_impl(mp11::mp_int<2>, U&& u) noexcept { T try_cast_impl(std::false_type, std::true_type, U&& u) noexcept {
return std::forward<U>(u); return static_cast<T>(u); // cast to avoid warnings
}
// pass-through cast
template <class T, class E>
T&& try_cast_impl(std::true_type, std::true_type, T&& t) noexcept {
return std::forward<T>(t);
} }
// cast fails at runtime with exception E instead of compile-time, T must be a value // cast fails at runtime with exception E instead of compile-time, T must be a value
template <class T, class E, class U> template <class T, class E, class U>
decltype(auto) try_cast(U&& u) noexcept(std::is_convertible<U, T>::value) { T try_cast(U&& u) noexcept(std::is_convertible<U, T>::value) {
return try_cast_impl<T, E>(mp11::mp_int<(std::is_convertible<U, T>::value + return try_cast_impl<T, E>(std::is_same<U, T>{}, std::is_convertible<U, T>{},
std::is_same<T, std::decay_t<U>>::value)>{},
std::forward<U>(u)); std::forward<U>(u));
} }

8
include/boost/histogram/histogram.hpp
View File

@ -140,14 +140,14 @@ public:
/// This version is more efficient than the one accepting a run-time number. /// This version is more efficient than the one accepting a run-time number.
template <unsigned N = 0> template <unsigned N = 0>
decltype(auto) axis(std::integral_constant<unsigned, N> = {}) const { decltype(auto) axis(std::integral_constant<unsigned, N> = {}) const {
BOOST_ASSERT_MSG(N < rank(), "index out of range"); assert(N < rank());
return detail::axis_get<N>(axes_); return detail::axis_get<N>(axes_);
} }
/// Get N-th axis with run-time number. /// Get N-th axis with run-time number.
/// Prefer the version that accepts a compile-time number, if you can use it. /// Prefer the version that accepts a compile-time number, if you can use it.
decltype(auto) axis(unsigned i) const { decltype(auto) axis(unsigned i) const {
BOOST_ASSERT_MSG(i < rank(), "index out of range"); assert(i < rank());
return detail::axis_get(axes_, i); return detail::axis_get(axes_, i);
} }
@ -371,7 +371,7 @@ public:
const auto idx = detail::linearize_indices(axes_, is); const auto idx = detail::linearize_indices(axes_, is);
if (!is_valid(idx)) if (!is_valid(idx))
BOOST_THROW_EXCEPTION(std::out_of_range("at least one index out of bounds")); BOOST_THROW_EXCEPTION(std::out_of_range("at least one index out of bounds"));
BOOST_ASSERT(idx < storage_.size()); assert(idx < storage_.size());
return storage_[idx]; return storage_[idx];
} }
@ -383,7 +383,7 @@ public:
const auto idx = detail::linearize_indices(axes_, is); const auto idx = detail::linearize_indices(axes_, is);
if (!is_valid(idx)) if (!is_valid(idx))
BOOST_THROW_EXCEPTION(std::out_of_range("at least one index out of bounds")); BOOST_THROW_EXCEPTION(std::out_of_range("at least one index out of bounds"));
BOOST_ASSERT(idx < storage_.size()); assert(idx < storage_.size());
return storage_[idx]; return storage_[idx];
} }

12
include/boost/histogram/indexed.hpp
View File

@ -8,7 +8,7 @@
#define BOOST_HISTOGRAM_INDEXED_HPP #define BOOST_HISTOGRAM_INDEXED_HPP
#include <array> #include <array>
#include <boost/config.hpp> #include <boost/config.hpp> // BOOST_ATTRIBUTE_NODISCARD
#include <boost/histogram/axis/traits.hpp> #include <boost/histogram/axis/traits.hpp>
#include <boost/histogram/detail/axes.hpp> #include <boost/histogram/detail/axes.hpp>
#include <boost/histogram/detail/iterator_adaptor.hpp> #include <boost/histogram/detail/iterator_adaptor.hpp>
@ -132,7 +132,7 @@ public:
/// Access indices as an iterable range. /// Access indices as an iterable range.
index_view indices() const noexcept { index_view indices() const noexcept {
BOOST_ASSERT(iter_.indices_.hist_); assert(iter_.indices_.hist_);
return {iter_.indices_.begin(), iter_.indices_.end()}; return {iter_.indices_.begin(), iter_.indices_.end()};
} }
@ -140,7 +140,7 @@ public:
/// @tparam N axis dimension. /// @tparam N axis dimension.
template <unsigned N = 0> template <unsigned N = 0>
decltype(auto) bin(std::integral_constant<unsigned, N> = {}) const { decltype(auto) bin(std::integral_constant<unsigned, N> = {}) const {
BOOST_ASSERT(iter_.indices_.hist_); assert(iter_.indices_.hist_);
return iter_.indices_.hist_->axis(std::integral_constant<unsigned, N>()) return iter_.indices_.hist_->axis(std::integral_constant<unsigned, N>())
.bin(index(N)); .bin(index(N));
} }
@ -148,7 +148,7 @@ public:
/// Access current bin. /// Access current bin.
/// @param d axis dimension. /// @param d axis dimension.
decltype(auto) bin(unsigned d) const { decltype(auto) bin(unsigned d) const {
BOOST_ASSERT(iter_.indices_.hist_); assert(iter_.indices_.hist_);
return iter_.indices_.hist_->axis(d).bin(index(d)); return iter_.indices_.hist_->axis(d).bin(index(d));
} }
@ -158,7 +158,7 @@ public:
without bin widths, like axis::category, are treated as having unit bin with. without bin widths, like axis::category, are treated as having unit bin with.
*/ */
double density() const { double density() const {
BOOST_ASSERT(iter_.indices_.hist_); assert(iter_.indices_.hist_);
double x = 1; double x = 1;
unsigned d = 0; unsigned d = 0;
iter_.indices_.hist_->for_each_axis([&](const auto& a) { iter_.indices_.hist_->for_each_axis([&](const auto& a) {
@ -239,7 +239,7 @@ public:
pointer operator->() noexcept { return pointer_proxy{operator*()}; } pointer operator->() noexcept { return pointer_proxy{operator*()}; }
iterator& operator++() { iterator& operator++() {
BOOST_ASSERT(iter_ < indices_.hist_->end()); assert(iter_ < indices_.hist_->end());
const auto cbeg = indices_.begin(); const auto cbeg = indices_.begin();
auto c = cbeg; auto c = cbeg;
++iter_; ++iter_;

23
include/boost/histogram/ostream.hpp
View File

@ -8,7 +8,6 @@
#ifndef BOOST_HISTOGRAM_OSTREAM_HPP #ifndef BOOST_HISTOGRAM_OSTREAM_HPP
#define BOOST_HISTOGRAM_OSTREAM_HPP #define BOOST_HISTOGRAM_OSTREAM_HPP
#include <boost/config/workaround.hpp>
#include <boost/histogram/accumulators/ostream.hpp> #include <boost/histogram/accumulators/ostream.hpp>
#include <boost/histogram/axis/ostream.hpp> #include <boost/histogram/axis/ostream.hpp>
#include <boost/histogram/detail/counting_streambuf.hpp> #include <boost/histogram/detail/counting_streambuf.hpp>
@ -50,15 +49,15 @@ public:
if (collect_) { if (collect_) {
if (static_cast<unsigned>(iter_ - base_t::begin()) == size_) { if (static_cast<unsigned>(iter_ - base_t::begin()) == size_) {
++size_; ++size_;
BOOST_ASSERT(size_ <= N); assert(size_ <= N);
BOOST_ASSERT(iter_ != end()); assert(iter_ != end());
*iter_ = 0; *iter_ = 0;
} }
count_ = 0; count_ = 0;
os_ << t; os_ << t;
*iter_ = std::max(*iter_, static_cast<int>(count_)); *iter_ = std::max(*iter_, static_cast<int>(count_));
} else { } else {
BOOST_ASSERT(iter_ != end()); assert(iter_ != end());
os_ << std::setw(*iter_) << t; os_ << std::setw(*iter_) << t;
} }
++iter_; ++iter_;
@ -88,7 +87,7 @@ public:
auto cend() const { return base_t::cbegin() + size_; } auto cend() const { return base_t::cbegin() + size_; }
void complete() { void complete() {
BOOST_ASSERT(collect_); // only call this once assert(collect_); // only call this once
collect_ = false; collect_ = false;
os_.rdbuf(orig_); os_.rdbuf(orig_);
} }
@ -192,9 +191,9 @@ void ostream_head(OStream& os, const Axis& ax, int index, double val) {
ax); ax);
} }
// cannot display generalized histograms yet // cannot display generalized histograms yet; line not reachable by coverage tests
template <class OStream, class Histogram> template <class OStream, class Histogram>
void ascii_plot(OStream&, const Histogram&, int, std::false_type) {} void ascii_plot(OStream&, const Histogram&, int, std::false_type) {} // LCOV_EXCL_LINE
template <class OStream, class Histogram> template <class OStream, class Histogram>
void ascii_plot(OStream& os, const Histogram& h, int w_total, std::true_type) { void ascii_plot(OStream& os, const Histogram& h, int w_total, std::true_type) {
@ -301,13 +300,9 @@ std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>&
using value_type = typename histogram<A, S>::value_type; using value_type = typename histogram<A, S>::value_type;
#if BOOST_WORKAROUND(BOOST_MSVC, >= 0) // must be non-const to avoid a msvc warning about possible use of if constexpr
#pragma warning(disable : 4127) // warning to use `if constexpr` bool show_ascii = std::is_convertible<value_type, double>::value && h.rank() == 1;
#endif if (show_ascii) {
if (std::is_convertible<value_type, double>::value && h.rank() == 1) {
#if BOOST_WORKAROUND(BOOST_MSVC, >= 0)
#pragma warning(default : 4127)
#endif
detail::ostream(os, h, false); detail::ostream(os, h, false);
detail::ascii_plot(os, h, w, std::is_convertible<value_type, double>{}); detail::ascii_plot(os, h, w, std::is_convertible<value_type, double>{});
} else { } else {

29
include/boost/histogram/unlimited_storage.hpp
View File

@ -9,8 +9,6 @@
#define BOOST_HISTOGRAM_UNLIMTED_STORAGE_HPP #define BOOST_HISTOGRAM_UNLIMTED_STORAGE_HPP
#include <algorithm> #include <algorithm>
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/core/alloc_construct.hpp> #include <boost/core/alloc_construct.hpp>
#include <boost/core/exchange.hpp> #include <boost/core/exchange.hpp>
#include <boost/core/nvp.hpp> #include <boost/core/nvp.hpp>
@ -23,6 +21,7 @@
#include <boost/mp11/algorithm.hpp> #include <boost/mp11/algorithm.hpp>
#include <boost/mp11/list.hpp> #include <boost/mp11/list.hpp>
#include <boost/mp11/utility.hpp> #include <boost/mp11/utility.hpp>
#include <cassert>
#include <cmath> #include <cmath>
#include <cstdint> #include <cstdint>
#include <functional> #include <functional>
@ -84,7 +83,7 @@ void* buffer_create(Allocator& a, std::size_t n) {
template <class Allocator, class Iterator> template <class Allocator, class Iterator>
auto buffer_create(Allocator& a, std::size_t n, Iterator iter) { auto buffer_create(Allocator& a, std::size_t n, Iterator iter) {
BOOST_ASSERT(n > 0u); assert(n > 0u);
auto ptr = a.allocate(n); // may throw auto ptr = a.allocate(n); // may throw
static_assert(std::is_trivially_copyable<decltype(ptr)>::value, static_assert(std::is_trivially_copyable<decltype(ptr)>::value,
"ptr must be trivially copyable"); "ptr must be trivially copyable");
@ -105,8 +104,8 @@ auto buffer_create(Allocator& a, std::size_t n, Iterator iter) {
template <class Allocator> template <class Allocator>
void buffer_destroy(Allocator& a, typename std::allocator_traits<Allocator>::pointer p, void buffer_destroy(Allocator& a, typename std::allocator_traits<Allocator>::pointer p,
std::size_t n) { std::size_t n) {
BOOST_ASSERT(p); assert(p);
BOOST_ASSERT(n > 0u); assert(n > 0u);
boost::alloc_destroy_n(a, p, n); boost::alloc_destroy_n(a, p, n);
a.deallocate(p, n); a.deallocate(p, n);
} }
@ -203,7 +202,7 @@ public:
~buffer_type() noexcept { destroy(); } ~buffer_type() noexcept { destroy(); }
void destroy() noexcept { void destroy() noexcept {
BOOST_ASSERT((ptr == nullptr) == (size == 0)); assert((ptr == nullptr) == (size == 0));
if (ptr == nullptr) return; if (ptr == nullptr) return;
visit([this](auto* p) { visit([this](auto* p) {
using T = std::decay_t<decltype(*p)>; using T = std::decay_t<decltype(*p)>;
@ -263,7 +262,7 @@ public:
: detail::partially_ordered<const_reference, const_reference, void> { : detail::partially_ordered<const_reference, const_reference, void> {
public: public:
const_reference(buffer_type& b, std::size_t i) noexcept : bref_(b), idx_(i) { const_reference(buffer_type& b, std::size_t i) noexcept : bref_(b), idx_(i) {
BOOST_ASSERT(idx_ < bref_.size); assert(idx_ < bref_.size);
} }
const_reference(const const_reference&) noexcept = default; const_reference(const const_reference&) noexcept = default;
@ -441,15 +440,11 @@ public:
auto s_begin = begin(s); auto s_begin = begin(s);
auto s_end = end(s); auto s_end = end(s);
using V = typename std::iterator_traits<decltype(begin(s))>::value_type; using V = typename std::iterator_traits<decltype(begin(s))>::value_type;
constexpr auto ti = buffer_type::template type_index<V>(); // must be non-const to avoid msvc warning about if constexpr
constexpr auto nt = mp11::mp_size<typename buffer_type::types>::value; auto ti = buffer_type::template type_index<V>();
auto nt = mp11::mp_size<typename buffer_type::types>::value;
const std::size_t size = static_cast<std::size_t>(std::distance(s_begin, s_end)); const std::size_t size = static_cast<std::size_t>(std::distance(s_begin, s_end));
#ifdef BOOST_NO_CXX17_IF_CONSTEXPR if (ti < nt)
if
#else
if constexpr
#endif
(ti < nt)
buffer_.template make<V>(size, s_begin); buffer_.template make<V>(size, s_begin);
else else
buffer_.template make<double>(size, s_begin); buffer_.template make<double>(size, s_begin);
@ -513,7 +508,7 @@ public:
ar& make_nvp("type", tmp.type); ar& make_nvp("type", tmp.type);
ar& make_nvp("size", size); ar& make_nvp("size", size);
tmp.visit([this, size](auto* tp) { tmp.visit([this, size](auto* tp) {
BOOST_ASSERT(tp == nullptr); assert(tp == nullptr);
using T = std::decay_t<decltype(*tp)>; using T = std::decay_t<decltype(*tp)>;
buffer_.template make<T>(size); buffer_.template make<T>(size);
}); });
@ -531,7 +526,7 @@ private:
struct incrementor { struct incrementor {
template <class T> template <class T>
void operator()(T* tp, buffer_type& b, std::size_t i) { void operator()(T* tp, buffer_type& b, std::size_t i) {
BOOST_ASSERT(tp && i < b.size); assert(tp && i < b.size);
if (!detail::safe_increment(tp[i])) { if (!detail::safe_increment(tp[i])) {
using U = detail::next_type<typename buffer_type::types, T>; using U = detail::next_type<typename buffer_type::types, T>;
b.template make<U>(b.size, tp); b.template make<U>(b.size, tp);

4
include/boost/histogram/unsafe_access.hpp
View File

@ -48,7 +48,7 @@ struct unsafe_access {
*/ */
template <class Histogram, unsigned I = 0> template <class Histogram, unsigned I = 0>
static decltype(auto) axis(Histogram& hist, std::integral_constant<unsigned, I> = {}) { static decltype(auto) axis(Histogram& hist, std::integral_constant<unsigned, I> = {}) {
BOOST_ASSERT_MSG(I < hist.rank(), "index out of range"); assert(I < hist.rank());
return detail::axis_get<I>(hist.axes_); return detail::axis_get<I>(hist.axes_);
} }
@ -59,7 +59,7 @@ struct unsafe_access {
*/ */
template <class Histogram> template <class Histogram>
static decltype(auto) axis(Histogram& hist, unsigned i) { static decltype(auto) axis(Histogram& hist, unsigned i) {
BOOST_ASSERT_MSG(i < hist.rank(), "index out of range"); assert(i < hist.rank());
return detail::axis_get(hist.axes_, i); return detail::axis_get(hist.axes_, i);
} }

5
test/accumulators_serialization_test.cpp
View File

@ -4,18 +4,19 @@
// (See accompanying file LICENSE_1_0.txt // (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt) // or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/assert.hpp>
#include <boost/core/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <boost/histogram/accumulators.hpp> #include <boost/histogram/accumulators.hpp>
#include <boost/histogram/serialization.hpp> #include <boost/histogram/serialization.hpp>
#include <boost/histogram/weight.hpp> #include <boost/histogram/weight.hpp>
#include <cassert>
#include "throw_exception.hpp" #include "throw_exception.hpp"
#include "utility_serialization.hpp" #include "utility_serialization.hpp"
using namespace boost::histogram; using namespace boost::histogram;
int main(int argc, char** argv) { int main(int argc, char** argv) {
BOOST_ASSERT(argc == 2); (void)argc;
assert(argc == 2);
// mean v0 // mean v0
{ {

3
test/axis_category_test.cpp
View File

@ -4,7 +4,6 @@
// (See accompanying file LICENSE_1_0.txt // (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt) // or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/core/ignore_unused.hpp>
#include <boost/core/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
#include <boost/histogram/axis/category.hpp> #include <boost/histogram/axis/category.hpp>
@ -30,7 +29,7 @@ int main() {
// bad ctor // bad ctor
{ {
int x[2]; int x[2];
boost::ignore_unused(x); (void)x;
BOOST_TEST_THROWS(axis::category<int>(x + 1, x), std::invalid_argument); BOOST_TEST_THROWS(axis::category<int>(x + 1, x), std::invalid_argument);
} }

4
test/axis_variant_serialization_test.cpp
View File

@ -6,7 +6,7 @@
// This test is inspired by the corresponding boost/beast test of detail_variant. // This test is inspired by the corresponding boost/beast test of detail_variant.
#include <boost/assert.hpp> #include <cassert>
#include <boost/core/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <boost/histogram/axis/integer.hpp> #include <boost/histogram/axis/integer.hpp>
#include <boost/histogram/axis/ostream.hpp> #include <boost/histogram/axis/ostream.hpp>
@ -20,7 +20,7 @@
using namespace boost::histogram::axis; using namespace boost::histogram::axis;
int main(int argc, char** argv) { int main(int argc, char** argv) {
BOOST_ASSERT(argc == 2); assert(argc == 2);
const auto filename = join(argv[1], "axis_variant_serialization_test.xml"); const auto filename = join(argv[1], "axis_variant_serialization_test.xml");

3
test/histogram_dynamic_test.cpp
View File

@ -5,7 +5,6 @@
// or copy at http://www.boost.org/LICENSE_1_0.txt) // or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <algorithm> #include <algorithm>
#include <boost/core/ignore_unused.hpp>
#include <boost/core/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <boost/histogram/axis.hpp> #include <boost/histogram/axis.hpp>
#include <boost/histogram/axis/ostream.hpp> #include <boost/histogram/axis/ostream.hpp>
@ -69,7 +68,7 @@ int main() {
h.fill(inputs); // should not crash h.fill(inputs); // should not crash
auto bad = std::vector<I>(BOOST_HISTOGRAM_DETAIL_AXES_LIMIT + 1, I(0, 1)); auto bad = std::vector<I>(BOOST_HISTOGRAM_DETAIL_AXES_LIMIT + 1, I(0, 1));
boost::ignore_unused(bad); (void)bad;
BOOST_TEST_THROWS((void)make_histogram(bad), std::invalid_argument); BOOST_TEST_THROWS((void)make_histogram(bad), std::invalid_argument);
} }

13
test/histogram_fill_test.cpp
View File

@ -6,7 +6,6 @@
#include <array> #include <array>
#include <boost/config.hpp> #include <boost/config.hpp>
#include <boost/core/ignore_unused.hpp>
#include <boost/core/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <boost/histogram/accumulators.hpp> #include <boost/histogram/accumulators.hpp>
#include <boost/histogram/accumulators/ostream.hpp> #include <boost/histogram/accumulators/ostream.hpp>
@ -14,12 +13,12 @@
#include <boost/histogram/axis/category.hpp> #include <boost/histogram/axis/category.hpp>
#include <boost/histogram/axis/integer.hpp> #include <boost/histogram/axis/integer.hpp>
#include <boost/histogram/axis/ostream.hpp> #include <boost/histogram/axis/ostream.hpp>
#include <boost/variant2/variant.hpp>
#include <boost/histogram/histogram.hpp> #include <boost/histogram/histogram.hpp>
#include <boost/histogram/literals.hpp> #include <boost/histogram/literals.hpp>
#include <boost/histogram/make_histogram.hpp> #include <boost/histogram/make_histogram.hpp>
#include <boost/histogram/ostream.hpp> #include <boost/histogram/ostream.hpp>
#include <boost/histogram/storage_adaptor.hpp> #include <boost/histogram/storage_adaptor.hpp>
#include <boost/variant2/variant.hpp>
#include <random> #include <random>
#include <sstream> #include <sstream>
#include <stdexcept> #include <stdexcept>
@ -105,11 +104,11 @@ void run_tests(const std::vector<int>& x, const std::vector<int>& y,
auto h = make(Tag(), in{1, 3}); auto h = make(Tag(), in{1, 3});
int bad1[2][4]; int bad1[2][4];
boost::ignore_unused(bad1); (void)bad1;
BOOST_TEST_THROWS(h.fill(bad1), std::invalid_argument); BOOST_TEST_THROWS(h.fill(bad1), std::invalid_argument);
std::vector<std::array<int, 4>> bad2; std::vector<std::array<int, 4>> bad2;
boost::ignore_unused(bad2); (void)bad2;
BOOST_TEST_THROWS(h.fill(bad2), std::invalid_argument); BOOST_TEST_THROWS(h.fill(bad2), std::invalid_argument);
} }
@ -148,7 +147,7 @@ void run_tests(const std::vector<int>& x, const std::vector<int>& y,
BOOST_TEST_EQ(h, h2); BOOST_TEST_EQ(h, h2);
auto w2 = {1}; auto w2 = {1};
boost::ignore_unused(w2); (void)w2;
BOOST_TEST_THROWS(h2.fill(x, weight(w2)), std::invalid_argument); BOOST_TEST_THROWS(h2.fill(x, weight(w2)), std::invalid_argument);
} }
@ -168,7 +167,7 @@ void run_tests(const std::vector<int>& x, const std::vector<int>& y,
// not rectangular // not rectangular
std::array<std::vector<int>, 2> bad = {{std::vector<int>(1), std::vector<int>(2)}}; std::array<std::vector<int>, 2> bad = {{std::vector<int>(1), std::vector<int>(2)}};
boost::ignore_unused(bad); (void)bad;
BOOST_TEST_THROWS(h2.fill(bad), std::invalid_argument); BOOST_TEST_THROWS(h2.fill(bad), std::invalid_argument);
} }
@ -285,7 +284,7 @@ void run_tests(const std::vector<int>& x, const std::vector<int>& y,
BOOST_TEST_EQ(h, h2); BOOST_TEST_EQ(h, h2);
const auto bad = {V(std::vector<std::string>(1, "foo")), V(std::vector<int>{1, 2})}; const auto bad = {V(std::vector<std::string>(1, "foo")), V(std::vector<int>{1, 2})};
boost::ignore_unused(bad); (void)bad;
BOOST_TEST_THROWS(h.fill(bad), std::invalid_argument); BOOST_TEST_THROWS(h.fill(bad), std::invalid_argument);
} }

4
test/histogram_serialization_test.cpp
View File

@ -4,7 +4,7 @@
// (See accompanying file LICENSE_1_0.txt // (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt) // or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/assert.hpp> #include <cassert>
#include <boost/core/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <boost/histogram/axis.hpp> #include <boost/histogram/axis.hpp>
#include <boost/histogram/axis/ostream.hpp> #include <boost/histogram/axis/ostream.hpp>
@ -43,7 +43,7 @@ void run_tests(const std::string& filename) {
} }
int main(int argc, char** argv) { int main(int argc, char** argv) {
BOOST_ASSERT(argc == 2); assert(argc == 2);
run_tests<static_tag>(join(argv[1], "histogram_serialization_test_static.xml")); run_tests<static_tag>(join(argv[1], "histogram_serialization_test_static.xml"));
run_tests<dynamic_tag>(join(argv[1], "histogram_serialization_test_dynamic.xml")); run_tests<dynamic_tag>(join(argv[1], "histogram_serialization_test_dynamic.xml"));
return boost::report_errors(); return boost::report_errors();

4
test/histogram_test.cpp
View File

@ -444,10 +444,10 @@ void run_tests() {
BOOST_TEST_EQ(h.at(j11), 1); BOOST_TEST_EQ(h.at(j11), 1);
BOOST_TEST_EQ(h[j11], 1); BOOST_TEST_EQ(h[j11], 1);
int j111[] = {1, 1, 1}; int j111[] = {1, 1, 1};
boost::ignore_unused(j111); (void)j111;
BOOST_TEST_THROWS((void)h.at(j111), std::invalid_argument); BOOST_TEST_THROWS((void)h.at(j111), std::invalid_argument);
int j13[] = {1, 3}; int j13[] = {1, 3};
boost::ignore_unused(j13); (void)j13;
BOOST_TEST_THROWS((void)h.at(j13), std::out_of_range); BOOST_TEST_THROWS((void)h.at(j13), std::out_of_range);
// tuple with weight // tuple with weight

4
test/storage_adaptor_serialization_test.cpp
View File

@ -5,7 +5,7 @@
// or copy at http://www.boost.org/LICENSE_1_0.txt) // or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <array> #include <array>
#include <boost/assert.hpp> #include <cassert>
#include <boost/core/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <boost/histogram/accumulators/thread_safe.hpp> #include <boost/histogram/accumulators/thread_safe.hpp>
#include <boost/histogram/serialization.hpp> #include <boost/histogram/serialization.hpp>
@ -32,7 +32,7 @@ void test_serialization(const std::string& filename) {
} }
int main(int argc, char** argv) { int main(int argc, char** argv) {
BOOST_ASSERT(argc == 2); assert(argc == 2);
test_serialization<std::vector<int>>( test_serialization<std::vector<int>>(
join(argv[1], "storage_adaptor_serialization_test_vector_int.xml")); join(argv[1], "storage_adaptor_serialization_test_vector_int.xml"));

4
test/unlimited_storage_serialization_test.cpp
View File

@ -6,7 +6,7 @@
#include <boost/archive/text_iarchive.hpp> #include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp> #include <boost/archive/text_oarchive.hpp>
#include <boost/assert.hpp> #include <cassert>
#include <boost/core/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <boost/histogram/serialization.hpp> #include <boost/histogram/serialization.hpp>
#include <boost/histogram/unlimited_storage.hpp> #include <boost/histogram/unlimited_storage.hpp>
@ -43,7 +43,7 @@ void run_test(const std::string& filename) {
} }
int main(int argc, char** argv) { int main(int argc, char** argv) {
BOOST_ASSERT(argc == 2); assert(argc == 2);
run_test<uint8_t>(join(argv[1], "unlimited_storage_serialization_test_u8.xml")); run_test<uint8_t>(join(argv[1], "unlimited_storage_serialization_test_u8.xml"));
run_test<uint16_t>(join(argv[1], "unlimited_storage_serialization_test_u16.xml")); run_test<uint16_t>(join(argv[1], "unlimited_storage_serialization_test_u16.xml"));

13
test/utility_allocator.hpp
View File

@ -5,11 +5,11 @@
// or copy at http://www.boost.org/LICENSE_1_0.txt) // or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <algorithm> #include <algorithm>
#include <boost/config.hpp>
#include <boost/core/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <boost/core/typeinfo.hpp> #include <boost/core/typeinfo.hpp>
#include <boost/histogram/detail/type_name.hpp> #include <boost/histogram/detail/type_name.hpp>
#include <boost/throw_exception.hpp> #include <boost/throw_exception.hpp>
#include <initializer_list>
#include <iostream> #include <iostream>
#include <unordered_map> #include <unordered_map>
#include <utility> #include <utility>
@ -32,7 +32,8 @@ struct tracing_allocator_db : std::pair<int, int> {
template <class... Ts> template <class... Ts>
void log(Ts&&... ts) { void log(Ts&&... ts) {
if (!tracing) return; if (!tracing) return;
log_impl(std::forward<Ts>(ts)...); // fold trick
(void)std::initializer_list<int>{(std::cerr << ts, 0)...};
std::cerr << std::endl; std::cerr << std::endl;
} }
@ -41,14 +42,6 @@ struct tracing_allocator_db : std::pair<int, int> {
private: private:
using map_t = std::unordered_map<const boost::core::typeinfo*, std::pair<int, int>>; using map_t = std::unordered_map<const boost::core::typeinfo*, std::pair<int, int>>;
map_t map_; map_t map_;
BOOST_ATTRIBUTE_UNUSED inline void log_impl() {}
template <class T, class... Ts>
void log_impl(T&& t, Ts&&... ts) {
std::cerr << t;
log_impl(std::forward<Ts>(ts)...);
}
}; };
template <class T> template <class T>

8
test/utility_serialization.hpp
View File

@ -9,9 +9,9 @@
#include <boost/archive/xml_iarchive.hpp> #include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp> #include <boost/archive/xml_oarchive.hpp>
#include <boost/assert.hpp> #include <boost/config.hpp> // BOOST_WINDOWS
#include <boost/config.hpp>
#include <boost/core/nvp.hpp> #include <boost/core/nvp.hpp>
#include <cassert>
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
#include <string> #include <string>
@ -31,13 +31,13 @@ std::string join(const char* a, const char* b) {
template <class T> template <class T>
void load_xml(const std::string& filename, T& t) { void load_xml(const std::string& filename, T& t) {
std::ifstream ifs(filename); std::ifstream ifs(filename);
BOOST_ASSERT(ifs.is_open()); assert(ifs.is_open());
// manually skip XML comments at the beginning of the stream, because of // manually skip XML comments at the beginning of the stream, because of
// https://github.com/boostorg/serialization/issues/169 // https://github.com/boostorg/serialization/issues/169
char line[128]; char line[128];
do { do {
ifs.getline(line, 128); ifs.getline(line, 128);
BOOST_ASSERT(std::strlen(line) < 127); assert(std::strlen(line) < 127);
} while (!ifs.fail() && !ifs.eof() && std::strstr(line, "-->") == nullptr); } while (!ifs.fail() && !ifs.eof() && std::strstr(line, "-->") == nullptr);
boost::archive::xml_iarchive ia(ifs); boost::archive::xml_iarchive ia(ifs);
ia >> boost::make_nvp("item", t); ia >> boost::make_nvp("item", t);