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

#include <generic_shared.hpp>

Detailed Description

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

Definition at line 60 of file generic_shared.hpp.

Inheritance diagram for casadi::GenericShared< Shared, Internal >:

Public Member Functions
	GenericShared ()
	Default constructor. More...
	GenericShared (const GenericShared &ref)
	Copy constructor (shallow copy) More...
	~GenericShared ()
	Destructor. More...
GenericShared &	operator= (const GenericShared &ref)
	Assignment operator. More...
void	own (Internal *node)
void	assign (Internal *node)
	Assign the node to a node class pointer without reference counting. More...
Internal *	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...
Internal *	operator-> () const
	Access a member function or object. 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< Shared, Internal > *	weak ()
	Get a weak reference to the object. More...

Protected Member Functions
void	count_up ()
void	count_down ()

Friends
template<class B , class S >
B	shared_cast (S &A)
	Typecast a shared object to a base class to a shared object to a derived class,. More...
template<class B , class S >
const B	shared_cast (const S &A)
	Typecast a shared object to a base class to a shared object to a derived class,. More...

Constructor & Destructor Documentation

GenericShared() [1/2]

template<typename Shared , typename Internal >

casadi::GenericShared< Shared, Internal >::GenericShared ( )

inline

Definition at line 69 of file generic_shared.hpp.

                    {
        node = nullptr;
    }

GenericShared() [2/2]

template<typename Shared , typename Internal >

casadi::GenericShared< Shared, Internal >::GenericShared ( const GenericShared< Shared, Internal > &  ref )

inline

Definition at line 74 of file generic_shared.hpp.

                                            {
        node = ref.node;
        count_up();
    }

~GenericShared()

template<typename Shared , typename Internal >

casadi::GenericShared< Shared, Internal >::~GenericShared ( )

inline

Definition at line 80 of file generic_shared.hpp.

                     {
      count_down();
    }

Member Function Documentation

__hash__()

template<typename Shared , typename Internal >

casadi_int casadi::GenericShared< Shared, Internal >::__hash__

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 141 of file generic_shared_impl.hpp.

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

assign()

template<typename Shared , typename Internal >

void casadi::GenericShared< Shared, Internal >::assign

(

Internal *

node

)

improper use will cause memory leaks!

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

Definition at line 79 of file generic_shared_impl.hpp.

                                                              {
    node = node_;
  }

count_down()

template<typename Shared , typename Internal >

void casadi::GenericShared< Shared, Internal >::count_down

protected

Definition at line 46 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()

template<typename Shared , typename Internal >

void casadi::GenericShared< Shared, Internal >::count_up

protected

Definition at line 36 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()

template<typename Shared , typename Internal >

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

Definition at line 84 of file generic_shared_impl.hpp.

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

get()

template<typename Shared , typename Internal >

Internal * casadi::GenericShared< Shared, Internal >::get

Definition at line 108 of file generic_shared_impl.hpp.

                                                       {
    return node;
  }

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

getCount()

template<typename Shared , typename Internal >

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

Definition at line 131 of file generic_shared_impl.hpp.

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

Referenced by casadi::MXNode::~MXNode().

is_null()

template<typename Shared , typename Internal >

bool casadi::GenericShared< Shared, Internal >::is_null

Definition at line 113 of file generic_shared_impl.hpp.

                                                      {
    return node==nullptr;
  }

Referenced by casadi::FunctionInternal::add_embedded(), casadi::FunctionInternal::alloc(), casadi::Nlpsol::callback(), casadi::DaeBuilderInternal::clear_cache(), casadi::Switch::codegen_body(), casadi::Conic::Conic(), casadi::conic_debug(), casadi::DaeBuilderInternal::export_fmu(), casadi::FunctionInternal::finalize(), casadi::Switch::find(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::get_n_in(), casadi::Switch::get_n_in(), casadi::FunctionInternal::get_n_out(), casadi::Switch::get_n_out(), casadi::FunctionInternal::get_name_in(), casadi::FunctionInternal::get_name_out(), casadi::FunctionInternal::get_partition(), casadi::FunctionInternal::get_sparsity_in(), casadi::Switch::get_sparsity_in(), casadi::FunctionInternal::get_sparsity_out(), casadi::Switch::get_sparsity_out(), casadi::MXFunction::get_stats(), casadi::Integrator::init(), casadi::Nlpsol::init(), casadi::Rootfinder::init(), casadi::Switch::init(), casadi::SLEQPInterface::init(), casadi::SnoptInterface::init(), casadi::SundialsInterface::init(), casadi::FastNewton::init(), casadi::Newton::init(), casadi::Scpgen::init(), casadi::BonminInterface::intermediate_callback(), casadi::IpoptInterface::intermediate_callback(), casadi::XFunction< DerivedType, MatType, NodeType >::jac(), casadi::FunctionInternal::jac_is_symm(), casadi::FunctionInternal::jac_sparsity(), casadi::OracleFunction::jit_dependencies(), casadi::SparsityInternal::maxtrans(), casadi::BlazingSplineFunction::merge(), casadi::Function::operator==(), casadi::DaeBuilderInternal::oracle(), casadi::SLEQPInterface::set_work(), casadi::SnoptInterface::set_work(), casadi::OptiNode::solve(), casadi::KnitroInterface::solve(), casadi::SLEQPInterface::solve(), casadi::WorhpInterface::solve(), casadi::FunctionInternal::sp_forward_block(), casadi::FunctionInternal::sp_reverse(), and casadi::Sparsity::uni_coloring().

operator->()

template<typename Shared , typename Internal >

Internal * casadi::GenericShared< Shared, Internal >::operator->

Definition at line 118 of file generic_shared_impl.hpp.

                                                              {
    casadi_assert_dev(!is_null());
    return node;
  }

Referenced by casadi::GenericWeakRef< Shared, Internal >::operator->().

operator=()

template<typename Shared , typename Internal >

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

(

const GenericShared< Shared, Internal > &

ref

)

Definition at line 94 of file generic_shared_impl.hpp.

                                                                     {
    // quick return if the old and new pointers point to the same object
    if (node == ref.node) return *this;
 
    // decrease the counter and delete if this was the last pointer
    count_down();
 
    // save the new pointer
    node = ref.node;
    count_up();
    return *this;
  }

own()

template<typename Shared , typename Internal >

void casadi::GenericShared< Shared, Internal >::own

(

Internal *

node

)

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

Definition at line 72 of file generic_shared_impl.hpp.

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

Referenced by casadi::Fmu::create(), casadi::Function::create(), casadi::Importer::create(), casadi::Linsol::create(), casadi::Resource::create(), casadi::GenericType::create(), casadi::Sparsity::create(), casadi::FunctionInternal::deserialize(), casadi::Linsol::deserialize(), casadi::FmuFunction::factory(), casadi::FmuFunction::get_forward(), casadi::FmuFunction::get_jacobian(), casadi::LinearInterpolant::get_jacobian(), casadi::CallSX::get_output(), casadi::FmuFunction::get_reverse(), and casadi::MXFunction::init().

swap()

template<typename Shared , typename Internal >

void casadi::GenericShared< Shared, Internal >::swap

(

GenericShared< Shared, Internal > &

other

)

Definition at line 124 of file generic_shared_impl.hpp.

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

weak()

template<typename Shared , typename Internal >

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

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

Definition at line 136 of file generic_shared_impl.hpp.

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

Friends And Related Function Documentation

shared_cast [1/2]

template<typename Shared , typename Internal >

template<class B , class S >

const B shared_cast ( const S &  A )

friend

cf. dynamic_cast (const)

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

Definition at line 230 of file generic_shared.hpp.

                                  {
    S A_copy = A;
    return shared_cast<B, S>(A_copy);
  }

shared_cast [2/2]

template<typename Shared , typename Internal >

template<class B , class S >

B shared_cast ( S &  A )

friend

cf. dynamic_cast

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

Get a pointer to the node

Create a return object

Quick return if not allowed

Assign node of B and return

Definition at line 208 of file generic_shared.hpp.

                      {
 
    typename S::internal_base_type* ptr = A.get();
 
    B ret;
 
    if (!B::test_cast(ptr)) return ret;
 
    ret.own(ptr);
    return ret;
  }

---

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

• generic_shared.hpp
• generic_shared_impl.hpp