Struct sigh_storage_mixin
Synopsis
#include <src/entt/entity/storage.hpp>
template<typename Type>
struct sigh_storage_mixin: Type
Description
Mixin type to use to add signal support to storage types.
- Template Parameters
Type- The type of the underlying storage.
Inheritance
Ancestors: Type
Methods
| emplace | Assigns entities to a storage. | |
| insert | Assigns entities to a storage. | |
| on_construct | Returns a sink object. | |
| on_destroy | Returns a sink object. | |
| on_update | Returns a sink object. | |
| patch | Patches the given instance for an entity. | |
| remove overload | Removes entities from a storage. |
Source
Lines 621-786 in src/entt/entity/storage.hpp.
template<typename Type>
struct sigh_storage_mixin: Type {
/*! @brief Underlying value type. */
using value_type = typename Type::value_type;
/*! @brief Underlying entity identifier. */
using entity_type = typename Type::entity_type;
/*! @brief Storage category. */
using storage_category = typename Type::storage_category;
/**
* @brief Returns a sink object.
*
* The sink returned by this function can be used to receive notifications
* whenever a new instance is created and assigned to an entity.<br/>
* The function type for a listener is equivalent to:
*
* @code{.cpp}
* void(basic_registry<entity_type> &, entity_type);
* @endcode
*
* Listeners are invoked **after** the object has been assigned to the
* entity.
*
* @sa sink
*
* @return A temporary sink object.
*/
[[nodiscard]] auto on_construct() ENTT_NOEXCEPT {
return sink{construction};
}
/**
* @brief Returns a sink object.
*
* The sink returned by this function can be used to receive notifications
* whenever an instance is explicitly updated.<br/>
* The function type for a listener is equivalent to:
*
* @code{.cpp}
* void(basic_registry<entity_type> &, entity_type);
* @endcode
*
* Listeners are invoked **after** the object has been updated.
*
* @sa sink
*
* @return A temporary sink object.
*/
[[nodiscard]] auto on_update() ENTT_NOEXCEPT {
return sink{update};
}
/**
* @brief Returns a sink object.
*
* The sink returned by this function can be used to receive notifications
* whenever an instance is removed from an entity and thus destroyed.<br/>
* The function type for a listener is equivalent to:
*
* @code{.cpp}
* void(basic_registry<entity_type> &, entity_type);
* @endcode
*
* Listeners are invoked **before** the object has been removed from the
* entity.
*
* @sa sink
*
* @return A temporary sink object.
*/
[[nodiscard]] auto on_destroy() ENTT_NOEXCEPT {
return sink{destruction};
}
/**
* @copybrief storage_adapter_mixin::emplace
* @tparam Args Types of arguments to use to construct the object.
* @param owner The registry that issued the request.
* @param entity A valid entity identifier.
* @param args Parameters to use to initialize the object.
* @return A reference to the newly created object.
*/
template<typename... Args>
decltype(auto) emplace(basic_registry<entity_type> &owner, const entity_type entity, Args &&... args) {
Type::emplace(owner, entity, std::forward<Args>(args)...);
construction.publish(owner, entity);
if constexpr(!std::is_same_v<storage_category, empty_storage_tag>) {
return this->get(entity);
}
}
/**
* @copybrief storage_adapter_mixin::insert
* @tparam It Type of input iterator.
* @tparam Args Types of arguments to use to construct the objects
* associated with the entities.
* @param owner The registry that issued the request.
* @param first An iterator to the first element of the range of entities.
* @param last An iterator past the last element of the range of entities.
* @param args Parameters to use to initialize the objects associated with
* the entities.
*/
template<typename It, typename... Args>
void insert(basic_registry<entity_type> &owner, It first, It last, Args &&... args) {
Type::insert(owner, first, last, std::forward<Args>(args)...);
if(!construction.empty()) {
for(; first != last; ++first) {
construction.publish(owner, *first);
}
}
}
/**
* @copybrief storage_adapter_mixin::remove
* @param owner The registry that issued the request.
* @param entity A valid entity identifier.
*/
void remove(basic_registry<entity_type> &owner, const entity_type entity) {
destruction.publish(owner, entity);
Type::remove(owner, entity);
}
/**
* @copybrief storage_adapter_mixin::remove
* @tparam It Type of input iterator.
* @param owner The registry that issued the request.
* @param first An iterator to the first element of the range of entities.
* @param last An iterator past the last element of the range of entities.
*/
template<typename It>
void remove(basic_registry<entity_type> &owner, It first, It last) {
if(!destruction.empty()) {
for(auto it = first; it != last; ++it) {
destruction.publish(owner, *it);
}
}
Type::remove(owner, first, last);
}
/**
* @copybrief storage_adapter_mixin::patch
* @tparam Func Types of the function objects to invoke.
* @param owner The registry that issued the request.
* @param entity A valid entity identifier.
* @param func Valid function objects.
* @return A reference to the patched instance.
*/
template<typename... Func>
decltype(auto) patch(basic_registry<entity_type> &owner, const entity_type entity, [[maybe_unused]] Func &&... func) {
if constexpr(std::is_same_v<storage_category, empty_storage_tag>) {
update.publish(owner, entity);
} else {
Type::patch(owner, entity, std::forward<Func>(func)...);
update.publish(owner, entity);
return this->get(entity);
}
}
private:
sigh<void(basic_registry<entity_type> &, const entity_type)> construction{};
sigh<void(basic_registry<entity_type> &, const entity_type)> destruction{};
sigh<void(basic_registry<entity_type> &, const entity_type)> update{};
};