Like a Mutual_ptr, except it can accept multiple partners. More...

#include <Mutual_ptr.hpp>

Inheritance diagram for hexed::Multiple_ptr< T, U >:

Public Member Functions
	Multiple_ptr (T *data)
	Constructs a `Multiple_ptr` and permanently associates it with `data`.

	Multiple_ptr (const Multiple_ptr &)=delete
	Cannot copy a `Multiple_ptr` because it is unclear what that should do to partners.

Multiple_ptr &	operator= (const Multiple_ptr &)=delete

	Multiple_ptr (Multiple_ptr &&other)

Multiple_ptr &	operator= (Multiple_ptr &&other)
	Moving a `Multiple_ptr` steals the others partners.

void	add (Ptr_base< U, T > &other)
	Adds `other` to the list of partners and reciprocally connects it with `this`.

void	remove (Ptr_base< U, T > &other)
	Removes `other` from the list of partners and reciprocally disconnects it from `this`.

	operator bool () const
	Returns `true` iff `this` has at least 1 partner.

T &	mine ()
	Obtain the object I am permanently associated with.

std::vector< Ptr_base< U, T > * >	partners ()
	Obtains the sequence of partners, in no particular order.

const T &	mine () const
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

std::vector< const Ptr_base< U, T > * >	partners () const
	Obtains the sequence of partners, in no particular order.

Additional Inherited Members
Protected Member Functions inherited from hexed::Ptr_base< T, U >
void	connect (Ptr_base< U, T > *other)
	Mutually connect us by calling both our `connect_self`.

void	disconnect (Ptr_base< U, T > *other)
	Mutually disconnect us by calling both our `disconnect_self`.

Detailed Description

template<typename T, typename U>
class hexed::Multiple_ptr< T, U >

Like a Mutual_ptr, except it can accept multiple partners.

Has a sequence of partners(), each of which is a Ptr_base<U, T>. Thus it can be connected to Mutual_ptrs or other Multiple_ptrs. Disconnecting (using Multiple_ptr::remove, Mutual_ptr::unpair(), or destroying the partners) will simply remove partners from the sequence.