sascha
/
query
1
0
Fork 0
Code Issues 4 Pull Requests Actions Packages Projects Releases Wiki Activity

renamed template parameters

This commit is contained in:
sascha 2026-05-07 14:28:22 +02:00
parent 3658664eb9
commit 3d4a61749b
1 changed files with 20 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
include/matador/object/object_cache.hpp
View File

@ -25,10 +25,10 @@ struct cache_entry_base {
[[nodiscard]] virtual bool is_dead() const noexcept = 0;
};
template<typename T>
template<typename Type>
struct cache_entry : cache_entry_base {
std::weak_ptr<object_proxy<T> > proxy;
std::weak_ptr<T> entity;
std::weak_ptr<object_proxy<Type> > proxy;
std::weak_ptr<Type> entity;
[[nodiscard]] bool is_dead() const noexcept override {
return proxy.expired() && entity.expired();
@ -63,8 +63,8 @@ public:
* Andernfalls wird ein neuer Proxy erzeugt, im Cache abgelegt und zurückgegeben.
* Falls für (T, id) bereits eine Entity vorhanden ist, wird sie an den Proxy gebunden.
*
* @tparam T Entity-Typ.
* @tparam ResolverPtr Zeiger-Typ auf einen Resolver, typischerweise
* @tparam Type Entity-Typ.
* @tparam ResolverPointerType Zeiger-Typ auf einen Resolver, typischerweise
* @c std::shared_ptr<object_resolver<T>> oder @c std::weak_ptr<object_resolver<T>>.
* @param id Identifier/Primärschlüssel der Entity.
* @param resolver_ptr Resolver (shared/weak), der zur Lazy-Auflösung durch den Proxy genutzt wird.
@ -72,23 +72,23 @@ public:
*
* @note Diese Methode ist threadsafe.
*/
template<typename T, typename ResolverPtr>
std::shared_ptr<object_proxy<T>> acquire_proxy(utils::identifier id, ResolverPtr &&resolver_ptr) {
const auto k = make_key<T>(id);
template<typename Type, typename ResolverPointerType>
std::shared_ptr<object_proxy<Type>> acquire_proxy(utils::identifier id, ResolverPointerType &&resolver_ptr) {
const auto k = make_key<Type>(id);
std::unique_lock lock(mutex_);
auto it = map_.find(k);
if (it != map_.end()) {
// found entry, return std::shared_ptr of proxy
auto *entry = entry_cast_<T>(it->second.get());
auto *entry = entry_cast_<Type>(it->second.get());
if (auto proxy_ptr = entry->proxy.lock()) {
return proxy_ptr;
}
// if the proxy is dead, but the entity is alive, create a new proxy and attach entity
auto weak_resolver = to_weak<T>(std::forward<ResolverPtr>(resolver_ptr));
auto proxy_ptr = std::make_shared<object_proxy<T>>(weak_resolver, id);
auto weak_resolver = to_weak<Type>(std::forward<ResolverPointerType>(resolver_ptr));
auto proxy_ptr = std::make_shared<object_proxy<Type>>(weak_resolver, id);
if (auto obj = entry->entity.lock()) {
proxy_ptr->attach(std::move(obj));
@ -101,12 +101,12 @@ public:
}
// entry couldn't be found, create a new entry
auto entry_ptr = std::make_unique<cache_entry<T>>();
auto entry_ptr = std::make_unique<cache_entry<Type>>();
auto *entry = entry_ptr.get();
// create a weak resolver and shared proxy
auto weak_resolver = to_weak<T>(std::forward<ResolverPtr>(resolver_ptr));
auto proxy_ptr = std::make_shared<object_proxy<T>>(weak_resolver, id);
auto weak_resolver = to_weak<Type>(std::forward<ResolverPointerType>(resolver_ptr));
auto proxy_ptr = std::make_shared<object_proxy<Type>>(weak_resolver, id);
// lock entity and attach to proxy
if (auto obj = entry->entity.lock()) {
@ -286,12 +286,10 @@ private:
}
template<typename T, typename U>
using enable_if_resolver_shared_ptr_t =
std::enable_if_t<std::is_base_of_v<object_resolver<T>, U>, int>;
using enable_if_resolver_shared_ptr_t = std::enable_if_t<std::is_base_of_v<object_resolver<T>, U>, int>;
template<typename T, typename U>
using enable_if_resolver_weak_ptr_t =
std::enable_if_t<std::is_base_of_v<object_resolver<T>, U>, int>;
using enable_if_resolver_weak_ptr_t = std::enable_if_t<std::is_base_of_v<object_resolver<T>, U>, int>;
// shared_ptr<Derived> -> weak_ptr<Base>
template<typename T, typename U, enable_if_resolver_shared_ptr_t<T, U> = 0>
@ -306,8 +304,8 @@ private:
}
// (2) Opportunistischer Cleanup: entferne Entry, wenn beide weak_ptr abgelaufen sind.
template<typename It>
bool prune_if_dead(It &it) {
template<typename IteratorType>
bool prune_if_dead(IteratorType &it) {
if (it == map_.end()) {
return false;
}
@ -319,9 +317,9 @@ private:
return false;
}
template<typename T>
template<typename Type>
void prune_if_dead_typed(typename std::unordered_map<key, std::unique_ptr<cache_entry_base>, key_hash>::iterator &it) {
(void)T{}; // T bleibt im Interface, damit bestehende Call-Sites unverändert bleiben können.
(void)Type{}; // T bleibt im Interface, damit bestehende Call-Sites unverändert bleiben können.
prune_if_dead(it);
}