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
55 template <typename Func>
56 void each_term(const Func& func) const {
57 this->filter().each_term(func);
58 }
59
61 void move(flecs::rule_base&& obj) {
62 this->destruct();
63 this->m_world = obj.m_world;
64 this->m_rule = obj.m_rule;
65 obj.m_world = nullptr;
66 obj.m_rule = nullptr;
67 }
68
70 return filter_base(m_world, ecs_rule_get_filter(m_rule));
71 }
72
77 const ecs_filter_t *f = ecs_rule_get_filter(m_rule);
78 char *result = ecs_filter_str(m_world, f);
79 return flecs::string(result);
80 }
81
82
88 char *result = ecs_rule_str(m_rule);
89 return flecs::string(result);
90 }
91
92 operator rule<>() const;
93
94protected:
95 world_t *m_world;
96 rule_t *m_rule;
97};
98
99template<typename ... Components>
100struct rule final : rule_base, iterable<Components...> {
101private:
102 using Terms = typename _::term_ptrs<Components...>::array;
103
104 ecs_iter_t get_iter(flecs::world_t *world) const override {
105 if (!world) {
106 world = m_world;
107 }
108 return ecs_rule_iter(world, m_rule);
109 }
110
111 ecs_iter_next_action_t next_action() const override {
112 return ecs_rule_next;
113 }
114
115 ecs_iter_next_action_t next_each_action() const override {
117 }
118
119public:
120 using rule_base::rule_base;
121
122 int32_t find_var(const char *name) {
123 return ecs_rule_find_var(m_rule, name);
124 }
125};
126
127// Mixin implementation
128template <typename... Comps, typename... Args>
129inline flecs::rule<Comps...> world::rule(Args &&... args) const {
130 return flecs::rule_builder<Comps...>(m_world, FLECS_FWD(args)...)
131 .build();
132}
133
134template <typename... Comps, typename... Args>
135inline flecs::rule_builder<Comps...> world::rule_builder(Args &&... args) const {
136 return flecs::rule_builder<Comps...>(m_world, FLECS_FWD(args)...);
137}
138
139// rule_base implementation
140inline rule_base::operator rule<>() const {
141 return flecs::rule<>(m_world, m_rule);
142}
143
144} // 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_builder< Comps... > rule_builder(Args &&... args) const
Create a rule builder.
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:567
ecs_entity_t ecs_get_entity(const ecs_poly_t *poly)
Get entity from poly.
Rule builder.
Used with ecs_filter_init().
Definition flecs.h:998
ecs_term_t * terms_buffer
For filters with lots of terms an outside array can be provided.
Definition flecs.h:1006
Filters allow for ad-hoc quick filtering of entity tables.
Definition flecs.h:786
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:87
flecs::string str() const
Converts this rule to a string expression.
Definition impl.hpp:76
void move(flecs::rule_base &&obj)
Move the rule.
Definition impl.hpp:61
Rule builder.
Definition builder.hpp:23
The world.
Definition world.hpp:132