1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
%module li_std_auto_ptr
%{
#if __GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
#pragma GCC diagnostic ignored "-Wdeprecated-declarations" // auto_ptr deprecation
#endif
#if defined(__clang__)
#pragma clang diagnostic push
// Suppress 'auto_ptr<>' is deprecated
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
#endif
%}
#if !(defined(SWIGGO) || defined(SWIGOCAML) || defined(SWIGR) || defined(SWIGSCILAB))
%warnfilter(509, 516) overloadTest(Klass);
%include "std_string.i"
//#include <iostream>
%include "std_auto_ptr.i"
%auto_ptr(Klass)
%inline %{
void show_cplusplus_version() {
printf("__cplusplus %d\n", (int)__cplusplus);
}
%}
%{
#if __cplusplus < 201703L
#include <memory>
#else
// If <memory> has already been include (Octave does) then unfortunately gcc incorrectly still provides
// std::auto_ptr when _GLIBCXX_USE_DEPRECATED is defined by the compiler configuration/OS/who knows what!!
#include <memory> // Now need to include it in case _GLIBCXX_USE_DEPRECATED is defined and <memory> has not been included, argh
#if !defined(_GLIBCXX_USE_DEPRECATED)
// Simple std::auto_ptr implementation for testing after its removal in C++17
namespace std {
template <class T> class auto_ptr {
T *ptr;
public:
explicit auto_ptr(T *p = 0) : ptr(p) {}
auto_ptr(auto_ptr&& a) : ptr(a.ptr) { a.ptr = 0;}
~auto_ptr() { delete ptr; }
T *release() { T *p = ptr; ptr = 0; return p; }
T* get() const { return ptr; }
void reset(T *p = 0) { delete ptr; ptr = p; }
T &operator*() const { return *ptr; }
T *operator->() const { return ptr; }
auto_ptr& operator=(auto_ptr&& a) { if (&a != this) { delete ptr; ptr = a.ptr; a.ptr = 0; } return *this; }
};
}
#endif
#endif
#include <string>
#include "swig_examples_lock.h"
%}
%inline %{
class Klass {
public:
explicit Klass(const char* label) :
m_label(label)
{
SwigExamples::Lock lock(critical_section);
total_count++;
}
const char* getLabel() const { return m_label.c_str(); }
virtual ~Klass()
{
SwigExamples::Lock lock(critical_section);
total_count--;
}
static int getTotal_count() { return total_count; }
private:
static SwigExamples::CriticalSection critical_section;
static int total_count;
std::string m_label;
};
SwigExamples::CriticalSection Klass::critical_section;
int Klass::total_count = 0;
%}
%inline %{
// Virtual inheritance used as this usually results in different values for Klass* and KlassInheritance*
// for testing class inheritance and auto_ptr
struct KlassInheritance : virtual Klass {
KlassInheritance(const char* label) : Klass(label) {
// std::cout << "ptrs.... " << std::hex << (Klass*)this << " " << (KlassInheritance*)this << std::endl;
}
};
std::string useKlassRawPtr(Klass* k) {
// std::cout << "useKlassRawPtr " << std::hex << (Klass*)k << std::endl;
std::string s(k->getLabel());
// std::cout << "useKlassRawPtr string: " << s << std::endl;
return s;
}
std::string takeKlassAutoPtr(std::auto_ptr<Klass> k) {
// std::cout << "takeKlassAutoPtr " << std::hex << (Klass*)k.get() << std::endl;
std::string s(k.get() ? k->getLabel() : "null smart pointer");
// std::cout << "takeKlassAutoPtr string: " << s << std::endl;
return s;
}
Klass *make_null() {
return 0;
}
bool is_nullptr(Klass *p) {
return p == 0;
}
Klass *get_not_owned_ptr(Klass *p) {
return p;
}
std::auto_ptr<Klass> makeKlassAutoPtr(const char* label) {
return std::auto_ptr<Klass>(new Klass(label));
}
std::auto_ptr<Klass> makeNullAutoPtr() {
return std::auto_ptr<Klass>();
}
int overloadTest() {
return 0;
}
int overloadTest(std::auto_ptr<Klass> kover) {
return 1;
}
int overloadTest(Klass k) {
return 2;
}
%}
#endif
|
