From 4c3b6d9252a2c7a42206324a42b215cf63c645d0 Mon Sep 17 00:00:00 2001 From: joaquintides Date: Fri, 11 Jul 2025 19:53:11 +0200 Subject: [PATCH 01/66] implemented bulk insertion --- include/boost/bloom/detail/core.hpp | 37 ++++++++++++++++++++++ include/boost/bloom/detail/type_traits.hpp | 15 +++++++++ include/boost/bloom/filter.hpp | 26 +++++++++++++-- test/test_insertion.cpp | 17 ++++++++-- test/test_utilities.hpp | 26 +++++++++++++++ 5 files changed, 116 insertions(+), 5 deletions(-) diff --git a/include/boost/bloom/detail/core.hpp b/include/boost/bloom/detail/core.hpp index d819360..adabf01 100644 --- a/include/boost/bloom/detail/core.hpp +++ b/include/boost/bloom/detail/core.hpp @@ -217,6 +217,7 @@ class filter_core:empty_value using difference_type=std::ptrdiff_t; using pointer=unsigned char*; using const_pointer=const unsigned char*; + static constexpr std::size_t bulk_insert_size=64; explicit filter_core(std::size_t m=0):filter_core{m,allocator_type{}}{} @@ -386,6 +387,15 @@ class filter_core:empty_value } } + template void bulk_insert(F f,std::size_t n) + { + while(n){ + auto n0=n<2*bulk_insert_size?n:bulk_insert_size; + bulk_insert_impl(std::forward(f),n0); + n-=n0; + } + } + void swap(filter_core& x)noexcept( allocator_propagate_on_container_swap_t::value|| allocator_is_always_equal_t::value) @@ -703,6 +713,33 @@ class filter_core:empty_value return p; } + template void bulk_insert_impl(F&& f,std::size_t n) + { + std::uint64_t hashes[2*bulk_insert_size-1]; + unsigned char* positions[2*bulk_insert_size-1]; + + for(auto i=n;i--;){ + auto& hash=hashes[i]=f(); + auto& p=positions[i]; + hs.prepare_hash(hash); + p=next_element(hash); + } + if(BOOST_UNLIKELY(ar.data==nullptr))return; + for(auto j=k-1;j--;){ + for(auto i=n;i--;){ + auto& hash=hashes[i]; + auto& p=positions[i]; + set(p,hash); + p=next_element(hash); + } + } + for(auto i=n;i--;){ + auto& hash=hashes[i]; + auto& p=positions[i]; + set(p,hash); + } + } + template void combine(const filter_core& x,F f) { diff --git a/include/boost/bloom/detail/type_traits.hpp b/include/boost/bloom/detail/type_traits.hpp index 1bda6e8..51c97e2 100644 --- a/include/boost/bloom/detail/type_traits.hpp +++ b/include/boost/bloom/detail/type_traits.hpp @@ -14,6 +14,7 @@ #include #include #include +#include #include #include @@ -136,6 +137,20 @@ template struct array_size: template struct is_power_of_two:std::integral_constant{}; +#if defined(BOOST_NO_CXX20_HDR_CONCEPTS) +template +using is_forward_iterator=std::is_base_of< + std::forward_iterator_tag, + typename std::iterator_traits::iterator_category +>; +#else +template +using is_forward_iterator=std::integral_constant< + bool, + std::forward_iterator +>; +#endif + } /* namespace detail */ } /* namespace bloom */ } /* namespace boost */ diff --git a/include/boost/bloom/filter.hpp b/include/boost/bloom/filter.hpp index 97cde3a..d197749 100644 --- a/include/boost/bloom/filter.hpp +++ b/include/boost/bloom/filter.hpp @@ -110,6 +110,7 @@ __declspec(empty_bases) /* activate EBO with multiple inheritance */ using const_reference=const value_type&; using pointer=value_type*; using const_pointer=const value_type*; + static constexpr std::size_t bulk_insert_size=super::bulk_insert_size; filter()=default; @@ -243,10 +244,13 @@ __declspec(empty_bases) /* activate EBO with multiple inheritance */ super::insert(hash_for(x)); } - template - void insert(InputIterator first,InputIterator last) + template + void insert(Iterator first,Iterator last) { - while(first!=last)insert(*first++); + insert_impl( + first,last, + std::integral_constant< + bool,detail::is_forward_iterator::value>{}); } void insert(std::initializer_list il) @@ -316,6 +320,22 @@ __declspec(empty_bases) /* activate EBO with multiple inheritance */ { return mix_policy::mix(h(),x); } + + template + void insert_impl( + Iterator first,Iterator last,std::false_type /* input iterator */) + { + while(first!=last)insert(*first++); + } + + template + void insert_impl( + Iterator first,Iterator last,std::true_type /* forward iterator */) + { + super::bulk_insert( + [&,this]{return hash_for(*first++);}, + static_cast(std::distance(first,last))); + } }; template< diff --git a/test/test_insertion.cpp b/test/test_insertion.cpp index f0bb43e..ec00c0a 100644 --- a/test/test_insertion.cpp +++ b/test/test_insertion.cpp @@ -47,31 +47,44 @@ void test_insertion() >; using value_type=typename filter::value_type; - filter f(10000); ValueFactory fac; { + filter f(10000); value_type x{fac(),0}; f.insert(const_cast(x)); BOOST_TEST(f.may_contain(x)); } { + filter f(10000); value_type x{fac(),0}; f.insert(std::move(x)); BOOST_TEST(f.may_contain(x)); } { - auto x=fac(); + filter f(10000); + auto x=fac(); f.insert(x); /* transparent insert */ BOOST_TEST(f.may_contain(x)); } { + filter f(10000); std::array input; for(auto& x:input)x={fac(),0}; f.insert(input.begin(),input.end()); BOOST_TEST(may_contain(f,input)); } { + filter f1(10000),f2(f1); + std::array input; + for(auto& x:input)x={fac(),0}; + f1.insert(input.begin(),input.end()); + f2.insert( + make_input_iterator(input.begin()),make_input_iterator(input.end())); + BOOST_TEST(f1==f2); + } + { + filter f(10000); std::initializer_list il={{fac(),0},{fac(),0},{fac(),0}}; f.insert(il); BOOST_TEST(may_contain(f,il)); diff --git a/test/test_utilities.hpp b/test/test_utilities.hpp index 3cb1960..af4f3c5 100644 --- a/test/test_utilities.hpp +++ b/test/test_utilities.hpp @@ -10,6 +10,7 @@ #define BOOST_BLOOM_TEST_TEST_UTILITIES_HPP #include +#include #include #include #include @@ -110,5 +111,30 @@ bool may_not_contain(const Filter& f,const Input& input) return res +class input_iterator +{ + using traits=std::iterator_traits; + Iterator it; + +public: + using iterator_category=std::input_iterator_tag; + using value_type=typename traits::value_type; + using difference_type=typename traits::value_type; + using pointer=typename traits::pointer; + using reference=typename traits::reference; + + input_iterator(Iterator it_):it{it_}{} + reference operator*()const{return *it;} + pointer operator->()const{return it;} + input_iterator& operator++(){++it;return *this;} + input_iterator operator++(int){auto res=*this;++it;return res;} + bool operator==(const input_iterator& x)const{return it==x.it;} + bool operator!=(const input_iterator& x)const{return !(*this==x);} +}; + +template +input_iterator make_input_iterator(Iterator it){return {it};} + } /* namespace test_utilities */ #endif From 58f2f308787af0950f3286d715c621ed994a99df Mon Sep 17 00:00:00 2001 From: joaquintides Date: Sat, 12 Jul 2025 09:35:09 +0200 Subject: [PATCH 02/66] fixed typedef --- test/test_utilities.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/test_utilities.hpp b/test/test_utilities.hpp index af4f3c5..6e10d13 100644 --- a/test/test_utilities.hpp +++ b/test/test_utilities.hpp @@ -120,7 +120,7 @@ class input_iterator public: using iterator_category=std::input_iterator_tag; using value_type=typename traits::value_type; - using difference_type=typename traits::value_type; + using difference_type=typename traits::difference_type; using pointer=typename traits::pointer; using reference=typename traits::reference; From 72367b74164ab3c3f9fef4e33978a88490f69f0b Mon Sep 17 00:00:00 2001 From: joaquintides Date: Sat, 12 Jul 2025 12:18:58 +0200 Subject: [PATCH 03/66] implemented bulk may_contain --- include/boost/bloom/detail/core.hpp | 52 ++++++++++++++++-- include/boost/bloom/detail/type_traits.hpp | 5 ++ include/boost/bloom/filter.hpp | 16 +++++- test/Jamfile.v2 | 1 + test/test_bulk_operations.cpp | 61 ++++++++++++++++++++++ test/test_insertion.cpp | 11 +--- 6 files changed, 131 insertions(+), 15 deletions(-) create mode 100644 test/test_bulk_operations.cpp diff --git a/include/boost/bloom/detail/core.hpp b/include/boost/bloom/detail/core.hpp index adabf01..3fa47c0 100644 --- a/include/boost/bloom/detail/core.hpp +++ b/include/boost/bloom/detail/core.hpp @@ -218,6 +218,7 @@ class filter_core:empty_value using pointer=unsigned char*; using const_pointer=const unsigned char*; static constexpr std::size_t bulk_insert_size=64; + static constexpr std::size_t bulk_lookup_size=64; explicit filter_core(std::size_t m=0):filter_core{m,allocator_type{}}{} @@ -387,11 +388,21 @@ class filter_core:empty_value } } - template void bulk_insert(F f,std::size_t n) + template void bulk_insert(HashStream h,std::size_t n) { while(n){ auto n0=n<2*bulk_insert_size?n:bulk_insert_size; - bulk_insert_impl(std::forward(f),n0); + bulk_insert_impl(std::forward(h),n0); + n-=n0; + } + } + + template + void bulk_may_contain(HashStream h,std::size_t n,F f)const + { + while(n){ + auto n0=n<2*bulk_lookup_size?n:bulk_lookup_size; + bulk_may_contain_impl(std::forward(h),n0,std::forward(f)); n-=n0; } } @@ -713,13 +724,14 @@ class filter_core:empty_value return p; } - template void bulk_insert_impl(F&& f,std::size_t n) + template + void bulk_insert_impl(HashStream&& h,std::size_t n) { std::uint64_t hashes[2*bulk_insert_size-1]; unsigned char* positions[2*bulk_insert_size-1]; for(auto i=n;i--;){ - auto& hash=hashes[i]=f(); + auto& hash=hashes[i]=h(); auto& p=positions[i]; hs.prepare_hash(hash); p=next_element(hash); @@ -740,6 +752,38 @@ class filter_core:empty_value } } + template + void bulk_may_contain_impl(HashStream&& h,std::size_t n,F&& f)const + { + std::uint64_t hashes[2*bulk_lookup_size-1]; + const unsigned char* positions[2*bulk_lookup_size-1]; + bool results[2*bulk_lookup_size-1]; + + for(auto i=n;i--;){ + auto& hash=hashes[i]=h(); + auto& p=positions[i]; + results[i]=true; + hs.prepare_hash(hash); + p=next_element(hash); + } + for(auto j=k-1;j--;){ + for(auto i=n;i--;){ + auto& hash=hashes[i]; + auto& p=positions[i]; + auto& res=results[i]; + res&=get(p,hash); + p=next_element(hash); + } + } + for(auto i=n;i--;){ + auto& hash=hashes[i]; + auto& p=positions[i]; + auto& res=results[i]; + res&=get(p,hash); + f(res); + } + } + template void combine(const filter_core& x,F f) { diff --git a/include/boost/bloom/detail/type_traits.hpp b/include/boost/bloom/detail/type_traits.hpp index 51c97e2..71a8e02 100644 --- a/include/boost/bloom/detail/type_traits.hpp +++ b/include/boost/bloom/detail/type_traits.hpp @@ -151,6 +151,11 @@ using is_forward_iterator=std::integral_constant< >; #endif +#define BOOST_BLOOM_STATIC_ASSERT_IS_FORWARD_ITERATOR(Iterator) \ +static_assert( \ + boost::bloom::detail::is_forward_iterator< Iterator >::value, \ + #Iterator " must be a forward iterator") + } /* namespace detail */ } /* namespace bloom */ } /* namespace boost */ diff --git a/include/boost/bloom/filter.hpp b/include/boost/bloom/filter.hpp index d197749..5743ed5 100644 --- a/include/boost/bloom/filter.hpp +++ b/include/boost/bloom/filter.hpp @@ -23,6 +23,7 @@ #include #include #include +#include #include #include #include @@ -111,6 +112,7 @@ __declspec(empty_bases) /* activate EBO with multiple inheritance */ using pointer=value_type*; using const_pointer=const value_type*; static constexpr std::size_t bulk_insert_size=super::bulk_insert_size; + static constexpr std::size_t bulk_lookup_size=super::bulk_lookup_size; filter()=default; @@ -302,6 +304,18 @@ __declspec(empty_bases) /* activate EBO with multiple inheritance */ return super::may_contain(hash_for(x)); } + + template + void may_contain(ForwardIterator first,ForwardIterator last,F f) + { + BOOST_BLOOM_STATIC_ASSERT_IS_FORWARD_ITERATOR(ForwardIterator); + + super::bulk_may_contain( + [=,this]()mutable{return hash_for(*first++);}, + static_cast(std::distance(first,last)), + [=,&f](bool res)mutable{f(*first++,res);}); + } + private: template< typename T1,std::size_t K1,typename SF,std::size_t S,typename H,typename A @@ -333,7 +347,7 @@ __declspec(empty_bases) /* activate EBO with multiple inheritance */ Iterator first,Iterator last,std::true_type /* forward iterator */) { super::bulk_insert( - [&,this]{return hash_for(*first++);}, + [=,this]()mutable{return hash_for(*first++);}, static_cast(std::distance(first,last))); } }; diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 6c81aae..213fd68 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -23,6 +23,7 @@ project run test_array.cpp ; run test_boost_bloom_hpp.cpp ; +run test_bulk_operations.cpp ; run test_capacity.cpp ; run test_combination.cpp ; run test_comparison.cpp ; diff --git a/test/test_bulk_operations.cpp b/test/test_bulk_operations.cpp new file mode 100644 index 0000000..c57a12a --- /dev/null +++ b/test/test_bulk_operations.cpp @@ -0,0 +1,61 @@ +/* Copyright 2025 Joaquin M Lopez Munoz. + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * See https://www.boost.org/libs/bloom for library home page. + */ + +#include +#include +#include +#include +#include "test_types.hpp" +#include "test_utilities.hpp" + +using namespace test_utilities; + +template +void test_bulk_operations() +{ + using filter=Filter; + using value_type=typename filter::value_type; + + ValueFactory fac; + { + filter f1(10000),f2(f1); + std::array input; + for(auto& x:input)x=fac(); + f1.insert(input.begin(),input.end()); + f2.insert( + make_input_iterator(input.begin()),make_input_iterator(input.end())); + BOOST_TEST(f1==f2); + } + { + Filter f(10000); + std::array input; + for(auto& x:input)x=fac(); + for(std::size_t i=0;i + void operator()(T) + { + using filter=typename T::type; + using value_type=typename filter::value_type; + + test_bulk_operations>(); + } +}; + +int main() +{ + boost::mp11::mp_for_each(lambda{}); + return boost::report_errors(); +} diff --git a/test/test_insertion.cpp b/test/test_insertion.cpp index ec00c0a..4d6b580 100644 --- a/test/test_insertion.cpp +++ b/test/test_insertion.cpp @@ -6,8 +6,8 @@ * See https://www.boost.org/libs/bloom for library home page. */ -#include #include +#include #include #include #include "test_types.hpp" @@ -74,15 +74,6 @@ void test_insertion() f.insert(input.begin(),input.end()); BOOST_TEST(may_contain(f,input)); } - { - filter f1(10000),f2(f1); - std::array input; - for(auto& x:input)x={fac(),0}; - f1.insert(input.begin(),input.end()); - f2.insert( - make_input_iterator(input.begin()),make_input_iterator(input.end())); - BOOST_TEST(f1==f2); - } { filter f(10000); std::initializer_list il={{fac(),0},{fac(),0},{fac(),0}}; From d58624ccf951f808eb96ca491ce79fa6839b1d6c Mon Sep 17 00:00:00 2001 From: joaquintides Date: Sat, 12 Jul 2025 12:24:53 +0200 Subject: [PATCH 04/66] dropped redundant this captures --- include/boost/bloom/filter.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/boost/bloom/filter.hpp b/include/boost/bloom/filter.hpp index 5743ed5..894b242 100644 --- a/include/boost/bloom/filter.hpp +++ b/include/boost/bloom/filter.hpp @@ -311,7 +311,7 @@ __declspec(empty_bases) /* activate EBO with multiple inheritance */ BOOST_BLOOM_STATIC_ASSERT_IS_FORWARD_ITERATOR(ForwardIterator); super::bulk_may_contain( - [=,this]()mutable{return hash_for(*first++);}, + [=]()mutable{return hash_for(*first++);}, static_cast(std::distance(first,last)), [=,&f](bool res)mutable{f(*first++,res);}); } @@ -347,7 +347,7 @@ __declspec(empty_bases) /* activate EBO with multiple inheritance */ Iterator first,Iterator last,std::true_type /* forward iterator */) { super::bulk_insert( - [=,this]()mutable{return hash_for(*first++);}, + [=]()mutable{return hash_for(*first++);}, static_cast(std::distance(first,last))); } }; From 60e5bfb3a8fc8421023dec21f2e95fe42f3f317f Mon Sep 17 00:00:00 2001 From: joaquintides Date: Sun, 13 Jul 2025 11:30:50 +0200 Subject: [PATCH 05/66] made bulk operations respect transparent hashers --- include/boost/bloom/detail/core.hpp | 10 ++++---- include/boost/bloom/filter.hpp | 36 ++++++++++++++++++++++------- test/test_insertion.cpp | 7 ++++++ test/test_utilities.hpp | 20 +++++++++++----- 4 files changed, 54 insertions(+), 19 deletions(-) diff --git a/include/boost/bloom/detail/core.hpp b/include/boost/bloom/detail/core.hpp index 3fa47c0..830d0fb 100644 --- a/include/boost/bloom/detail/core.hpp +++ b/include/boost/bloom/detail/core.hpp @@ -218,7 +218,7 @@ class filter_core:empty_value using pointer=unsigned char*; using const_pointer=const unsigned char*; static constexpr std::size_t bulk_insert_size=64; - static constexpr std::size_t bulk_lookup_size=64; + static constexpr std::size_t bulk_may_contain_size=64; explicit filter_core(std::size_t m=0):filter_core{m,allocator_type{}}{} @@ -401,7 +401,7 @@ class filter_core:empty_value void bulk_may_contain(HashStream h,std::size_t n,F f)const { while(n){ - auto n0=n<2*bulk_lookup_size?n:bulk_lookup_size; + auto n0=n<2*bulk_may_contain_size?n:bulk_may_contain_size; bulk_may_contain_impl(std::forward(h),n0,std::forward(f)); n-=n0; } @@ -755,9 +755,9 @@ class filter_core:empty_value template void bulk_may_contain_impl(HashStream&& h,std::size_t n,F&& f)const { - std::uint64_t hashes[2*bulk_lookup_size-1]; - const unsigned char* positions[2*bulk_lookup_size-1]; - bool results[2*bulk_lookup_size-1]; + std::uint64_t hashes[2*bulk_may_contain_size-1]; + const unsigned char* positions[2*bulk_may_contain_size-1]; + bool results[2*bulk_may_contain_size-1]; for(auto i=n;i--;){ auto& hash=hashes[i]=h(); diff --git a/include/boost/bloom/filter.hpp b/include/boost/bloom/filter.hpp index 894b242..0038256 100644 --- a/include/boost/bloom/filter.hpp +++ b/include/boost/bloom/filter.hpp @@ -112,7 +112,8 @@ __declspec(empty_bases) /* activate EBO with multiple inheritance */ using pointer=value_type*; using const_pointer=const value_type*; static constexpr std::size_t bulk_insert_size=super::bulk_insert_size; - static constexpr std::size_t bulk_lookup_size=super::bulk_lookup_size; + static constexpr std::size_t bulk_may_contain_size= + super::bulk_may_contain_size; filter()=default; @@ -246,13 +247,13 @@ __declspec(empty_bases) /* activate EBO with multiple inheritance */ super::insert(hash_for(x)); } - template - void insert(Iterator first,Iterator last) + template + void insert(InputIterator first,InputIterator last) { insert_impl( first,last, std::integral_constant< - bool,detail::is_forward_iterator::value>{}); + bool,detail::is_forward_iterator::value>{}); } void insert(std::initializer_list il) @@ -304,14 +305,13 @@ __declspec(empty_bases) /* activate EBO with multiple inheritance */ return super::may_contain(hash_for(x)); } - template - void may_contain(ForwardIterator first,ForwardIterator last,F f) + void may_contain(ForwardIterator first,ForwardIterator last,F f)const { BOOST_BLOOM_STATIC_ASSERT_IS_FORWARD_ITERATOR(ForwardIterator); super::bulk_may_contain( - [=]()mutable{return hash_for(*first++);}, + [=]()mutable{return promoting_hash_for(*first++);}, static_cast(std::distance(first,last)), [=,&f](bool res)mutable{f(*first++,res);}); } @@ -335,6 +335,26 @@ __declspec(empty_bases) /* activate EBO with multiple inheritance */ return mix_policy::mix(h(),x); } + /* promoting_hash_for forces conversion to value_type unless Hash + * is transparent. + */ + + /* NOLINTNEXTLINE(readability-redundant-inline-specifier) */ + inline std::uint64_t promoting_hash_for(const T& x)const + { + return hash_for(x); + } + + template< + typename U, + typename H=hasher,detail::enable_if_transparent_t* =nullptr + > + /* NOLINTNEXTLINE(readability-redundant-inline-specifier) */ + inline std::uint64_t promoting_hash_for(const U& x)const + { + return hash_for(x); + } + template void insert_impl( Iterator first,Iterator last,std::false_type /* input iterator */) @@ -347,7 +367,7 @@ __declspec(empty_bases) /* activate EBO with multiple inheritance */ Iterator first,Iterator last,std::true_type /* forward iterator */) { super::bulk_insert( - [=]()mutable{return hash_for(*first++);}, + [=]()mutable{return promoting_hash_for(*first++);}, static_cast(std::distance(first,last))); } }; diff --git a/test/test_insertion.cpp b/test/test_insertion.cpp index 4d6b580..2c90430 100644 --- a/test/test_insertion.cpp +++ b/test/test_insertion.cpp @@ -74,6 +74,13 @@ void test_insertion() f.insert(input.begin(),input.end()); BOOST_TEST(may_contain(f,input)); } + { + filter f(10000); + std::array input; + for(auto& x:input)x=fac(); + f.insert(input.begin(),input.end()); /* transparent insert */ + BOOST_TEST(may_contain(f,input)); + } { filter f(10000); std::initializer_list il={{fac(),0},{fac(),0},{fac(),0}}; diff --git a/test/test_utilities.hpp b/test/test_utilities.hpp index 6e10d13..c74f69d 100644 --- a/test/test_utilities.hpp +++ b/test/test_utilities.hpp @@ -96,19 +96,27 @@ void* capped_new(std::size_t n) } template -bool may_contain(const Filter& f,const Input& input) +std::size_t may_contain_count(const Filter& f,const Input& input) { + using input_value_type=typename Input::value_type; std::size_t res=0; - for(const auto& x:input)res+=f.may_contain(x); - return res==input.size(); + f.may_contain( + input.begin(),input.end(), + [&](const input_value_type&,bool b){res+=b;}); + return res; +} + +template +bool may_contain(const Filter& f,const Input& input) +{ + return may_contain_count(f,input)==input.size(); } template bool may_not_contain(const Filter& f,const Input& input) { - std::size_t res=0; - for(const auto& x:input)res+=f.may_contain(x); - return res From 4f5d7fea626b9038b17672830fef6c5defdbdbea Mon Sep 17 00:00:00 2001 From: joaquintides Date: Sun, 13 Jul 2025 11:47:45 +0200 Subject: [PATCH 06/66] fixed typedef in input_iterator --- test/test_utilities.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/test_utilities.hpp b/test/test_utilities.hpp index c74f69d..51555a4 100644 --- a/test/test_utilities.hpp +++ b/test/test_utilities.hpp @@ -129,7 +129,7 @@ class input_iterator using iterator_category=std::input_iterator_tag; using value_type=typename traits::value_type; using difference_type=typename traits::difference_type; - using pointer=typename traits::pointer; + using pointer=Iterator; using reference=typename traits::reference; input_iterator(Iterator it_):it{it_}{} From 280c6732ee969668d64f8d65865a110aa8ca0ca9 Mon Sep 17 00:00:00 2001 From: joaquintides Date: Sun, 13 Jul 2025 12:59:04 +0200 Subject: [PATCH 07/66] documented bulk operations --- doc/bloom.adoc | 1 + doc/bloom/future_work.adoc | 18 ------- doc/bloom/reference/filter.adoc | 85 +++++++++++++++++++++++++++------ doc/bloom/release_notes.adoc | 4 ++ doc/bloom/tutorial.adoc | 38 +++++++++++++++ 5 files changed, 113 insertions(+), 33 deletions(-) diff --git a/doc/bloom.adoc b/doc/bloom.adoc index f6797e4..7c8645a 100644 --- a/doc/bloom.adoc +++ b/doc/bloom.adoc @@ -12,6 +12,7 @@ :stem: latexmath :small: pass:[] :small-end: pass:[] +:cpp: C++ ++++