#include <observed_value.hpp>

Inheritance diagram for Nui::ObservedContainer< ContainerT >:

Collaboration diagram for Nui::ObservedContainer< ContainerT >:

[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>
	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)

	ModifiableObserved (T &&t)

	ModifiableObserved (CustomEventContextFlag_t, EventContext *ctx)

	ModifiableObserved (CustomEventContextFlag_t, EventContext *ctx, T &&t)

ModifiableObserved &	operator= (const ModifiableObserved &)=delete

ModifiableObserved &	operator= (ModifiableObserved &&other)

ModifiableObserved &	operator= (ContainerT const &contained)

ModifiableObserved &	operator= (ContainerT &&contained)

ModifiableObserved &	operator= (T &&t)
	Assign a completely new value. More...

requires std::equality_comparable_with< ContainerT, T > &&Fundamental< T > &&Fundamental< ContainerT > ModifiableObserved &	operator= (T &&t)

	~ModifiableObserved ()=default

requires PlusAssignable< T, U > ModifiableObserved< T > &	operator+= (U const &rhs)

requires MinusAssignable< T, U > ModifiableObserved< T > &	operator-= (U const &rhs)

requires std::equality_comparable_with< ContainerT, T > 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. More...

ModificationProxy	modifyNow ()

	operator bool () const requires std

ContainerT const &	value () const

ContainerT &	operator* ()

ContainerT const &	operator* () const

ContainerT *	operator-> ()

ContainerT const *	operator-> () const

void	assignWithoutUpdate (ContainerT &&t)
	Sets the value without making an update. More...

Public Member Functions inherited from Nui::ObservedBase
	ObservedBase (CustomEventContextFlag_t, EventContext *ctx)

virtual	~ObservedBase ()=default

	ObservedBase (ObservedBase const &)=delete

	ObservedBase (ObservedBase &&other)

ObservedBase &	operator= (ObservedBase const &)=delete

ObservedBase &	operator= (ObservedBase &&other)

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. More...

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 >