casadi::RevWeakCache< K, T > Class Template Reference

#include <generic_shared.hpp>

Detailed Description

template<typename K, typename T>
class casadi::RevWeakCache< K, T >

Key is stored as a weakref Value is stored as regular ref

Definition at line 328 of file generic_shared.hpp.

Public Member Functions
void	tocache (const K &key, const T &f, bool needs_lock=true)
void	tocache_if_missing (const K &key, T &f)
bool	incache (const K &key, T &f, bool needs_lock=true) const

Member Function Documentation

incache()

template<typename K , typename T >

bool casadi::RevWeakCache< K, T >::incache ( const K &  key, T &  f, bool  needs_lock = true  ) const

inline

Definition at line 365 of file generic_shared.hpp.

                                                                 {
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
      // Safe access to cache_
      casadi::conditional_lock_guard<std::mutex> lock(mtx_, needs_lock);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
      const void* k = key.get();
      auto it = pre_cache_.find(k);
      K temp;
      if (it!=pre_cache_.end() && it->second.shared_if_alive(temp)) {
        auto it2 = cache_.find(k);
        f = it2->second;
        return true;
      } else {
        return false;
      }
    }

tocache()

template<typename K , typename T >

void casadi::RevWeakCache< K, T >::tocache ( const K &  key, const T &  f, bool  needs_lock = true  )

inline

Definition at line 330 of file generic_shared.hpp.

                                                                 {
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
      // Safe access to cache_
      casadi::conditional_lock_guard<std::mutex> lock(mtx_, needs_lock);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
      // Add to cache
      const void* k = key.get();
      pre_cache_.insert(std::make_pair(k, key));
      cache_.insert(std::make_pair(k, f));
      // Remove a lost reference, if any, to prevent uncontrolled growth
      for (auto it = pre_cache_.begin(); it!=pre_cache_.end(); ++it) {
        if (!it->second.alive()) {
          pre_cache_.erase(it);
          cache_.erase(it->first);
          break; // just one dead reference is enough
        }
      }
    }

tocache_if_missing()

template<typename K , typename T >

void casadi::RevWeakCache< K, T >::tocache_if_missing ( const K &  key, T &  f  )

inline

Definition at line 356 of file generic_shared.hpp.

                                                {
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
      // Safe access to cache_
      std::lock_guard<std::mutex> lock(mtx_);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
      if (!incache(key, f, false)) {
        tocache(key, f, false);
      }
    }

---

The documentation for this class was generated from the following file:

• generic_shared.hpp