MemCore::MemVector< T > Struct Template Reference

A convenience class that looks like a std::vector<>, but is actually referring to a reference-counted common chunk of data. More...

#include <elementary/memcore/Chunk.hpp>

Inheritance diagram for MemCore::MemVector< T >:

Public Member Functions
const RefPtr< Chunk< T > > &	ChunkPtr () const
	Returning a chunk pointer, trivial operation that points to the base class.
MemVector	copyData () const
	Explicitly copy all data into a new Chunk.
	MemVector ()=delete
	No default initializer!
	MemVector (const MemVector &someChunk)
	Construct from an existing MemVector.
	MemVector (const RefPtr< Chunk< T > > &someChunk)
	Construct from an existing chunk, sharing data without copying.
	MemVector (const std::initializer_list< T > &initial_elements)
	Construct from list of given elements.
	MemVector (const std::vector< T > &initial_elements)
	Copy data from a non-reference counted vector.
	MemVector (size_t nElements, bool ReserveOnly=false)
	Allocate vector by giving number of elements Resizing the vector is no problem, all shared instances will see changes immediatly.
	operator const std::vector< T > & () const
	Type conversion, makes this look like a std::vector<>
	operator std::vector< T > & ()
	Type conversion, makes this look like a std::vector<>
void	operator= (const MemVector &)=delete
	No, cannot copy, this would be too easy to confuse.
T &	operator[] (size_t i)
	Operator acess, writable.
const T &	operator[] (size_t i) const
	Operator access, readonly.
size_t	size () const
	The number of stored elements.
std::vector< T > &	std_vector ()
	Explicit reference to stored std::vector.
const std::vector< T > &	std_vector () const
	Explicit reference to stored std::vector.
Public Member Functions inherited from MemCore::StrongPtr< Object, ObjectBase >
StrongPtr &	assignStrong (const DynPtr_t &other)
	assign a strong pointer from a weak pointer
StrongPtr &	assignStrong (const ReferenceBase< ObjectBase_t > *Obj)
	assign a strong pointer from a native pointer
StrongPtr &	assignStrong (const std::nullptr_t &)
	Assign nullptr to a strong pointer, which will remove the referenced object if its counter reaches zero, but the pointer will remain a valid weak pointer with sustained hash value (the referer will still be around).
template<typename... Arguments>
auto	operator() (Arguments...parameters) const -> decltype((*this->getPtrValue())(parameters...))
	Function call operator forwarding.
refvalue_t &	operator* () const
	The dereferencing *-operator.
pointer_t	operator-> () const
	The pointer operator.
StrongPtr &	operator= (const DynPtr_t &other)
	Assignment operator, same as assignStrong()
StrongPtr &	operator= (const ReferenceBase< ObjectBase_t > *Obj)
	Assignment from object base class pointer.
StrongPtr &	operator= (const std::initializer_list< StrongPtr > &other)
	Syntactic sugar: Allows assignment with {} to create a nullptr.
StrongPtr &	operator= (const std::nullptr_t &)
	Assignment operator with nullptr, invalidate.
StrongPtr &	operator= (const StrongPtr &other)
	Assignment operator, same as assignStrong()
template<class IndexType >
auto	operator[] (const IndexType &I) const -> decltype((*this->getPtrValue())[I])
	Index operator forwarding.
	StrongPtr ()
	Default constructor (makes a NULL pointer)
	StrongPtr (const ReferenceBase< ObjectBase_t > *Obj)
	Strong pointer from reference base of object, eg. via new operator.
	StrongPtr (const ReferenceBase< ObjectBase_t > *Obj, const NotNullPtr &)
	Strong pointer from reference base of object, eg. via new operator.
	StrongPtr (const std::nullptr_t &)
	Explicitely construct a nullptr pointer.
template<class ChildObject >
	StrongPtr (const StrongPtr< ChildObject, ObjectBase > &Other)
	Reference pointer with dynamic type identification.
	StrongPtr (const StrongPtr< Object, ObjectBase > &Other)
	Copy constructor.
template<class ChildObject >
	StrongPtr (const WeakPtr< ChildObject, ObjectBase_t > &Other)
	Reference pointer with dynamic type identification.
	~StrongPtr ()
	Destructor, the last one cleans up and destructs the object itself.
Public Member Functions inherited from MemCore::WeakPtr< Object, ObjectBase >
pointer_t	getPtrValue () const
	The pointer value, checked for null.
pointer_t	operator-> () const
	The pointer operator.
refvalue_t &	operator* () const
	The dereferencing *-operator.
size_t	operator~ () const
	Convenience operator to easily retrieve the object count ID of the referenced object, a unique number for each instance.
	WeakPtr ()
	Default constructor, makes a NULL pointer.
	WeakPtr (const std::nullptr_t &)
	Explicitely construct NULL pointer.
	WeakPtr (const ReferenceBase< ObjectBase > *Obj)
	Weak pointer from reference base of object.
	WeakPtr (const ReferenceBase< ObjectBase > *Obj, const NotNullPtr &)
	Weak pointer from reference base of object which must not be null.
template<class AnyObject >
	WeakPtr (const WeakPtr< AnyObject, ObjectBase > &Other)
	Weak pointer from pointer to another class.
	WeakPtr (const WeakPtr &Other)
	Copy constructor.
	~WeakPtr ()
	Default destructor, removes weak references to the object, the last one cleans up the referrer proxy object.
WeakPtr &	assignWeak (const WeakPtr &other)
	Assign a weak pointer (explicit function call, same as assignment operator for weak pointers)
WeakPtr &	operator= (const WeakPtr &other)
	Assignment operator (same as assignWeak() )
Public Member Functions inherited from MemCore::DynPtr< Object, ObjectBase >
const DynPtr &	getDynPtr () const noexcept
	Convenience type cast to dynamic pointer class.
const type_info &	getType () const noexcept
	Return type info of associated object, typeid(NullPtr) or typeid(void) if none.
bool	isAssignable (const DynPtr< ObjectBase, ObjectBase > &Other) const noexcept
	Check whether a given pointer to a base class may be assigned to a pointer of the derived class.
	operator void * () const noexcept
	Check if the pointer is valid.
bool	operator! () const noexcept
	Check if the pointer is invalid.
void	speak (const char *s, const char *prefix="") const noexcept
	Print some debug messages to the console.

Public Attributes
std::vector< T > &	This
	Direct access to the stored std::vector via reference.

Additional Inherited Members
Public Types inherited from MemCore::StrongPtr< Object, ObjectBase >
typedef WeakPtr< Object, ObjectBase >::ObjectBase_t	ObjectBase_t
	Exporting the base class of the reference counted objects.
Public Types inherited from MemCore::WeakPtr< Object, ObjectBase >
typedef Object	object_t
	Exporting the type of the derived class.
typedef ObjectBase	ObjectBase_t
	Exporting the type of the base class.
typedef RefPtrTypeTrait< Object, ObjectBase >::ReferencePointerType	pointer_t
	The result type of the pointer operator, may be changed with the RefPtrTypeTrait<> class.
typedef RefPtrTypeTrait< Object, ObjectBase >::ReferenceValueType	refvalue_t
	The result of the dereferencing operator, may be changed with the RefPtrTypeTrait<> class.
Public Types inherited from MemCore::DynPtr< Object, ObjectBase >
typedef Object	object_t
	Type of the associated object.
Static Public Member Functions inherited from MemCore::WeakPtr< Object, ObjectBase >
Static Public Member Functions inherited from MemCore::DynPtr< Object, ObjectBase >
static const DynPtr &	getNullPtr () noexcept
	Associated static NullPtr - avoids creation of a temporary object when a reference is needed.
Protected Member Functions inherited from MemCore::WeakPtr< Object, ObjectBase >
	WeakPtr (Object *that, const SelfInitialize &)
	Internal constructor used when initializing an object with its own self-reference.
Protected Member Functions inherited from MemCore::DynPtr< Object, ObjectBase >
template<class AnyObject >
	DynPtr (const DynPtr< AnyObject, ObjectBase > &Other) noexcept
	Implicit type conversion within the same class hierarchy Any pointer.
	DynPtr (const std::nullptr_t &) noexcept
	Assign from nullptr.
Related Symbols inherited from MemCore::DynPtr< Object, ObjectBase >
void	Speak (const char *s, const char *prefix="") const
	Verbose information printing for this pointer.

Detailed Description

template<class T>
struct MemCore::MemVector< T >

A convenience class that looks like a std::vector<>, but is actually referring to a reference-counted common chunk of data.

It can be used like many std::vector<>'s sharing their data storage. Otherwise, nothing special here.

Examples

AnemoneBoundingVolume.cpp, and SeagrassBoundingVolume.cpp.

Constructor & Destructor Documentation

MemVector()

template<class T >

MemCore::MemVector< T >::MemVector ( size_t  nElements, bool  ReserveOnly = false  )

inline

Allocate vector by giving number of elements Resizing the vector is no problem, all shared instances will see changes immediatly.

Parameters

ReserveOnly

Tells if the vector shall be initialized with no elements, but reserved to hold the given number of elements. This is useful when new elements are added via push_back().