everett::session< Engine > Struct Template Reference

#include <session.h>

Classes
struct	identity
struct	logical_state
struct	publication
struct	request
struct	ticket

Public Types
using	world_type = typename Engine::world_type
using	contribution_type = typename Engine::contribution_type
using	snapshot_type = std::shared_ptr< publication const >

Public Member Functions
	session (Engine engine, session_limits limits)
	session (session const &)=delete
session &	operator= (session const &)=delete
	session (session &&)=delete
session &	operator= (session &&)=delete
	~session ()
snapshot_type	snapshot () const noexcept
template<class C > requires (!std::same_as<std::remove_cvref_t<C>, contribution_type>) && requires(C && input) { { Engine::borrow_contribution(std::forward<C>(input)) } -> std::same_as<contribution_type>; }
std::optional< ticket >	try_submit (C &&input)
template<class C > requires (!std::same_as<std::remove_cvref_t<C>, contribution_type>) && requires(C && input) { { Engine::borrow_contribution(std::forward<C>(input)) } -> std::same_as<contribution_type>; }
ticket	submit (C &&input)
template<class C > requires (!std::same_as<std::remove_cvref_t<C>, contribution_type>) && requires(C && input) { { Engine::borrow_contribution(std::forward<C>(input)) } -> std::same_as<contribution_type>; }
snapshot_type	apply (C &&input)
template<class C > requires std::same_as<std::remove_cvref_t<C>, contribution_type>
std::optional< ticket >	try_submit (C &&input)
template<class C > requires std::same_as<std::remove_cvref_t<C>, contribution_type>
ticket	submit (C &&input)
template<class C > requires std::same_as<std::remove_cvref_t<C>, contribution_type>
snapshot_type	apply (C &&input)
bool	cancel (ticket const &value)
session_reservation	outstanding () const
std::uint64_t	pending_count () const
std::exception_ptr	failure () const
void	close ()
void	shutdown ()

Private Member Functions
bool	fits (session_reservation charge) const noexcept
void	available () const
template<class C >
std::optional< ticket >	enqueue (C &&input, bool wait)
void	unreserve (session_reservation charge) noexcept
snapshot_type	next (world_type world, bool contribution) const
void	failed (std::shared_ptr< request > const &active, std::exception_ptr error) noexcept
void	run (bool pending) noexcept

Private Attributes
std::unique_ptr< Engine >	engine_
session_limits	limits_
std::shared_ptr< identity const >	identity_ = std::make_shared<identity const>()
snapshot_type	current_
std::mutex	mutex_
std::mutex	join_mutex_
std::condition_variable	changed_
std::list< std::shared_ptr< request > >	queue_
session_reservation	reserved_
std::uint64_t	count_ = 0
bool	closing_ = false
std::exception_ptr	failure_
std::thread	worker_

Static Private Attributes
static thread_local session const *	worker_session_ = nullptr

Member Typedef Documentation

contribution_type

template<class Engine >

using everett::session< Engine >::contribution_type = typename Engine::contribution_type

snapshot_type

template<class Engine >

using everett::session< Engine >::snapshot_type = std::shared_ptr<publication const>

world_type

template<class Engine >

using everett::session< Engine >::world_type = typename Engine::world_type

Constructor & Destructor Documentation

session() [1/3]

template<class Engine >

everett::session< Engine >::session ( Engine  engine, session_limits  limits  )

inlineexplicit

session() [2/3]

template<class Engine >

everett::session< Engine >::session ( session< Engine > const &  )

delete

session() [3/3]

template<class Engine >

everett::session< Engine >::session ( session< Engine > &&  )

delete

~session()

template<class Engine >

everett::session< Engine >::~session ( )

inline

Member Function Documentation

apply() [1/2]

template<class Engine >

template<class C >
requires (!std::same_as<std::remove_cvref_t<C>, contribution_type>) && requires(C && input) { { Engine::borrow_contribution(std::forward<C>(input)) } -> std::same_as<contribution_type>; }

snapshot_type everett::session< Engine >::apply ( C &&  input )

inline

apply() [2/2]

template<class Engine >

template<class C >
requires std::same_as<std::remove_cvref_t<C>, contribution_type>

snapshot_type everett::session< Engine >::apply ( C &&  input )

inline

available()

template<class Engine >

void everett::session< Engine >::available ( ) const

inlineprivate

cancel()

template<class Engine >

bool everett::session< Engine >::cancel ( ticket const &  value )

inline

close()

template<class Engine >

void everett::session< Engine >::close ( )

inline

enqueue()

template<class Engine >

template<class C >

std::optional< ticket > everett::session< Engine >::enqueue ( C &&  input, bool  wait  )

inlineprivate

failed()

template<class Engine >

void everett::session< Engine >::failed ( std::shared_ptr< request > const &  active, std::exception_ptr  error  )

inlineprivatenoexcept

failure()

template<class Engine >

std::exception_ptr everett::session< Engine >::failure ( ) const

inline

fits()

template<class Engine >

bool everett::session< Engine >::fits ( session_reservation  charge ) const

inlineprivatenoexcept

next()

template<class Engine >

snapshot_type everett::session< Engine >::next ( world_type  world, bool  contribution  ) const

inlineprivate

operator=() [1/2]

template<class Engine >

session & everett::session< Engine >::operator= ( session< Engine > &&  )

delete

operator=() [2/2]

template<class Engine >

session & everett::session< Engine >::operator= ( session< Engine > const &  )

delete

outstanding()

template<class Engine >

session_reservation everett::session< Engine >::outstanding ( ) const

inline

pending_count()

template<class Engine >

std::uint64_t everett::session< Engine >::pending_count ( ) const

inline

run()

template<class Engine >

void everett::session< Engine >::run ( bool  pending )

inlineprivatenoexcept

shutdown()

template<class Engine >

void everett::session< Engine >::shutdown ( )

inline

snapshot()

template<class Engine >

snapshot_type everett::session< Engine >::snapshot ( ) const

inlinenoexcept

submit() [1/2]

template<class Engine >

template<class C >
requires (!std::same_as<std::remove_cvref_t<C>, contribution_type>) && requires(C && input) { { Engine::borrow_contribution(std::forward<C>(input)) } -> std::same_as<contribution_type>; }

ticket everett::session< Engine >::submit ( C &&  input )

inline

submit() [2/2]

template<class Engine >

template<class C >
requires std::same_as<std::remove_cvref_t<C>, contribution_type>

ticket everett::session< Engine >::submit ( C &&  input )

inline

try_submit() [1/2]

template<class Engine >

template<class C >
requires (!std::same_as<std::remove_cvref_t<C>, contribution_type>) && requires(C && input) { { Engine::borrow_contribution(std::forward<C>(input)) } -> std::same_as<contribution_type>; }

std::optional< ticket > everett::session< Engine >::try_submit ( C &&  input )

inline

try_submit() [2/2]

template<class Engine >

template<class C >
requires std::same_as<std::remove_cvref_t<C>, contribution_type>

std::optional< ticket > everett::session< Engine >::try_submit ( C &&  input )

inline

unreserve()

template<class Engine >

void everett::session< Engine >::unreserve ( session_reservation  charge )

inlineprivatenoexcept

Member Data Documentation

changed_

template<class Engine >

std::condition_variable everett::session< Engine >::changed_

private

closing_

template<class Engine >

bool everett::session< Engine >::closing_ = false

private

count_

template<class Engine >

std::uint64_t everett::session< Engine >::count_ = 0

private

current_

template<class Engine >

snapshot_type everett::session< Engine >::current_

private

engine_

template<class Engine >

std::unique_ptr<Engine> everett::session< Engine >::engine_

private

failure_

template<class Engine >

std::exception_ptr everett::session< Engine >::failure_

private

identity_

template<class Engine >

std::shared_ptr<identity const> everett::session< Engine >::identity_ = std::make_shared<identity const>()

private

join_mutex_

template<class Engine >

std::mutex everett::session< Engine >::join_mutex_

private

limits_

template<class Engine >

session_limits everett::session< Engine >::limits_

private

mutex_

template<class Engine >

std::mutex everett::session< Engine >::mutex_

mutableprivate

queue_

template<class Engine >

std::list<std::shared_ptr<request> > everett::session< Engine >::queue_

private

reserved_

template<class Engine >

session_reservation everett::session< Engine >::reserved_

private

worker_

template<class Engine >

std::thread everett::session< Engine >::worker_

private

worker_session_

template<class Engine >

thread_local session const* everett::session< Engine >::worker_session_ = nullptr

inlinestaticprivate

---

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

• include/everett/session.h