casadi::WeakRef Class Reference

Weak reference type. More...

#include <shared_object.hpp>

Detailed Description

A weak reference to a GenericShared

Author

Joel Andersson

Date

2013

Extra doc: https://github.com/casadi/casadi/wiki/L_ax

Definition at line 114 of file shared_object.hpp.

Inheritance diagram for casadi::WeakRef:

Collaboration diagram for casadi::WeakRef:

Public Member Functions
	WeakRef (int dummy=0)
	WeakRef (SharedObject shared)
SharedObject	shared () const
	Get a shared (owning) reference. More...
bool	alive () const
	Check if alive. More...
bool	shared_if_alive (SharedObject &shared) const
	Thread-safe alternative to alive()/shared() More...
GenericWeakRefInternal< SharedObject, SharedObjectInternal > *	operator-> ()
	Access functions of the node. More...
const GenericWeakRefInternal< SharedObject, SharedObjectInternal > *	operator-> () const
	Const access functions of the node. More...
void	own (SharedObjectInternal *node)
void	assign (SharedObjectInternal *node)
	Assign the node to a node class pointer without reference counting. More...
SharedObjectInternal *	get () const
	Get a const pointer to the node. More...
casadi_int	getCount () const
	Get the reference count. More...
void	swap (GenericShared &other)
	Swap content with another instance. More...
std::string	debug_repr () const
bool	is_null () const
	Is a null pointer? More...
casadi_int	__hash__ () const
	Returns a number that is unique for a given Node. More...
GenericWeakRef< SharedObject, SharedObjectInternal > *	weak ()
	Get a weak reference to the object. More...

Protected Member Functions
void	count_up ()
void	count_down ()

Constructor & Destructor Documentation

WeakRef() [1/2]

casadi::WeakRef::WeakRef ( int  dummy = 0 )

inline

Definition at line 117 of file shared_object.hpp.

                         : GenericWeakRef<SharedObject, SharedObjectInternal>(dummy) {
    }

WeakRef() [2/2]

casadi::WeakRef::WeakRef ( SharedObject  shared )

inline

Definition at line 119 of file shared_object.hpp.

                                 : GenericWeakRef<SharedObject, SharedObjectInternal>(shared) {
    }

Member Function Documentation

__hash__()

casadi_int casadi::GenericShared< SharedObject , SharedObjectInternal >::__hash__

inherited

If the Object does not point to any node, "0" is returned.

Extra doc: https://github.com/casadi/casadi/wiki/L_av

Definition at line 123 of file generic_shared_impl.hpp.

                                                             {
    return reinterpret_cast<casadi_int>(get());
  }

alive()

bool casadi::GenericWeakRef< SharedObject , SharedObjectInternal >::alive

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_b1

Definition at line 165 of file generic_shared_impl.hpp.

                                                     {
    return !is_null() && (*this)->raw_ != nullptr;
  }

assign()

void casadi::GenericShared< SharedObject , SharedObjectInternal >::assign ( Internal *  node )

inherited

improper use will cause memory leaks!

Extra doc: https://github.com/casadi/casadi/wiki/L_at

Definition at line 96 of file generic_shared_impl.hpp.

                                                              {
    node = node_;
  }

count_down()

void casadi::GenericShared< SharedObject , SharedObjectInternal >::count_down

protectedinherited

Definition at line 133 of file generic_shared_impl.hpp.

                                                   {
#ifdef WITH_EXTRA_CHECKS
    casadi_assert_dev(Function::call_depth_==0);
#endif // WITH_EXTRA_CHECKS
    if (!node) return;
    if (node->weak_ref_) {
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
      auto mutex = node->weak_ref_->get_mutex();
      // Avoid triggering a delete while a weak_ref.shared_if_alive is being called
      std::lock_guard<std::mutex> lock(*mutex);
      // Could it be that this mutex is destroyed when the lock goes out of scope?
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
 
      if (--static_cast<Internal*>(node)->count == 0) {
        delete node;
        node = nullptr;
      }
    } else {
      if (--static_cast<Internal*>(node)->count == 0) {
        delete node;
        node = nullptr;
      }
    }
  }

count_up()

void casadi::GenericShared< SharedObject , SharedObjectInternal >::count_up

protectedinherited

Definition at line 132 of file generic_shared_impl.hpp.

                                                 {
#ifdef WITH_EXTRA_CHECKS
    casadi_assert_dev(Function::call_depth_==0);
#endif // WITH_EXTRA_CHECKS
 
    if (node) static_cast<Internal*>(node)->count++;
 
  }

debug_repr()

std::string casadi::GenericShared< SharedObject , SharedObjectInternal >::debug_repr

inherited

Definition at line 112 of file generic_shared_impl.hpp.

                                                              {
    if (node) {
        return node->debug_repr(node);
    } else {
        return "NULL";
    }
  }

get()

SharedObjectInternal * casadi::GenericShared< SharedObject , SharedObjectInternal >::get

inherited

Definition at line 99 of file generic_shared_impl.hpp.

                                                       {
    return node;
  }

getCount()

casadi_int casadi::GenericShared< SharedObject , SharedObjectInternal >::getCount

inherited

Definition at line 102 of file generic_shared_impl.hpp.

                                                             {
    return (*this)->getCount();
  }

is_null()

bool casadi::GenericShared< SharedObject , SharedObjectInternal >::is_null

inherited

Definition at line 116 of file generic_shared_impl.hpp.

                                                      {
    return node==nullptr;
  }

operator->() [1/2]

GenericWeakRefInternal< SharedObject , SharedObjectInternal > * casadi::GenericWeakRef< SharedObject , SharedObjectInternal >::operator->

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_b2

Definition at line 175 of file generic_shared_impl.hpp.

                                               {
    return static_cast<GenericWeakRefInternal<Shared, Internal>*>(
      GenericShared<Shared, Internal>::operator->());
  }

operator->() [2/2]

const GenericWeakRefInternal< SharedObject , SharedObjectInternal > * casadi::GenericWeakRef< SharedObject , SharedObjectInternal >::operator->

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_b3

Definition at line 180 of file generic_shared_impl.hpp.

                                                     {
    return static_cast<const GenericWeakRefInternal<Shared, Internal>*>(
      GenericShared<Shared, Internal>::operator->());
  }

own()

void casadi::GenericShared< SharedObject , SharedObjectInternal >::own ( Internal *  node )

inherited

Assign the node to a node class pointer (or null)

Definition at line 89 of file generic_shared_impl.hpp.

                                                           {
    count_down();
    node = node_;
    count_up();
  }

shared()

SharedObject casadi::GenericWeakRef< SharedObject , SharedObjectInternal >::shared

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_b0

Definition at line 160 of file generic_shared_impl.hpp.

                                                        {
    Shared ret;
    if (alive()) {
      ret.own((*this)->raw_);
    }
    return ret;
  }

shared_if_alive()

bool casadi::GenericWeakRef< SharedObject , SharedObjectInternal >::shared_if_alive ( SharedObject &  shared ) const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_29i

Definition at line 170 of file generic_shared_impl.hpp.

                                                                             {
    if (is_null()) return false;
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    // Safe access to ...
    std::lock_guard<std::mutex> lock(*(*this)->mutex_);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
    if (alive()) {
      shared.own((*this)->raw_);
      return true;
    }
    return false;
  }

swap()

void casadi::GenericShared< SharedObject , SharedObjectInternal >::swap ( GenericShared< SharedObject, SharedObjectInternal > &  other )

inherited

Definition at line 105 of file generic_shared_impl.hpp.

                                                                 {
    GenericShared<Shared, Internal> temp = *this;
    *this = other;
    other = temp;
  }

weak()

GenericWeakRef< SharedObject , SharedObjectInternal > * casadi::GenericShared< SharedObject , SharedObjectInternal >::weak

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_aw

Definition at line 130 of file generic_shared_impl.hpp.

                                                                          {
    return (*this)->weak();
  }

---

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

• shared_object.hpp