everett::replacement_rebuild_engine< P, A, DepthLimit, Family > Struct Template Reference

#include <replacement_rebuild.h>

Classes
struct	mutation
struct	rebuild

Public Types
using	policy_type = P
using	sort_type = typed_detail::default_sort_t< P >
using	semantics = sort_semantics< sort_type >
using	key_type = typed_detail::key_t< sort_type >
using	state_type = typed_detail::state_t< sort_type >
using	arrow_type = typed_detail::arrow_t< sort_type >
using	engine_type = typed_engine< P, A, DepthLimit, Family >
using	runtime_type = typename engine_type::runtime_type
using	runtime_family = Family
using	metadata_type = replacement_metadata< A >
using	typed_world_type = typename engine_type::world_type
using	world_type = replacement_world< P, A, Family >
using	contribution_type = typename engine_type::contribution_type
using	scan_type = typed_scan< sort_type, typed_world_type >

Public Member Functions
	replacement_rebuild_engine ()
	replacement_rebuild_engine (std::string schema)
	replacement_rebuild_engine (replacement_rebuild_engine const &)=delete
replacement_rebuild_engine &	operator= (replacement_rebuild_engine const &)=delete
	replacement_rebuild_engine (replacement_rebuild_engine &&) noexcept=default
replacement_rebuild_engine &	operator= (replacement_rebuild_engine &&) noexcept=default
world_type	snapshot () const
bool	failed () const noexcept
void	poison () noexcept
auto	storage () const
void	rebase (world_type state)
bool	pending () const noexcept
bool	admission_ready () const noexcept
replacement_rebuild_work	work () const noexcept
replacement_rebuild_status	status () const
world_type	contribute (contribution_type input)
std::optional< world_type >	advance (std::uint64_t budget)

Static Public Member Functions
static replacement_rebuild_engine	from_clean (typed_world_type source)
static replacement_rebuild_engine	from_snapshot (world_type source)
template<class Storage > requires requires { engine_type::from_snapshot(source, std::move(storage)); }
static replacement_rebuild_engine	from_clean (typed_world_type source, Storage storage)
template<class Storage > requires requires { engine_type::from_snapshot(source, std::move(storage)); }
static replacement_rebuild_engine	from_snapshot (world_type source, Storage storage)
static auto	batch ()
template<class S = sort_type> requires std::same_as<S, sort_type>
static contribution_type	put (key_type const &key, state_type const &value)
template<class S = sort_type> requires std::same_as<S, sort_type>
static contribution_type	erase (key_type const &key)
template<class S = sort_type> requires std::same_as<S, sort_type>
static contribution_type	change (key_type const &key, arrow_type const &arrow)
static std::uint64_t	reservation_work (std::uint64_t records)
static session_reservation	reservation (contribution_type const &input)

Static Public Attributes
static constexpr bool	charged_service = engine_type::charged_service
static constexpr std::uint64_t	small_limit = 64
static constexpr std::uint64_t	tiny_record_limit = 256

Private Member Functions
	replacement_rebuild_engine (world_type value)
template<class Storage >
	replacement_rebuild_engine (world_type value, Storage storage)
void	initialize_restore ()
world_type	publication () const
void	active () const
void	writable () const
void	foreground_advance (std::uint64_t budget)
void	apply (mutation entry)
void	start (bool small)
void	grant (std::uint64_t amount)
std::uint64_t	price () const
void	candidate_work (auto &&operation)
template<class Source >
auto	convert_tiny (Source const &source)
void	tiny_rebuild ()

Static Private Member Functions
static contribution_type	command (mutation const &entry)
static std::uint64_t	mass (typed_world_type const &state)
static std::uint64_t	add (std::uint64_t a, std::uint64_t b)
static std::uint64_t	mul (std::uint64_t a, std::uint64_t b)
static std::uint64_t	ceil (std::uint64_t a, std::uint64_t b)
static void	require (bool value, char const *message)
static arrow_type	clean (key_type const &key, state_type const &state)
static std::uint64_t	action_bound (std::uint64_t height)
static std::uint64_t	tiny_conversion_bound ()

Private Attributes
std::unique_ptr< engine_type >	foreground_
world_type	published_
std::unique_ptr< rebuild >	job_
std::uint64_t	base_ = 0
std::uint64_t	mutations_ = 0
replacement_rebuild_work	work_
bool	failed_ = false
bool	recovering_ = false

Member Typedef Documentation

arrow_type

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

using everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::arrow_type = typed_detail::arrow_t<sort_type>

contribution_type

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

using everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::contribution_type = typename engine_type::contribution_type

engine_type

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

using everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::engine_type = typed_engine<P, A, DepthLimit, Family>

key_type

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

using everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::key_type = typed_detail::key_t<sort_type>

metadata_type

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

using everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::metadata_type = replacement_metadata<A>

policy_type

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

using everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::policy_type = P

runtime_family

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

using everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::runtime_family = Family

runtime_type

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

using everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::runtime_type = typename engine_type::runtime_type

scan_type

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

using everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::scan_type = typed_scan<sort_type, typed_world_type>

semantics

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

using everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::semantics = sort_semantics<sort_type>

sort_type

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

using everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::sort_type = typed_detail::default_sort_t<P>

state_type

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

using everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::state_type = typed_detail::state_t<sort_type>

typed_world_type

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

using everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::typed_world_type = typename engine_type::world_type

world_type

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

using everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::world_type = replacement_world<P, A, Family>

Constructor & Destructor Documentation

replacement_rebuild_engine() [1/6]

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::replacement_rebuild_engine ( )

inline

replacement_rebuild_engine() [2/6]

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::replacement_rebuild_engine ( std::string  schema )

inlineexplicit

replacement_rebuild_engine() [3/6]

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::replacement_rebuild_engine ( replacement_rebuild_engine< P, A, DepthLimit, Family > const &  )

delete

replacement_rebuild_engine() [4/6]

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::replacement_rebuild_engine ( replacement_rebuild_engine< P, A, DepthLimit, Family > &&  )

defaultnoexcept

replacement_rebuild_engine() [5/6]

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::replacement_rebuild_engine ( world_type  value )

inlineexplicitprivate

replacement_rebuild_engine() [6/6]

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

template<class Storage >

everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::replacement_rebuild_engine ( world_type  value, Storage  storage  )

inlineprivate

Member Function Documentation

action_bound()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

static std::uint64_t everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::action_bound ( std::uint64_t  height )

inlinestaticprivate

active()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

void everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::active ( ) const

inlineprivate

add()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

static std::uint64_t everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::add ( std::uint64_t  a, std::uint64_t  b  )

inlinestaticprivate

admission_ready()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

bool everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::admission_ready ( ) const

inlinenoexcept

advance()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

std::optional< world_type > everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::advance ( std::uint64_t  budget )

inline

apply()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

void everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::apply ( mutation  entry )

inlineprivate

batch()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

static auto everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::batch ( )

inlinestatic

candidate_work()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

void everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::candidate_work ( auto &&  operation )

inlineprivate

ceil()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

static std::uint64_t everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::ceil ( std::uint64_t  a, std::uint64_t  b  )

inlinestaticprivate

change()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

template<class S = sort_type>
requires std::same_as<S, sort_type>

static contribution_type everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::change ( key_type const &  key, arrow_type const &  arrow  )

inlinestatic

clean()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

static arrow_type everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::clean ( key_type const &  key, state_type const &  state  )

inlinestaticprivate

command()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

static contribution_type everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::command ( mutation const &  entry )

inlinestaticprivate

contribute()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

world_type everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::contribute ( contribution_type  input )

inline

convert_tiny()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

template<class Source >

auto everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::convert_tiny ( Source const &  source )

inlineprivate

erase()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

template<class S = sort_type>
requires std::same_as<S, sort_type>

static contribution_type everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::erase ( key_type const &  key )

inlinestatic

failed()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

bool everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::failed ( ) const

inlinenoexcept

foreground_advance()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

void everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::foreground_advance ( std::uint64_t  budget )

inlineprivate

from_clean() [1/2]

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

static replacement_rebuild_engine everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::from_clean ( typed_world_type  source )

inlinestatic

from_clean() [2/2]

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

template<class Storage >
requires requires { engine_type::from_snapshot(source, std::move(storage)); }

static replacement_rebuild_engine everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::from_clean ( typed_world_type  source, Storage  storage  )

inlinestatic

from_snapshot() [1/2]

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

static replacement_rebuild_engine everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::from_snapshot ( world_type  source )

inlinestatic

from_snapshot() [2/2]

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

template<class Storage >
requires requires { engine_type::from_snapshot(source, std::move(storage)); }

static replacement_rebuild_engine everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::from_snapshot ( world_type  source, Storage  storage  )

inlinestatic

grant()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

void everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::grant ( std::uint64_t  amount )

inlineprivate

initialize_restore()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

void everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::initialize_restore ( )

inlineprivate

mass()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

static std::uint64_t everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::mass ( typed_world_type const &  state )

inlinestaticprivate

mul()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

static std::uint64_t everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::mul ( std::uint64_t  a, std::uint64_t  b  )

inlinestaticprivate

operator=() [1/2]

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

replacement_rebuild_engine & everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::operator= ( replacement_rebuild_engine< P, A, DepthLimit, Family > &&  )

defaultnoexcept

operator=() [2/2]

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

replacement_rebuild_engine & everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::operator= ( replacement_rebuild_engine< P, A, DepthLimit, Family > const &  )

delete

pending()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

bool everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::pending ( ) const

inlinenoexcept

poison()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

void everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::poison ( )

inlinenoexcept

price()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

std::uint64_t everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::price ( ) const

inlineprivate

publication()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

world_type everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::publication ( ) const

inlineprivate

put()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

template<class S = sort_type>
requires std::same_as<S, sort_type>

static contribution_type everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::put ( key_type const &  key, state_type const &  value  )

inlinestatic

rebase()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

void everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::rebase ( world_type  state )

inline

require()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

static void everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::require ( bool  value, char const *  message  )

inlinestaticprivate

reservation()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

static session_reservation everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::reservation ( contribution_type const &  input )

inlinestatic

reservation_work()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

static std::uint64_t everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::reservation_work ( std::uint64_t  records )

inlinestatic

snapshot()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

world_type everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::snapshot ( ) const

inline

start()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

void everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::start ( bool  small )

inlineprivate

status()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

replacement_rebuild_status everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::status ( ) const

inline

storage()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

auto everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::storage ( ) const

inline

tiny_conversion_bound()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

static std::uint64_t everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::tiny_conversion_bound ( )

inlinestaticprivate

tiny_rebuild()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

void everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::tiny_rebuild ( )

inlineprivate

work()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

replacement_rebuild_work everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::work ( ) const

inlinenoexcept

writable()

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

void everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::writable ( ) const

inlineprivate

Member Data Documentation

base_

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

std::uint64_t everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::base_ = 0

private

charged_service

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

constexpr bool everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::charged_service = engine_type::charged_service

staticconstexpr

failed_

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

bool everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::failed_ = false

private

foreground_

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

std::unique_ptr<engine_type> everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::foreground_

private

job_

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

std::unique_ptr<rebuild> everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::job_

private

mutations_

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

std::uint64_t everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::mutations_ = 0

private

published_

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

world_type everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::published_

private

recovering_

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

bool everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::recovering_ = false

private

small_limit

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

constexpr std::uint64_t everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::small_limit = 64

staticconstexpr

tiny_record_limit

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

constexpr std::uint64_t everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::tiny_record_limit = 256

staticconstexpr

work_

template<class P = storage_policy<>, class A = wrapping_fingerprint_algebra, std::uint64_t DepthLimit = 256, class Family = redundant_runtime_family<P>>

replacement_rebuild_work everett::replacement_rebuild_engine< P, A, DepthLimit, Family >::work_

private

---

The documentation for this struct was generated from the following file:

• include/everett/replacement_rebuild.h