List of all members | Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions
casadi::SharedSXElem Class Reference

#include <output_sx.hpp>

Detailed Description

Definition at line 38 of file output_sx.hpp.

Inheritance diagram for casadi::SharedSXElem:
Inheritance graph
[legend]
Collaboration diagram for casadi::SharedSXElem:
Collaboration graph
[legend]

Public Types

using internal_base_type = OutputSX
 
using base_type = SharedSXElem
 

Public Member Functions

void own (OutputSX *node)
 
void assign (OutputSX *node)
 Assign the node to a node class pointer without reference counting. More...
 
OutputSX * 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...
 
OutputSX * 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< SharedSXElem, OutputSX > * weak ()
 Get a weak reference to the object. More...
 

Static Public Member Functions

static bool test_cast (const OutputSX *ptr)
 

Protected Member Functions

void count_up ()
 
void count_down ()
 

Member Typedef Documentation

◆ base_type

using casadi::SharedSXElem::base_type = SharedSXElem

Definition at line 47 of file output_sx.hpp.

◆ internal_base_type

using casadi::SharedSXElem::internal_base_type = OutputSX

Definition at line 46 of file output_sx.hpp.

Member Function Documentation

◆ __hash__()

casadi_int casadi::GenericShared< SharedSXElem , OutputSX >::__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.

148  {
149  return reinterpret_cast<casadi_int>(get());
150  }

◆ assign()

void casadi::GenericShared< SharedSXElem , OutputSX >::assign ( OutputSX *  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.

86  {
87  node = node_;
88  }

◆ count_down()

void casadi::GenericShared< SharedSXElem , OutputSX >::count_down
protectedinherited

Definition at line 133 of file generic_shared_impl.hpp.

46  {
47 #ifdef WITH_EXTRA_CHECKS
48  casadi_assert_dev(Function::call_depth_==0);
49 #endif // WITH_EXTRA_CHECKS
50  if (!node) return;
51 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
52  GenericWeakRef<Shared, Internal>* weak_ref =
53  node->weak_ref_.load(std::memory_order_acquire);
54 #else
55  GenericWeakRef<Shared, Internal>* weak_ref = node->weak_ref_;
56 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
57  if (weak_ref) {
58 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
59  // get_mutex() returns a shared_ptr copy, so the mutex outlives this lock
60  // even if delete node (below) destroys the WeakRefInternal holding it
61  auto mutex = weak_ref->get_mutex();
62  // Avoid triggering a delete while a weak_ref.shared_if_alive is being called
63  std::lock_guard<std::mutex> lock(*mutex);
64 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
65 
66  if (--static_cast<Internal*>(node)->count == 0) {
67  delete node;
68  node = nullptr;
69  }
70  } else {
71  if (--static_cast<Internal*>(node)->count == 0) {
72  delete node;
73  node = nullptr;
74  }
75  }
76  }

◆ count_up()

void casadi::GenericShared< SharedSXElem , OutputSX >::count_up
protectedinherited

Definition at line 132 of file generic_shared_impl.hpp.

36  {
37 #ifdef WITH_EXTRA_CHECKS
38  casadi_assert_dev(Function::call_depth_==0);
39 #endif // WITH_EXTRA_CHECKS
40 
41  if (node) static_cast<Internal*>(node)->count++;
42 
43  }

◆ debug_repr()

std::string casadi::GenericShared< SharedSXElem , OutputSX >::debug_repr
inherited

Definition at line 112 of file generic_shared_impl.hpp.

91  {
92  if (node) {
93  return node->debug_repr(node);
94  } else {
95  return "NULL";
96  }
97  }
casadi::GenericSharedInternal::debug_repr
std::string debug_repr(const Internal *) const
Definition: generic_shared_internal.hpp:175

◆ get()

OutputSX * casadi::GenericShared< SharedSXElem , OutputSX >::get
inherited

Definition at line 99 of file generic_shared_impl.hpp.

115  {
116  return node;
117  }

◆ getCount()

casadi_int casadi::GenericShared< SharedSXElem , OutputSX >::getCount
inherited

Definition at line 102 of file generic_shared_impl.hpp.

138  {
139  return (*this)->getCount();
140  }

◆ is_null()

bool casadi::GenericShared< SharedSXElem , OutputSX >::is_null
inherited

Definition at line 116 of file generic_shared_impl.hpp.

120  {
121  return node==nullptr;
122  }

◆ operator->()

OutputSX * casadi::GenericShared< SharedSXElem , OutputSX >::operator->
inherited

Definition at line 108 of file generic_shared_impl.hpp.

125  {
126  casadi_assert_dev(!is_null());
127  return node;
128  }

◆ own()

void casadi::GenericShared< SharedSXElem , OutputSX >::own ( OutputSX *  node)
inherited

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

Definition at line 89 of file generic_shared_impl.hpp.

79  {
80  count_down();
81  node = node_;
82  count_up();
83  }

◆ swap()

void casadi::GenericShared< SharedSXElem , OutputSX >::swap ( GenericShared< SharedSXElem, OutputSX > &  other)
inherited

Definition at line 105 of file generic_shared_impl.hpp.

131  {
132  GenericShared<Shared, Internal> temp = *this;
133  *this = other;
134  other = temp;
135  }

◆ test_cast()

static bool casadi::SharedSXElem::test_cast ( const OutputSX *  ptr)
inlinestatic

Definition at line 42 of file output_sx.hpp.

42  {
43  return ptr;
44  }

◆ weak()

GenericWeakRef< SharedSXElem , OutputSX > * casadi::GenericShared< SharedSXElem , OutputSX >::weak
inherited

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

Definition at line 130 of file generic_shared_impl.hpp.

143  {
144  return (*this)->weak();
145  }
The documentation for this class was generated from the following file: