Dash Core Source Documentation (0.16.0.1)

Find detailed information regarding the Dash Core source code.

immer::detail::rbts::node< T, MemoryPolicy, B, BL > Struct Template Reference

#include <node.hpp>

Classes

union  data_t
 
struct  impl_data_t
 
struct  inner_t
 
struct  leaf_t
 
struct  relaxed_data_t
 

Public Types

enum  kind_t { kind_t::leaf, kind_t::inner }
 
using node_t = node
 
using memory = MemoryPolicy
 
using heap_policy = typename memory::heap
 
using transience = typename memory::transience_t
 
using refs_t = typename memory::refcount
 
using ownee_t = typename transience::ownee
 
using edit_t = typename transience::edit
 
using value_t = T
 
using relaxed_data_with_meta_t = combine_standard_layout_t< relaxed_data_t, refs_t, ownee_t >
 
using relaxed_data_no_meta_t = combine_standard_layout_t< relaxed_data_t >
 
using relaxed_t = std::conditional_t< embed_relaxed, relaxed_data_no_meta_t, relaxed_data_with_meta_t >
 
using impl_t = combine_standard_layout_t< impl_data_t, refs_t, ownee_t >
 
using heap = typename heap_policy::template optimized< max_sizeof_inner >::type
 

Public Member Functions

kind_t kind () const
 
relaxed_trelaxed ()
 
const relaxed_trelaxed () const
 
node_t ** inner ()
 
T * leaf ()
 
bool can_mutate (edit_t e) const
 
bool can_relax () const
 
relaxed_tensure_mutable_relaxed (edit_t e)
 
relaxed_tensure_mutable_relaxed_e (edit_t e, edit_t ec)
 
relaxed_tensure_mutable_relaxed_n (edit_t e, count_t n)
 
node_tinc ()
 
const node_tinc () const
 
bool dec () const
 
void dec_unsafe () const
 
shift_t compute_shift ()
 
bool check (shift_t shift, size_t size)
 

Static Public Member Functions

static constexpr std::size_t sizeof_packed_leaf_n (count_t count)
 
static constexpr std::size_t sizeof_packed_inner_n (count_t count)
 
static constexpr std::size_t sizeof_packed_relaxed_n (count_t count)
 
static constexpr std::size_t sizeof_packed_inner_r_n (count_t count)
 
static constexpr std::size_t sizeof_inner_n (count_t n)
 
static constexpr std::size_t sizeof_inner_r_n (count_t n)
 
static constexpr std::size_t sizeof_relaxed_n (count_t n)
 
static constexpr std::size_t sizeof_leaf_n (count_t n)
 
static refs_trefs (const relaxed_t *x)
 
static const ownee_townee (const relaxed_t *x)
 
static ownee_townee (relaxed_t *x)
 
static refs_trefs (const node_t *x)
 
static const ownee_townee (const node_t *x)
 
static ownee_townee (node_t *x)
 
static node_tmake_inner_n (count_t n)
 
static node_tmake_inner_e (edit_t e)
 
static node_tmake_inner_r_n (count_t n)
 
static node_tmake_inner_sr_n (count_t n, relaxed_t *r)
 
static node_tmake_inner_r_e (edit_t e)
 
static node_tmake_inner_sr_e (edit_t e, relaxed_t *r)
 
static node_tmake_leaf_n (count_t n)
 
static node_tmake_leaf_e (edit_t e)
 
static node_tmake_inner_n (count_t n, node_t *x)
 
static node_tmake_inner_n (edit_t n, node_t *x)
 
static node_tmake_inner_n (count_t n, node_t *x, node_t *y)
 
static node_tmake_inner_r_n (count_t n, node_t *x)
 
static node_tmake_inner_r_n (count_t n, node_t *x, size_t xs)
 
static node_tmake_inner_r_n (count_t n, node_t *x, node_t *y)
 
static node_tmake_inner_r_n (count_t n, node_t *x, size_t xs, node_t *y)
 
static node_tmake_inner_r_n (count_t n, node_t *x, size_t xs, node_t *y, size_t ys)
 
static node_tmake_inner_r_n (count_t n, node_t *x, size_t xs, node_t *y, size_t ys, node_t *z, size_t zs)
 
template<typename U >
static node_tmake_leaf_n (count_t n, U &&x)
 
template<typename U >
static node_tmake_leaf_e (edit_t e, U &&x)
 
static node_tmake_path (shift_t shift, node_t *node)
 
static node_tmake_path_e (edit_t e, shift_t shift, node_t *node)
 
static node_tcopy_inner (node_t *src, count_t n)
 
static node_tcopy_inner_n (count_t allocn, node_t *src, count_t n)
 
static node_tcopy_inner_e (edit_t e, node_t *src, count_t n)
 
static node_tdo_copy_inner (node_t *dst, node_t *src, count_t n)
 
static node_tcopy_inner_r (node_t *src, count_t n)
 
static node_tcopy_inner_r_n (count_t allocn, node_t *src, count_t n)
 
static node_tcopy_inner_r_e (edit_t e, node_t *src, count_t n)
 
static node_tcopy_inner_sr_e (edit_t e, node_t *src, count_t n)
 
static node_tdo_copy_inner_r (node_t *dst, node_t *src, count_t n)
 
static node_tdo_copy_inner_sr (node_t *dst, node_t *src, count_t n)
 
static node_tcopy_leaf (node_t *src, count_t n)
 
static node_tcopy_leaf_e (edit_t e, node_t *src, count_t n)
 
static node_tcopy_leaf_n (count_t allocn, node_t *src, count_t n)
 
static node_tcopy_leaf (node_t *src1, count_t n1, node_t *src2, count_t n2)
 
static node_tcopy_leaf_e (edit_t e, node_t *src1, count_t n1, node_t *src2, count_t n2)
 
static node_tcopy_leaf_e (edit_t e, node_t *src, count_t idx, count_t last)
 
static node_tcopy_leaf (node_t *src, count_t idx, count_t last)
 
template<typename U >
static node_tcopy_leaf_emplace (node_t *src, count_t n, U &&x)
 
static void delete_inner (node_t *p, count_t n)
 
static void delete_inner_e (node_t *p)
 
static void delete_inner_any (node_t *p, count_t n)
 
static void delete_inner_r (node_t *p, count_t n)
 
static void delete_inner_r_e (node_t *p)
 
static void delete_leaf (node_t *p, count_t n)
 
static void inc_nodes (node_t **p, count_t n)
 

Public Attributes

impl_t impl
 

Static Public Attributes

static constexpr auto bits = B
 
static constexpr auto bits_leaf = BL
 
static constexpr bool embed_relaxed = memory::prefer_fewer_bigger_objects
 
static constexpr bool keep_headroom = !std::is_empty<refs_t>{}
 
static constexpr std::size_t max_sizeof_leaf
 
static constexpr std::size_t max_sizeof_inner
 
static constexpr std::size_t max_sizeof_relaxed
 
static constexpr std::size_t max_sizeof_inner_r
 

Detailed Description

template<typename T, typename MemoryPolicy, bits_t B, bits_t BL>
struct immer::detail::rbts::node< T, MemoryPolicy, B, BL >

Definition at line 35 of file node.hpp.

Member Typedef Documentation

◆ edit_t

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
using immer::detail::rbts::node< T, MemoryPolicy, B, BL >::edit_t = typename transience::edit

Definition at line 46 of file node.hpp.

◆ heap

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
using immer::detail::rbts::node< T, MemoryPolicy, B, BL >::heap = typename heap_policy::template optimized<max_sizeof_inner>::type

Definition at line 160 of file node.hpp.

◆ heap_policy

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
using immer::detail::rbts::node< T, MemoryPolicy, B, BL >::heap_policy = typename memory::heap

Definition at line 42 of file node.hpp.

◆ impl_t

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
using immer::detail::rbts::node< T, MemoryPolicy, B, BL >::impl_t = combine_standard_layout_t< impl_data_t, refs_t, ownee_t>

Definition at line 101 of file node.hpp.

◆ memory

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
using immer::detail::rbts::node< T, MemoryPolicy, B, BL >::memory = MemoryPolicy

Definition at line 41 of file node.hpp.

◆ node_t

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
using immer::detail::rbts::node< T, MemoryPolicy, B, BL >::node_t = node

Definition at line 40 of file node.hpp.

◆ ownee_t

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
using immer::detail::rbts::node< T, MemoryPolicy, B, BL >::ownee_t = typename transience::ownee

Definition at line 45 of file node.hpp.

◆ refs_t

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
using immer::detail::rbts::node< T, MemoryPolicy, B, BL >::refs_t = typename memory::refcount

Definition at line 44 of file node.hpp.

◆ relaxed_data_no_meta_t

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
using immer::detail::rbts::node< T, MemoryPolicy, B, BL >::relaxed_data_no_meta_t = combine_standard_layout_t<relaxed_data_t>

Definition at line 69 of file node.hpp.

◆ relaxed_data_with_meta_t

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
using immer::detail::rbts::node< T, MemoryPolicy, B, BL >::relaxed_data_with_meta_t = combine_standard_layout_t<relaxed_data_t, refs_t, ownee_t>

Definition at line 66 of file node.hpp.

◆ relaxed_t

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
using immer::detail::rbts::node< T, MemoryPolicy, B, BL >::relaxed_t = std::conditional_t<embed_relaxed, relaxed_data_no_meta_t, relaxed_data_with_meta_t>

Definition at line 73 of file node.hpp.

◆ transience

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
using immer::detail::rbts::node< T, MemoryPolicy, B, BL >::transience = typename memory::transience_t

Definition at line 43 of file node.hpp.

◆ value_t

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
using immer::detail::rbts::node< T, MemoryPolicy, B, BL >::value_t = T

Definition at line 47 of file node.hpp.

Member Enumeration Documentation

◆ kind_t

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
enum immer::detail::rbts::node::kind_t
strong
Enumerator
leaf 
inner 

Definition at line 51 of file node.hpp.

Member Function Documentation

◆ can_mutate()

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
bool immer::detail::rbts::node< T, MemoryPolicy, B, BL >::can_mutate ( edit_t  e) const
inline

◆ can_relax()

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
bool immer::detail::rbts::node< T, MemoryPolicy, B, BL >::can_relax ( ) const
inline

◆ check()

◆ compute_shift()

◆ copy_inner()

◆ copy_inner_e()

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static node_t* immer::detail::rbts::node< T, MemoryPolicy, B, BL >::copy_inner_e ( edit_t  e,
node_t src,
count_t  n 
)
inlinestatic

◆ copy_inner_n()

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static node_t* immer::detail::rbts::node< T, MemoryPolicy, B, BL >::copy_inner_n ( count_t  allocn,
node_t src,
count_t  n 
)
inlinestatic

◆ copy_inner_r()

◆ copy_inner_r_e()

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static node_t* immer::detail::rbts::node< T, MemoryPolicy, B, BL >::copy_inner_r_e ( edit_t  e,
node_t src,
count_t  n 
)
inlinestatic

◆ copy_inner_r_n()

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static node_t* immer::detail::rbts::node< T, MemoryPolicy, B, BL >::copy_inner_r_n ( count_t  allocn,
node_t src,
count_t  n 
)
inlinestatic

◆ copy_inner_sr_e()

◆ copy_leaf() [1/3]

◆ copy_leaf() [2/3]

◆ copy_leaf() [3/3]

◆ copy_leaf_e() [1/3]

◆ copy_leaf_e() [2/3]

◆ copy_leaf_e() [3/3]

◆ copy_leaf_emplace()

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
template<typename U >
static node_t* immer::detail::rbts::node< T, MemoryPolicy, B, BL >::copy_leaf_emplace ( node_t src,
count_t  n,
U &&  x 
)
inlinestatic

◆ copy_leaf_n()

◆ dec()

◆ dec_unsafe()

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
void immer::detail::rbts::node< T, MemoryPolicy, B, BL >::dec_unsafe ( ) const
inline

◆ delete_inner()

◆ delete_inner_any()

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static void immer::detail::rbts::node< T, MemoryPolicy, B, BL >::delete_inner_any ( node_t p,
count_t  n 
)
inlinestatic

◆ delete_inner_e()

◆ delete_inner_r()

◆ delete_inner_r_e()

◆ delete_leaf()

◆ do_copy_inner()

◆ do_copy_inner_r()

◆ do_copy_inner_sr()

◆ ensure_mutable_relaxed()

◆ ensure_mutable_relaxed_e()

◆ ensure_mutable_relaxed_n()

◆ inc() [1/2]

◆ inc() [2/2]

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
const node_t* immer::detail::rbts::node< T, MemoryPolicy, B, BL >::inc ( ) const
inline

◆ inc_nodes()

◆ inner()

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
node_t** immer::detail::rbts::node< T, MemoryPolicy, B, BL >::inner ( )
inline

Definition at line 181 of file node.hpp.

References immer::detail::rbts::node< T, MemoryPolicy, B, BL >::impl, immer::detail::rbts::node< T, MemoryPolicy, B, BL >::inner, and immer::detail::rbts::node< T, MemoryPolicy, B, BL >::kind().

Referenced by immer::detail::rbts::node< T, MemoryPolicy, B, BL >::check(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::compute_shift(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::copy_inner(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::do_copy_inner(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::do_copy_inner_r(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::do_copy_inner_sr(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::make_inner_n(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::make_inner_r_n(), immer::detail::rbts::rbtree< T, MemoryPolicy, B, BL >::push_back(), immer::detail::rbts::rbtree< T, MemoryPolicy, B, BL >::push_back_mut(), immer::detail::rbts::rrbtree< T, MemoryPolicy, B, BL >::push_tail(), immer::detail::rbts::rrbtree< T, MemoryPolicy, B, BL >::push_tail_mut(), immer::detail::rbts::visit_maybe_relaxed_descent(), immer::detail::rbts::update_visitor< NodeT >::visit_regular(), immer::detail::rbts::get_mut_visitor< NodeT >::visit_regular(), immer::detail::rbts::push_tail_mut_visitor< NodeT, Mutating >::visit_regular(), immer::detail::rbts::slice_right_mut_visitor< NodeT, Collapse, Mutating >::visit_regular(), immer::detail::rbts::slice_left_mut_visitor< NodeT, Collapse, Mutating >::visit_regular(), immer::detail::rbts::visit_regular_descent(), immer::detail::rbts::update_visitor< NodeT >::visit_relaxed(), immer::detail::rbts::get_mut_visitor< NodeT >::visit_relaxed(), immer::detail::rbts::push_tail_mut_visitor< NodeT, Mutating >::visit_relaxed(), immer::detail::rbts::slice_right_mut_visitor< NodeT, Collapse, Mutating >::visit_relaxed(), and immer::detail::rbts::slice_left_mut_visitor< NodeT, Collapse, Mutating >::visit_relaxed().

◆ kind()

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
kind_t immer::detail::rbts::node< T, MemoryPolicy, B, BL >::kind ( ) const
inline

Definition at line 163 of file node.hpp.

References immer::detail::rbts::node< T, MemoryPolicy, B, BL >::impl.

Referenced by immer::detail::rbts::node< T, MemoryPolicy, B, BL >::check(), immer::detail::rbts::rbtree< T, MemoryPolicy, B, BL >::check_root(), immer::detail::rbts::rrbtree< T, MemoryPolicy, B, BL >::check_root(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::compute_shift(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::copy_inner(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::copy_inner_e(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::copy_inner_n(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::copy_inner_r(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::copy_inner_r_e(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::copy_inner_r_n(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::copy_inner_sr_e(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::copy_leaf(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::copy_leaf_e(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::copy_leaf_n(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::delete_inner(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::delete_inner_e(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::delete_inner_r(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::delete_inner_r_e(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::delete_leaf(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::do_copy_inner(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::do_copy_inner_r(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::inner(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::leaf(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::make_path(), immer::detail::rbts::node< T, MemoryPolicy, B, BL >::make_path_e(), and immer::detail::rbts::node< T, MemoryPolicy, B, BL >::relaxed().

◆ leaf()

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
T* immer::detail::rbts::node< T, MemoryPolicy, B, BL >::leaf ( )
inline

◆ make_inner_e()

◆ make_inner_n() [1/4]

◆ make_inner_n() [2/4]

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static node_t* immer::detail::rbts::node< T, MemoryPolicy, B, BL >::make_inner_n ( count_t  n,
node_t x 
)
inlinestatic

◆ make_inner_n() [3/4]

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static node_t* immer::detail::rbts::node< T, MemoryPolicy, B, BL >::make_inner_n ( edit_t  n,
node_t x 
)
inlinestatic

◆ make_inner_n() [4/4]

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static node_t* immer::detail::rbts::node< T, MemoryPolicy, B, BL >::make_inner_n ( count_t  n,
node_t x,
node_t y 
)
inlinestatic

◆ make_inner_r_e()

◆ make_inner_r_n() [1/7]

◆ make_inner_r_n() [2/7]

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static node_t* immer::detail::rbts::node< T, MemoryPolicy, B, BL >::make_inner_r_n ( count_t  n,
node_t x 
)
inlinestatic

◆ make_inner_r_n() [3/7]

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static node_t* immer::detail::rbts::node< T, MemoryPolicy, B, BL >::make_inner_r_n ( count_t  n,
node_t x,
size_t  xs 
)
inlinestatic

◆ make_inner_r_n() [4/7]

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static node_t* immer::detail::rbts::node< T, MemoryPolicy, B, BL >::make_inner_r_n ( count_t  n,
node_t x,
node_t y 
)
inlinestatic

◆ make_inner_r_n() [5/7]

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static node_t* immer::detail::rbts::node< T, MemoryPolicy, B, BL >::make_inner_r_n ( count_t  n,
node_t x,
size_t  xs,
node_t y 
)
inlinestatic

◆ make_inner_r_n() [6/7]

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static node_t* immer::detail::rbts::node< T, MemoryPolicy, B, BL >::make_inner_r_n ( count_t  n,
node_t x,
size_t  xs,
node_t y,
size_t  ys 
)
inlinestatic

◆ make_inner_r_n() [7/7]

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static node_t* immer::detail::rbts::node< T, MemoryPolicy, B, BL >::make_inner_r_n ( count_t  n,
node_t x,
size_t  xs,
node_t y,
size_t  ys,
node_t z,
size_t  zs 
)
inlinestatic

◆ make_inner_sr_e()

◆ make_inner_sr_n()

◆ make_leaf_e() [1/2]

◆ make_leaf_e() [2/2]

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
template<typename U >
static node_t* immer::detail::rbts::node< T, MemoryPolicy, B, BL >::make_leaf_e ( edit_t  e,
U &&  x 
)
inlinestatic

◆ make_leaf_n() [1/2]

◆ make_leaf_n() [2/2]

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
template<typename U >
static node_t* immer::detail::rbts::node< T, MemoryPolicy, B, BL >::make_leaf_n ( count_t  n,
U &&  x 
)
inlinestatic

◆ make_path()

◆ make_path_e()

◆ ownee() [1/4]

◆ ownee() [2/4]

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static ownee_t& immer::detail::rbts::node< T, MemoryPolicy, B, BL >::ownee ( relaxed_t x)
inlinestatic

Definition at line 195 of file node.hpp.

◆ ownee() [3/4]

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static const ownee_t& immer::detail::rbts::node< T, MemoryPolicy, B, BL >::ownee ( const node_t x)
inlinestatic

◆ ownee() [4/4]

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static ownee_t& immer::detail::rbts::node< T, MemoryPolicy, B, BL >::ownee ( node_t x)
inlinestatic

◆ refs() [1/2]

◆ refs() [2/2]

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static refs_t& immer::detail::rbts::node< T, MemoryPolicy, B, BL >::refs ( const node_t x)
inlinestatic

◆ relaxed() [1/2]

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
relaxed_t* immer::detail::rbts::node< T, MemoryPolicy, B, BL >::relaxed ( )
inline

◆ relaxed() [2/2]

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
const relaxed_t* immer::detail::rbts::node< T, MemoryPolicy, B, BL >::relaxed ( ) const
inline

◆ sizeof_inner_n()

◆ sizeof_inner_r_n()

◆ sizeof_leaf_n()

◆ sizeof_packed_inner_n()

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static constexpr std::size_t immer::detail::rbts::node< T, MemoryPolicy, B, BL >::sizeof_packed_inner_n ( count_t  count)
inlinestatic

◆ sizeof_packed_inner_r_n()

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static constexpr std::size_t immer::detail::rbts::node< T, MemoryPolicy, B, BL >::sizeof_packed_inner_r_n ( count_t  count)
inlinestatic

◆ sizeof_packed_leaf_n()

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static constexpr std::size_t immer::detail::rbts::node< T, MemoryPolicy, B, BL >::sizeof_packed_leaf_n ( count_t  count)
inlinestatic

◆ sizeof_packed_relaxed_n()

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
static constexpr std::size_t immer::detail::rbts::node< T, MemoryPolicy, B, BL >::sizeof_packed_relaxed_n ( count_t  count)
inlinestatic

◆ sizeof_relaxed_n()

Member Data Documentation

◆ bits

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
constexpr auto immer::detail::rbts::node< T, MemoryPolicy, B, BL >::bits = B
static

Definition at line 37 of file node.hpp.

◆ bits_leaf

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
constexpr auto immer::detail::rbts::node< T, MemoryPolicy, B, BL >::bits_leaf = BL
static

Definition at line 38 of file node.hpp.

◆ embed_relaxed

◆ impl

◆ keep_headroom

◆ max_sizeof_inner

◆ max_sizeof_inner_r

◆ max_sizeof_leaf

template<typename T , typename MemoryPolicy , bits_t B, bits_t BL>
constexpr std::size_t immer::detail::rbts::node< T, MemoryPolicy, B, BL >::max_sizeof_leaf
static

◆ max_sizeof_relaxed


The documentation for this struct was generated from the following file:
Released under the MIT license