Flecs v3.2
A fast entity component system (ECS) for C & C++
Loading...
Searching...
No Matches
impl.hpp
Go to the documentation of this file.
1
6#pragma once
7
8#include "builder.hpp"
9
10namespace flecs {
11
15
16struct rule_base {
17 rule_base()
18 : m_world(nullptr)
19 , m_rule(nullptr) { }
20
21 rule_base(world_t *world, rule_t *rule = nullptr)
22 : m_world(world)
23 , m_rule(rule) { }
24
25 rule_base(world_t *world, ecs_filter_desc_t *desc)
26 : m_world(world)
27 {
28 m_rule = ecs_rule_init(world, desc);
29 if (desc->terms_buffer) {
30 ecs_os_free(desc->terms_buffer);
31 }
32 }
33
34 bool is_valid() const {
35 return m_rule != nullptr;
36 }
37
38 operator rule_t*() const {
39 return m_rule;
40 }
41
43 return flecs::entity(m_world, ecs_get_entity(m_rule));
44 }
45
47 void destruct() {
48 if (m_rule) {
49 ecs_rule_fini(m_rule);
50 m_world = nullptr;
51 m_rule = nullptr;
52 }
53 }
54
56 void move(flecs::rule_base&& obj) {
57 this->destruct();
58 this->m_world = obj.m_world;
59 this->m_rule = obj.m_rule;
60 obj.m_world = nullptr;
61 obj.m_rule = nullptr;
62 }
63
65 return filter_base(m_world, ecs_rule_get_filter(m_rule));
66 }
67
72 const ecs_filter_t *f = ecs_rule_get_filter(m_rule);
73 char *result = ecs_filter_str(m_world, f);
74 return flecs::string(result);
75 }
76
77
83 char *result = ecs_rule_str(m_rule);
84 return flecs::string(result);
85 }
86
87 operator rule<>() const;
88
89protected:
90 world_t *m_world;
91 rule_t *m_rule;
92};
93
94template<typename ... Components>
95struct rule final : rule_base, iterable<Components...> {
96private:
97 using Terms = typename _::term_ptrs<Components...>::array;
98
99 ecs_iter_t get_iter(flecs::world_t *world) const override {
100 if (!world) {
101 world = m_world;
102 }
103 return ecs_rule_iter(world, m_rule);
104 }
105
106 ecs_iter_next_action_t next_action() const override {
107 return ecs_rule_next;
108 }
109
110 ecs_iter_next_action_t next_each_action() const override {
112 }
113
114public:
115 using rule_base::rule_base;
116
117 int32_t find_var(const char *name) {
118 return ecs_rule_find_var(m_rule, name);
119 }
120};
121
122// Mixin implementation
123template <typename... Comps, typename... Args>
124inline flecs::rule<Comps...> world::rule(Args &&... args) const {
125 return flecs::rule_builder<Comps...>(m_world, FLECS_FWD(args)...)
126 .build();
127}
128
129template <typename... Comps, typename... Args>
130inline flecs::rule_builder<Comps...> world::rule_builder(Args &&... args) const {
131 return flecs::rule_builder<Comps...>(m_world, FLECS_FWD(args)...);
132}
133
134// rule_base implementation
135inline rule_base::operator rule<>() const {
136 return flecs::rule<>(m_world, m_rule);
137}
138
139} // namespace flecs
FLECS_API void ecs_rule_fini(ecs_rule_t *rule)
Delete a rule.
FLECS_API const ecs_filter_t * ecs_rule_get_filter(const ecs_rule_t *rule)
Obtain filter from rule.
FLECS_API bool ecs_rule_next(ecs_iter_t *it)
Progress rule iterator.
FLECS_API char * ecs_rule_str(const ecs_rule_t *rule)
Convert rule to a string.
FLECS_API bool ecs_rule_next_instanced(ecs_iter_t *it)
Progress instanced iterator.
FLECS_API ecs_iter_t ecs_rule_iter(const ecs_world_t *world, const ecs_rule_t *rule)
Iterate a rule.
FLECS_API ecs_rule_t * ecs_rule_init(ecs_world_t *world, const ecs_filter_desc_t *desc)
Create a rule.
FLECS_API int32_t ecs_rule_find_var(const ecs_rule_t *rule, const char *name)
Find variable index.
flecs::rule< Comps... > rule(Args &&... args) const
Create a rule.
char * ecs_filter_str(const ecs_world_t *world, const ecs_filter_t *filter)
Convert filter to string expression.
bool(* ecs_iter_next_action_t)(ecs_iter_t *it)
Function prototype for iterating an iterator.
Definition flecs.h:531
ecs_entity_t ecs_get_entity(const ecs_poly_t *poly)
Get entity from poly.
Used with ecs_filter_init.
Definition flecs.h:961
ecs_term_t * terms_buffer
For filters with lots of terms an outside array can be provided.
Definition flecs.h:969
Filters alllow for ad-hoc quick filtering of entity tables.
Definition flecs.h:745
Entity.
Definition entity.hpp:30
void destruct()
Free the rule.
Definition impl.hpp:47
flecs::string rule_str() const
Converts this rule to a string that can be used to aid debugging the behavior of the rule.
Definition impl.hpp:82
flecs::string str() const
Converts this rule to a string expression.
Definition impl.hpp:71
void move(flecs::rule_base &&obj)
Move the rule.
Definition impl.hpp:56
Rule builder.
Definition builder.hpp:23
The world.
Definition world.hpp:132
Builder base class.