Stowage/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2025-10-19 16:03:29 +00:00
Code Issues Projects Releases Packages Wiki Activity

Remove OAHashMap, in favour of AHashMap.

Browse source 
The two types had (mostly) the same decisions, but `AHashMap` is a faster implementation, and is more consistent with `HashMap`.
This commit is contained in:
Lukas Tenbrink 2025-05-31 15:50:10 +02:00
parent b89c47bb85
commit 963c20565b
16 changed files with 219 additions and 878 deletions
Download patch file Download diff file Expand all files Collapse all files

254
core/math/a_star.cpp
View file

@ -49,10 +49,9 @@ void AStar3D::add_point(int64_t p_id, const Vector3 &p_pos, real_t p_weight_scal
ERR_FAIL_COND_MSG(p_id < 0, vformat("Can't add a point with negative id: %d.", p_id));
ERR_FAIL_COND_MSG(p_weight_scale < 0.0, vformat("Can't add a point with weight scale less than 0.0: %f.", p_weight_scale));
Point *found_pt;
bool p_exists = points.lookup(p_id, found_pt);
Point **point_entry = points.getptr(p_id);
if (!p_exists) {
if (!point_entry) {
Point *pt = memnew(Point);
pt->id = p_id;
pt->pos = p_pos;
@ -61,89 +60,86 @@ void AStar3D::add_point(int64_t p_id, const Vector3 &p_pos, real_t p_weight_scal
pt->open_pass = 0;
pt->closed_pass = 0;
pt->enabled = true;
points.set(p_id, pt);
points.insert_new(p_id, pt);
} else {
Point *found_pt = *point_entry;
found_pt->pos = p_pos;
found_pt->weight_scale = p_weight_scale;
}
}
Vector3 AStar3D::get_point_position(int64_t p_id) const {
Point *p = nullptr;
bool p_exists = points.lookup(p_id, p);
ERR_FAIL_COND_V_MSG(!p_exists, Vector3(), vformat("Can't get point's position. Point with id: %d doesn't exist.", p_id));
Point *const *point_entry = points.getptr(p_id);
ERR_FAIL_COND_V_MSG(!point_entry, Vector3(), vformat("Can't get point's position. Point with id: %d doesn't exist.", p_id));
return p->pos;
return (*point_entry)->pos;
}
void AStar3D::set_point_position(int64_t p_id, const Vector3 &p_pos) {
Point *p = nullptr;
bool p_exists = points.lookup(p_id, p);
ERR_FAIL_COND_MSG(!p_exists, vformat("Can't set point's position. Point with id: %d doesn't exist.", p_id));
Point **point_entry = points.getptr(p_id);
ERR_FAIL_COND_MSG(!point_entry, vformat("Can't set point's position. Point with id: %d doesn't exist.", p_id));
p->pos = p_pos;
(*point_entry)->pos = p_pos;
}
real_t AStar3D::get_point_weight_scale(int64_t p_id) const {
Point *p = nullptr;
bool p_exists = points.lookup(p_id, p);
ERR_FAIL_COND_V_MSG(!p_exists, 0, vformat("Can't get point's weight scale. Point with id: %d doesn't exist.", p_id));
Point *const *point_entry = points.getptr(p_id);
ERR_FAIL_COND_V_MSG(!point_entry, 0, vformat("Can't get point's weight scale. Point with id: %d doesn't exist.", p_id));
return p->weight_scale;
return (*point_entry)->weight_scale;
}
void AStar3D::set_point_weight_scale(int64_t p_id, real_t p_weight_scale) {
Point *p = nullptr;
bool p_exists = points.lookup(p_id, p);
ERR_FAIL_COND_MSG(!p_exists, vformat("Can't set point's weight scale. Point with id: %d doesn't exist.", p_id));
Point **point_entry = points.getptr(p_id);
ERR_FAIL_COND_MSG(!point_entry, vformat("Can't set point's weight scale. Point with id: %d doesn't exist.", p_id));
ERR_FAIL_COND_MSG(p_weight_scale < 0.0, vformat("Can't set point's weight scale less than 0.0: %f.", p_weight_scale));
p->weight_scale = p_weight_scale;
(*point_entry)->weight_scale = p_weight_scale;
}
void AStar3D::remove_point(int64_t p_id) {
Point *p = nullptr;
bool p_exists = points.lookup(p_id, p);
ERR_FAIL_COND_MSG(!p_exists, vformat("Can't remove point. Point with id: %d doesn't exist.", p_id));
Point **point_entry = points.getptr(p_id);
ERR_FAIL_COND_MSG(!point_entry, vformat("Can't remove point. Point with id: %d doesn't exist.", p_id));
Point *p = *point_entry;
for (OAHashMap<int64_t, Point *>::Iterator it = p->neighbors.iter(); it.valid; it = p->neighbors.next_iter(it)) {
Segment s(p_id, (*it.key));
for (KeyValue<int64_t, Point *> &kv : p->neighbors) {
Segment s(p_id, kv.key);
segments.erase(s);
(*it.value)->neighbors.remove(p->id);
(*it.value)->unlinked_neighbours.remove(p->id);
kv.value->neighbors.erase(p->id);
kv.value->unlinked_neighbours.erase(p->id);
}
for (OAHashMap<int64_t, Point *>::Iterator it = p->unlinked_neighbours.iter(); it.valid; it = p->unlinked_neighbours.next_iter(it)) {
Segment s(p_id, (*it.key));
for (KeyValue<int64_t, Point *> &kv : p->unlinked_neighbours) {
Segment s(p_id, kv.key);
segments.erase(s);
(*it.value)->neighbors.remove(p->id);
(*it.value)->unlinked_neighbours.remove(p->id);
kv.value->neighbors.erase(p->id);
kv.value->unlinked_neighbours.erase(p->id);
}
memdelete(p);
points.remove(p_id);
points.erase(p_id);
last_free_id = p_id;
}
void AStar3D::connect_points(int64_t p_id, int64_t p_with_id, bool bidirectional) {
ERR_FAIL_COND_MSG(p_id == p_with_id, vformat("Can't connect point with id: %d to itself.", p_id));
Point *a = nullptr;
bool from_exists = points.lookup(p_id, a);
ERR_FAIL_COND_MSG(!from_exists, vformat("Can't connect points. Point with id: %d doesn't exist.", p_id));
Point **a_entry = points.getptr(p_id);
ERR_FAIL_COND_MSG(!a_entry, vformat("Can't connect points. Point with id: %d doesn't exist.", p_id));
Point *a = *a_entry;
Point *b = nullptr;
bool to_exists = points.lookup(p_with_id, b);
ERR_FAIL_COND_MSG(!to_exists, vformat("Can't connect points. Point with id: %d doesn't exist.", p_with_id));
Point **b_entry = points.getptr(p_with_id);
ERR_FAIL_COND_MSG(!b_entry, vformat("Can't connect points. Point with id: %d doesn't exist.", p_with_id));
Point *b = *b_entry;
a->neighbors.set(b->id, b);
a->neighbors.insert(b->id, b);
if (bidirectional) {
b->neighbors.set(a->id, a);
b->neighbors.insert(a->id, a);
} else {
b->unlinked_neighbours.set(a->id, a);
b->unlinked_neighbours.insert(a->id, a);
}
Segment s(p_id, p_with_id);
@ -156,8 +152,8 @@ void AStar3D::connect_points(int64_t p_id, int64_t p_with_id, bool bidirectional
s.direction |= element->direction;
if (s.direction == Segment::BIDIRECTIONAL) {
// Both are neighbors of each other now
a->unlinked_neighbours.remove(b->id);
b->unlinked_neighbours.remove(a->id);
a->unlinked_neighbours.erase(b->id);
b->unlinked_neighbours.erase(a->id);
}
segments.remove(element);
}
@ -166,13 +162,13 @@ void AStar3D::connect_points(int64_t p_id, int64_t p_with_id, bool bidirectional
}
void AStar3D::disconnect_points(int64_t p_id, int64_t p_with_id, bool bidirectional) {
Point *a = nullptr;
bool a_exists = points.lookup(p_id, a);
ERR_FAIL_COND_MSG(!a_exists, vformat("Can't disconnect points. Point with id: %d doesn't exist.", p_id));
Point **a_entry = points.getptr(p_id);
ERR_FAIL_COND_MSG(!a_entry, vformat("Can't disconnect points. Point with id: %d doesn't exist.", p_id));
Point *a = *a_entry;
Point *b = nullptr;
bool b_exists = points.lookup(p_with_id, b);
ERR_FAIL_COND_MSG(!b_exists, vformat("Can't disconnect points. Point with id: %d doesn't exist.", p_with_id));
Point **b_entry = points.getptr(p_with_id);
ERR_FAIL_COND_MSG(!b_entry, vformat("Can't disconnect points. Point with id: %d doesn't exist.", p_with_id));
Point *b = *b_entry;
Segment s(p_id, p_with_id);
int remove_direction = bidirectional ? (int)Segment::BIDIRECTIONAL : (int)s.direction;
@ -183,18 +179,18 @@ void AStar3D::disconnect_points(int64_t p_id, int64_t p_with_id, bool bidirectio
// Erase the directions to be removed
s.direction = (element->direction & ~remove_direction);
a->neighbors.remove(b->id);
a->neighbors.erase(b->id);
if (bidirectional) {
b->neighbors.remove(a->id);
b->neighbors.erase(a->id);
if (element->direction != Segment::BIDIRECTIONAL) {
a->unlinked_neighbours.remove(b->id);
b->unlinked_neighbours.remove(a->id);
a->unlinked_neighbours.erase(b->id);
b->unlinked_neighbours.erase(a->id);
}
} else {
if (s.direction == Segment::NONE) {
b->unlinked_neighbours.remove(a->id);
b->unlinked_neighbours.erase(a->id);
} else {
a->unlinked_neighbours.set(b->id, b);
a->unlinked_neighbours.insert(b->id, b);
}
}
@ -212,22 +208,21 @@ bool AStar3D::has_point(int64_t p_id) const {
PackedInt64Array AStar3D::get_point_ids() {
PackedInt64Array point_list;
for (OAHashMap<int64_t, Point *>::Iterator it = points.iter(); it.valid; it = points.next_iter(it)) {
point_list.push_back(*(it.key));
for (KeyValue<int64_t, Point *> &kv : points) {
point_list.push_back(kv.key);
}
return point_list;
}
Vector<int64_t> AStar3D::get_point_connections(int64_t p_id) {
Point *p = nullptr;
bool p_exists = points.lookup(p_id, p);
ERR_FAIL_COND_V_MSG(!p_exists, Vector<int64_t>(), vformat("Can't get point's connections. Point with id: %d doesn't exist.", p_id));
Point **p_entry = points.getptr(p_id);
ERR_FAIL_COND_V_MSG(!p_entry, Vector<int64_t>(), vformat("Can't get point's connections. Point with id: %d doesn't exist.", p_id));
Vector<int64_t> point_list;
for (OAHashMap<int64_t, Point *>::Iterator it = p->neighbors.iter(); it.valid; it = p->neighbors.next_iter(it)) {
point_list.push_back((*it.key));
for (KeyValue<int64_t, Point *> &kv : (*p_entry)->neighbors) {
point_list.push_back(kv.key);
}
return point_list;
@ -243,15 +238,15 @@ bool AStar3D::are_points_connected(int64_t p_id, int64_t p_with_id, bool bidirec
void AStar3D::clear() {
last_free_id = 0;
for (OAHashMap<int64_t, Point *>::Iterator it = points.iter(); it.valid; it = points.next_iter(it)) {
memdelete(*(it.value));
for (KeyValue<int64_t, Point *> &kv : points) {
memdelete(kv.value);
}
segments.clear();
points.clear();
}
int64_t AStar3D::get_point_count() const {
return points.get_num_elements();
return points.size();
}
int64_t AStar3D::get_point_capacity() const {
@ -267,15 +262,15 @@ int64_t AStar3D::get_closest_point(const Vector3 &p_point, bool p_include_disabl
int64_t closest_id = -1;
real_t closest_dist = 1e20;
for (OAHashMap<int64_t, Point *>::Iterator it = points.iter(); it.valid; it = points.next_iter(it)) {
if (!p_include_disabled && !(*it.value)->enabled) {
for (const KeyValue<int64_t, Point *> &kv : points) {
if (!p_include_disabled && !kv.value->enabled) {
continue; // Disabled points should not be considered.
}
// Keep the closest point's ID, and in case of multiple closest IDs,
// the smallest one (makes it deterministic).
real_t d = p_point.distance_squared_to((*it.value)->pos);
int64_t id = *(it.key);
real_t d = p_point.distance_squared_to(kv.value->pos);
int64_t id = kv.key;
if (d <= closest_dist) {
if (d == closest_dist && id > closest_id) { // Keep lowest ID.
continue;
@ -293,9 +288,8 @@ Vector3 AStar3D::get_closest_position_in_segment(const Vector3 &p_point) const {
Vector3 closest_point;
for (const Segment &E : segments) {
Point *from_point = nullptr, *to_point = nullptr;
points.lookup(E.key.first, from_point);
points.lookup(E.key.second, to_point);
const Point *from_point = *points.getptr(E.key.first);
const Point *to_point = *points.getptr(E.key.second);
if (!(from_point->enabled && to_point->enabled)) {
continue;
@ -348,8 +342,8 @@ bool AStar3D::_solve(Point *begin_point, Point *end_point, bool p_allow_partial_
open_list.remove_at(open_list.size() - 1);
p->closed_pass = pass; // Mark the point as closed.
for (OAHashMap<int64_t, Point *>::Iterator it = p->neighbors.iter(); it.valid; it = p->neighbors.next_iter(it)) {
Point *e = *(it.value); // The neighbor point.
for (const KeyValue<int64_t, Point *> &kv : p->neighbors) {
Point *e = kv.value; // The neighbor point.
if (!e->enabled || e->closed_pass == pass) {
continue;
@ -390,13 +384,13 @@ real_t AStar3D::_estimate_cost(int64_t p_from_id, int64_t p_end_id) {
return scost;
}
Point *from_point = nullptr;
bool from_exists = points.lookup(p_from_id, from_point);
ERR_FAIL_COND_V_MSG(!from_exists, 0, vformat("Can't estimate cost. Point with id: %d doesn't exist.", p_from_id));
Point **from_entry = points.getptr(p_from_id);
ERR_FAIL_COND_V_MSG(!from_entry, 0, vformat("Can't estimate cost. Point with id: %d doesn't exist.", p_from_id));
Point *from_point = *from_entry;
Point *end_point = nullptr;
bool end_exists = points.lookup(p_end_id, end_point);
ERR_FAIL_COND_V_MSG(!end_exists, 0, vformat("Can't estimate cost. Point with id: %d doesn't exist.", p_end_id));
Point **end_entry = points.getptr(p_end_id);
ERR_FAIL_COND_V_MSG(!end_entry, 0, vformat("Can't estimate cost. Point with id: %d doesn't exist.", p_end_id));
Point *end_point = *end_entry;
return from_point->pos.distance_to(end_point->pos);
}
@ -407,25 +401,25 @@ real_t AStar3D::_compute_cost(int64_t p_from_id, int64_t p_to_id) {
return scost;
}
Point *from_point = nullptr;
bool from_exists = points.lookup(p_from_id, from_point);
ERR_FAIL_COND_V_MSG(!from_exists, 0, vformat("Can't compute cost. Point with id: %d doesn't exist.", p_from_id));
Point **from_entry = points.getptr(p_from_id);
ERR_FAIL_COND_V_MSG(!from_entry, 0, vformat("Can't compute cost. Point with id: %d doesn't exist.", p_from_id));
Point *from_point = *from_entry;
Point *to_point = nullptr;
bool to_exists = points.lookup(p_to_id, to_point);
ERR_FAIL_COND_V_MSG(!to_exists, 0, vformat("Can't compute cost. Point with id: %d doesn't exist.", p_to_id));
Point **to_entry = points.getptr(p_to_id);
ERR_FAIL_COND_V_MSG(!to_entry, 0, vformat("Can't compute cost. Point with id: %d doesn't exist.", p_to_id));
Point *to_point = *to_entry;
return from_point->pos.distance_to(to_point->pos);
}
Vector<Vector3> AStar3D::get_point_path(int64_t p_from_id, int64_t p_to_id, bool p_allow_partial_path) {
Point *a = nullptr;
bool from_exists = points.lookup(p_from_id, a);
ERR_FAIL_COND_V_MSG(!from_exists, Vector<Vector3>(), vformat("Can't get point path. Point with id: %d doesn't exist.", p_from_id));
Point **a_entry = points.getptr(p_from_id);
ERR_FAIL_COND_V_MSG(!a_entry, Vector<Vector3>(), vformat("Can't get point path. Point with id: %d doesn't exist.", p_from_id));
Point *a = *a_entry;
Point *b = nullptr;
bool to_exists = points.lookup(p_to_id, b);
ERR_FAIL_COND_V_MSG(!to_exists, Vector<Vector3>(), vformat("Can't get point path. Point with id: %d doesn't exist.", p_to_id));
Point **b_entry = points.getptr(p_to_id);
ERR_FAIL_COND_V_MSG(!b_entry, Vector<Vector3>(), vformat("Can't get point path. Point with id: %d doesn't exist.", p_to_id));
Point *b = *b_entry;
if (a == b) {
Vector<Vector3> ret;
@ -473,13 +467,13 @@ Vector<Vector3> AStar3D::get_point_path(int64_t p_from_id, int64_t p_to_id, bool
}
Vector<int64_t> AStar3D::get_id_path(int64_t p_from_id, int64_t p_to_id, bool p_allow_partial_path) {
Point *a = nullptr;
bool from_exists = points.lookup(p_from_id, a);
ERR_FAIL_COND_V_MSG(!from_exists, Vector<int64_t>(), vformat("Can't get id path. Point with id: %d doesn't exist.", p_from_id));
Point **a_entry = points.getptr(p_from_id);
ERR_FAIL_COND_V_MSG(!a_entry, Vector<int64_t>(), vformat("Can't get id path. Point with id: %d doesn't exist.", p_from_id));
Point *a = *a_entry;
Point *b = nullptr;
bool to_exists = points.lookup(p_to_id, b);
ERR_FAIL_COND_V_MSG(!to_exists, Vector<int64_t>(), vformat("Can't get id path. Point with id: %d doesn't exist.", p_to_id));
Point **b_entry = points.getptr(p_to_id);
ERR_FAIL_COND_V_MSG(!b_entry, Vector<int64_t>(), vformat("Can't get id path. Point with id: %d doesn't exist.", p_to_id));
Point *b = *b_entry;
if (a == b) {
Vector<int64_t> ret;
@ -527,17 +521,17 @@ Vector<int64_t> AStar3D::get_id_path(int64_t p_from_id, int64_t p_to_id, bool p_
}
void AStar3D::set_point_disabled(int64_t p_id, bool p_disabled) {
Point *p = nullptr;
bool p_exists = points.lookup(p_id, p);
ERR_FAIL_COND_MSG(!p_exists, vformat("Can't set if point is disabled. Point with id: %d doesn't exist.", p_id));
Point **p_entry = points.getptr(p_id);
ERR_FAIL_COND_MSG(!p_entry, vformat("Can't set if point is disabled. Point with id: %d doesn't exist.", p_id));
Point *p = *p_entry;
p->enabled = !p_disabled;
}
bool AStar3D::is_point_disabled(int64_t p_id) const {
Point *p = nullptr;
bool p_exists = points.lookup(p_id, p);
ERR_FAIL_COND_V_MSG(!p_exists, false, vformat("Can't get if point is disabled. Point with id: %d doesn't exist.", p_id));
Point *const *p_entry = points.getptr(p_id);
ERR_FAIL_COND_V_MSG(!p_entry, false, vformat("Can't get if point is disabled. Point with id: %d doesn't exist.", p_id));
Point *p = *p_entry;
return !p->enabled;
}
@ -674,13 +668,13 @@ real_t AStar2D::_estimate_cost(int64_t p_from_id, int64_t p_end_id) {
return scost;
}
AStar3D::Point *from_point = nullptr;
bool from_exists = astar.points.lookup(p_from_id, from_point);
ERR_FAIL_COND_V_MSG(!from_exists, 0, vformat("Can't estimate cost. Point with id: %d doesn't exist.", p_from_id));
AStar3D::Point **from_entry = astar.points.getptr(p_from_id);
ERR_FAIL_COND_V_MSG(!from_entry, 0, vformat("Can't estimate cost. Point with id: %d doesn't exist.", p_from_id));
AStar3D::Point *from_point = *from_entry;
AStar3D::Point *end_point = nullptr;
bool to_exists = astar.points.lookup(p_end_id, end_point);
ERR_FAIL_COND_V_MSG(!to_exists, 0, vformat("Can't estimate cost. Point with id: %d doesn't exist.", p_end_id));
AStar3D::Point **end_entry = astar.points.getptr(p_end_id);
ERR_FAIL_COND_V_MSG(!end_entry, 0, vformat("Can't estimate cost. Point with id: %d doesn't exist.", p_end_id));
AStar3D::Point *end_point = *end_entry;
return from_point->pos.distance_to(end_point->pos);
}
@ -691,25 +685,25 @@ real_t AStar2D::_compute_cost(int64_t p_from_id, int64_t p_to_id) {
return scost;
}
AStar3D::Point *from_point = nullptr;
bool from_exists = astar.points.lookup(p_from_id, from_point);
ERR_FAIL_COND_V_MSG(!from_exists, 0, vformat("Can't compute cost. Point with id: %d doesn't exist.", p_from_id));
AStar3D::Point **from_entry = astar.points.getptr(p_from_id);
ERR_FAIL_COND_V_MSG(!from_entry, 0, vformat("Can't compute cost. Point with id: %d doesn't exist.", p_from_id));
AStar3D::Point *from_point = *from_entry;
AStar3D::Point *to_point = nullptr;
bool to_exists = astar.points.lookup(p_to_id, to_point);
ERR_FAIL_COND_V_MSG(!to_exists, 0, vformat("Can't compute cost. Point with id: %d doesn't exist.", p_to_id));
AStar3D::Point **to_entry = astar.points.getptr(p_to_id);
ERR_FAIL_COND_V_MSG(!to_entry, 0, vformat("Can't compute cost. Point with id: %d doesn't exist.", p_to_id));
AStar3D::Point *to_point = *to_entry;
return from_point->pos.distance_to(to_point->pos);
}
Vector<Vector2> AStar2D::get_point_path(int64_t p_from_id, int64_t p_to_id, bool p_allow_partial_path) {
AStar3D::Point *a = nullptr;
bool from_exists = astar.points.lookup(p_from_id, a);
ERR_FAIL_COND_V_MSG(!from_exists, Vector<Vector2>(), vformat("Can't get point path. Point with id: %d doesn't exist.", p_from_id));
AStar3D::Point **a_entry = astar.points.getptr(p_from_id);
ERR_FAIL_COND_V_MSG(!a_entry, Vector<Vector2>(), vformat("Can't get point path. Point with id: %d doesn't exist.", p_from_id));
AStar3D::Point *a = *a_entry;
AStar3D::Point *b = nullptr;
bool to_exists = astar.points.lookup(p_to_id, b);
ERR_FAIL_COND_V_MSG(!to_exists, Vector<Vector2>(), vformat("Can't get point path. Point with id: %d doesn't exist.", p_to_id));
AStar3D::Point **b_entry = astar.points.getptr(p_to_id);
ERR_FAIL_COND_V_MSG(!b_entry, Vector<Vector2>(), vformat("Can't get point path. Point with id: %d doesn't exist.", p_to_id));
AStar3D::Point *b = *b_entry;
if (a == b) {
Vector<Vector2> ret = { Vector2(a->pos.x, a->pos.y) };
@ -756,13 +750,13 @@ Vector<Vector2> AStar2D::get_point_path(int64_t p_from_id, int64_t p_to_id, bool
}
Vector<int64_t> AStar2D::get_id_path(int64_t p_from_id, int64_t p_to_id, bool p_allow_partial_path) {
AStar3D::Point *a = nullptr;
bool from_exists = astar.points.lookup(p_from_id, a);
ERR_FAIL_COND_V_MSG(!from_exists, Vector<int64_t>(), vformat("Can't get id path. Point with id: %d doesn't exist.", p_from_id));
AStar3D::Point **a_entry = astar.points.getptr(p_from_id);
ERR_FAIL_COND_V_MSG(!a_entry, Vector<int64_t>(), vformat("Can't get id path. Point with id: %d doesn't exist.", p_from_id));
AStar3D::Point *a = *a_entry;
AStar3D::Point *b = nullptr;
bool to_exists = astar.points.lookup(p_to_id, b);
ERR_FAIL_COND_V_MSG(!to_exists, Vector<int64_t>(), vformat("Can't get id path. Point with id: %d doesn't exist.", p_to_id));
AStar3D::Point **to_entry = astar.points.getptr(p_to_id);
ERR_FAIL_COND_V_MSG(!to_entry, Vector<int64_t>(), vformat("Can't get id path. Point with id: %d doesn't exist.", p_to_id));
AStar3D::Point *b = *to_entry;
if (a == b) {
Vector<int64_t> ret;
@ -845,8 +839,8 @@ bool AStar2D::_solve(AStar3D::Point *begin_point, AStar3D::Point *end_point, boo
open_list.remove_at(open_list.size() - 1);
p->closed_pass = astar.pass; // Mark the point as closed.
for (OAHashMap<int64_t, AStar3D::Point *>::Iterator it = p->neighbors.iter(); it.valid; it = p->neighbors.next_iter(it)) {
AStar3D::Point *e = *(it.value); // The neighbor point.
for (KeyValue<int64_t, AStar3D::Point *> &kv : p->neighbors) {
AStar3D::Point *e = kv.value; // The neighbor point.
if (!e->enabled || e->closed_pass == astar.pass) {
continue;

8
core/math/a_star.h
View file

@ -32,7 +32,7 @@
#include "core/object/gdvirtual.gen.inc"
#include "core/object/ref_counted.h"
#include "core/templates/oa_hash_map.h"
#include "core/templates/a_hash_map.h"
/**
A* pathfinding algorithm.
@ -50,8 +50,8 @@ class AStar3D : public RefCounted {
real_t weight_scale = 0;
bool enabled = false;
OAHashMap<int64_t, Point *> neighbors = 4u;
OAHashMap<int64_t, Point *> unlinked_neighbours = 4u;
AHashMap<int64_t, Point *> neighbors = 4u;
AHashMap<int64_t, Point *> unlinked_neighbours = 4u;
// Used for pathfinding.
Point *prev_point = nullptr;
@ -110,7 +110,7 @@ class AStar3D : public RefCounted {
mutable int64_t last_free_id = 0;
uint64_t pass = 1;
OAHashMap<int64_t, Point *> points;
AHashMap<int64_t, Point *> points;
HashSet<Segment, Segment> segments;
Point *last_closest_point = nullptr;

10
core/math/convex_hull.cpp
View file

@ -61,7 +61,7 @@ subject to the following restrictions:
#include "core/error/error_macros.h"
#include "core/math/aabb.h"
#include "core/math/math_defs.h"
#include "core/templates/oa_hash_map.h"
#include "core/templates/a_hash_map.h"
#include "core/templates/paged_allocator.h"
//#define DEBUG_CONVEX_HULL
@ -2267,7 +2267,7 @@ Error ConvexHullComputer::convex_hull(const Vector<Vector3> &p_points, Geometry3
// Copy the edges over. There's two "half-edges" for every edge, so we pick only one of them.
r_mesh.edges.resize(ch.edges.size() / 2);
OAHashMap<uint64_t, int32_t> edge_map(ch.edges.size() * 4); // The higher the capacity, the faster the insert
AHashMap<uint64_t, int32_t> edge_map(ch.edges.size() * 4); // The higher the capacity, the faster the insert
uint32_t edges_copied = 0;
for (uint32_t i = 0; i < ch.edges.size(); i++) {
@ -2292,11 +2292,11 @@ Error ConvexHullComputer::convex_hull(const Vector<Vector3> &p_points, Geometry3
uint64_t key = b;
key <<= 32;
key |= a;
int32_t index;
if (!edge_map.lookup(key, index)) {
int32_t *index_ptr = edge_map.getptr(key);
if (!index_ptr) {
ERR_PRINT("Invalid edge");
} else {
r_mesh.edges[index].face_b = edge_faces[i];
r_mesh.edges[*index_ptr].face_b = edge_faces[i];
}
}
}

6
core/math/delaunay_3d.h
View file

@ -33,9 +33,9 @@
#include "core/math/aabb.h"
#include "core/math/projection.h"
#include "core/math/vector3.h"
#include "core/templates/a_hash_map.h"
#include "core/templates/list.h"
#include "core/templates/local_vector.h"
#include "core/templates/oa_hash_map.h"
#include "core/templates/vector.h"
#include "thirdparty/misc/r128.h"
@ -260,7 +260,7 @@ public:
circum_sphere_compute(points, root);
}
OAHashMap<Triangle, uint32_t, TriangleHasher> triangles_inserted;
AHashMap<Triangle, uint32_t, TriangleHasher> triangles_inserted;
LocalVector<Triangle> triangles;
for (uint32_t i = 0; i < point_count; i++) {
@ -293,7 +293,7 @@ public:
for (uint32_t k = 0; k < 4; k++) {
Triangle t = Triangle(simplex->points[triangle_order[k][0]], simplex->points[triangle_order[k][1]], simplex->points[triangle_order[k][2]]);
uint32_t *p = triangles_inserted.lookup_ptr(t);
uint32_t *p = triangles_inserted.getptr(t);
if (p) {
// This Delaunay implementation uses the Bowyer-Watson algorithm.
// The rule is that you don't reuse any triangles that were

402
core/templates/oa_hash_map.h
View file

@ -1,402 +0,0 @@
/**************************************************************************/
/* oa_hash_map.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#pragma once
#include "core/os/memory.h"
#include "core/templates/hashfuncs.h"
#include "core/templates/pair.h"
/**
* A HashMap implementation that uses open addressing with Robin Hood hashing.
* Robin Hood hashing swaps out entries that have a smaller probing distance
* than the to-be-inserted entry, that evens out the average probing distance
* and enables faster lookups. Backward shift deletion is employed to further
* improve the performance and to avoid infinite loops in rare cases.
*
* The entries are stored inplace, so huge keys or values might fill cache lines
* a lot faster.
*
* Only used keys and values are constructed. For free positions there's space
* in the arrays for each, but that memory is kept uninitialized.
*
* The assignment operator copy the pairs from one map to the other.
*/
template <typename TKey, typename TValue,
typename Hasher = HashMapHasherDefault,
typename Comparator = HashMapComparatorDefault<TKey>>
class OAHashMap {
private:
TValue *values = nullptr;
TKey *keys = nullptr;
uint32_t *hashes = nullptr;
uint32_t capacity = 0;
uint32_t num_elements = 0;
static const uint32_t EMPTY_HASH = 0;
_FORCE_INLINE_ uint32_t _hash(const TKey &p_key) const {
uint32_t hash = Hasher::hash(p_key);
if (hash == EMPTY_HASH) {
hash = EMPTY_HASH + 1;
}
return hash;
}
_FORCE_INLINE_ uint32_t _get_probe_length(uint32_t p_pos, uint32_t p_hash) const {
uint32_t original_pos = p_hash % capacity;
return (p_pos - original_pos + capacity) % capacity;
}
_FORCE_INLINE_ void _construct(uint32_t p_pos, uint32_t p_hash, const TKey &p_key, const TValue &p_value) {
memnew_placement(&keys[p_pos], TKey(p_key));
memnew_placement(&values[p_pos], TValue(p_value));
hashes[p_pos] = p_hash;
num_elements++;
}
bool _lookup_pos(const TKey &p_key, uint32_t &r_pos) const {
uint32_t hash = _hash(p_key);
uint32_t pos = hash % capacity;
uint32_t distance = 0;
while (true) {
if (hashes[pos] == EMPTY_HASH) {
return false;
}
if (distance > _get_probe_length(pos, hashes[pos])) {
return false;
}
if (hashes[pos] == hash && Comparator::compare(keys[pos], p_key)) {
r_pos = pos;
return true;
}
pos = (pos + 1) % capacity;
distance++;
}
}
void _insert_with_hash(uint32_t p_hash, const TKey &p_key, const TValue &p_value) {
uint32_t hash = p_hash;
uint32_t distance = 0;
uint32_t pos = hash % capacity;
TKey key = p_key;
TValue value = p_value;
while (true) {
if (hashes[pos] == EMPTY_HASH) {
_construct(pos, hash, key, value);
return;
}
// not an empty slot, let's check the probing length of the existing one
uint32_t existing_probe_len = _get_probe_length(pos, hashes[pos]);
if (existing_probe_len < distance) {
SWAP(hash, hashes[pos]);
SWAP(key, keys[pos]);
SWAP(value, values[pos]);
distance = existing_probe_len;
}
pos = (pos + 1) % capacity;
distance++;
}
}
void _resize_and_rehash(uint32_t p_new_capacity) {
uint32_t old_capacity = capacity;
// Capacity can't be 0.
capacity = MAX(1u, p_new_capacity);
TKey *old_keys = keys;
TValue *old_values = values;
uint32_t *old_hashes = hashes;
num_elements = 0;
keys = static_cast<TKey *>(Memory::alloc_static(sizeof(TKey) * capacity));
values = static_cast<TValue *>(Memory::alloc_static(sizeof(TValue) * capacity));
static_assert(EMPTY_HASH == 0, "Assuming EMPTY_HASH = 0 for alloc_static_zeroed call");
hashes = static_cast<uint32_t *>(Memory::alloc_static_zeroed(sizeof(uint32_t) * capacity));
if (old_capacity == 0) {
// Nothing to do.
return;
}
for (uint32_t i = 0; i < old_capacity; i++) {
if (old_hashes[i] == EMPTY_HASH) {
continue;
}
_insert_with_hash(old_hashes[i], old_keys[i], old_values[i]);
old_keys[i].~TKey();
old_values[i].~TValue();
}
Memory::free_static(old_keys);
Memory::free_static(old_values);
Memory::free_static(old_hashes);
}
void _resize_and_rehash() {
_resize_and_rehash(capacity * 2);
}
public:
_FORCE_INLINE_ uint32_t get_capacity() const { return capacity; }
_FORCE_INLINE_ uint32_t get_num_elements() const { return num_elements; }
bool is_empty() const {
return num_elements == 0;
}
void clear() {
for (uint32_t i = 0; i < capacity; i++) {
if (hashes[i] == EMPTY_HASH) {
continue;
}
hashes[i] = EMPTY_HASH;
values[i].~TValue();
keys[i].~TKey();
}
num_elements = 0;
}
void insert(const TKey &p_key, const TValue &p_value) {
if (num_elements + 1 > 0.9 * capacity) {
_resize_and_rehash();
}
uint32_t hash = _hash(p_key);
_insert_with_hash(hash, p_key, p_value);
}
void set(const TKey &p_key, const TValue &p_data) {
uint32_t pos = 0;
bool exists = _lookup_pos(p_key, pos);
if (exists) {
values[pos] = p_data;
} else {
insert(p_key, p_data);
}
}
/**
* returns true if the value was found, false otherwise.
*
* if r_data is not nullptr then the value will be written to the object
* it points to.
*/
bool lookup(const TKey &p_key, TValue &r_data) const {
uint32_t pos = 0;
bool exists = _lookup_pos(p_key, pos);
if (exists) {
r_data = values[pos];
return true;
}
return false;
}
const TValue *lookup_ptr(const TKey &p_key) const {
uint32_t pos = 0;
bool exists = _lookup_pos(p_key, pos);
if (exists) {
return &values[pos];
}
return nullptr;
}
TValue *lookup_ptr(const TKey &p_key) {
uint32_t pos = 0;
bool exists = _lookup_pos(p_key, pos);
if (exists) {
return &values[pos];
}
return nullptr;
}
_FORCE_INLINE_ bool has(const TKey &p_key) const {
uint32_t _pos = 0;
return _lookup_pos(p_key, _pos);
}
void remove(const TKey &p_key) {
uint32_t pos = 0;
bool exists = _lookup_pos(p_key, pos);
if (!exists) {
return;
}
uint32_t next_pos = (pos + 1) % capacity;
while (hashes[next_pos] != EMPTY_HASH &&
_get_probe_length(next_pos, hashes[next_pos]) != 0) {
SWAP(hashes[next_pos], hashes[pos]);
SWAP(keys[next_pos], keys[pos]);
SWAP(values[next_pos], values[pos]);
pos = next_pos;
next_pos = (pos + 1) % capacity;
}
hashes[pos] = EMPTY_HASH;
values[pos].~TValue();
keys[pos].~TKey();
num_elements--;
}
/**
* reserves space for a number of elements, useful to avoid many resizes and rehashes
* if adding a known (possibly large) number of elements at once, must be larger than old
* capacity.
**/
void reserve(uint32_t p_new_capacity) {
ERR_FAIL_COND_MSG(p_new_capacity < get_num_elements(), "reserve() called with a capacity smaller than the current size. This is likely a mistake.");
if (p_new_capacity <= capacity) {
return;
}
_resize_and_rehash(p_new_capacity);
}
struct Iterator {
bool valid;
const TKey *key;
TValue *value = nullptr;
private:
uint32_t pos;
friend class OAHashMap;
};
Iterator iter() const {
Iterator it;
it.valid = true;
it.pos = 0;
return next_iter(it);
}
Iterator next_iter(const Iterator &p_iter) const {
if (!p_iter.valid) {
return p_iter;
}
Iterator it;
it.valid = false;
it.pos = p_iter.pos;
it.key = nullptr;
it.value = nullptr;
for (uint32_t i = it.pos; i < capacity; i++) {
it.pos = i + 1;
if (hashes[i] == EMPTY_HASH) {
continue;
}
it.valid = true;
it.key = &keys[i];
it.value = &values[i];
return it;
}
return it;
}
OAHashMap(std::initializer_list<KeyValue<TKey, TValue>> p_init) {
reserve(p_init.size());
for (const KeyValue<TKey, TValue> &E : p_init) {
set(E.key, E.value);
}
}
OAHashMap(const OAHashMap &p_other) {
(*this) = p_other;
}
void operator=(const OAHashMap &p_other) {
if (capacity != 0) {
clear();
}
_resize_and_rehash(p_other.capacity);
for (Iterator it = p_other.iter(); it.valid; it = p_other.next_iter(it)) {
set(*it.key, *it.value);
}
}
OAHashMap(uint32_t p_initial_capacity = 64) {
// Capacity can't be 0.
capacity = MAX(1u, p_initial_capacity);
keys = static_cast<TKey *>(Memory::alloc_static(sizeof(TKey) * capacity));
values = static_cast<TValue *>(Memory::alloc_static(sizeof(TValue) * capacity));
static_assert(EMPTY_HASH == 0, "Assuming EMPTY_HASH = 0 for alloc_static_zeroed call");
hashes = static_cast<uint32_t *>(Memory::alloc_static_zeroed(sizeof(uint32_t) * capacity));
}
~OAHashMap() {
for (uint32_t i = 0; i < capacity; i++) {
if (hashes[i] == EMPTY_HASH) {
continue;
}
values[i].~TValue();
keys[i].~TKey();
}
Memory::free_static(keys);
Memory::free_static(values);
Memory::free_static(hashes);
}
};

38
core/variant/variant_call.cpp
View file

@ -36,8 +36,8 @@
#include "core/io/marshalls.h"
#include "core/object/class_db.h"
#include "core/os/os.h"
#include "core/templates/a_hash_map.h"
#include "core/templates/local_vector.h"
#include "core/templates/oa_hash_map.h"
typedef void (*VariantFunc)(Variant &r_ret, Variant &p_self, const Variant **p_args);
typedef void (*VariantConstructFunc)(Variant &r_ret, const Variant **p_args);
@ -1264,7 +1264,7 @@ struct VariantBuiltInMethodInfo {
}
};
typedef OAHashMap<StringName, VariantBuiltInMethodInfo> BuiltinMethodMap;
typedef AHashMap<StringName, VariantBuiltInMethodInfo> BuiltinMethodMap;
static BuiltinMethodMap *builtin_method_info;
static List<StringName> *builtin_method_names;
@ -1318,7 +1318,7 @@ void Variant::callp(const StringName &p_method, const Variant **p_args, int p_ar
} else {
r_error.error = Callable::CallError::CALL_OK;
const VariantBuiltInMethodInfo *imf = builtin_method_info[type].lookup_ptr(p_method);
const VariantBuiltInMethodInfo *imf = builtin_method_info[type].getptr(p_method);
if (!imf) {
r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
@ -1350,7 +1350,7 @@ void Variant::call_const(const StringName &p_method, const Variant **p_args, int
} else {
r_error.error = Callable::CallError::CALL_OK;
const VariantBuiltInMethodInfo *imf = builtin_method_info[type].lookup_ptr(p_method);
const VariantBuiltInMethodInfo *imf = builtin_method_info[type].getptr(p_method);
if (!imf) {
r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
@ -1369,7 +1369,7 @@ void Variant::call_const(const StringName &p_method, const Variant **p_args, int
void Variant::call_static(Variant::Type p_type, const StringName &p_method, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
r_error.error = Callable::CallError::CALL_OK;
const VariantBuiltInMethodInfo *imf = builtin_method_info[p_type].lookup_ptr(p_method);
const VariantBuiltInMethodInfo *imf = builtin_method_info[p_type].getptr(p_method);
if (!imf) {
r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
@ -1404,35 +1404,35 @@ bool Variant::has_builtin_method(Variant::Type p_type, const StringName &p_metho
Variant::ValidatedBuiltInMethod Variant::get_validated_builtin_method(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, nullptr);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].lookup_ptr(p_method);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
ERR_FAIL_NULL_V(method, nullptr);
return method->validated_call;
}
Variant::PTRBuiltInMethod Variant::get_ptr_builtin_method(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, nullptr);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].lookup_ptr(p_method);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
ERR_FAIL_NULL_V(method, nullptr);
return method->ptrcall;
}
MethodInfo Variant::get_builtin_method_info(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, MethodInfo());
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].lookup_ptr(p_method);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
ERR_FAIL_NULL_V(method, MethodInfo());
return method->get_method_info(p_method);
}
int Variant::get_builtin_method_argument_count(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, 0);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].lookup_ptr(p_method);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
ERR_FAIL_NULL_V(method, 0);
return method->argument_count;
}
Variant::Type Variant::get_builtin_method_argument_type(Variant::Type p_type, const StringName &p_method, int p_argument) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, Variant::NIL);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].lookup_ptr(p_method);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
ERR_FAIL_NULL_V(method, Variant::NIL);
ERR_FAIL_INDEX_V(p_argument, method->argument_count, Variant::NIL);
return method->get_argument_type(p_argument);
@ -1440,7 +1440,7 @@ Variant::Type Variant::get_builtin_method_argument_type(Variant::Type p_type, co
String Variant::get_builtin_method_argument_name(Variant::Type p_type, const StringName &p_method, int p_argument) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, String());
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].lookup_ptr(p_method);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
ERR_FAIL_NULL_V(method, String());
#ifdef DEBUG_ENABLED
ERR_FAIL_INDEX_V(p_argument, method->argument_count, String());
@ -1452,14 +1452,14 @@ String Variant::get_builtin_method_argument_name(Variant::Type p_type, const Str
Vector<Variant> Variant::get_builtin_method_default_arguments(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, Vector<Variant>());
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].lookup_ptr(p_method);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
ERR_FAIL_NULL_V(method, Vector<Variant>());
return method->default_arguments;
}
bool Variant::has_builtin_method_return_value(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, false);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].lookup_ptr(p_method);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
ERR_FAIL_NULL_V(method, false);
return method->has_return_type;
}
@ -1478,35 +1478,35 @@ int Variant::get_builtin_method_count(Variant::Type p_type) {
Variant::Type Variant::get_builtin_method_return_type(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, Variant::NIL);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].lookup_ptr(p_method);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
ERR_FAIL_NULL_V(method, Variant::NIL);
return method->return_type;
}
bool Variant::is_builtin_method_const(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, false);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].lookup_ptr(p_method);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
ERR_FAIL_NULL_V(method, false);
return method->is_const;
}
bool Variant::is_builtin_method_static(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, false);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].lookup_ptr(p_method);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
ERR_FAIL_NULL_V(method, false);
return method->is_static;
}
bool Variant::is_builtin_method_vararg(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, false);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].lookup_ptr(p_method);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
ERR_FAIL_NULL_V(method, false);
return method->is_vararg;
}
uint32_t Variant::get_builtin_method_hash(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, 0);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].lookup_ptr(p_method);
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
ERR_FAIL_NULL_V(method, 0);
uint32_t hash = hash_murmur3_one_32(method->is_const);
hash = hash_murmur3_one_32(method->is_static, hash);
@ -1531,7 +1531,7 @@ void Variant::get_method_list(List<MethodInfo> *p_list) const {
}
} else {
for (const StringName &E : builtin_method_names[type]) {
const VariantBuiltInMethodInfo *method = builtin_method_info[type].lookup_ptr(E);
const VariantBuiltInMethodInfo *method = builtin_method_info[type].getptr(E);
ERR_CONTINUE(!method);
p_list->push_back(method->get_method_info(E));
}

2
core/variant/variant_construct.h
View file

@ -37,8 +37,8 @@
#include "core/io/compression.h"
#include "core/object/class_db.h"
#include "core/os/os.h"
#include "core/templates/a_hash_map.h"
#include "core/templates/local_vector.h"
#include "core/templates/oa_hash_map.h"
template <typename T>
struct PtrConstruct {};

28
core/variant/variant_utility.cpp
View file

@ -34,7 +34,7 @@
#include "core/object/ref_counted.h"
#include "core/object/script_language.h"
#include "core/os/os.h"
#include "core/templates/oa_hash_map.h"
#include "core/templates/a_hash_map.h"
#include "core/templates/rid.h"
#include "core/templates/rid_owner.h"
#include "core/variant/binder_common.h"
@ -1596,7 +1596,7 @@ struct VariantUtilityFunctionInfo {
Variant::UtilityFunctionType type;
};
static OAHashMap<StringName, VariantUtilityFunctionInfo> utility_function_table;
static AHashMap<StringName, VariantUtilityFunctionInfo> utility_function_table;
static List<StringName> utility_function_name_table;
template <typename T>
@ -1788,7 +1788,7 @@ void Variant::_unregister_variant_utility_functions() {
}
void Variant::call_utility_function(const StringName &p_name, Variant *r_ret, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
const VariantUtilityFunctionInfo *bfi = utility_function_table.lookup_ptr(p_name);
const VariantUtilityFunctionInfo *bfi = utility_function_table.getptr(p_name);
if (!bfi) {
r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
r_error.argument = 0;
@ -1816,7 +1816,7 @@ bool Variant::has_utility_function(const StringName &p_name) {
}
Variant::ValidatedUtilityFunction Variant::get_validated_utility_function(const StringName &p_name) {
const VariantUtilityFunctionInfo *bfi = utility_function_table.lookup_ptr(p_name);
const VariantUtilityFunctionInfo *bfi = utility_function_table.getptr(p_name);
if (!bfi) {
return nullptr;
}
@ -1825,7 +1825,7 @@ Variant::ValidatedUtilityFunction Variant::get_validated_utility_function(const
}
Variant::PTRUtilityFunction Variant::get_ptr_utility_function(const StringName &p_name) {
const VariantUtilityFunctionInfo *bfi = utility_function_table.lookup_ptr(p_name);
const VariantUtilityFunctionInfo *bfi = utility_function_table.getptr(p_name);
if (!bfi) {
return nullptr;
}
@ -1834,7 +1834,7 @@ Variant::PTRUtilityFunction Variant::get_ptr_utility_function(const StringName &
}
Variant::UtilityFunctionType Variant::get_utility_function_type(const StringName &p_name) {
const VariantUtilityFunctionInfo *bfi = utility_function_table.lookup_ptr(p_name);
const VariantUtilityFunctionInfo *bfi = utility_function_table.getptr(p_name);
if (!bfi) {
return Variant::UTILITY_FUNC_TYPE_MATH;
}
@ -1844,7 +1844,7 @@ Variant::UtilityFunctionType Variant::get_utility_function_type(const StringName
MethodInfo Variant::get_utility_function_info(const StringName &p_name) {
MethodInfo info;
const VariantUtilityFunctionInfo *bfi = utility_function_table.lookup_ptr(p_name);
const VariantUtilityFunctionInfo *bfi = utility_function_table.getptr(p_name);
if (bfi) {
info.name = p_name;
if (bfi->returns_value && bfi->return_type == Variant::NIL) {
@ -1865,7 +1865,7 @@ MethodInfo Variant::get_utility_function_info(const StringName &p_name) {
}
int Variant::get_utility_function_argument_count(const StringName &p_name) {
const VariantUtilityFunctionInfo *bfi = utility_function_table.lookup_ptr(p_name);
const VariantUtilityFunctionInfo *bfi = utility_function_table.getptr(p_name);
if (!bfi) {
return 0;
}
@ -1874,7 +1874,7 @@ int Variant::get_utility_function_argument_count(const StringName &p_name) {
}
Variant::Type Variant::get_utility_function_argument_type(const StringName &p_name, int p_arg) {
const VariantUtilityFunctionInfo *bfi = utility_function_table.lookup_ptr(p_name);
const VariantUtilityFunctionInfo *bfi = utility_function_table.getptr(p_name);
if (!bfi) {
return Variant::NIL;
}
@ -1883,7 +1883,7 @@ Variant::Type Variant::get_utility_function_argument_type(const StringName &p_na
}
String Variant::get_utility_function_argument_name(const StringName &p_name, int p_arg) {
const VariantUtilityFunctionInfo *bfi = utility_function_table.lookup_ptr(p_name);
const VariantUtilityFunctionInfo *bfi = utility_function_table.getptr(p_name);
if (!bfi) {
return String();
}
@ -1893,7 +1893,7 @@ String Variant::get_utility_function_argument_name(const StringName &p_name, int
}
bool Variant::has_utility_function_return_value(const StringName &p_name) {
const VariantUtilityFunctionInfo *bfi = utility_function_table.lookup_ptr(p_name);
const VariantUtilityFunctionInfo *bfi = utility_function_table.getptr(p_name);
if (!bfi) {
return false;
}
@ -1901,7 +1901,7 @@ bool Variant::has_utility_function_return_value(const StringName &p_name) {
}
Variant::Type Variant::get_utility_function_return_type(const StringName &p_name) {
const VariantUtilityFunctionInfo *bfi = utility_function_table.lookup_ptr(p_name);
const VariantUtilityFunctionInfo *bfi = utility_function_table.getptr(p_name);
if (!bfi) {
return Variant::NIL;
}
@ -1910,7 +1910,7 @@ Variant::Type Variant::get_utility_function_return_type(const StringName &p_name
}
bool Variant::is_utility_function_vararg(const StringName &p_name) {
const VariantUtilityFunctionInfo *bfi = utility_function_table.lookup_ptr(p_name);
const VariantUtilityFunctionInfo *bfi = utility_function_table.getptr(p_name);
if (!bfi) {
return false;
}
@ -1919,7 +1919,7 @@ bool Variant::is_utility_function_vararg(const StringName &p_name) {
}
uint32_t Variant::get_utility_function_hash(const StringName &p_name) {
const VariantUtilityFunctionInfo *bfi = utility_function_table.lookup_ptr(p_name);
const VariantUtilityFunctionInfo *bfi = utility_function_table.getptr(p_name);
ERR_FAIL_NULL_V(bfi, 0);
uint32_t hash = hash_murmur3_one_32(bfi->is_vararg);

28
drivers/gles3/shader_gles3.cpp
View file

@ -570,10 +570,10 @@ bool ShaderGLES3::_load_from_cache(Version *p_version) {
int cache_variant_count = static_cast<int>(f->get_32());
ERR_FAIL_COND_V_MSG(cache_variant_count != variant_count, false, "shader cache variant count mismatch, expected " + itos(variant_count) + " got " + itos(cache_variant_count)); //should not happen but check
LocalVector<OAHashMap<uint64_t, Version::Specialization>> variants;
LocalVector<AHashMap<uint64_t, Version::Specialization>> variants;
for (int i = 0; i < cache_variant_count; i++) {
uint32_t cache_specialization_count = f->get_32();
OAHashMap<uint64_t, Version::Specialization> variant;
AHashMap<uint64_t, Version::Specialization> variant;
for (uint32_t j = 0; j < cache_specialization_count; j++) {
uint64_t specialization_key = f->get_64();
uint32_t variant_size = f->get_32();
@ -648,18 +648,14 @@ void ShaderGLES3::_save_to_cache(Version *p_version) {
f->store_32(variant_count);
for (int i = 0; i < variant_count; i++) {
int cache_specialization_count = p_version->variants[i].get_num_elements();
int cache_specialization_count = p_version->variants[i].size();
f->store_32(cache_specialization_count);
for (OAHashMap<uint64_t, ShaderGLES3::Version::Specialization>::Iterator it = p_version->variants[i].iter(); it.valid; it = p_version->variants[i].next_iter(it)) {
const uint64_t specialization_key = *it.key;
for (KeyValue<uint64_t, ShaderGLES3::Version::Specialization> &kv : p_version->variants[i]) {
const uint64_t specialization_key = kv.key;
f->store_64(specialization_key);
const Version::Specialization *specialization = it.value;
if (specialization == nullptr) {
f->store_32(0);
continue;
}
const Version::Specialization *specialization = &kv.value;
GLint program_size = 0;
glGetProgramiv(specialization->id, GL_PROGRAM_BINARY_LENGTH, &program_size);
if (program_size == 0) {
@ -689,11 +685,11 @@ void ShaderGLES3::_clear_version(Version *p_version) {
}
for (int i = 0; i < variant_count; i++) {
for (OAHashMap<uint64_t, Version::Specialization>::Iterator it = p_version->variants[i].iter(); it.valid; it = p_version->variants[i].next_iter(it)) {
if (it.value->id != 0) {
glDeleteShader(it.value->vert_id);
glDeleteShader(it.value->frag_id);
glDeleteProgram(it.value->id);
for (KeyValue<uint64_t, Version::Specialization> &kv : p_version->variants[i]) {
if (kv.value.id != 0) {
glDeleteShader(kv.value.vert_id);
glDeleteShader(kv.value.frag_id);
glDeleteProgram(kv.value.id);
}
}
}
@ -709,7 +705,7 @@ void ShaderGLES3::_initialize_version(Version *p_version) {
}
p_version->variants.reserve(variant_count);
for (int i = 0; i < variant_count; i++) {
OAHashMap<uint64_t, Version::Specialization> variant;
AHashMap<uint64_t, Version::Specialization> variant;
p_version->variants.push_back(variant);
Version::Specialization spec;
_compile_specialization(spec, i, p_version, specialization_default_mask);

12
drivers/gles3/shader_gles3.h
View file

@ -102,7 +102,7 @@ private:
}
};
LocalVector<OAHashMap<uint64_t, Specialization>> variants;
LocalVector<AHashMap<uint64_t, Specialization>> variants;
};
Mutex variant_set_mutex;
@ -192,25 +192,25 @@ protected:
_initialize_version(version); //may lack initialization
}
Version::Specialization *spec = version->variants[p_variant].lookup_ptr(p_specialization);
Version::Specialization *spec = version->variants[p_variant].getptr(p_specialization);
if (!spec) {
if (false) {
// Queue load this specialization and use defaults in the meantime (TODO)
spec = version->variants[p_variant].lookup_ptr(specialization_default_mask);
spec = version->variants[p_variant].getptr(specialization_default_mask);
} else {
// Compile on the spot
Version::Specialization s;
_compile_specialization(s, p_variant, version, p_specialization);
version->variants[p_variant].insert(p_specialization, s);
spec = version->variants[p_variant].lookup_ptr(p_specialization);
spec = version->variants[p_variant].getptr(p_specialization);
if (shader_cache_dir_valid) {
_save_to_cache(version);
}
}
} else if (spec->build_queued) {
// Still queued, wait
spec = version->variants[p_variant].lookup_ptr(specialization_default_mask);
spec = version->variants[p_variant].getptr(specialization_default_mask);
}
if (!spec || !spec->ok) {
@ -228,7 +228,7 @@ protected:
Version *version = version_owner.get_or_null(p_version);
ERR_FAIL_NULL_V(version, -1);
ERR_FAIL_INDEX_V(p_variant, int(version->variants.size()), -1);
Version::Specialization *spec = version->variants[p_variant].lookup_ptr(p_specialization);
Version::Specialization *spec = version->variants[p_variant].getptr(p_specialization);
ERR_FAIL_NULL_V(spec, -1);
ERR_FAIL_INDEX_V(p_which, int(spec->uniform_location.size()), -1);
return spec->uniform_location[p_which];

12
editor/gui/editor_quick_open_dialog.cpp
View file

@ -475,7 +475,7 @@ void QuickOpenResultContainer::set_query_and_update(const String &p_query) {
Vector<QuickOpenResultCandidate> *QuickOpenResultContainer::_get_history() {
if (base_types.size() == 1) {
return selected_history.lookup_ptr(base_types[0]);
return selected_history.getptr(base_types[0]);
}
return nullptr;
}
@ -485,7 +485,7 @@ void QuickOpenResultContainer::_setup_candidate(QuickOpenResultCandidate &p_cand
p_candidate.result = nullptr;
StringName actual_type;
{
StringName *actual_type_ptr = filetypes.lookup_ptr(p_filepath);
StringName *actual_type_ptr = filetypes.getptr(p_filepath);
if (actual_type_ptr) {
actual_type = *actual_type_ptr;
} else {
@ -496,12 +496,12 @@ void QuickOpenResultContainer::_setup_candidate(QuickOpenResultCandidate &p_cand
if (item.preview.is_valid()) {
p_candidate.thumbnail = item.preview;
} else if (file_type_icons.has(actual_type)) {
p_candidate.thumbnail = *file_type_icons.lookup_ptr(actual_type);
p_candidate.thumbnail = *file_type_icons.getptr(actual_type);
} else if (has_theme_icon(actual_type, EditorStringName(EditorIcons))) {
p_candidate.thumbnail = get_editor_theme_icon(actual_type);
file_type_icons.insert(actual_type, p_candidate.thumbnail);
} else {
p_candidate.thumbnail = *file_type_icons.lookup_ptr(SNAME("__default_icon"));
p_candidate.thumbnail = *file_type_icons.getptr(SNAME("__default_icon"));
}
}
@ -820,11 +820,11 @@ void QuickOpenResultContainer::save_selected_item() {
const StringName &base_type = base_types[0];
QuickOpenResultCandidate &selected = candidates.write[selection_index];
Vector<QuickOpenResultCandidate> *type_history = selected_history.lookup_ptr(base_type);
Vector<QuickOpenResultCandidate> *type_history = selected_history.getptr(base_type);
if (!type_history) {
selected_history.insert(base_type, Vector<QuickOpenResultCandidate>());
type_history = selected_history.lookup_ptr(base_type);
type_history = selected_history.getptr(base_type);
} else {
for (int i = 0; i < type_history->size(); i++) {
if (selected.file_path == type_history->get(i).file_path) {

8
editor/gui/editor_quick_open_dialog.h
View file

@ -30,7 +30,7 @@
#pragma once
#include "core/templates/oa_hash_map.h"
#include "core/templates/a_hash_map.h"
#include "scene/gui/dialogs.h"
#include "scene/gui/margin_container.h"
@ -111,10 +111,10 @@ private:
Vector<FuzzySearchResult> search_results;
Vector<StringName> base_types;
Vector<String> filepaths;
OAHashMap<String, StringName> filetypes;
AHashMap<String, StringName> filetypes;
Vector<QuickOpenResultCandidate> candidates;
OAHashMap<StringName, Vector<QuickOpenResultCandidate>> selected_history;
AHashMap<StringName, Vector<QuickOpenResultCandidate>> selected_history;
HashSet<String> history_set;
String query;
@ -142,7 +142,7 @@ private:
CheckButton *include_addons_toggle = nullptr;
CheckButton *fuzzy_search_toggle = nullptr;
OAHashMap<StringName, Ref<Texture2D>> file_type_icons;
AHashMap<StringName, Ref<Texture2D>> file_type_icons;
static QuickOpenDisplayMode get_adaptive_display_mode(const Vector<StringName> &p_base_types);

18
modules/csg/csg_shape.cpp
View file

@ -576,7 +576,7 @@ void CSGShape3D::update_shape() {
CSGBrush *n = _get_brush();
ERR_FAIL_NULL_MSG(n, "Cannot get CSGBrush.");
OAHashMap<Vector3, Vector3> vec_map;
AHashMap<Vector3, Vector3> vec_map;
Vector<int> face_count;
face_count.resize(n->materials.size() + 1);
@ -594,13 +594,12 @@ void CSGShape3D::update_shape() {
for (int j = 0; j < 3; j++) {
Vector3 v = n->faces[i].vertices[j];
Vector3 add;
if (vec_map.lookup(v, add)) {
add += p.normal;
Vector3 *vec = vec_map.getptr(v);
if (vec) {
*vec += p.normal;
} else {
add = p.normal;
vec_map.insert(v, p.normal);
}
vec_map.set(v, add);
}
}
@ -655,8 +654,11 @@ void CSGShape3D::update_shape() {
Vector3 normal = p.normal;
if (n->faces[i].smooth && vec_map.lookup(v, normal)) {
normal.normalize();
if (n->faces[i].smooth) {
Vector3 *ptr = vec_map.getptr(v);
if (ptr) {
normal = ptr->normalized();
}
}
if (n->faces[i].invert) {

22
modules/gdscript/gdscript_utility_functions.cpp
View file

@ -35,7 +35,7 @@
#include "core/io/resource_loader.h"
#include "core/object/class_db.h"
#include "core/object/object.h"
#include "core/templates/oa_hash_map.h"
#include "core/templates/a_hash_map.h"
#include "core/templates/vector.h"
#include "core/variant/typed_array.h"
@ -514,7 +514,7 @@ struct GDScriptUtilityFunctionInfo {
bool is_constant = false;
};
static OAHashMap<StringName, GDScriptUtilityFunctionInfo> utility_function_table;
static AHashMap<StringName, GDScriptUtilityFunctionInfo> utility_function_table;
static List<StringName> utility_function_name_table;
static void _register_function(const StringName &p_name, const MethodInfo &p_method_info, GDScriptUtilityFunctions::FunctionPtr p_function, bool p_is_const) {
@ -598,50 +598,50 @@ void GDScriptUtilityFunctions::unregister_functions() {
}
GDScriptUtilityFunctions::FunctionPtr GDScriptUtilityFunctions::get_function(const StringName &p_function) {
GDScriptUtilityFunctionInfo *info = utility_function_table.lookup_ptr(p_function);
GDScriptUtilityFunctionInfo *info = utility_function_table.getptr(p_function);
ERR_FAIL_NULL_V(info, nullptr);
return info->function;
}
bool GDScriptUtilityFunctions::has_function_return_value(const StringName &p_function) {
GDScriptUtilityFunctionInfo *info = utility_function_table.lookup_ptr(p_function);
GDScriptUtilityFunctionInfo *info = utility_function_table.getptr(p_function);
ERR_FAIL_NULL_V(info, false);
return info->info.return_val.type != Variant::NIL || bool(info->info.return_val.usage & PROPERTY_USAGE_NIL_IS_VARIANT);
}
Variant::Type GDScriptUtilityFunctions::get_function_return_type(const StringName &p_function) {
GDScriptUtilityFunctionInfo *info = utility_function_table.lookup_ptr(p_function);
GDScriptUtilityFunctionInfo *info = utility_function_table.getptr(p_function);
ERR_FAIL_NULL_V(info, Variant::NIL);
return info->info.return_val.type;
}
StringName GDScriptUtilityFunctions::get_function_return_class(const StringName &p_function) {
GDScriptUtilityFunctionInfo *info = utility_function_table.lookup_ptr(p_function);
GDScriptUtilityFunctionInfo *info = utility_function_table.getptr(p_function);
ERR_FAIL_NULL_V(info, StringName());
return info->info.return_val.class_name;
}
Variant::Type GDScriptUtilityFunctions::get_function_argument_type(const StringName &p_function, int p_arg) {
GDScriptUtilityFunctionInfo *info = utility_function_table.lookup_ptr(p_function);
GDScriptUtilityFunctionInfo *info = utility_function_table.getptr(p_function);
ERR_FAIL_NULL_V(info, Variant::NIL);
ERR_FAIL_INDEX_V(p_arg, info->info.arguments.size(), Variant::NIL);
return info->info.arguments[p_arg].type;
}
int GDScriptUtilityFunctions::get_function_argument_count(const StringName &p_function) {
GDScriptUtilityFunctionInfo *info = utility_function_table.lookup_ptr(p_function);
GDScriptUtilityFunctionInfo *info = utility_function_table.getptr(p_function);
ERR_FAIL_NULL_V(info, 0);
return info->info.arguments.size();
}
bool GDScriptUtilityFunctions::is_function_vararg(const StringName &p_function) {
GDScriptUtilityFunctionInfo *info = utility_function_table.lookup_ptr(p_function);
GDScriptUtilityFunctionInfo *info = utility_function_table.getptr(p_function);
ERR_FAIL_NULL_V(info, false);
return (bool)(info->info.flags & METHOD_FLAG_VARARG);
}
bool GDScriptUtilityFunctions::is_function_constant(const StringName &p_function) {
GDScriptUtilityFunctionInfo *info = utility_function_table.lookup_ptr(p_function);
GDScriptUtilityFunctionInfo *info = utility_function_table.getptr(p_function);
ERR_FAIL_NULL_V(info, false);
return info->is_constant;
}
@ -657,7 +657,7 @@ void GDScriptUtilityFunctions::get_function_list(List<StringName> *r_functions)
}
MethodInfo GDScriptUtilityFunctions::get_function_info(const StringName &p_function) {
GDScriptUtilityFunctionInfo *info = utility_function_table.lookup_ptr(p_function);
GDScriptUtilityFunctionInfo *info = utility_function_table.getptr(p_function);
ERR_FAIL_NULL_V(info, MethodInfo());
return info->info;
}

248
tests/core/templates/test_oa_hash_map.h
View file

@ -1,248 +0,0 @@
/**************************************************************************/
/* test_oa_hash_map.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#pragma once
#include "core/templates/oa_hash_map.h"
#include "scene/resources/texture.h"
#include "tests/test_macros.h"
namespace TestOAHashMap {
TEST_CASE("[OAHashMap] List initialization") {
OAHashMap<int, String> map{ { 0, "A" }, { 1, "B" }, { 2, "C" }, { 3, "D" }, { 4, "E" } };
CHECK(map.get_num_elements() == 5);
String value;
CHECK(map.lookup(0, value));
CHECK(value == "A");
CHECK(map.lookup(1, value));
CHECK(value == "B");
CHECK(map.lookup(2, value));
CHECK(value == "C");
CHECK(map.lookup(3, value));
CHECK(value == "D");
CHECK(map.lookup(4, value));
CHECK(value == "E");
}
TEST_CASE("[OAHashMap] List initialization with existing elements") {
OAHashMap<int, String> map{ { 0, "A" }, { 0, "B" }, { 0, "C" }, { 0, "D" }, { 0, "E" } };
CHECK(map.get_num_elements() == 1);
String value;
CHECK(map.lookup(0, value));
CHECK(value == "E");
}
TEST_CASE("[OAHashMap] Insert element") {
OAHashMap<int, int> map;
map.insert(42, 84);
int data = 0;
bool lookup_res = map.lookup(42, data);
int value = *map.lookup_ptr(42);
CHECK(lookup_res);
CHECK(value == 84);
CHECK(data == 84);
}
TEST_CASE("[OAHashMap] Set element") {
OAHashMap<int, int> map;
map.set(42, 84);
int data = 0;
bool lookup_res = map.lookup(42, data);
int value = *map.lookup_ptr(42);
CHECK(lookup_res);
CHECK(value == 84);
CHECK(data == 84);
}
TEST_CASE("[OAHashMap] Overwrite element") {
OAHashMap<int, int> map;
map.set(42, 84);
map.set(42, 1234);
int result = *map.lookup_ptr(42);
CHECK(result == 1234);
}
TEST_CASE("[OAHashMap] Remove element") {
OAHashMap<int, int> map;
map.insert(42, 84);
map.remove(42);
CHECK(!map.has(42));
}
TEST_CASE("[OAHashMap] Get Num_Elements") {
OAHashMap<int, int> map;
map.set(42, 84);
map.set(123, 84);
map.set(123, 84);
map.set(0, 84);
map.set(123485, 84);
CHECK(map.get_num_elements() == 4);
}
TEST_CASE("[OAHashMap] Iteration") {
OAHashMap<int, int> map;
map.insert(42, 84);
map.insert(123, 12385);
map.insert(0, 12934);
map.insert(123485, 1238888);
map.set(123, 111111);
Vector<Pair<int, int>> expected;
expected.push_back(Pair<int, int>(42, 84));
expected.push_back(Pair<int, int>(123, 111111));
expected.push_back(Pair<int, int>(0, 12934));
expected.push_back(Pair<int, int>(123485, 1238888));
for (OAHashMap<int, int>::Iterator it = map.iter(); it.valid; it = map.next_iter(it)) {
int64_t result = expected.find(Pair<int, int>(*it.key, *it.value));
CHECK(result >= 0);
}
}
TEST_CASE("[OAHashMap] Insert, iterate, remove many strings") {
uint64_t pre_mem = Memory::get_mem_usage();
{
const int elem_max = 40;
OAHashMap<String, int> map;
for (int i = 0; i < elem_max; i++) {
map.insert(itos(i), i);
}
Vector<String> elems_still_valid;
for (int i = 0; i < elem_max; i++) {
if ((i % 5) == 0) {
map.remove(itos(i));
} else {
elems_still_valid.push_back(itos(i));
}
}
CHECK(elems_still_valid.size() == map.get_num_elements());
for (int i = 0; i < elems_still_valid.size(); i++) {
CHECK(map.has(elems_still_valid[i]));
}
}
CHECK(Memory::get_mem_usage() == pre_mem);
}
TEST_CASE("[OAHashMap] Clear") {
OAHashMap<int, int> map;
map.insert(42, 84);
map.insert(0, 1234);
map.clear();
CHECK(!map.has(42));
CHECK(!map.has(0));
CHECK(map.is_empty());
}
TEST_CASE("[OAHashMap] Copy constructor") {
uint64_t pre_mem = Memory::get_mem_usage();
{
OAHashMap<int, int> map0;
const uint32_t count = 5;
for (uint32_t i = 0; i < count; i++) {
map0.insert(i, i);
}
OAHashMap<int, int> map1(map0);
CHECK(map0.get_num_elements() == map1.get_num_elements());
CHECK(map0.get_capacity() == map1.get_capacity());
CHECK(*map0.lookup_ptr(0) == *map1.lookup_ptr(0));
}
CHECK(Memory::get_mem_usage() == pre_mem);
}
TEST_CASE("[OAHashMap] Operator =") {
uint64_t pre_mem = Memory::get_mem_usage();
{
OAHashMap<int, int> map0;
OAHashMap<int, int> map1;
const uint32_t count = 5;
map1.insert(1234, 1234);
for (uint32_t i = 0; i < count; i++) {
map0.insert(i, i);
}
map1 = map0;
CHECK(map0.get_num_elements() == map1.get_num_elements());
CHECK(map0.get_capacity() == map1.get_capacity());
CHECK(*map0.lookup_ptr(0) == *map1.lookup_ptr(0));
}
CHECK(Memory::get_mem_usage() == pre_mem);
}
TEST_CASE("[OAHashMap] Non-trivial types") {
uint64_t pre_mem = Memory::get_mem_usage();
{
OAHashMap<String, Ref<Texture2D>> map1;
const uint32_t count = 10;
for (uint32_t i = 0; i < count; i++) {
String string = "qwerty";
string += itos(i);
Ref<Texture2D> ref_texture_2d;
map1.set(string, ref_texture_2d);
Ref<Texture2D> map_vec = *map1.lookup_ptr(string);
CHECK(map_vec == ref_texture_2d);
}
OAHashMap<String, Ref<Texture2D>> map1copy(map1);
CHECK(map1copy.has(String("qwerty0")));
map1copy = map1;
CHECK(map1copy.has(String("qwerty2")));
OAHashMap<int64_t, Vector4 *> map2;
for (uint32_t i = 0; i < count; i++) {
Vector4 *vec = memnew(Vector4);
vec->x = 10;
vec->y = 12;
vec->z = 151;
vec->w = -13;
map2.set(i, vec);
Vector4 *p = nullptr;
map2.lookup(i, p);
CHECK(*p == *vec);
}
OAHashMap<int64_t, Vector4 *> map3(map2);
for (OAHashMap<int64_t, Vector4 *>::Iterator it = map2.iter(); it.valid; it = map2.next_iter(it)) {
memdelete(*(it.value));
}
}
CHECK(Memory::get_mem_usage() == pre_mem);
}
} // namespace TestOAHashMap

1
tests/test_main.cpp
View file

@ -103,7 +103,6 @@
#include "tests/core/templates/test_list.h"
#include "tests/core/templates/test_local_vector.h"
#include "tests/core/templates/test_lru.h"
#include "tests/core/templates/test_oa_hash_map.h"
#include "tests/core/templates/test_paged_array.h"
#include "tests/core/templates/test_rid.h"
#include "tests/core/templates/test_span.h"