everett::nursery_map< Key, Value, Compare > Struct Template Reference

#include <nursery_map.h>

Classes
struct	binding
struct	edit_token
struct	node
struct	snapshot_type
struct	statistics

Public Types
using	key_type = Key
using	mapped_type = Value
using	compare_type = Compare

Public Member Functions
	nursery_map (Compare compare={})
	nursery_map (nursery_map const &)=delete
nursery_map &	operator= (nursery_map const &)=delete
	nursery_map (nursery_map &&other) noexcept
nursery_map &	operator= (nursery_map &&other) noexcept
snapshot_type	freeze ()
Value const *	find (Key const &key) const
std::size_t	size () const
bool	empty () const
template<class F >
void	for_each (F &&visit) const
bool	failed () const noexcept
statistics	work () const noexcept
bool	insert_or_assign (Key key, Value value)
bool	erase (Key const &key)

Static Public Member Functions
static nursery_map	thaw (snapshot_type const &snapshot)

Private Types
using	binding_pointer = std::shared_ptr< binding const >
using	node_pointer = std::shared_ptr< node >

Private Member Functions
	nursery_map (node_pointer root, std::shared_ptr< Compare const > compare, std::size_t size)
void	require_active () const
void	begin_edit ()
void	editable (node_pointer &item)
void	rotate_left (node_pointer &item)
void	rotate_right (node_pointer &item)
void	rebalance (node_pointer &item)
bool	insert (node_pointer &item, Key &key, Value &value)
binding_pointer	remove_first (node_pointer &item)
bool	remove (node_pointer &item, Key const &key)

Static Private Member Functions
static unsigned	height (node_pointer const &item) noexcept
static void	refresh (node_pointer const &item) noexcept
static int	balance (node_pointer const &item) noexcept
static Value const *	find_in (node_pointer const &root, Key const &key, Compare const &compare)
template<class F >
static void	visit_in (node_pointer const &item, F &visit)

Private Attributes
node_pointer	root_
std::shared_ptr< Compare const >	compare_
std::shared_ptr< edit_token >	edit_
std::size_t	size_ = 0
statistics	work_
bool	failed_ = false

Member Typedef Documentation

binding_pointer

template<class Key , class Value , class Compare = std::less<Key>>

using everett::nursery_map< Key, Value, Compare >::binding_pointer = std::shared_ptr<binding const>

private

compare_type

template<class Key , class Value , class Compare = std::less<Key>>

using everett::nursery_map< Key, Value, Compare >::compare_type = Compare

key_type

template<class Key , class Value , class Compare = std::less<Key>>

using everett::nursery_map< Key, Value, Compare >::key_type = Key

mapped_type

template<class Key , class Value , class Compare = std::less<Key>>

using everett::nursery_map< Key, Value, Compare >::mapped_type = Value

node_pointer

template<class Key , class Value , class Compare = std::less<Key>>

using everett::nursery_map< Key, Value, Compare >::node_pointer = std::shared_ptr<node>

private

Constructor & Destructor Documentation

nursery_map() [1/4]

template<class Key , class Value , class Compare = std::less<Key>>

everett::nursery_map< Key, Value, Compare >::nursery_map ( Compare  compare = {} )

inlineexplicit

nursery_map() [2/4]

template<class Key , class Value , class Compare = std::less<Key>>

everett::nursery_map< Key, Value, Compare >::nursery_map ( nursery_map< Key, Value, Compare > const &  )

delete

nursery_map() [3/4]

template<class Key , class Value , class Compare = std::less<Key>>

everett::nursery_map< Key, Value, Compare >::nursery_map ( nursery_map< Key, Value, Compare > &&  other )

inlinenoexcept

nursery_map() [4/4]

template<class Key , class Value , class Compare = std::less<Key>>

everett::nursery_map< Key, Value, Compare >::nursery_map ( node_pointer  root, std::shared_ptr< Compare const >  compare, std::size_t  size  )

inlineprivate

Member Function Documentation

balance()

template<class Key , class Value , class Compare = std::less<Key>>

static int everett::nursery_map< Key, Value, Compare >::balance ( node_pointer const &  item )

inlinestaticprivatenoexcept

begin_edit()

template<class Key , class Value , class Compare = std::less<Key>>

void everett::nursery_map< Key, Value, Compare >::begin_edit ( )

inlineprivate

editable()

template<class Key , class Value , class Compare = std::less<Key>>

void everett::nursery_map< Key, Value, Compare >::editable ( node_pointer &  item )

inlineprivate

empty()

template<class Key , class Value , class Compare = std::less<Key>>

bool everett::nursery_map< Key, Value, Compare >::empty ( ) const

inline

erase()

template<class Key , class Value , class Compare = std::less<Key>>

bool everett::nursery_map< Key, Value, Compare >::erase ( Key const &  key )

inline

failed()

template<class Key , class Value , class Compare = std::less<Key>>

bool everett::nursery_map< Key, Value, Compare >::failed ( ) const

inlinenoexcept

find()

template<class Key , class Value , class Compare = std::less<Key>>

Value const * everett::nursery_map< Key, Value, Compare >::find ( Key const &  key ) const

inline

find_in()

template<class Key , class Value , class Compare = std::less<Key>>

static Value const * everett::nursery_map< Key, Value, Compare >::find_in ( node_pointer const &  root, Key const &  key, Compare const &  compare  )

inlinestaticprivate

for_each()

template<class Key , class Value , class Compare = std::less<Key>>

template<class F >

void everett::nursery_map< Key, Value, Compare >::for_each ( F &&  visit ) const

inline

freeze()

template<class Key , class Value , class Compare = std::less<Key>>

snapshot_type everett::nursery_map< Key, Value, Compare >::freeze ( )

inline

height()

template<class Key , class Value , class Compare = std::less<Key>>

static unsigned everett::nursery_map< Key, Value, Compare >::height ( node_pointer const &  item )

inlinestaticprivatenoexcept

insert()

template<class Key , class Value , class Compare = std::less<Key>>

bool everett::nursery_map< Key, Value, Compare >::insert ( node_pointer &  item, Key &  key, Value &  value  )

inlineprivate

insert_or_assign()

template<class Key , class Value , class Compare = std::less<Key>>

bool everett::nursery_map< Key, Value, Compare >::insert_or_assign ( Key  key, Value  value  )

inline

operator=() [1/2]

template<class Key , class Value , class Compare = std::less<Key>>

nursery_map & everett::nursery_map< Key, Value, Compare >::operator= ( nursery_map< Key, Value, Compare > &&  other )

inlinenoexcept

operator=() [2/2]

template<class Key , class Value , class Compare = std::less<Key>>

nursery_map & everett::nursery_map< Key, Value, Compare >::operator= ( nursery_map< Key, Value, Compare > const &  )

delete

rebalance()

template<class Key , class Value , class Compare = std::less<Key>>

void everett::nursery_map< Key, Value, Compare >::rebalance ( node_pointer &  item )

inlineprivate

refresh()

template<class Key , class Value , class Compare = std::less<Key>>

static void everett::nursery_map< Key, Value, Compare >::refresh ( node_pointer const &  item )

inlinestaticprivatenoexcept

remove()

template<class Key , class Value , class Compare = std::less<Key>>

bool everett::nursery_map< Key, Value, Compare >::remove ( node_pointer &  item, Key const &  key  )

inlineprivate

remove_first()

template<class Key , class Value , class Compare = std::less<Key>>

binding_pointer everett::nursery_map< Key, Value, Compare >::remove_first ( node_pointer &  item )

inlineprivate

require_active()

template<class Key , class Value , class Compare = std::less<Key>>

void everett::nursery_map< Key, Value, Compare >::require_active ( ) const

inlineprivate

rotate_left()

template<class Key , class Value , class Compare = std::less<Key>>

void everett::nursery_map< Key, Value, Compare >::rotate_left ( node_pointer &  item )

inlineprivate

rotate_right()

template<class Key , class Value , class Compare = std::less<Key>>

void everett::nursery_map< Key, Value, Compare >::rotate_right ( node_pointer &  item )

inlineprivate

size()

template<class Key , class Value , class Compare = std::less<Key>>

std::size_t everett::nursery_map< Key, Value, Compare >::size ( ) const

inline

thaw()

template<class Key , class Value , class Compare = std::less<Key>>

static nursery_map everett::nursery_map< Key, Value, Compare >::thaw ( snapshot_type const &  snapshot )

inlinestatic

visit_in()

template<class Key , class Value , class Compare = std::less<Key>>

template<class F >

static void everett::nursery_map< Key, Value, Compare >::visit_in ( node_pointer const &  item, F &  visit  )

inlinestaticprivate

work()

template<class Key , class Value , class Compare = std::less<Key>>

statistics everett::nursery_map< Key, Value, Compare >::work ( ) const

inlinenoexcept

Member Data Documentation

compare_

template<class Key , class Value , class Compare = std::less<Key>>

std::shared_ptr<Compare const> everett::nursery_map< Key, Value, Compare >::compare_

private

edit_

template<class Key , class Value , class Compare = std::less<Key>>

std::shared_ptr<edit_token> everett::nursery_map< Key, Value, Compare >::edit_

private

failed_

template<class Key , class Value , class Compare = std::less<Key>>

bool everett::nursery_map< Key, Value, Compare >::failed_ = false

private

root_

template<class Key , class Value , class Compare = std::less<Key>>

node_pointer everett::nursery_map< Key, Value, Compare >::root_

private

size_

template<class Key , class Value , class Compare = std::less<Key>>

std::size_t everett::nursery_map< Key, Value, Compare >::size_ = 0

private

work_

template<class Key , class Value , class Compare = std::less<Key>>

statistics everett::nursery_map< Key, Value, Compare >::work_

private

---

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

• include/everett/nursery_map.h