Struct vertex

Synopsis

#include <src/entt/entity/organizer.hpp>

struct vertex

Description

Vertex type of a task graph defined as an adjacency list.

Methods

vertexConstructs a vertex of the task graph.
callbackReturns the function associated with a vertex.
childrenReturns the list of nodes reachable from a given vertex.
dataReturns the payload associated with a vertex, if any.
infoReturns a type info object associated with a vertex.
nameReturns a user defined name associated with a vertex, if any.
preparePrepares a registry and assures that all required resources are properly instantiated before using them.
ro_countReturns the number of read-only resources of a vertex.
ro_dependencyFills a buffer with the type info objects for the writable resources of a vertex.
rw_countReturns the number of writable resources of a vertex.
rw_dependencyFills a buffer with the type info objects for the read-only resources of a vertex.
top_levelChecks if a vertex is also a top-level one.

Source

Lines 255-367 in src/entt/entity/organizer.hpp.

struct vertex {
    /**
     * @brief Constructs a vertex of the task graph.
     * @param vtype True if the vertex is a top-level one, false otherwise.
     * @param data The data associated with the vertex.
     * @param edges The indices of the children in the adjacency list.
     */
    vertex(const bool vtype, vertex_data data, std::vector<std::size_t> edges)
        : is_top_level{vtype},
          node{std::move(data)},
          reachable{std::move(edges)}
    {}
    /**
     * @brief Fills a buffer with the type info objects for the writable
     * resources of a vertex.
     * @param buffer A buffer pre-allocated by the user.
     * @param length The length of the user-supplied buffer.
     * @return The number of type info objects written to the buffer.
     */
    size_type ro_dependency(type_info *buffer, const std::size_t length) const ENTT_NOEXCEPT {
        return node.dependency(false, buffer, length);
    }
    /**
     * @brief Fills a buffer with the type info objects for the read-only
     * resources of a vertex.
     * @param buffer A buffer pre-allocated by the user.
     * @param length The length of the user-supplied buffer.
     * @return The number of type info objects written to the buffer.
     */
    size_type rw_dependency(type_info *buffer, const std::size_t length) const ENTT_NOEXCEPT {
        return node.dependency(true, buffer, length);
    }
    /**
     * @brief Returns the number of read-only resources of a vertex.
     * @return The number of read-only resources of the vertex.
     */
    size_type ro_count() const ENTT_NOEXCEPT {
        return node.ro_count;
    }
    /**
     * @brief Returns the number of writable resources of a vertex.
     * @return The number of writable resources of the vertex.
     */
    size_type rw_count() const ENTT_NOEXCEPT {
        return node.rw_count;
    }
    /**
     * @brief Checks if a vertex is also a top-level one.
     * @return True if the vertex is a top-level one, false otherwise.
     */
    bool top_level() const ENTT_NOEXCEPT {
        return is_top_level;
    }
    /**
     * @brief Returns a type info object associated with a vertex.
     * @return A properly initialized type info object.
     */
    type_info info() const ENTT_NOEXCEPT {
        return node.info;
    }
    /**
     * @brief Returns a user defined name associated with a vertex, if any.
     * @return The user defined name associated with the vertex, if any.
     */
    const char * name() const ENTT_NOEXCEPT {
        return node.name;
    }
    /**
     * @brief Returns the function associated with a vertex.
     * @return The function associated with the vertex.
     */
    function_type * callback() const ENTT_NOEXCEPT {
        return node.callback;
    }
    /**
     * @brief Returns the payload associated with a vertex, if any.
     * @return The payload associated with the vertex, if any.
     */
    const void * data() const ENTT_NOEXCEPT {
        return node.payload;
    }
    /**
     * @brief Returns the list of nodes reachable from a given vertex.
     * @return The list of nodes reachable from the vertex.
     */
    const std::vector<std::size_t> & children() const ENTT_NOEXCEPT {
        return reachable;
    }
    /**
     * @brief Prepares a registry and assures that all required resources
     * are properly instantiated before using them.
     * @param reg A valid registry.
     */
    void prepare(basic_registry<entity_type> &reg) const {
        node.prepare ? node.prepare(reg) : void();
    }
private:
    bool is_top_level;
    vertex_data node;
    std::vector<std::size_t> reachable;
};





Add Discussion

Log in to comment