Everett: everett::persistent_engine< Core, Ids > Struct Template Reference

Everett

Loading...

Searching...

No Matches

#include <connection.h>

Classes
struct	contribution_type

struct	prepared_transaction

Public Types
using	core_type = Core

using	family_type = typename Core::runtime_family

using	policy_type = typename Core::policy_type

using	typed_world_type = typename Core::world_type

using	world_type = stored_world< typed_world_type >

using	ordinary_contribution = typename Core::contribution_type

using	metadata_type = typename Core::metadata_type

using	store_type = runtime_store< policy_type, Ids, sqlite_catalog_ops, typename Core::runtime_family >

Public Member Functions
	persistent_engine (persistent_engine const &)=delete

persistent_engine &	operator= (persistent_engine const &)=delete

	persistent_engine (persistent_engine &&) noexcept(std::is_nothrow_move_constructible_v< store_type > &&std::is_nothrow_move_constructible_v< Core > &&std::is_nothrow_move_constructible_v< world_type >)=default

persistent_engine &	operator= (persistent_engine &&)=delete

world_type	snapshot () const

bool	failed () const noexcept

bool	pending () const noexcept

bool	admission_ready () const noexcept

std::string const &	last_operation () const noexcept

world_type	contribute (contribution_type input)

world_type	contribute_ordinary (ordinary_contribution input)

std::optional< world_type >	advance (std::uint64_t budget)

Static Public Member Functions
static persistent_engine	connect (std::filesystem::path const &root, std::string_view name, connection_options const &options={}, Ids ids={})

template<class C > requires std::same_as<std::remove_cvref_t<C>, ordinary_contribution> && std::constructible_from<ordinary_contribution, C &&>
static contribution_type	borrow_contribution (C &&input)

static session_reservation	reservation (contribution_type const &input)

Private Member Functions
	persistent_engine (store_type store, Core core, world_type current, std::string schema)

world_type	publish (typed_world_type updated, bool mutation)

world_type	install (prepared_transaction input)

void	remember_failure () noexcept

void	require_active () const

void	poison () noexcept

Static Private Member Functions
static store_type	open_store (std::filesystem::path const &root, bool create, Ids ids)

static world_type	restore (typename store_type::stored_type saved, std::string_view schema, std::shared_ptr< connection_detail::logical_state const > logical=std::make_shared< connection_detail::logical_state >())

Private Attributes
store_type	store_

std::shared_ptr< private_construction< policy_type > >	core_scope_

std::unique_ptr< Core >	core_

world_type	current_

std::string	schema_

std::exception_ptr	catalog_failure_

bool	failed_ = false

Member Typedef Documentation

◆ core_type

template<class Core = active_engine<>, class Ids = random_object_ids>

using everett::persistent_engine< Core, Ids >::core_type = Core

◆ family_type

template<class Core = active_engine<>, class Ids = random_object_ids>

using everett::persistent_engine< Core, Ids >::family_type = typename Core::runtime_family

◆ metadata_type

template<class Core = active_engine<>, class Ids = random_object_ids>

using everett::persistent_engine< Core, Ids >::metadata_type = typename Core::metadata_type

◆ ordinary_contribution

template<class Core = active_engine<>, class Ids = random_object_ids>

using everett::persistent_engine< Core, Ids >::ordinary_contribution = typename Core::contribution_type

◆ policy_type

template<class Core = active_engine<>, class Ids = random_object_ids>

using everett::persistent_engine< Core, Ids >::policy_type = typename Core::policy_type

◆ store_type

template<class Core = active_engine<>, class Ids = random_object_ids>

using everett::persistent_engine< Core, Ids >::store_type = runtime_store<policy_type, Ids, sqlite_catalog_ops, typename Core::runtime_family>

◆ typed_world_type

template<class Core = active_engine<>, class Ids = random_object_ids>

using everett::persistent_engine< Core, Ids >::typed_world_type = typename Core::world_type

◆ world_type

template<class Core = active_engine<>, class Ids = random_object_ids>

using everett::persistent_engine< Core, Ids >::world_type = stored_world<typed_world_type>

Constructor & Destructor Documentation

◆ persistent_engine() [1/3]

template<class Core = active_engine<>, class Ids = random_object_ids>

everett::persistent_engine< Core, Ids >::persistent_engine ( persistent_engine< Core, Ids > const & )

delete

◆ persistent_engine() [2/3]

template<class Core = active_engine<>, class Ids = random_object_ids>

everett::persistent_engine< Core, Ids >::persistent_engine ( persistent_engine< Core, Ids > && ) const &&

defaultnoexcept

◆ persistent_engine() [3/3]

template<class Core = active_engine<>, class Ids = random_object_ids>

everett::persistent_engine< Core, Ids >::persistent_engine	(	store_type	store,
		Core	core,
		world_type	current,
		std::string	schema
	)

inlineprivate

Member Function Documentation

◆ admission_ready()

template<class Core = active_engine<>, class Ids = random_object_ids>

bool everett::persistent_engine< Core, Ids >::admission_ready ( ) const

inlinenoexcept

◆ advance()

template<class Core = active_engine<>, class Ids = random_object_ids>

std::optional< world_type > everett::persistent_engine< Core, Ids >::advance ( std::uint64_t budget )

inline

◆ borrow_contribution()

template<class Core = active_engine<>, class Ids = random_object_ids>

template<class C >
requires std::same_as<std::remove_cvref_t<C>, ordinary_contribution> && std::constructible_from<ordinary_contribution, C &&>

static contribution_type everett::persistent_engine< Core, Ids >::borrow_contribution ( C && input )

inlinestatic

◆ connect()

template<class Core = active_engine<>, class Ids = random_object_ids>

static persistent_engine everett::persistent_engine< Core, Ids >::connect	(	std::filesystem::path const &	root,
		std::string_view	name,
		connection_options const &	options = `{}`,
		Ids	ids = `{}`
	)

inlinestatic

◆ contribute()

template<class Core = active_engine<>, class Ids = random_object_ids>

world_type everett::persistent_engine< Core, Ids >::contribute ( contribution_type input )

inline

◆ contribute_ordinary()

template<class Core = active_engine<>, class Ids = random_object_ids>

world_type everett::persistent_engine< Core, Ids >::contribute_ordinary ( ordinary_contribution input )

inline

◆ failed()

template<class Core = active_engine<>, class Ids = random_object_ids>

bool everett::persistent_engine< Core, Ids >::failed ( ) const

inlinenoexcept

◆ install()

template<class Core = active_engine<>, class Ids = random_object_ids>

world_type everett::persistent_engine< Core, Ids >::install ( prepared_transaction input )

inlineprivate

◆ last_operation()

template<class Core = active_engine<>, class Ids = random_object_ids>

std::string const & everett::persistent_engine< Core, Ids >::last_operation ( ) const

inlinenoexcept

◆ open_store()

template<class Core = active_engine<>, class Ids = random_object_ids>

static store_type everett::persistent_engine< Core, Ids >::open_store	(	std::filesystem::path const &	root,
		bool	create,
		Ids	ids
	)

inlinestaticprivate

◆ operator=() [1/2]

template<class Core = active_engine<>, class Ids = random_object_ids>

persistent_engine & everett::persistent_engine< Core, Ids >::operator= ( persistent_engine< Core, Ids > && )

delete

◆ operator=() [2/2]

template<class Core = active_engine<>, class Ids = random_object_ids>

persistent_engine & everett::persistent_engine< Core, Ids >::operator= ( persistent_engine< Core, Ids > const & )

delete

◆ pending()

template<class Core = active_engine<>, class Ids = random_object_ids>

bool everett::persistent_engine< Core, Ids >::pending ( ) const

inlinenoexcept

◆ poison()

template<class Core = active_engine<>, class Ids = random_object_ids>

void everett::persistent_engine< Core, Ids >::poison ( )

inlineprivatenoexcept

◆ publish()

template<class Core = active_engine<>, class Ids = random_object_ids>

world_type everett::persistent_engine< Core, Ids >::publish	(	typed_world_type	updated,
		bool	mutation
	)

inlineprivate

◆ remember_failure()

template<class Core = active_engine<>, class Ids = random_object_ids>

void everett::persistent_engine< Core, Ids >::remember_failure ( )

inlineprivatenoexcept

◆ require_active()

template<class Core = active_engine<>, class Ids = random_object_ids>

void everett::persistent_engine< Core, Ids >::require_active ( ) const

inlineprivate

◆ reservation()

template<class Core = active_engine<>, class Ids = random_object_ids>

static session_reservation everett::persistent_engine< Core, Ids >::reservation ( contribution_type const & input )

inlinestatic

◆ restore()

template<class Core = active_engine<>, class Ids = random_object_ids>

static world_type everett::persistent_engine< Core, Ids >::restore	(	typename store_type::stored_type	saved,
		std::string_view	schema,
		std::shared_ptr< connection_detail::logical_state const >	logical = `std::make_shared<connection_detail::logical_state>()`
	)

inlinestaticprivate

◆ snapshot()

template<class Core = active_engine<>, class Ids = random_object_ids>

world_type everett::persistent_engine< Core, Ids >::snapshot ( ) const

inline

Member Data Documentation

◆ catalog_failure_

template<class Core = active_engine<>, class Ids = random_object_ids>

std::exception_ptr everett::persistent_engine< Core, Ids >::catalog_failure_

private

◆ core_

template<class Core = active_engine<>, class Ids = random_object_ids>

std::unique_ptr<Core> everett::persistent_engine< Core, Ids >::core_

private

◆ core_scope_

template<class Core = active_engine<>, class Ids = random_object_ids>

std::shared_ptr<private_construction<policy_type> > everett::persistent_engine< Core, Ids >::core_scope_

private

◆ current_

template<class Core = active_engine<>, class Ids = random_object_ids>

world_type everett::persistent_engine< Core, Ids >::current_

private

◆ failed_

template<class Core = active_engine<>, class Ids = random_object_ids>

bool everett::persistent_engine< Core, Ids >::failed_ = false

private

◆ schema_

template<class Core = active_engine<>, class Ids = random_object_ids>

std::string everett::persistent_engine< Core, Ids >::schema_

private

◆ store_

template<class Core = active_engine<>, class Ids = random_object_ids>

store_type everett::persistent_engine< Core, Ids >::store_

private

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

include/everett/connection.h