std::shuffle_order_engine< TEngine, k > Template-Klassenreferenz

#include <shuffle_order_engine.hpp>

Öffentliche Typen
using	base_type = TEngine
using	result_type = typename base_type::result_type

Öffentliche Methoden
	shuffle_order_engine ()
	shuffle_order_engine (const base_type &e)
	shuffle_order_engine (base_type &&e)
	shuffle_order_engine (result_type val)
void	seed ()
void	seed (result_type sd)
result_type	operator() ()
void	discard (unsigned long long z)
const base_type &	base () const

Öffentliche, statische Methoden
static constexpr result_type	min ()
static constexpr result_type	max ()

Statische öffentliche Attribute
static constexpr size_t	table_size = k

Ausführliche Beschreibung

template<class TEngine, size_t k>
class std::shuffle_order_engine< TEngine, k >

Dokumentation der benutzerdefinierten Datentypen

base_type

template<class TEngine , size_t k>

using std::shuffle_order_engine< TEngine, k >::base_type = TEngine

result_type

template<class TEngine , size_t k>

using std::shuffle_order_engine< TEngine, k >::result_type = typename base_type::result_type

Beschreibung der Konstruktoren und Destruktoren

shuffle_order_engine() [1/4]

template<class TEngine , size_t k>

std::shuffle_order_engine< TEngine, k >::shuffle_order_engine ( )

inline

: m_x() { init(); }

shuffle_order_engine() [2/4]

template<class TEngine , size_t k>

std::shuffle_order_engine< TEngine, k >::shuffle_order_engine ( const base_type &  e )

inlineexplicit

: m_x(e)  { init(); }

shuffle_order_engine() [3/4]

template<class TEngine , size_t k>

std::shuffle_order_engine< TEngine, k >::shuffle_order_engine ( base_type &&  e )

inlineexplicit

: m_x(e)  { init(); }

shuffle_order_engine() [4/4]

template<class TEngine , size_t k>

std::shuffle_order_engine< TEngine, k >::shuffle_order_engine ( result_type  val )

inlineexplicit

: m_x(val)  { init(); }

Dokumentation der Elementfunktionen

base()

template<class TEngine , size_t k>

const base_type& std::shuffle_order_engine< TEngine, k >::base ( void  ) const

inline

{ return m_x; }

discard()

template<class TEngine , size_t k>

void std::shuffle_order_engine< TEngine, k >::discard ( unsigned long long  z )

inline

                                           {
            for (; z != 0ULL; --z)
                (*this).operator ()();
        }

max()

template<class TEngine , size_t k>

static constexpr result_type std::shuffle_order_engine< TEngine, k >::max ( )

inlinestatic

{ return base_type::max(); }

min()

template<class TEngine , size_t k>

static constexpr result_type std::shuffle_order_engine< TEngine, k >::min ( )

inlinestatic

{ return base_type::min(); }

operator()()

template<class TEngine , size_t k>

result_type std::shuffle_order_engine< TEngine, k >::operator() ( )

inline

                                 {
            size_t j = table_size * ((m_y - min()) / ((max() - min()) +1 ));
            m_y = m_stored[j];
            m_stored[j] = m_x();
            return m_y;
        }

seed() [1/2]

template<class TEngine , size_t k>

void std::shuffle_order_engine< TEngine, k >::seed ( )

inline

{ m_x.seed(); init(); }

seed() [2/2]

template<class TEngine , size_t k>

void std::shuffle_order_engine< TEngine, k >::seed ( result_type  sd )

inline

{ m_x.seed(sd); init(); }

Dokumentation der Datenelemente

table_size

template<class TEngine , size_t k>

constexpr size_t std::shuffle_order_engine< TEngine, k >::table_size = k

static

---

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:

• include/hash/shuffle_order_engine.hpp