casadi::GenericSharedInternal< Shared, Internal > Class Template Reference

#include <generic_shared_internal.hpp>

Detailed Description

template<typename Shared, typename Internal>
class casadi::GenericSharedInternal< Shared, Internal >

Internal class for the reference counting framework, see comments on the public class.

Definition at line 43 of file generic_shared_internal.hpp.

Public Member Functions
	GenericSharedInternal ()
	Default constructor. More...
	GenericSharedInternal (const GenericSharedInternal &node)
	Copy constructor. More...
GenericSharedInternal &	operator= (const GenericSharedInternal &node)
	Assignment operator. More...
virtual	~GenericSharedInternal ()=0
	Destructor. More...
casadi_int	getCount () const
	Get the reference count. More...
std::string	debug_repr (const Internal *) const
GenericWeakRef< Shared, Internal > *	weak ()
	Get a weak reference to the object. More...

Protected Member Functions
void	initSingleton ()
void	destroySingleton ()
template<class B >
B	shared_from_this ()
	Get a shared object from the current internal object. More...
template<class B >
const B	shared_from_this () const
	Get a shared object from the current internal object. More...

Friends
class	GenericShared< Shared, Internal >

Constructor & Destructor Documentation

GenericSharedInternal() [1/2]

template<typename Shared , typename Internal >

casadi::GenericSharedInternal< Shared, Internal >::GenericSharedInternal

Definition at line 165 of file generic_shared_internal.hpp.

                                                                 {
    static_cast<Internal*>(this)->count = 0;
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    weak_ref_.store(nullptr, std::memory_order_relaxed);
#else
    weak_ref_ = nullptr;
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
  }

GenericSharedInternal() [2/2]

template<typename Shared , typename Internal >

casadi::GenericSharedInternal< Shared, Internal >::GenericSharedInternal

(

const GenericSharedInternal< Shared, Internal > &

node

)

Definition at line 146 of file generic_shared_internal.hpp.

                                                           {
    static_cast<Internal*>(this)->count = 0; // reference counter is _not_ copied
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    weak_ref_.store(nullptr, std::memory_order_relaxed); // nor same weak references
#else
    weak_ref_ = nullptr; // nor will they have the same weak references
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
  }

~GenericSharedInternal()

template<typename Shared , typename Internal >

casadi::GenericSharedInternal< Shared, Internal >::~GenericSharedInternal

pure virtual

Definition at line 181 of file generic_shared_internal.hpp.

                                                                  {
    #ifdef WITH_REFCOUNT_WARNINGS
    if (static_cast<Internal*>(this)->count!=0) {
      // Note that casadi_assert_warning cannot be used in destructors
      std::cerr << "Reference counting failure." <<
                   "Possible cause: Circular dependency in user code." << std::endl;
    }
    #endif // WITH_REFCOUNT_WARNINGS
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    GenericWeakRef<Shared, Internal>* weak_ref =
      weak_ref_.exchange(nullptr, std::memory_order_acq_rel);
#else
    GenericWeakRef<Shared, Internal>* weak_ref = weak_ref_;
    weak_ref_ = nullptr;
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
    if (weak_ref != nullptr) {
      // Assumption: no other GenericSharedInternal instances
      // point to the same WeakRefInternal through weak_ref
      weak_ref->kill();
      delete weak_ref;
    }
  }

Member Function Documentation

debug_repr()

template<typename Shared , typename Internal >

std::string casadi::GenericSharedInternal< Shared, Internal >::debug_repr

(

const Internal *

i

)

const

Definition at line 175 of file generic_shared_internal.hpp.

                                                                                       {
    // Note: i != this because of something something multiple inheritance
    return str( (casadi_int)(i)) + "/" + static_cast<const Internal*>(this)->class_name();
  }

References casadi::str().

destroySingleton()

template<typename Shared , typename Internal >

void casadi::GenericSharedInternal< Shared, Internal >::destroySingleton ( )

inlineprotected

Called in the destructor of singletons

Definition at line 77 of file generic_shared_internal.hpp.

                            {
      static_cast<Internal*>(this)->count--;
    }

getCount()

template<typename Shared , typename Internal >

casadi_int casadi::GenericSharedInternal< Shared, Internal >::getCount

Definition at line 205 of file generic_shared_internal.hpp.

                                                                     {
    return static_cast<const Internal*>(this)->count;
  }

initSingleton()

template<typename Shared , typename Internal >

void casadi::GenericSharedInternal< Shared, Internal >::initSingleton ( )

inlineprotected

Called in the constructor of singletons to avoid that the counter reaches zero

Definition at line 71 of file generic_shared_internal.hpp.

                         {
      casadi_assert_dev(static_cast<Internal*>(this)->count==0);
      static_cast<Internal*>(this)->count++;
    }

operator=()

template<typename Shared , typename Internal >

GenericSharedInternal< Shared, Internal > & casadi::GenericSharedInternal< Shared, Internal >::operator=

(

const GenericSharedInternal< Shared, Internal > &

node

)

Definition at line 158 of file generic_shared_internal.hpp.

                                                                 {
    // do _not_ copy the reference counter
    return *this;
  }

shared_from_this() [1/2]

template<typename Shared , typename Internal >

template<class B >

B casadi::GenericSharedInternal< Shared, Internal >::shared_from_this ( )

inlineprotected

Definition at line 83 of file generic_shared_internal.hpp.

                         {
      casadi_assert_dev(B::test_cast(static_cast<Internal*>(this)));
      B ret;
      ret.own(static_cast<Internal*>(this));
      return ret;
    }

shared_from_this() [2/2]

template<typename Shared , typename Internal >

template<class B >

const B casadi::GenericSharedInternal< Shared, Internal >::shared_from_this ( ) const

inlineprotected

Definition at line 92 of file generic_shared_internal.hpp.

                                     {
      casadi_assert_dev(B::test_cast(static_cast<const Internal*>(this)));
      B ret;
      ret.own(const_cast<Internal*>(static_cast<const Internal*>(this)));
      return ret;
    }

weak()

template<typename Shared , typename Internal >

GenericWeakRef< Shared, Internal > * casadi::GenericSharedInternal< Shared, Internal >::weak

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

Definition at line 210 of file generic_shared_internal.hpp.

                                                                                  {
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    auto* w = weak_ref_.load(std::memory_order_acquire);
    if (!w) {
      auto* nw = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
      GenericWeakRef<Shared, Internal>* expected = nullptr;
      if (weak_ref_.compare_exchange_strong(
            expected, nw, std::memory_order_release, std::memory_order_acquire)) {
        w = nw;
      } else {
        delete nw; // lost the race; another thread published first
        w = expected;
      }
    }
    return w;
#else
    if (weak_ref_==nullptr) {
      weak_ref_ = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
    }
    return weak_ref_;
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
  }

Friends And Related Function Documentation

GenericShared< Shared, Internal >

template<typename Shared , typename Internal >

friend class GenericShared< Shared, Internal >

friend

Definition at line 243 of file generic_shared_internal.hpp.

---

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

• generic_shared.hpp
• generic_shared_internal.hpp