1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef _LIBCPP___RANDOM_DISCARD_BLOCK_ENGINE_H
10#define _LIBCPP___RANDOM_DISCARD_BLOCK_ENGINE_H
11
12#include <__config>
13#include <__random/is_seed_sequence.h>
14#include <__utility/move.h>
15#include <iosfwd>
16#include <limits>
17#include <type_traits>
18
19#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
20#  pragma GCC system_header
21#endif
22
23_LIBCPP_PUSH_MACROS
24#include <__undef_macros>
25
26_LIBCPP_BEGIN_NAMESPACE_STD
27
28template<class _Engine, size_t __p, size_t __r>
29class _LIBCPP_TEMPLATE_VIS discard_block_engine
30{
31    _Engine __e_;
32    int     __n_;
33
34    static_assert(  0 <  __r, "discard_block_engine invalid parameters");
35    static_assert(__r <= __p, "discard_block_engine invalid parameters");
36#ifndef _LIBCPP_CXX03_LANG // numeric_limits::max() is not constexpr in C++03
37    static_assert(__r <= numeric_limits<int>::max(), "discard_block_engine invalid parameters");
38#endif
39public:
40    // types
41    typedef typename _Engine::result_type result_type;
42
43    // engine characteristics
44    static _LIBCPP_CONSTEXPR const size_t block_size = __p;
45    static _LIBCPP_CONSTEXPR const size_t used_block = __r;
46
47#ifdef _LIBCPP_CXX03_LANG
48    static const result_type _Min = _Engine::_Min;
49    static const result_type _Max = _Engine::_Max;
50#else
51    static _LIBCPP_CONSTEXPR const result_type _Min = _Engine::min();
52    static _LIBCPP_CONSTEXPR const result_type _Max = _Engine::max();
53#endif
54
55    _LIBCPP_INLINE_VISIBILITY
56    static _LIBCPP_CONSTEXPR result_type min() { return _Engine::min(); }
57    _LIBCPP_INLINE_VISIBILITY
58    static _LIBCPP_CONSTEXPR result_type max() { return _Engine::max(); }
59
60    // constructors and seeding functions
61    _LIBCPP_INLINE_VISIBILITY
62    discard_block_engine() : __n_(0) {}
63    _LIBCPP_INLINE_VISIBILITY
64    explicit discard_block_engine(const _Engine& __e)
65        : __e_(__e), __n_(0) {}
66#ifndef _LIBCPP_CXX03_LANG
67    _LIBCPP_INLINE_VISIBILITY
68    explicit discard_block_engine(_Engine&& __e)
69        : __e_(_VSTD::move(__e)), __n_(0) {}
70#endif // _LIBCPP_CXX03_LANG
71    _LIBCPP_INLINE_VISIBILITY
72    explicit discard_block_engine(result_type __sd) : __e_(__sd), __n_(0) {}
73    template<class _Sseq>
74        _LIBCPP_INLINE_VISIBILITY
75        explicit discard_block_engine(_Sseq& __q,
76        typename enable_if<__is_seed_sequence<_Sseq, discard_block_engine>::value &&
77                           !is_convertible<_Sseq, _Engine>::value>::type* = 0)
78        : __e_(__q), __n_(0) {}
79    _LIBCPP_INLINE_VISIBILITY
80    void seed() {__e_.seed(); __n_ = 0;}
81    _LIBCPP_INLINE_VISIBILITY
82    void seed(result_type __sd) {__e_.seed(__sd); __n_ = 0;}
83    template<class _Sseq>
84        _LIBCPP_INLINE_VISIBILITY
85        typename enable_if
86        <
87            __is_seed_sequence<_Sseq, discard_block_engine>::value,
88            void
89        >::type
90        seed(_Sseq& __q) {__e_.seed(__q); __n_ = 0;}
91
92    // generating functions
93    result_type operator()();
94    _LIBCPP_INLINE_VISIBILITY
95    void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
96
97    // property functions
98    _LIBCPP_INLINE_VISIBILITY
99    const _Engine& base() const _NOEXCEPT {return __e_;}
100
101    template<class _Eng, size_t _Pp, size_t _Rp>
102    friend
103    bool
104    operator==(
105        const discard_block_engine<_Eng, _Pp, _Rp>& __x,
106        const discard_block_engine<_Eng, _Pp, _Rp>& __y);
107
108    template<class _Eng, size_t _Pp, size_t _Rp>
109    friend
110    bool
111    operator!=(
112        const discard_block_engine<_Eng, _Pp, _Rp>& __x,
113        const discard_block_engine<_Eng, _Pp, _Rp>& __y);
114
115    template <class _CharT, class _Traits,
116              class _Eng, size_t _Pp, size_t _Rp>
117    friend
118    basic_ostream<_CharT, _Traits>&
119    operator<<(basic_ostream<_CharT, _Traits>& __os,
120               const discard_block_engine<_Eng, _Pp, _Rp>& __x);
121
122    template <class _CharT, class _Traits,
123              class _Eng, size_t _Pp, size_t _Rp>
124    friend
125    basic_istream<_CharT, _Traits>&
126    operator>>(basic_istream<_CharT, _Traits>& __is,
127               discard_block_engine<_Eng, _Pp, _Rp>& __x);
128};
129
130template<class _Engine, size_t __p, size_t __r>
131    _LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::block_size;
132
133template<class _Engine, size_t __p, size_t __r>
134    _LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::used_block;
135
136template<class _Engine, size_t __p, size_t __r>
137typename discard_block_engine<_Engine, __p, __r>::result_type
138discard_block_engine<_Engine, __p, __r>::operator()()
139{
140    if (__n_ >= static_cast<int>(__r))
141    {
142        __e_.discard(__p - __r);
143        __n_ = 0;
144    }
145    ++__n_;
146    return __e_();
147}
148
149template<class _Eng, size_t _Pp, size_t _Rp>
150inline _LIBCPP_INLINE_VISIBILITY
151bool
152operator==(const discard_block_engine<_Eng, _Pp, _Rp>& __x,
153           const discard_block_engine<_Eng, _Pp, _Rp>& __y)
154{
155    return __x.__n_ == __y.__n_ && __x.__e_ == __y.__e_;
156}
157
158template<class _Eng, size_t _Pp, size_t _Rp>
159inline _LIBCPP_INLINE_VISIBILITY
160bool
161operator!=(const discard_block_engine<_Eng, _Pp, _Rp>& __x,
162           const discard_block_engine<_Eng, _Pp, _Rp>& __y)
163{
164    return !(__x == __y);
165}
166
167template <class _CharT, class _Traits,
168          class _Eng, size_t _Pp, size_t _Rp>
169_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
170operator<<(basic_ostream<_CharT, _Traits>& __os,
171           const discard_block_engine<_Eng, _Pp, _Rp>& __x)
172{
173    __save_flags<_CharT, _Traits> __lx(__os);
174    typedef basic_ostream<_CharT, _Traits> _Ostream;
175    __os.flags(_Ostream::dec | _Ostream::left);
176    _CharT __sp = __os.widen(' ');
177    __os.fill(__sp);
178    return __os << __x.__e_ << __sp << __x.__n_;
179}
180
181template <class _CharT, class _Traits,
182          class _Eng, size_t _Pp, size_t _Rp>
183_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
184operator>>(basic_istream<_CharT, _Traits>& __is,
185           discard_block_engine<_Eng, _Pp, _Rp>& __x)
186{
187    __save_flags<_CharT, _Traits> __lx(__is);
188    typedef basic_istream<_CharT, _Traits> _Istream;
189    __is.flags(_Istream::dec | _Istream::skipws);
190    _Eng __e;
191    int __n;
192    __is >> __e >> __n;
193    if (!__is.fail())
194    {
195        __x.__e_ = __e;
196        __x.__n_ = __n;
197    }
198    return __is;
199}
200
201_LIBCPP_END_NAMESPACE_STD
202
203_LIBCPP_POP_MACROS
204
205#endif // _LIBCPP___RANDOM_DISCARD_BLOCK_ENGINE_H
206