std::discard_block_engine< TEngine, p, r > Template-Klassenreferenz

#include <discard_block_engine.hpp>

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

Öffentliche Methoden
	discard_block_engine ()
	discard_block_engine (const base_type &bt)
	discard_block_engine (result_type s)
void	seed (result_type s)
void	seed ()
result_type	operator() (void)
void	discard (unsigned long long z)
const base_type &	base (void) const

Statische öffentliche Attribute
static const size_t	block_size = p
static const size_t	used_block = r

Ausführliche Beschreibung

template<class TEngine, size_t p, size_t r>
class std::discard_block_engine< TEngine, p, r >

Dokumentation der benutzerdefinierten Datentypen

base_type

template<class TEngine , size_t p, size_t r>

using std::discard_block_engine< TEngine, p, r >::base_type = TEngine

result_type

template<class TEngine , size_t p, size_t r>

using std::discard_block_engine< TEngine, p, r >::result_type = typename TEngine::result_type

Beschreibung der Konstruktoren und Destruktoren

discard_block_engine() [1/3]

template<class TEngine , size_t p, size_t r>

std::discard_block_engine< TEngine, p, r >::discard_block_engine ( )

inline

            : m_e(), m_n(0) {}

discard_block_engine() [2/3]

template<class TEngine , size_t p, size_t r>

std::discard_block_engine< TEngine, p, r >::discard_block_engine ( const base_type &  bt )

inlineexplicit

            : m_e(bt), m_n(0) {}

discard_block_engine() [3/3]

template<class TEngine , size_t p, size_t r>

std::discard_block_engine< TEngine, p, r >::discard_block_engine ( result_type  s )

inlineexplicit

            : m_e(s), m_n(0) {}

Dokumentation der Elementfunktionen

base()

template<class TEngine , size_t p, size_t r>

const base_type& std::discard_block_engine< TEngine, p, r >::base ( void  ) const

inline

{ return m_e; }

discard()

template<class TEngine , size_t p, size_t r>

void std::discard_block_engine< TEngine, p, r >::discard ( unsigned long long  z )

inline

                                           {
           for(; z > 0; --z) 
                this->operator()();
        }

operator()()

template<class TEngine , size_t p, size_t r>

result_type std::discard_block_engine< TEngine, p, r >::operator() ( void  )

inline

                                     {
             if(m_n >= used_block) {
                m_e.discard(block_size - m_n);
                m_n = 0;
            }
            ++m_n;
            return m_e();
        }

seed() [1/2]

template<class TEngine , size_t p, size_t r>

void std::discard_block_engine< TEngine, p, r >::seed ( result_type  s )

inline

                                 {
            m_e.seed(s);
            m_n = 0;
        }

seed() [2/2]

template<class TEngine , size_t p, size_t r>

void std::discard_block_engine< TEngine, p, r >::seed ( )

inline

                    {
            m_e.seed();
            m_n = 0;
        }

Dokumentation der Datenelemente

block_size

template<class TEngine , size_t p, size_t r>

const size_t std::discard_block_engine< TEngine, p, r >::block_size = p

static

used_block

template<class TEngine , size_t p, size_t r>

const size_t std::discard_block_engine< TEngine, p, r >::used_block = r

static

---

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

• include/hash/discard_block_engine.hpp