GenericShared implements a reference counting framework similar for efficient and. More...

#include <shared_object.hpp>

Detailed Description

easily-maintained memory management.

To use the class, both the GenericShared class (the public class), and the GenericSharedInternal class (the internal class) must be inherited from. It can be done in two different files and together with memory management, this approach provides a clear distinction of which methods of the class are to be considered "public", i.e. methods for public use that can be considered to remain over time with small changes, and the internal memory.

When interfacing a software, which typically includes including some header file, this is best done only in the file where the internal class is defined, to avoid polluting the global namespace and other side effects.

The default constructor always means creating a null pointer to an internal class only. To allocate an internal class (this works only when the internal class isn't abstract), use the constructor with arguments.

The copy constructor and the assignment operator perform shallow copies only, to make a deep copy you must use the clone method explicitly. This will give a shared pointer instance.

In an inheritance hierarchy, you can cast down automatically, e.g. (SXFunction is a child class of Function): SXFunction derived(...); Function base = derived;

To cast up, use the shared_cast template function, which works analogously to dynamic_cast, static_cast, const_cast etc, e.g.: SXFunction derived(...); Function base = derived; SXFunction derived_from_base = shared_cast<SXFunction>(base);

A failed shared_cast will result in a null pointer (cf. dynamic_cast)

Author: Joel Andersson

Date: 2010

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

Definition at line 78 of file shared_object.hpp.

Inheritance diagram for casadi::SharedObject:

[legend]

Collaboration diagram for casadi::SharedObject:

[legend]

Public Types
using	internal_base_type = SharedObjectInternal

using	base_type = SharedObject

Public Member Functions
std::string	class_name () const
	Get class name. More...

void	disp (std::ostream &stream, bool more=false) const
	Print a description of the object. More...

std::string	get_str (bool more=false) const
	Get string representation. More...

void	print_ptr (std::ostream &stream=casadi::uout()) const

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...

SharedObjectInternal *	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< SharedObject, SharedObjectInternal > *	weak ()
	Get a weak reference to the object. More...

Protected Member Functions
void	count_up ()

void	count_down ()

Member Typedef Documentation

◆ base_type

using casadi::SharedObject::base_type = SharedObject

Definition at line 103 of file shared_object.hpp.

◆ internal_base_type

using casadi::SharedObject::internal_base_type = SharedObjectInternal

Definition at line 102 of file shared_object.hpp.

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

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

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

                                                               {
     node = node_;
   }

◆ class_name()

std::string casadi::SharedObject::class_name ( ) const

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

Definition at line 31 of file shared_object.cpp.

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

Referenced by casadi::FmuFunction::check_mem_count(), casadi::MXFunction::export_code_body(), and casadi::BlazingSplineFunction::merge().

◆ count_down()

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

protectedinherited

Definition at line 134 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 133 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 113 of file generic_shared_impl.hpp.

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

◆ disp()

void casadi::SharedObject::disp	(	std::ostream &	stream,
		bool	more = `false`
	)		const

Definition at line 35 of file shared_object.cpp.

                                                              {
     if (is_null()) {
       stream << "NULL";
     } else {
       (*this)->disp(stream, more);
     }
   }

References casadi::GenericShared< SharedObject, SharedObjectInternal >::is_null().

Referenced by casadi::Nlpsol::disp_more(), and casadi::CsparseInterface::nfact().

◆ get()

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

inherited

Definition at line 100 of file generic_shared_impl.hpp.

                                                        {
     return node;
   }

◆ get_str()

std::string casadi::SharedObject::get_str ( bool more = false ) const

inline

Definition at line 91 of file shared_object.hpp.

                                                {
         std::stringstream ss;
         disp(ss, more);
         return ss.str();
       }

◆ getCount()

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

inherited

Definition at line 103 of file generic_shared_impl.hpp.

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

◆ is_null()

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

inherited

Definition at line 117 of file generic_shared_impl.hpp.

                                                       {
     return node==nullptr;
   }

◆ operator->()

SharedObjectInternal * casadi::GenericShared< SharedObject , SharedObjectInternal >::operator->

inherited

Definition at line 109 of file generic_shared_impl.hpp.

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

◆ own()

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

inherited

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

Definition at line 90 of file generic_shared_impl.hpp.

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

◆ print_ptr()

void casadi::SharedObject::print_ptr ( std::ostream & stream = casadi::uout() ) const

Print the pointer to the internal class

Definition at line 43 of file shared_object.cpp.

                                                        {
     stream << get();
   }

References casadi::GenericShared< SharedObject, SharedObjectInternal >::get().

◆ swap()

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

inherited

Definition at line 106 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 131 of file generic_shared_impl.hpp.

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

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

Detailed Description

Public Types

Public Member Functions

Protected Member Functions

Member Typedef Documentation

◆ base_type

◆ internal_base_type

Member Function Documentation

◆ __hash__()

◆ assign()

◆ class_name()

◆ count_down()

◆ count_up()

◆ debug_repr()

◆ disp()

◆ get()

◆ get_str()

◆ getCount()

◆ is_null()

◆ operator->()

◆ own()

◆ print_ptr()

◆ swap()

◆ weak()

◆ hash()