Several attribute collections for the same simplex type, behind one container. More...

#include <AttributeCollection.hpp>

Inheritance diagram for wmtk::AttributeContainerGroup:

Public Member Functions
void	add (AbstractAttributeContainer *c)

void	move (size_t from, size_t to) override

void	resize (size_t s) override

void	reset_from (size_t first) override

void	clear () override

void	rollback () override

void	begin_protect () override

void	end_protect () override

void	append_recorded (std::vector< size_t > &out) override

Private Attributes
std::vector< AbstractAttributeContainer * >	m_children

Detailed Description

Several attribute collections for the same simplex type, behind one container.

A mesh exposes exactly one p_vertex_attrs / p_face_attrs / ... slot, so a class hierarchy that wants to split its attributes – shared fields on a base class, application-specific fields on the derived one – has nowhere to register the second collection. Point the slot at one of these instead and register both.

Splitting rather than unioning matters because an AttributeCollection<T> is a member: a derived class cannot change its type, and AttributeCollection<Derived> is not usable as an AttributeCollection<Base> (the storage is a std::vector<Derived>, so it has the wrong stride). Without this, every application pays for every other application's fields on every simplex.

The children keep their own rollback lists and are protected and rolled back independently, which is exactly right: AttributeCollection::operator[] records the rollback entry, so a write to an extras collection inside an operation is undone on failure just like a write to the shared one. Order of registration is the order of forwarding; no child observes another.

Non-owning: the collections outlive the group by being members of the same objects.

Member Function Documentation

◆ append_recorded()

void wmtk::AttributeContainerGroup::append_recorded ( std::vector< size_t > & out )

inlineoverridevirtual

Appends to out the index of every entry this thread has recorded since begin_protect(): every entry the operation reached through non-const access, which rollback() would write back. Lets a caller check that an operation stayed within the simplices it owns.

Reimplemented from wmtk::AbstractAttributeContainer.

◆ begin_protect()

void wmtk::AttributeContainerGroup::begin_protect ( )

inlineoverridevirtual

Implements wmtk::AbstractAttributeContainer.

◆ clear()

void wmtk::AttributeContainerGroup::clear ( )

inlineoverridevirtual

Implements wmtk::AbstractAttributeContainer.

◆ end_protect()

void wmtk::AttributeContainerGroup::end_protect ( )

inlineoverridevirtual

Implements wmtk::AbstractAttributeContainer.

◆ move()

void wmtk::AttributeContainerGroup::move	(	size_t	from,
		size_t	to
	)

inlineoverridevirtual

Reimplemented from wmtk::AbstractAttributeContainer.

◆ reset_from()

void wmtk::AttributeContainerGroup::reset_from ( size_t first )

inlineoverridevirtual

Resets every entry from first to the end of the storage to a default-constructed value. consolidate_mesh() calls it on the spare region past the compacted live range: move() leaves its source intact, so without this those slots would still hold the records compacted out of them, and the next operation handed one would inherit a dead simplex's attributes.

Implements wmtk::AbstractAttributeContainer.