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
|
%module li_std_container_typemaps
%include stl.i
%include std_list.i
%include std_deque.i
%include std_set.i
%include std_multiset.i
%{
#include <vector>
#include <list>
#include <deque>
#include <set>
#include <iostream>
#include <iterator>
#include <algorithm>
#include <numeric>
using namespace std;
%}
%inline %{
class ClassA
{
public:
ClassA() : a(0) {}
ClassA(int _a) : a(_a) {}
ClassA(const ClassA& c) : a(c.a) {}
int a;
};
typedef ClassA* ClassAPtr;
enum _Color { RED=1, GREEN=10, YELLOW=11, BLUE=100, MAGENTA=101, CYAN=111 };
typedef enum _Color Color;
namespace std {
template<typename T> T binaryOperation(T x, T y) {
return static_cast<T>(x + y);
}
template<> bool binaryOperation(bool x, bool y) {
return x | y;
}
template<> ClassAPtr binaryOperation(ClassAPtr x, ClassAPtr y) {
if (x)
y->a += x->a;
return y;
}
template<typename SeqCont>
struct sequence_container {
typedef typename SeqCont::value_type value_type;
static SeqCont ret_container(const value_type value1, const value_type value2) {
SeqCont s;
s.insert(s.end(), value1);
s.insert(s.end(), value2);
return s;
}
static value_type val_container(const SeqCont container) {
return std::accumulate(container.begin(), container.end(), value_type(),
binaryOperation<value_type>);
}
static value_type ref_container(const SeqCont& container) {
return std::accumulate(container.begin(), container.end(), value_type(),
binaryOperation<value_type>);
}
};
template<typename T, class Container>
Container ret_container(const T value1, const T value2) {
return sequence_container<Container>::ret_container(value1, value2);
}
template<typename T, class Container>
T val_container(const Container container) {
return sequence_container<Container >::val_container(container);
}
template<typename T, class Container>
T ref_container(const Container& container) {
return sequence_container<Container >::ref_container(container);
}
}
%}
%define %instantiate_containers_templates(TYPE...)
namespace std
{
%template(TYPE ## _vector) std::vector<TYPE>;
%template(TYPE ## _list) std::list<TYPE>;
%template(TYPE ## _deque) std::deque<TYPE>;
%template(TYPE ## _set) std::set<TYPE>;
%template(TYPE ## _multiset) std::multiset<TYPE>;
}
%enddef
%define %instantiate_containers_functions(TYPE...)
namespace std
{
%template(ret_ ## TYPE ## _vector) ret_container<TYPE, std::vector<TYPE> >;
%template(val_ ## TYPE ## _vector) val_container<TYPE, std::vector<TYPE> >;
%template(ref_ ## TYPE ## _vector) ref_container<TYPE, std::vector<TYPE> >;
%template(ret_ ## TYPE ## _list) ret_container<TYPE, std::list<TYPE> >;
%template(val_ ## TYPE ## _list) val_container<TYPE, std::list<TYPE> >;
%template(ref_ ## TYPE ## _list) ref_container<TYPE, std::list<TYPE> >;
%template(ret_ ## TYPE ## _deque) ret_container<TYPE, std::deque<TYPE> >;
%template(val_ ## TYPE ## _deque) val_container<TYPE, std::deque<TYPE> >;
%template(ref_ ## TYPE ## _deque) ref_container<TYPE, std::deque<TYPE> >;
%template(ret_ ## TYPE ## _set) ret_container<TYPE, std::set<TYPE> >;
%template(val_ ## TYPE ## _set) val_container<TYPE, std::set<TYPE> >;
%template(ref_ ## TYPE ## _set) ref_container<TYPE, std::set<TYPE> >;
%template(ret_ ## TYPE ## _multiset) ret_container<TYPE, std::multiset<TYPE> >;
%template(val_ ## TYPE ## _multiset) val_container<TYPE, std::multiset<TYPE> >;
%template(ref_ ## TYPE ## _multiset) ref_container<TYPE, std::multiset<TYPE> >;
}
%enddef
%define %instantiate_containers_templates_and_functions(TYPE...)
%instantiate_containers_templates(TYPE);
%instantiate_containers_functions(TYPE);
%enddef
%instantiate_containers_templates_and_functions(int);
%instantiate_containers_templates_and_functions(double);
%instantiate_containers_templates_and_functions(float);
%instantiate_containers_templates_and_functions(bool);
%instantiate_containers_templates_and_functions(string);
%instantiate_containers_templates_and_functions(ClassAPtr);
|
