Nui
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | Friends | List of all members
Nui::ObservedContainer< ContainerT > Class Template Reference

#include <observed_value.hpp>

Inheritance diagram for Nui::ObservedContainer< ContainerT >:
Inheritance graph
[legend]
Collaboration diagram for Nui::ObservedContainer< ContainerT >:
Collaboration graph
[legend]

Public Types

using value_type = typename ContainerT::value_type
 
using allocator_type = typename ContainerT::allocator_type
 
using size_type = typename ContainerT::size_type
 
using difference_type = typename ContainerT::difference_type
 
using reference = ContainerWrapUtility::ReferenceWrapper< typename ContainerT::value_type, ContainerT >
 
using const_reference = typename ContainerT::const_reference
 
using pointer = ContainerWrapUtility::PointerWrapper< typename ContainerT::value_type, ContainerT >
 
using const_pointer = typename ContainerT::const_pointer
 
using iterator = ContainerWrapUtility::IteratorWrapper< typename ContainerT::iterator, ContainerT >
 
using const_iterator = typename ContainerT::const_iterator
 
using reverse_iterator = ContainerWrapUtility::IteratorWrapper< typename ContainerT::reverse_iterator, ContainerT >
 
using const_reverse_iterator = typename ContainerT::const_reverse_iterator
 
- Public Types inherited from Nui::ModifiableObserved< ContainerT >
using value_type = ContainerT
 

Public Member Functions

 ObservedContainer (CustomEventContextFlag_t, EventContext *ctx)
 
 ObservedContainer ()
 
template<typename T = ContainerT>
 ObservedContainer (CustomEventContextFlag_t, EventContext *ctx, T &&t)
 
template<typename T = ContainerT>
requires std::constructible_from<ContainerT, T>
 ObservedContainer (T &&t)
 
 ObservedContainer (RangeEventContext &&rangeContext)
 
 ObservedContainer (CustomEventContextFlag_t, EventContext *ctx, RangeEventContext &&rangeContext)
 
template<typename T = ContainerT>
 ObservedContainer (T &&t, RangeEventContext &&rangeContext)
 
template<typename T = ContainerT>
 ObservedContainer (CustomEventContextFlag_t, EventContext *ctx, T &&t, RangeEventContext &&rangeContext)
 
 ObservedContainer (const ObservedContainer &)=delete
 
 ObservedContainer (ObservedContainer &&)=default
 
ObservedContainer & operator= (const ObservedContainer &)=delete
 
ObservedContainer & operator= (ObservedContainer &&)=default
 
 ~ObservedContainer ()
 
constexpr auto map (auto &&function) const
 
constexpr auto map (auto &&function)
 
template<typename T = ContainerT>
ObservedContainer & operator= (T &&t)
 
void assign (size_type count, const value_type &value)
 
template<typename Iterator >
void assign (Iterator first, Iterator last)
 
void assign (std::initializer_list< value_type > ilist)
 
reference front ()
 
const_reference front () const
 
reference back ()
 
const_reference back () const
 
pointer data () noexcept
 
const_pointer data () const noexcept
 
reference at (size_type pos)
 
const_reference at (size_type pos) const
 
reference operator[] (size_type pos)
 
const_reference operator[] (size_type pos) const
 
iterator begin () noexcept
 
const_iterator begin () const noexcept
 
iterator end () noexcept
 
const_iterator end () const noexcept
 
const_iterator cbegin () const noexcept
 
const_iterator cend () const noexcept
 
reverse_iterator rbegin () noexcept
 
const_reverse_iterator rbegin () const noexcept
 
reverse_iterator rend () noexcept
 
const_reverse_iterator rend () const noexcept
 
const_reverse_iterator crbegin () const noexcept
 
const_reverse_iterator crend () const noexcept
 
bool empty () const noexcept
 
std::size_t size () const noexcept
 
template<typename U = ContainerT>
Detail::PickFirst_t< std::size_t, decltype(std::declval< U >().max_size())> max_size () const noexcept
 
template<typename U = ContainerT>
Detail::PickFirst_t< void, decltype(std::declval< U >().reserve(std::declval< std::size_t >()))> reserve (size_type capacity)
 
template<typename U = ContainerT>
Detail::PickFirst_t< std::size_t, decltype(std::declval< U >().capacity())> capacity () const noexcept
 
template<typename U = ContainerT>
Detail::PickFirst_t< void, decltype(std::declval< U >().shrink_to_fit())> shrink_to_fit ()
 
void clear ()
 
template<typename U = ContainerT>
Detail::PickFirst_t< std::pair< typename ContainerT::iterator, bool >, decltype(std::declval< U >().insert(std::declval< const value_type & >()))> insert (const value_type &value)
 
template<typename U = ContainerT>
Detail::PickFirst_t< std::pair< typename ContainerT::iterator, bool >, decltype(std::declval< U >().insert(std::declval< value_type && >()))> insert (value_type &&value)
 
iterator insert (iterator pos, const value_type &value)
 
iterator insert (const_iterator pos, const value_type &value)
 
iterator insert (iterator pos, value_type &&value)
 
iterator insert (const_iterator pos, value_type &&value)
 
iterator insert (iterator pos, size_type count, const value_type &value)
 
iterator insert (const_iterator pos, size_type count, const value_type &value)
 
template<typename Iterator >
iterator insert (iterator pos, Iterator first, Iterator last)
 
template<typename Iterator >
iterator insert (const_iterator pos, Iterator first, Iterator last)
 
iterator insert (iterator pos, std::initializer_list< value_type > ilist)
 
iterator insert (const_iterator pos, std::initializer_list< value_type > ilist)
 
template<typename... Args>
iterator emplace (const_iterator pos, Args &&... args)
 
iterator erase (iterator pos)
 
iterator erase (const_iterator pos)
 
iterator erase (iterator first, iterator last)
 
iterator erase (const_iterator first, const_iterator last)
 
template<typename U = ContainerT>
Detail::PickFirst_t< void, decltype(std::declval< U >().push_back(std::declval< const value_type & >()))> push_back (const value_type &value)
 
template<typename U = ContainerT>
Detail::PickFirst_t< void, decltype(std::declval< U >().push_back(std::declval< value_type >()))> push_back (value_type &&value)
 
template<typename U = ContainerT>
Detail::PickFirst_t< void, decltype(std::declval< U >().push_front(std::declval< const value_type & >()))> push_front (const value_type &value)
 
template<typename U = ContainerT>
Detail::PickFirst_t< void, decltype(std::declval< U >().push_front(std::declval< value_type >()))> push_front (value_type &&value)
 
template<typename... Args>
void emplace_back (Args &&... args)
 
template<typename U = ContainerT, typename... Args>
Detail::PickFirst_t< void, decltype(std::declval< U >().emplace_front())> emplace_front (Args &&... args)
 
void pop_back ()
 
template<typename U = ContainerT>
Detail::PickFirst_t< void, decltype(std::declval< U >().pop_front())> pop_front ()
 
template<typename U = ContainerT>
Detail::PickFirst_t< void, decltype(std::declval< U >().resize(std::declval< std::size_t >()))> resize (size_type count)
 
template<typename U = ContainerT>
Detail::PickFirst_t< void, decltype(std::declval< U >().resize(std::declval< std::size_t >(), std::declval< value_type const & >()))> resize (size_type count, value_type const &fillValue)
 
void swap (ContainerT &other)
 
ContainerT & value ()
 
ContainerT const & value () const
 
RangeEventContext & rangeContext ()
 
RangeEventContext const & rangeContext () const
 
- Public Member Functions inherited from Nui::ModifiableObserved< ContainerT >
 ModifiableObserved ()
 
 ModifiableObserved (const ModifiableObserved &)=delete
 
 ModifiableObserved (ModifiableObserved &&other) noexcept
 
 ModifiableObserved (T &&t)
 
 ModifiableObserved (CustomEventContextFlag_t, EventContext *ctx)
 
 ModifiableObserved (CustomEventContextFlag_t, EventContext *ctx, T &&t)
 
ModifiableObserved & operator= (const ModifiableObserved &)=delete
 
ModifiableObserved & operator= (ModifiableObserved &&other) noexcept
 
ModifiableObserved & operator= (ContainerT const &contained)
 
ModifiableObserved & operator= (ContainerT &&contained)
 
ModifiableObserved & operator= (T &&t)
 Assign a completely new value.
 
ModifiableObserved & operator= (T &&t)
 
 ~ModifiableObserved () override=default
 
ModifiableObserved< T > & operator+= (U const &rhs)
 
ModifiableObserved< T > & operator-= (U const &rhs)
 
ModifiableObserved & assignChecked (T &&other)
 
ModificationProxy modify ()
 Can be used to make mutations to the underlying class that get commited when the returned proxy is destroyed.
 
ModificationProxy modifyNow ()
 
 operator bool () const
 
ContainerT & value ()
 
ContainerT const & value () const
 
ContainerT & operator* ()
 
ContainerT const & operator* () const
 
ContainerT * operator-> ()
 
ContainerT const * operator-> () const
 
void assignWithoutUpdate (T &&t)
 Sets the value without making an update.
 
- Public Member Functions inherited from Nui::ObservedBase
 ObservedBase (CustomEventContextFlag_t, EventContext *ctx)
 
virtual ~ObservedBase ()=default
 
 ObservedBase (ObservedBase const &)=delete
 
 ObservedBase (ObservedBase &&other) noexcept
 
ObservedBase & operator= (ObservedBase const &)=delete
 
ObservedBase & operator= (ObservedBase &&other) noexcept
 
void attachEvent (EventContext::EventIdType eventId) const
 
void attachOneshotEvent (EventContext::EventIdType eventId) const
 
void detachEvent (EventContext::EventIdType eventId) const
 
std::size_t attachedEventCount () const
 
std::size_t attachedOneshotEventCount () const
 
std::size_t totalAttachedEventCount () const
 
void detachAllEvents ()
 You should never need to do this.
 
void updateNow (bool force=false) const
 

Protected Member Functions

void update (bool force=false) const override
 
void insertRangeChecked (std::size_t low, std::size_t high, RangeOperationType type)
 
auto registerAfterEffect ()
 
void eraseNotify (std::size_t index, std::size_t high)
 

Protected Attributes

MoveDetector moveDetector_
 
std::shared_ptr< RangeEventContext > rangeContext_
 
EventContext::EventIdType afterEffectId_
 
- Protected Attributes inherited from Nui::ModifiableObserved< ContainerT >
ContainerT contained_
 
- Protected Attributes inherited from Nui::ObservedBase
EventContext * eventContext_
 
std::vector< EventContext::EventIdType > attachedEvents_
 
std::vector< EventContext::EventIdType > attachedOneshotEvents_
 

Friends

class ContainerWrapUtility::ReferenceWrapper< typename ContainerT::value_type, ContainerT >
 
class ContainerWrapUtility::PointerWrapper< typename ContainerT::value_type, ContainerT >
 

Member Typedef Documentation

◆ allocator_type

template<typename ContainerT >
using Nui::ObservedContainer< ContainerT >::allocator_type = typename ContainerT::allocator_type

◆ const_iterator

template<typename ContainerT >
using Nui::ObservedContainer< ContainerT >::const_iterator = typename ContainerT::const_iterator

◆ const_pointer

template<typename ContainerT >
using Nui::ObservedContainer< ContainerT >::const_pointer = typename ContainerT::const_pointer

◆ const_reference

template<typename ContainerT >
using Nui::ObservedContainer< ContainerT >::const_reference = typename ContainerT::const_reference

◆ const_reverse_iterator

template<typename ContainerT >
using Nui::ObservedContainer< ContainerT >::const_reverse_iterator = typename ContainerT::const_reverse_iterator

◆ difference_type

template<typename ContainerT >
using Nui::ObservedContainer< ContainerT >::difference_type = typename ContainerT::difference_type

◆ iterator

template<typename ContainerT >
using Nui::ObservedContainer< ContainerT >::iterator = ContainerWrapUtility::IteratorWrapper<typename ContainerT::iterator, ContainerT>

◆ pointer

template<typename ContainerT >
using Nui::ObservedContainer< ContainerT >::pointer = ContainerWrapUtility::PointerWrapper<typename ContainerT::value_type, ContainerT>

◆ reference

template<typename ContainerT >
using Nui::ObservedContainer< ContainerT >::reference = ContainerWrapUtility::ReferenceWrapper<typename ContainerT::value_type, ContainerT>

◆ reverse_iterator

template<typename ContainerT >
using Nui::ObservedContainer< ContainerT >::reverse_iterator = ContainerWrapUtility::IteratorWrapper<typename ContainerT::reverse_iterator, ContainerT>

◆ size_type

template<typename ContainerT >
using Nui::ObservedContainer< ContainerT >::size_type = typename ContainerT::size_type

◆ value_type

template<typename ContainerT >
using Nui::ObservedContainer< ContainerT >::value_type = typename ContainerT::value_type

Constructor & Destructor Documentation

◆ ObservedContainer() [1/10]

template<typename ContainerT >
Nui::ObservedContainer< ContainerT >::ObservedContainer ( CustomEventContextFlag_t  ,
EventContext *  ctx 
)
inlineexplicit

◆ ObservedContainer() [2/10]

template<typename ContainerT >
Nui::ObservedContainer< ContainerT >::ObservedContainer ( )
inlineexplicit

◆ ObservedContainer() [3/10]

template<typename ContainerT >
template<typename T = ContainerT>
Nui::ObservedContainer< ContainerT >::ObservedContainer ( CustomEventContextFlag_t  ,
EventContext *  ctx,
T &&  t 
)
inlineexplicit

◆ ObservedContainer() [4/10]

template<typename ContainerT >
template<typename T = ContainerT>
requires std::constructible_from<ContainerT, T>
Nui::ObservedContainer< ContainerT >::ObservedContainer ( T &&  t)
inlineexplicit

◆ ObservedContainer() [5/10]

template<typename ContainerT >
Nui::ObservedContainer< ContainerT >::ObservedContainer ( RangeEventContext &&  rangeContext)
inlineexplicit

◆ ObservedContainer() [6/10]

template<typename ContainerT >
Nui::ObservedContainer< ContainerT >::ObservedContainer ( CustomEventContextFlag_t  ,
EventContext *  ctx,
RangeEventContext &&  rangeContext 
)
inlineexplicit

◆ ObservedContainer() [7/10]

template<typename ContainerT >
template<typename T = ContainerT>
Nui::ObservedContainer< ContainerT >::ObservedContainer ( T &&  t,
RangeEventContext &&  rangeContext 
)
inline

◆ ObservedContainer() [8/10]

template<typename ContainerT >
template<typename T = ContainerT>
Nui::ObservedContainer< ContainerT >::ObservedContainer ( CustomEventContextFlag_t  ,
EventContext *  ctx,
T &&  t,
RangeEventContext &&  rangeContext 
)
inline

◆ ObservedContainer() [9/10]

template<typename ContainerT >
Nui::ObservedContainer< ContainerT >::ObservedContainer ( const ObservedContainer< ContainerT > &  )
delete

◆ ObservedContainer() [10/10]

template<typename ContainerT >
Nui::ObservedContainer< ContainerT >::ObservedContainer ( ObservedContainer< ContainerT > &&  )
default

◆ ~ObservedContainer()

template<typename ContainerT >
Nui::ObservedContainer< ContainerT >::~ObservedContainer ( )
inline

Member Function Documentation

◆ assign() [1/3]

template<typename ContainerT >
template<typename Iterator >
void Nui::ObservedContainer< ContainerT >::assign ( Iterator  first,
Iterator  last 
)
inline

◆ assign() [2/3]

template<typename ContainerT >
void Nui::ObservedContainer< ContainerT >::assign ( size_type  count,
const value_type &  value 
)
inline

◆ assign() [3/3]

template<typename ContainerT >
void Nui::ObservedContainer< ContainerT >::assign ( std::initializer_list< value_type >  ilist)
inline

◆ at() [1/2]

template<typename ContainerT >
reference Nui::ObservedContainer< ContainerT >::at ( size_type  pos)
inline

◆ at() [2/2]

template<typename ContainerT >
const_reference Nui::ObservedContainer< ContainerT >::at ( size_type  pos) const
inline

◆ back() [1/2]

template<typename ContainerT >
reference Nui::ObservedContainer< ContainerT >::back ( )
inline

◆ back() [2/2]

template<typename ContainerT >
const_reference Nui::ObservedContainer< ContainerT >::back ( ) const
inline

◆ begin() [1/2]

template<typename ContainerT >
const_iterator Nui::ObservedContainer< ContainerT >::begin ( ) const
inlinenoexcept

◆ begin() [2/2]

template<typename ContainerT >
iterator Nui::ObservedContainer< ContainerT >::begin ( )
inlinenoexcept

◆ capacity()

template<typename ContainerT >
template<typename U = ContainerT>
Detail::PickFirst_t< std::size_t, decltype(std::declval< U >().capacity())> Nui::ObservedContainer< ContainerT >::capacity ( ) const
inlinenoexcept

◆ cbegin()

template<typename ContainerT >
const_iterator Nui::ObservedContainer< ContainerT >::cbegin ( ) const
inlinenoexcept

◆ cend()

template<typename ContainerT >
const_iterator Nui::ObservedContainer< ContainerT >::cend ( ) const
inlinenoexcept

◆ clear()

template<typename ContainerT >
void Nui::ObservedContainer< ContainerT >::clear ( )
inline

◆ crbegin()

template<typename ContainerT >
const_reverse_iterator Nui::ObservedContainer< ContainerT >::crbegin ( ) const
inlinenoexcept

◆ crend()

template<typename ContainerT >
const_reverse_iterator Nui::ObservedContainer< ContainerT >::crend ( ) const
inlinenoexcept

◆ data() [1/2]

template<typename ContainerT >
const_pointer Nui::ObservedContainer< ContainerT >::data ( ) const
inlinenoexcept

◆ data() [2/2]

template<typename ContainerT >
pointer Nui::ObservedContainer< ContainerT >::data ( )
inlinenoexcept

◆ emplace()

template<typename ContainerT >
template<typename... Args>
iterator Nui::ObservedContainer< ContainerT >::emplace ( const_iterator  pos,
Args &&...  args 
)
inline

◆ emplace_back()

template<typename ContainerT >
template<typename... Args>
void Nui::ObservedContainer< ContainerT >::emplace_back ( Args &&...  args)
inline

◆ emplace_front()

template<typename ContainerT >
template<typename U = ContainerT, typename... Args>
Detail::PickFirst_t< void, decltype(std::declval< U >().emplace_front())> Nui::ObservedContainer< ContainerT >::emplace_front ( Args &&...  args)
inline

◆ empty()

template<typename ContainerT >
bool Nui::ObservedContainer< ContainerT >::empty ( ) const
inlinenoexcept

◆ end() [1/2]

template<typename ContainerT >
const_iterator Nui::ObservedContainer< ContainerT >::end ( ) const
inlinenoexcept

◆ end() [2/2]

template<typename ContainerT >
iterator Nui::ObservedContainer< ContainerT >::end ( )
inlinenoexcept

◆ erase() [1/4]

template<typename ContainerT >
iterator Nui::ObservedContainer< ContainerT >::erase ( const_iterator  first,
const_iterator  last 
)
inline

◆ erase() [2/4]

template<typename ContainerT >
iterator Nui::ObservedContainer< ContainerT >::erase ( const_iterator  pos)
inline

◆ erase() [3/4]

template<typename ContainerT >
iterator Nui::ObservedContainer< ContainerT >::erase ( iterator  first,
iterator  last 
)
inline

◆ erase() [4/4]

template<typename ContainerT >
iterator Nui::ObservedContainer< ContainerT >::erase ( iterator  pos)
inline

◆ eraseNotify()

template<typename ContainerT >
void Nui::ObservedContainer< ContainerT >::eraseNotify ( std::size_t  index,
std::size_t  high 
)
inlineprotected

◆ front() [1/2]

template<typename ContainerT >
reference Nui::ObservedContainer< ContainerT >::front ( )
inline

◆ front() [2/2]

template<typename ContainerT >
const_reference Nui::ObservedContainer< ContainerT >::front ( ) const
inline

◆ insert() [1/12]

template<typename ContainerT >
template<typename U = ContainerT>
Detail::PickFirst_t< std::pair< typename ContainerT::iterator, bool >, decltype(std::declval< U >().insert(std::declval< const value_type & >()))> Nui::ObservedContainer< ContainerT >::insert ( const value_type &  value)
inline

◆ insert() [2/12]

template<typename ContainerT >
iterator Nui::ObservedContainer< ContainerT >::insert ( const_iterator  pos,
const value_type &  value 
)
inline

◆ insert() [3/12]

template<typename ContainerT >
template<typename Iterator >
iterator Nui::ObservedContainer< ContainerT >::insert ( const_iterator  pos,
Iterator  first,
Iterator  last 
)
inline

◆ insert() [4/12]

template<typename ContainerT >
iterator Nui::ObservedContainer< ContainerT >::insert ( const_iterator  pos,
size_type  count,
const value_type &  value 
)
inline

◆ insert() [5/12]

template<typename ContainerT >
iterator Nui::ObservedContainer< ContainerT >::insert ( const_iterator  pos,
std::initializer_list< value_type >  ilist 
)
inline

◆ insert() [6/12]

template<typename ContainerT >
iterator Nui::ObservedContainer< ContainerT >::insert ( const_iterator  pos,
value_type &&  value 
)
inline

◆ insert() [7/12]

template<typename ContainerT >
iterator Nui::ObservedContainer< ContainerT >::insert ( iterator  pos,
const value_type &  value 
)
inline

◆ insert() [8/12]

template<typename ContainerT >
template<typename Iterator >
iterator Nui::ObservedContainer< ContainerT >::insert ( iterator  pos,
Iterator  first,
Iterator  last 
)
inline

◆ insert() [9/12]

template<typename ContainerT >
iterator Nui::ObservedContainer< ContainerT >::insert ( iterator  pos,
size_type  count,
const value_type &  value 
)
inline

◆ insert() [10/12]

template<typename ContainerT >
iterator Nui::ObservedContainer< ContainerT >::insert ( iterator  pos,
std::initializer_list< value_type >  ilist 
)
inline

◆ insert() [11/12]

template<typename ContainerT >
iterator Nui::ObservedContainer< ContainerT >::insert ( iterator  pos,
value_type &&  value 
)
inline

◆ insert() [12/12]

template<typename ContainerT >
template<typename U = ContainerT>
Detail::PickFirst_t< std::pair< typename ContainerT::iterator, bool >, decltype(std::declval< U >().insert(std::declval< value_type && >()))> Nui::ObservedContainer< ContainerT >::insert ( value_type &&  value)
inline

◆ insertRangeChecked()

template<typename ContainerT >
void Nui::ObservedContainer< ContainerT >::insertRangeChecked ( std::size_t  low,
std::size_t  high,
RangeOperationType  type 
)
inlineprotected

◆ map() [1/2]

template<typename ContainerT >
constexpr auto Nui::ObservedContainer< ContainerT >::map ( auto &&  function)
constexpr

◆ map() [2/2]

template<typename ContainerT >
constexpr auto Nui::ObservedContainer< ContainerT >::map ( auto &&  function) const
constexpr

◆ max_size()

template<typename ContainerT >
template<typename U = ContainerT>
Detail::PickFirst_t< std::size_t, decltype(std::declval< U >().max_size())> Nui::ObservedContainer< ContainerT >::max_size ( ) const
inlinenoexcept

◆ operator=() [1/3]

template<typename ContainerT >
ObservedContainer & Nui::ObservedContainer< ContainerT >::operator= ( const ObservedContainer< ContainerT > &  )
delete

◆ operator=() [2/3]

template<typename ContainerT >
ObservedContainer & Nui::ObservedContainer< ContainerT >::operator= ( ObservedContainer< ContainerT > &&  )
default

◆ operator=() [3/3]

template<typename ContainerT >
template<typename T = ContainerT>
ObservedContainer & Nui::ObservedContainer< ContainerT >::operator= ( T &&  t)
inline

◆ operator[]() [1/2]

template<typename ContainerT >
reference Nui::ObservedContainer< ContainerT >::operator[] ( size_type  pos)
inline

◆ operator[]() [2/2]

template<typename ContainerT >
const_reference Nui::ObservedContainer< ContainerT >::operator[] ( size_type  pos) const
inline

◆ pop_back()

template<typename ContainerT >
void Nui::ObservedContainer< ContainerT >::pop_back ( )
inline

◆ pop_front()

template<typename ContainerT >
template<typename U = ContainerT>
Detail::PickFirst_t< void, decltype(std::declval< U >().pop_front())> Nui::ObservedContainer< ContainerT >::pop_front ( )
inline

◆ push_back() [1/2]

template<typename ContainerT >
template<typename U = ContainerT>
Detail::PickFirst_t< void, decltype(std::declval< U >().push_back(std::declval< const value_type & >()))> Nui::ObservedContainer< ContainerT >::push_back ( const value_type &  value)
inline

◆ push_back() [2/2]

template<typename ContainerT >
template<typename U = ContainerT>
Detail::PickFirst_t< void, decltype(std::declval< U >().push_back(std::declval< value_type >()))> Nui::ObservedContainer< ContainerT >::push_back ( value_type &&  value)
inline

◆ push_front() [1/2]

template<typename ContainerT >
template<typename U = ContainerT>
Detail::PickFirst_t< void, decltype(std::declval< U >().push_front(std::declval< const value_type & >()))> Nui::ObservedContainer< ContainerT >::push_front ( const value_type &  value)
inline

◆ push_front() [2/2]

template<typename ContainerT >
template<typename U = ContainerT>
Detail::PickFirst_t< void, decltype(std::declval< U >().push_front(std::declval< value_type >()))> Nui::ObservedContainer< ContainerT >::push_front ( value_type &&  value)
inline

◆ rangeContext() [1/2]

template<typename ContainerT >
RangeEventContext & Nui::ObservedContainer< ContainerT >::rangeContext ( )
inline

◆ rangeContext() [2/2]

template<typename ContainerT >
RangeEventContext const & Nui::ObservedContainer< ContainerT >::rangeContext ( ) const
inline

◆ rbegin() [1/2]

template<typename ContainerT >
const_reverse_iterator Nui::ObservedContainer< ContainerT >::rbegin ( ) const
inlinenoexcept

◆ rbegin() [2/2]

template<typename ContainerT >
reverse_iterator Nui::ObservedContainer< ContainerT >::rbegin ( )
inlinenoexcept

◆ registerAfterEffect()

template<typename ContainerT >
auto Nui::ObservedContainer< ContainerT >::registerAfterEffect ( )
inlineprotected

◆ rend() [1/2]

template<typename ContainerT >
const_reverse_iterator Nui::ObservedContainer< ContainerT >::rend ( ) const
inlinenoexcept

◆ rend() [2/2]

template<typename ContainerT >
reverse_iterator Nui::ObservedContainer< ContainerT >::rend ( )
inlinenoexcept

◆ reserve()

template<typename ContainerT >
template<typename U = ContainerT>
Detail::PickFirst_t< void, decltype(std::declval< U >().reserve(std::declval< std::size_t >()))> Nui::ObservedContainer< ContainerT >::reserve ( size_type  capacity)
inline

◆ resize() [1/2]

template<typename ContainerT >
template<typename U = ContainerT>
Detail::PickFirst_t< void, decltype(std::declval< U >().resize(std::declval< std::size_t >()))> Nui::ObservedContainer< ContainerT >::resize ( size_type  count)
inline

◆ resize() [2/2]

template<typename ContainerT >
template<typename U = ContainerT>
Detail::PickFirst_t< void, decltype(std::declval< U >().resize(std::declval< std::size_t >(), std::declval< value_type const & >()))> Nui::ObservedContainer< ContainerT >::resize ( size_type  count,
value_type const &  fillValue 
)
inline

◆ shrink_to_fit()

template<typename ContainerT >
template<typename U = ContainerT>
Detail::PickFirst_t< void, decltype(std::declval< U >().shrink_to_fit())> Nui::ObservedContainer< ContainerT >::shrink_to_fit ( )
inline

◆ size()

template<typename ContainerT >
std::size_t Nui::ObservedContainer< ContainerT >::size ( ) const
inlinenoexcept

◆ swap()

template<typename ContainerT >
void Nui::ObservedContainer< ContainerT >::swap ( ContainerT &  other)
inline

◆ update()

template<typename ContainerT >
void Nui::ObservedContainer< ContainerT >::update ( bool  force = false) const
inlineoverrideprotectedvirtual

Reimplemented from Nui::ObservedBase.

◆ value() [1/2]

template<typename ContainerT >
ContainerT & Nui::ObservedContainer< ContainerT >::value ( )
inline

◆ value() [2/2]

template<typename ContainerT >
ContainerT const & Nui::ObservedContainer< ContainerT >::value ( ) const
inline

Friends And Related Symbol Documentation

◆ ContainerWrapUtility::PointerWrapper< typename ContainerT::value_type, ContainerT >

template<typename ContainerT >
friend class ContainerWrapUtility::PointerWrapper< typename ContainerT::value_type, ContainerT >
friend

◆ ContainerWrapUtility::ReferenceWrapper< typename ContainerT::value_type, ContainerT >

template<typename ContainerT >
friend class ContainerWrapUtility::ReferenceWrapper< typename ContainerT::value_type, ContainerT >
friend

Member Data Documentation

◆ afterEffectId_

template<typename ContainerT >
EventContext::EventIdType Nui::ObservedContainer< ContainerT >::afterEffectId_
mutableprotected

◆ moveDetector_

template<typename ContainerT >
MoveDetector Nui::ObservedContainer< ContainerT >::moveDetector_
protected

◆ rangeContext_

template<typename ContainerT >
std::shared_ptr<RangeEventContext> Nui::ObservedContainer< ContainerT >::rangeContext_
mutableprotected
The documentation for this class was generated from the following files:
Generated by doxygen 1.9.8