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

#include <generic_shared.hpp>

Detailed Description

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

Definition at line 240 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
void	cache (std::vector< K > &keys, std::vector< T > &entries) const

Member Function Documentation

cache()

template<typename K , typename T >

void casadi::WeakCache< K, T >::cache ( std::vector< K > &  keys, std::vector< T > &  entries  ) const

inline

Definition at line 288 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
      keys.clear();
      entries.clear();
      // Add all entries that haven't been deleted
      for (auto&& cf : cache_) {
        typename T::base_type temp;
        if (cf.second.shared_if_alive(temp)) {
          keys.push_back(cf.first);
          entries.push_back(shared_cast<T>(temp));
        }
      }
    }

incache()

template<typename K , typename T >

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

inline

Definition at line 274 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
      auto it = cache_.find(key);
      typename T::base_type temp;
      if (it!=cache_.end() && it->second.shared_if_alive(temp)) {
        f = shared_cast<T>(temp);
        return true;
      } else {
        return false;
      }
    }

Referenced by casadi::CallSX::get_output().

tocache()

template<typename K , typename T >

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

inline

Definition at line 242 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
      cache_.insert(std::make_pair(key, f));
      // Remove a lost reference, if any, to prevent uncontrolled growth
      for (auto it = cache_.begin(); it!=cache_.end(); ++it) {
        if (!it->second.alive()) {
          cache_.erase(it);
          break; // just one dead reference is enough
        }
      }
    }

tocache_if_missing()

template<typename K , typename T >

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

inline

Definition at line 265 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);
      }
    }

Referenced by casadi::CallSX::get_output().

---

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

• generic_shared.hpp