Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

[range.iter.ops], default_sentinel, and unreachable_sentinel #329

Merged
merged 1 commit into from
Dec 2, 2019
Merged

[range.iter.ops], default_sentinel, and unreachable_sentinel #329

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
69 changes: 69 additions & 0 deletions stl/inc/algorithm
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1791,6 +1791,74 @@ _NODISCARD _FwdIt unique(_ExPo&&, _FwdIt _First, _FwdIt _Last) noexcept /* termi
#endif // _HAS_CXX17

// FUNCTION TEMPLATE unique_copy
#if _HAS_IF_CONSTEXPR
// clang-format off
#ifdef __cpp_lib_concepts
template <class _InIt, class _OutIt>
concept _Can_reread_dest = forward_iterator<_OutIt> && same_as<iter_value_t<_InIt>, iter_value_t<_OutIt>>;
#else // ^^^ defined(__cpp_lib_concepts) / !defined(__cpp_lib_concepts) vvv
template <class _InIt, class _OutIt>
_INLINE_VAR constexpr bool _Can_reread_dest =
_Is_fwd_iter_v<_OutIt> && is_same_v<_Iter_value_t<_InIt>, _Iter_value_t<_OutIt>>;
#endif // __cpp_lib_concepts
// clang-format on

template <class _InIt, class _OutIt, class _Pr>
_OutIt unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred) { // copy compressing pairs that match
_Adl_verify_range(_First, _Last);

auto _UFirst = _Get_unwrapped(_First);
const auto _ULast = _Get_unwrapped(_Last);

if (_UFirst == _ULast) {
return _Dest;
}

auto _UDest = _Get_unwrapped_unverified(_Dest);

if constexpr (_Is_fwd_iter_v<_InIt>) { // can reread the source for comparison
auto _Firstb = _UFirst;

*_UDest = *_Firstb;
++_UDest;

while (++_UFirst != _ULast) {
if (!static_cast<bool>(_Pred(*_Firstb, *_UFirst))) { // copy unmatched
_Firstb = _UFirst;
*_UDest = *_Firstb;
++_UDest;
}
}
} else if constexpr (_Can_reread_dest<_InIt, _OutIt>) { // assignment copies T; can reread dest for comparison
*_UDest = *_UFirst;

while (++_UFirst != _ULast) {
if (!static_cast<bool>(_Pred(*_UDest, *_UFirst))) {
*++_UDest = *_UFirst;
}
}

++_UDest;
} else { // can't reread source or dest, construct a temporary
_Iter_value_t<_InIt> _Val = *_UFirst;

*_UDest = _Val;
++_UDest;

while (++_UFirst != _ULast) {
if (!static_cast<bool>(_Pred(_Val, *_UFirst))) { // copy unmatched
_Val = *_UFirst;
*_UDest = _Val;
++_UDest;
}
}
}

_Seek_wrapped(_Dest, _UDest);
return _Dest;
}

#else // ^^^ _HAS_IF_CONSTEXPR / !_HAS_IF_CONSTEXPR vvv
template <class _FwdIt, class _OutIt, class _Pr>
_OutIt _Unique_copy_unchecked(_FwdIt _First, _FwdIt _Last, _OutIt _Dest, _Pr _Pred, true_type, _Any_tag) {
// copy compressing pairs satisfying _Pred, forward source iterator
Expand Down Expand Up @@ -1865,6 +1933,7 @@ _OutIt unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred) { // copy

return _Dest;
}
#endif // _HAS_IF_CONSTEXPR

#if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template <class _InIt, class _DestTy, size_t _DestSize, class _Pr>
Expand Down
10 changes: 5 additions & 5 deletions stl/inc/concepts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -180,7 +180,7 @@ namespace ranges {
// CONCEPT swappable
template <class _Ty>
concept swappable = requires(_Ty& __x, _Ty& __y) {
_STD ranges::swap(__x, __y);
_RANGES swap(__x, __y);
};

// CONCEPT swappable_with
Expand All @@ -192,10 +192,10 @@ concept swappable_with =
common_reference_with<const remove_reference_t<_Ty1>&, const remove_reference_t<_Ty2>&>
#endif // select LWG-3175 vs. N4810
&& requires(_Ty1&& __t, _Ty2&& __u) {
_STD ranges::swap(static_cast<_Ty1&&>(__t), static_cast<_Ty1&&>(__t));
_STD ranges::swap(static_cast<_Ty2&&>(__u), static_cast<_Ty2&&>(__u));
_STD ranges::swap(static_cast<_Ty1&&>(__t), static_cast<_Ty2&&>(__u));
_STD ranges::swap(static_cast<_Ty2&&>(__u), static_cast<_Ty1&&>(__t));
_RANGES swap(static_cast<_Ty1&&>(__t), static_cast<_Ty1&&>(__t));
_RANGES swap(static_cast<_Ty2&&>(__u), static_cast<_Ty2&&>(__u));
_RANGES swap(static_cast<_Ty1&&>(__t), static_cast<_Ty2&&>(__u));
_RANGES swap(static_cast<_Ty2&&>(__u), static_cast<_Ty1&&>(__t));
};

// CONCEPT copy_constructible
Expand Down
67 changes: 37 additions & 30 deletions stl/inc/execution
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -833,8 +833,9 @@ struct _Static_partition_range;
template <class _RanIt, class _Diff>
struct _Static_partition_range<_RanIt, _Diff, true> {
using _Target_diff = _Iter_diff_t<_RanIt>;
_Unwrapped_t<_RanIt> _Start_at;
using _Chunk_type = _Iterator_range<_Unwrapped_t<_RanIt>>;
using _URanIt = _Unwrapped_t<const _RanIt&>;
_URanIt _Start_at;
CaseyCarter marked this conversation as resolved.
Show resolved Hide resolved
using _Chunk_type = _Iterator_range<_URanIt>;

_RanIt _Populate(const _Static_partition_team<_Diff>& _Team,
_RanIt _First) { // statically partition a random-access iterator range and return next(_First, _Team._Count)
Expand All @@ -852,7 +853,7 @@ struct _Static_partition_range<_RanIt, _Diff, true> {
return _Team._Count == _Last - _First;
}

_Unwrapped_t<_RanIt> _Get_first(size_t /* _Chunk_number */,
_URanIt _Get_first(size_t /* _Chunk_number */,
const _Diff _Offset) { // get the first iterator for _Chunk _Chunk_number (which is at offset _Offset)
return _Start_at + static_cast<_Target_diff>(_Offset);
}
Expand All @@ -868,8 +869,9 @@ struct _Static_partition_range<_RanIt, _Diff, true> {
template <class _FwdIt, class _Diff>
struct _Static_partition_range<_FwdIt, _Diff, false> {
using _Target_diff = _Iter_diff_t<_FwdIt>;
_Parallel_vector<_Unwrapped_t<_FwdIt>> _Division_points;
using _Chunk_type = _Iterator_range<_Unwrapped_t<_FwdIt>>;
using _UFwdIt = _Unwrapped_t<const _FwdIt&>;
_Parallel_vector<_UFwdIt> _Division_points;
using _Chunk_type = _Iterator_range<_UFwdIt>;

_FwdIt _Populate(const _Static_partition_team<_Diff>& _Team,
_FwdIt _First) { // statically partition a forward iterator range and return next(_First, _Team._Count)
Expand Down Expand Up @@ -933,7 +935,7 @@ struct _Static_partition_range<_FwdIt, _Diff, false> {
return _First == _Last;
}

_Unwrapped_t<_FwdIt> _Get_first(const size_t _Chunk_number, _Diff /* _Offset */) {
_UFwdIt _Get_first(const size_t _Chunk_number, _Diff /* _Offset */) {
// get the first iterator for _Chunk _Chunk_number (which is at offset _Offset)
return _Division_points[_Chunk_number];
}
Expand All @@ -952,8 +954,8 @@ struct _Static_partition_range_backward;
template <class _RanIt, class _Diff>
struct _Static_partition_range_backward<_RanIt, _Diff, true> {
using _Target_diff = _Iter_diff_t<_RanIt>;
_Unwrapped_t<_RanIt> _Start_at;
using _Chunk_type = _Iterator_range<_Unwrapped_t<_RanIt>>;
_Unwrapped_t<const _RanIt&> _Start_at;
using _Chunk_type = _Iterator_range<_Unwrapped_t<const _RanIt&>>;

void _Populate(const _Static_partition_team<_Diff>& _Team, _RanIt _Last) {
// statically partition a random-access iterator range ending at _Last
Expand All @@ -972,8 +974,8 @@ struct _Static_partition_range_backward<_RanIt, _Diff, true> {
template <class _BidIt, class _Diff>
struct _Static_partition_range_backward<_BidIt, _Diff, false> {
using _Target_diff = _Iter_diff_t<_BidIt>;
_Parallel_vector<_Unwrapped_t<_BidIt>> _Division_points;
using _Chunk_type = _Iterator_range<_Unwrapped_t<_BidIt>>;
_Parallel_vector<_Unwrapped_t<const _BidIt&>> _Division_points;
using _Chunk_type = _Iterator_range<_Unwrapped_t<const _BidIt&>>;

void _Populate(const _Static_partition_team<_Diff>& _Team, _BidIt _Last) {
// statically partition a bidirectional iterator range ending at _Last
Expand Down Expand Up @@ -1364,7 +1366,7 @@ template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_E
_NODISCARD _FwdIt find(_ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) noexcept /* terminates */ {
// find first matching _Val
_REQUIRE_PARALLEL_ITERATOR(_FwdIt);
using _UFwdIt = _Unwrapped_t<_FwdIt>;
using _UFwdIt = _Unwrapped_t<const _FwdIt&>;
_Adl_verify_range(_First, _Last);
_Seek_wrapped(_First,
_Find_parallel_unchecked(_STD forward<_ExPo>(_Exec), _Get_unwrapped(_First), _Get_unwrapped(_Last),
Expand All @@ -1377,7 +1379,7 @@ template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_E
_NODISCARD _FwdIt find_if(_ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
// find first satisfying _Pred
_REQUIRE_PARALLEL_ITERATOR(_FwdIt);
using _UFwdIt = _Unwrapped_t<_FwdIt>;
using _UFwdIt = _Unwrapped_t<const _FwdIt&>;
_Adl_verify_range(_First, _Last);
auto _Pass_pred = _Pass_fn(_Pred);
_Seek_wrapped(_First,
Expand All @@ -1391,7 +1393,7 @@ template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_E
_NODISCARD _FwdIt find_if_not(_ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
// find first satisfying !_Pred
_REQUIRE_PARALLEL_ITERATOR(_FwdIt);
using _UFwdIt = _Unwrapped_t<_FwdIt>;
using _UFwdIt = _Unwrapped_t<const _FwdIt&>;
_Adl_verify_range(_First, _Last);
auto _Pass_pred = _Pass_fn(_Pred);
_Seek_wrapped(_First, _Find_parallel_unchecked(_STD forward<_ExPo>(_Exec), _Get_unwrapped(_First),
Expand Down Expand Up @@ -1606,7 +1608,7 @@ _NODISCARD _FwdIt1 find_first_of(_ExPo&& _Exec, const _FwdIt1 _First1, _FwdIt1 _
const _FwdIt2 _Last2, _Pr _Pred) noexcept /* terminates */ {
// look for one of [_First2, _Last2) that matches element
_REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
using _UFwdIt1 = _Unwrapped_t<_FwdIt1>;
using _UFwdIt1 = _Unwrapped_t<const _FwdIt1&>;
_Adl_verify_range(_First1, _Last1);
_Adl_verify_range(_First2, _Last2);
const auto _UFirst2 = _Get_unwrapped(_First2);
Expand Down Expand Up @@ -1768,18 +1770,20 @@ _NODISCARD _Iter_diff_t<_FwdIt> count(
}

// PARALLEL FUNCTION TEMPLATE mismatch
template <class _FwdIt1, class _FwdIt2, bool = _Use_atomic_iterator<_Unwrapped_t<_FwdIt1>>&& _Is_random_iter_v<_FwdIt2>,
bool = _Use_atomic_iterator<_Unwrapped_t<_FwdIt2>>&& _Is_random_iter_v<_FwdIt1>>
template <class _FwdIt1, class _FwdIt2,
bool = _Use_atomic_iterator<_Unwrapped_t<const _FwdIt1&>>&& _Is_random_iter_v<_FwdIt2>,
bool = _Use_atomic_iterator<_Unwrapped_t<const _FwdIt2&>>&& _Is_random_iter_v<_FwdIt1>>
struct _Static_partitioned_mismatch_results;

template <class _FwdIt1, class _FwdIt2, bool _Unused>
struct _Static_partitioned_mismatch_results<_FwdIt1, _FwdIt2, true, _Unused> {
// atomically manipulate atomic<_FwdIt1> and calculate the second iterator by adding distance to it
_Parallel_choose_min_result<_FwdIt1> _Storage;

_Static_partitioned_mismatch_results(const _FwdIt1 _Last1, const _Unwrapped_t<_FwdIt2>&) : _Storage(_Last1) {}
_Static_partitioned_mismatch_results(const _FwdIt1 _Last1, const _Unwrapped_t<const _FwdIt2&>&)
: _Storage(_Last1) {}

void _Imbue(const size_t _Chunk_number, const _FwdIt1 _First1, const _Unwrapped_t<_FwdIt2>&) {
void _Imbue(const size_t _Chunk_number, const _FwdIt1 _First1, const _Unwrapped_t<const _FwdIt2&>&) {
_Storage._Imbue(_Chunk_number, _First1);
}

Expand All @@ -1794,9 +1798,10 @@ struct _Static_partitioned_mismatch_results<_FwdIt1, _FwdIt2, false, true> {
// atomically manipulate atomic<_FwdIt2> and calculate the first iterator by adding distance to it
_Parallel_choose_min_result<_FwdIt2> _Storage;

_Static_partitioned_mismatch_results(const _Unwrapped_t<_FwdIt1>&, const _FwdIt2 _Last2) : _Storage(_Last2) {}
_Static_partitioned_mismatch_results(const _Unwrapped_t<const _FwdIt1&>&, const _FwdIt2 _Last2)
: _Storage(_Last2) {}

void _Imbue(const size_t _Chunk_number, const _Unwrapped_t<_FwdIt1>&, const _FwdIt2 _First2) {
void _Imbue(const size_t _Chunk_number, const _Unwrapped_t<const _FwdIt1&>&, const _FwdIt2 _First2) {
_Storage._Imbue(_Chunk_number, _First2);
}

Expand All @@ -1809,12 +1814,13 @@ struct _Static_partitioned_mismatch_results<_FwdIt1, _FwdIt2, false, true> {
template <class _FwdIt1, class _FwdIt2>
struct _Static_partitioned_mismatch_results<_FwdIt1, _FwdIt2, false, false> {
// get both iterators by manipulating them under lock
_Parallel_choose_min_chunk<pair<_Unwrapped_t<_FwdIt1>, _Unwrapped_t<_FwdIt2>>> _Storage;
using _UFwdIt1 = _Unwrapped_t<const _FwdIt1&>;
using _UFwdIt2 = _Unwrapped_t<const _FwdIt2&>;
_Parallel_choose_min_chunk<pair<_UFwdIt1, _UFwdIt2>> _Storage;

_Static_partitioned_mismatch_results(const _Unwrapped_t<_FwdIt1> _Last1, const _Unwrapped_t<_FwdIt2> _Last2)
: _Storage({_Last1, _Last2}) {}
_Static_partitioned_mismatch_results(const _UFwdIt1 _Last1, const _UFwdIt2 _Last2) : _Storage({_Last1, _Last2}) {}

void _Imbue(const size_t _Chunk_number, const _Unwrapped_t<_FwdIt1> _First1, const _Unwrapped_t<_FwdIt2> _First2) {
void _Imbue(const size_t _Chunk_number, const _UFwdIt1 _First1, const _UFwdIt2 _First2) {
_Storage._Imbue(_Chunk_number, {_First1, _First2});
}

Expand Down Expand Up @@ -4055,7 +4061,7 @@ _FwdIt3 set_difference(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2
template <class _InIt, class _Ty, class _BinOp>
_Ty _Reduce_move_unchecked(_InIt _First, const _InIt _Last, _Ty _Val, _BinOp _Reduce_op) {
// return reduction, choose optimization
if constexpr (_Plus_on_arithmetic_ranges_reduction_v<_Unwrapped_t<_InIt>, _Ty, _BinOp>) {
if constexpr (_Plus_on_arithmetic_ranges_reduction_v<_Unwrapped_t<const _InIt&>, _Ty, _BinOp>) {
(void) _Reduce_op; // TRANSITION, VSO-486357
return _Reduce_plus_arithmetic_ranges(_First, _Last, _Val);
} else {
Expand Down Expand Up @@ -4626,7 +4632,7 @@ _FwdIt2 inclusive_scan(
if (_Count >= 2) { // ... with at least 2 elements
_TRY_BEGIN
auto _Passed_op = _Pass_fn(_Reduce_op);
_Static_partitioned_inclusive_scan2<_Ty, _Ty, _Unwrapped_t<_FwdIt1>, decltype(_UDest),
_Static_partitioned_inclusive_scan2<_Ty, _Ty, _Unwrapped_t<const _FwdIt1&>, decltype(_UDest),
decltype(_Passed_op)>
_Operation{_Hw_threads, _Count, _Passed_op, _Val};
_Operation._Basis1._Populate(_Operation._Team, _UFirst);
Expand Down Expand Up @@ -4670,7 +4676,7 @@ _FwdIt2 inclusive_scan(
_TRY_BEGIN
_No_init_tag _Tag;
auto _Passed_op = _Pass_fn(_Reduce_op);
_Static_partitioned_inclusive_scan2<_Iter_value_t<_FwdIt1>, _No_init_tag, _Unwrapped_t<_FwdIt1>,
_Static_partitioned_inclusive_scan2<_Iter_value_t<_FwdIt1>, _No_init_tag, _Unwrapped_t<const _FwdIt1&>,
decltype(_UDest), decltype(_Passed_op)>
_Operation{_Hw_threads, _Count, _Passed_op, _Tag};
_Operation._Basis1._Populate(_Operation._Team, _UFirst);
Expand Down Expand Up @@ -4962,7 +4968,7 @@ _FwdIt2 transform_inclusive_scan(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _L
_TRY_BEGIN
auto _Passed_reduce = _Pass_fn(_Reduce_op);
auto _Passed_transform = _Pass_fn(_Transform_op);
_Static_partitioned_transform_inclusive_scan2<_Ty, _Ty, _Unwrapped_t<_FwdIt1>, decltype(_UDest),
_Static_partitioned_transform_inclusive_scan2<_Ty, _Ty, _Unwrapped_t<const _FwdIt1&>, decltype(_UDest),
decltype(_Passed_reduce), decltype(_Passed_transform)>
_Operation{_Hw_threads, _Count, _Passed_reduce, _Passed_transform, _Val};
_Operation._Basis1._Populate(_Operation._Team, _UFirst);
Expand Down Expand Up @@ -5010,8 +5016,9 @@ _FwdIt2 transform_inclusive_scan(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _L
auto _Passed_reduce = _Pass_fn(_Reduce_op);
auto _Passed_transform = _Pass_fn(_Transform_op);
using _Intermediate_t = decay_t<decltype(_Transform_op(*_UFirst))>;
_Static_partitioned_transform_inclusive_scan2<_Intermediate_t, _No_init_tag, _Unwrapped_t<_FwdIt1>,
decltype(_UDest), decltype(_Passed_reduce), decltype(_Passed_transform)>
_Static_partitioned_transform_inclusive_scan2<_Intermediate_t, _No_init_tag,
_Unwrapped_t<const _FwdIt1&>, decltype(_UDest), decltype(_Passed_reduce),
decltype(_Passed_transform)>
_Operation{_Hw_threads, _Count, _Passed_reduce, _Passed_transform, _Tag};
_Operation._Basis1._Populate(_Operation._Team, _UFirst);
_Seek_wrapped(_Dest, _Operation._Basis2._Populate(_Operation._Team, _UDest));
Expand Down
10 changes: 5 additions & 5 deletions stl/inc/filesystem
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -279,9 +279,9 @@ namespace filesystem {
template <class _Src>
_NODISCARD auto _Stringoid_from_Source(const _Src& _Source) {
using _EcharT = _Iter_value_t<decay_t<_Src>>;
if constexpr (is_pointer_v<_Unwrapped_unverified_t<_Src>>) {
if constexpr (is_pointer_v<_Unwrapped_unverified_t<const _Src&>>) {
return basic_string_view<_EcharT>(_Get_unwrapped_unverified(_Source));
} else if constexpr (is_pointer_v<_Unwrapped_t<_Src>>) {
} else if constexpr (is_pointer_v<_Unwrapped_t<const _Src&>>) {
const auto _Data = _Get_unwrapped(_Source);
auto _Next = _Source;
while (*_Next != _EcharT{}) {
Expand Down Expand Up @@ -1582,8 +1582,8 @@ namespace filesystem {

using _Prevent_inheriting_unwrap = _Path_iterator;

template <class _Iter2 = _Base_iter, enable_if_t<_Unwrappable_v<_Iter2>, int> = 0>
_NODISCARD _Path_iterator<_Unwrapped_t<_Base_iter>> _Unwrapped() const {
template <class _Iter2 = _Base_iter, enable_if_t<_Unwrappable_v<const _Iter2&>, int> = 0>
_NODISCARD _Path_iterator<_Unwrapped_t<const _Iter2&>> _Unwrapped() const {
return {_Position._Unwrapped(), _Element.native(), _Mypath};
}

Expand All @@ -1592,7 +1592,7 @@ namespace filesystem {
template <class _Other>
friend class _Path_iterator;

template <class _Other, enable_if_t<_Wrapped_seekable_v<_Base_iter, _Other>, int> = 0>
template <class _Other, enable_if_t<_Wrapped_seekable_v<_Base_iter, const _Other&>, int> = 0>
constexpr void _Seek_to(const _Path_iterator<_Other>& _It) {
_Position._Seek_to(_It._Position);
_Element = _It._Element;
Expand Down
4 changes: 2 additions & 2 deletions stl/inc/functional
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1706,7 +1706,7 @@ struct _Boyer_moore_hash_delta_1_table { // stores the Boyer-Moore delta_1 table
using _Value_t = _Iter_value_t<_RanItPat>;
using _Diff = _Iter_diff_t<_RanItPat>;

_Boyer_moore_hash_delta_1_table(_RanItPat _Pat_first_arg, _Unwrapped_t<_RanItPat> _UPat_first,
_Boyer_moore_hash_delta_1_table(_RanItPat _Pat_first_arg, _Unwrapped_t<const _RanItPat&> _UPat_first,
const _Diff _Pat_size_arg, _Hash_ty&& _Hash_fn, _Pred_eq&& _Eq)
: _Pat_first(_Pat_first_arg), _Pat_size(_Pat_size_arg),
_Map(0, _STD move(_Hash_fn), _STD move(_Eq)) { // initialize a delta_1 hash table
Expand Down Expand Up @@ -1743,7 +1743,7 @@ struct _Boyer_moore_flat_delta_1_table { // stores the Boyer-Moore delta_1 table
using _Value_t = _Iter_value_t<_RanItPat>;
using _Diff = _Iter_diff_t<_RanItPat>;

_Boyer_moore_flat_delta_1_table(_RanItPat _Pat_first_arg, _Unwrapped_t<_RanItPat> _UPat_first,
_Boyer_moore_flat_delta_1_table(_RanItPat _Pat_first_arg, _Unwrapped_t<const _RanItPat&> _UPat_first,
const _Diff _Pat_size_arg, _Unused_parameter, _Unused_parameter)
: _Pat_first(_Pat_first_arg), _Pat_size(_Pat_size_arg) { // initialize a delta_1 flat table
_STD fill(_STD begin(_Table), _STD end(_Table), _Pat_size);
Expand Down
Loading