InPlaceBuffer< BA, siz, DEFAULT > Class Template Reference

#include "lib/opaque-holder.hpp"

Description

template<class BA, size_t siz = sizeof(BA), class DEFAULT = BA>
class lib::InPlaceBuffer< BA, siz, DEFAULT >

Buffer to place and maintain an object instance privately within another object.

Variation of a similar concept as with OpaqueHolder, but implemented here with reduced security and lesser overhead. InPlaceBuffer is just a chunk of storage, which can be accessed through a common base class interface and allows to place new objects there. It has no way to keep track of the actual object living currently in the buffer. Thus, using InPlaceBuffer requires the placed class(es) themselves to maintain their lifecycle, and especially it is mandatory for the base class to provide a virtual dtor. On the other hand, just the (alignment rounded) storage for the object(s) placed into the buffer is required.

Remarks

as a complement, PlantingHandle may be used on APIs to offer a lightweight way for clients to provide a callback.

Warning

InPlaceBuffer really takes ownership, and even creates a default constructed instance of the base class right away. Yet the requirement for a virtual dtor is deliberately not enforced here, to allow use for types without VTable.

Template Parameters

BA	the nominal Base/Interface class for a family of types
siz	maximum storage required for the targets to be held inline
DEFAULT	the default instance to place initially

Definition at line 615 of file opaque-holder.hpp.

Public Types
using	Handle = PlantingHandle< BA, DEFAULT >
	a "planting handle" can be used to expose an opaque InPlaceBuffer through an API

Public Member Functions
template<class SUB >
	InPlaceBuffer (SUB &&instance)
	immediately move-emplace an embedded subclass type
template<class TY , typename... ARGS>
	InPlaceBuffer (TypeTag< TY >, ARGS &&...args)
	immediately emplace an embedded subclass type
template<class SUB >
SUB *	access ()
template<class TY , typename... ARGS>
TY &	create (ARGS &&...args)
	Abbreviation for placement new.
template<class SUB >
SUB &	emplace (SUB &&implementation)
	move-construct an instance of subclass into the opaque buffer
BA &	operator* () const
BA *	operator-> () const
DEFAULT &	reset ()

Static Public Member Functions
template<typename SUB >
static auto	embedType ()
	helper to mark the subclass type to create. More...

Classes
struct	TypeTag

Private Member Functions
void	destroy ()
BA &	getObj () const
void	placeDefault ()
Private Member Functions inherited from NonCopyable
	NonCopyable (NonCopyable const &)=delete
NonCopyable &	operator= (NonCopyable const &)=delete

Private Attributes
std::byte	buf_ [siz]

---

Class Documentation

lib::InPlaceBuffer::TypeTag

struct lib::InPlaceBuffer::TypeTag

Collaboration diagram for InPlaceBuffer< BA, siz, DEFAULT >::TypeTag< TY >:

Member Function Documentation

embedType()

static auto embedType ( )

inlinestatic

helper to mark the subclass type to create.

Remarks

we can not specify explicit template arguments on ctor calls, so the only way is to use a dummy marker argument to pass the type. Use as InPlaceBuffer(embedType<XYZ>, arg1, arg2, arg3)

Definition at line 671 of file opaque-holder.hpp.

Inheritance diagram for InPlaceBuffer< BA, siz, DEFAULT >:

Collaboration diagram for InPlaceBuffer< BA, siz, DEFAULT >:

---

The documentation for this class was generated from the following file:

• opaque-holder.hpp