]> gerrit.simantics Code Review - simantics/3d.git/blob - org.jcae.opencascade/src/TCol.i
Allow unsplitting removal of reducers by joining pipe runs
[simantics/3d.git] / org.jcae.opencascade / src / TCol.i
1 /*
2  * Project Info:  http://jcae.sourceforge.net
3  * 
4  * This program is free software; you can redistribute it and/or modify it under
5  * the terms of the GNU Lesser General Public License as published by the Free
6  * Software Foundation; either version 2.1 of the License, or (at your option)
7  * any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11  * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12  * details.
13  *
14  *
15  */
16  
17  /**
18  * Handle_TColgp_HArray1OfBoolean
19  */
20  %{#include <TColStd_HArray1OfBoolean.hxx>%}
21  class Handle_TColStd_HArray1OfBoolean
22 {
23         Handle_TColStd_HArray1OfBoolean()=0;
24 };
25
26 %typemap(jni) Handle_TColStd_HArray1OfBoolean, const Handle_TColStd_HArray1OfBoolean&   "jbooleanArray"
27 %typemap(jtype) Handle_TColStd_HArray1OfBoolean, const Handle_TColStd_HArray1OfBoolean& "boolean[]"
28 %typemap(jstype) Handle_TColStd_HArray1OfBoolean, const Handle_TColStd_HArray1OfBoolean& "boolean[]"
29 %typemap(javain) Handle_TColStd_HArray1OfBoolean, const Handle_TColStd_HArray1OfBoolean& "$javainput"
30
31 %typemap(in) Handle_TColStd_HArray1OfBoolean, const Handle_TColStd_HArray1OfBoolean&, Handle_TColStd_HArray1OfBoolean&
32 {
33         int i,j;
34         if (!$input)
35         {
36                 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
37                 return $null;
38         }
39         jsize sz = JCALL1(GetArrayLength, jenv, $input);
40         jboolean* jarr = JCALL2(GetBooleanArrayElements, jenv, $input, NULL);
41         
42         if (!jarr)
43         {
44                 //sinn? - modulo test 3
45                 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array (2)");
46                 return $null;
47         }
48         TColStd_HArray1OfBoolean *a = new TColStd_HArray1OfBoolean(1,sz);
49         for (i=1,j=0; i<=sz; i++,j++) {
50           a->SetValue(i,Standard_Boolean(jarr[j]));
51         }
52         
53         Handle_TColStd_HArray1OfBoolean *c = new Handle_TColStd_HArray1OfBoolean(a);
54         $1 = *(Handle_TColStd_HArray1OfBoolean **)&c;
55         
56 }
57
58 %typemap(freearg) TColgp_Array1OfBoolean, const TColgp_Array1OfBoolean& 
59 {
60         delete $1;
61 }
62  
63  /**
64  * Handle_TColgp_HArray1OfPnt
65  */
66 %{#include <TColgp_HArray1OfPnt.hxx>%}
67 /*class TColgp_HArray1OfPnt {
68
69   public:
70   TColgp_HArray1OfPnt(const Standard_Integer Low,const Standard_Integer Up);
71   void SetValue(const Standard_Integer Index,const gp_Pnt& Value);
72 };*//*
73 %rename(TColgp_HArray1OfPnt) Handle_TColgp_HArray1OfPnt;
74  */
75 class Handle_TColgp_HArray1OfPnt
76 {
77         Handle_TColgp_HArray1OfPnt()=0;
78 };
79
80 %typemap(jni) Handle_TColgp_HArray1OfPnt, const Handle_TColgp_HArray1OfPnt&   "jdoubleArray"
81 %typemap(jtype) Handle_TColgp_HArray1OfPnt, const Handle_TColgp_HArray1OfPnt& "double[]"
82 %typemap(jstype) Handle_TColgp_HArray1OfPnt, const Handle_TColgp_HArray1OfPnt& "double[]"
83 %typemap(javain)Handle_TColgp_HArray1OfPnt, const Handle_TColgp_HArray1OfPnt& "$javainput"
84 %typemap(in) Handle_TColgp_HArray1OfPnt, const  Handle_TColgp_HArray1OfPnt, const Handle_TColgp_HArray1OfPnt&, Handle_TColgp_HArray1OfPnt&
85 {
86         int i,j;
87         if (!$input)
88         {
89                 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
90                 return $null;
91         }
92         jsize sz = JCALL1(GetArrayLength, jenv, $input);
93         jdouble* jarr = JCALL2(GetDoubleArrayElements, jenv, $input, NULL);
94         
95         if (!jarr)
96         {
97                 //sinn? - modulo test 3
98                 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array (2)");
99                 return $null;
100         }
101         //Handle(TColgp_HArray1OfPnt) b = new TColgp_HArray1OfPnt(1,sz/3);
102         //TODO: this is a leak!
103         TColgp_HArray1OfPnt *a = new TColgp_HArray1OfPnt(1,sz/3);
104         //Handle(TColgp_HArray1OfPnt) a = new TColgp_HArray1OfPnt(1,sz/3);
105         
106         for (i=1,j=0; i<=sz/3; i++,j=j+3) {
107           a->SetValue(i,gp_Pnt(jarr[j],jarr[j+1],jarr[j+2]));
108         }
109         
110         Handle_TColgp_HArray1OfPnt *c = new Handle_TColgp_HArray1OfPnt(a);
111         $1 = *(Handle_TColgp_HArray1OfPnt **)&c;
112         
113         /*
114         
115         arg1 = *(TColgp_HArray1OfPnt **)&jarg1;
116         
117         TColgp_HArray1OfPnt $1 = a;*/
118         //Handle_TColgp_HArray1OfPnt $1 = Handle(a);
119         
120 }
121
122
123 /**
124  * TColgp_Array1OfVec
125  */
126 %{#include <TColgp_Array1OfVec.hxx>%}
127 %typemap(jni) TColgp_Array1OfVec, const TColgp_Array1OfVec&   "jdoubleArray"
128 %typemap(jtype) TColgp_Array1OfVec, const TColgp_Array1OfVec& "double[]"
129 %typemap(jstype) TColgp_Array1OfVec, const TColgp_Array1OfVec& "double[]"
130 %typemap(javain)TColgp_Array1OfVec, const TColgp_Array1OfVec& "$javainput"
131
132 %typemap(in) TColgp_Array1OfVec, const TColgp_Array1OfVec&, TColgp_Array1OfVec&
133 {
134         int i,j;
135         if (!$input)
136         {
137                 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
138                 return $null;
139         }
140         jsize sz = JCALL1(GetArrayLength, jenv, $input);
141         jdouble* jarr = JCALL2(GetDoubleArrayElements, jenv, $input, NULL);
142         
143         if (!jarr)
144         {
145                 //sinn? - modulo test 3
146                 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array (2)");
147                 return $null;
148         }
149         $1 = new TColgp_Array1OfVec(1,sz/3);
150         for (i=1,j=0; i<=sz/3; i++,j=j+3) {
151           $1->SetValue(i,gp_Vec(gp_Dir(jarr[j],jarr[j+1],jarr[j+2])));
152         }
153         
154 }
155
156 %typemap(freearg) TColgp_Array1OfVec, const TColgp_Array1OfVec& 
157 {
158         delete $1;
159 }
160
161  
162 /**
163  * TColgp_Array1OfPnt
164  */
165 %{#include <TColgp_Array1OfPnt.hxx>%}
166 %typemap(jni) TColgp_Array1OfPnt, const TColgp_Array1OfPnt&   "jdoubleArray"
167 %typemap(jtype) TColgp_Array1OfPnt, const TColgp_Array1OfPnt& "double[]"
168 %typemap(jstype) TColgp_Array1OfPnt, const TColgp_Array1OfPnt& "double[]"
169 %typemap(javain)TColgp_Array1OfPnt, const TColgp_Array1OfPnt& "$javainput"
170 %typemap(javaout)TColgp_Array1OfPnt, const TColgp_Array1OfPnt&
171 {
172         return $jnicall;
173 }
174
175 %typemap(out) TColgp_Array1OfPnt&
176 {
177     const TColgp_Array1OfPnt &Nodes = *$1;
178     int i,j,s;
179     s=Nodes.Length()*3;
180     jdouble * ns=(jdouble *)malloc(sizeof(jdouble)*s);
181     for(j=0,i=Nodes.Lower();i<=Nodes.Upper();j+=3,i++)
182     {
183         ns[j]=Nodes(i).X();
184         ns[j+1]=Nodes(i).Y();
185         ns[j+2]=Nodes(i).Z();
186     }
187     jdoubleArray jarray=JCALL1(NewDoubleArray, jenv, s);
188         JCALL4(SetDoubleArrayRegion, jenv, jarray, 0, s, ns);
189     free(ns);
190     $result=jarray;
191 }
192
193 /*
194  * @author Jens Schmidt
195  *
196  */
197 %typemap(in) TColgp_Array1OfPnt, const TColgp_Array1OfPnt&, TColgp_Array1OfPnt& /*(jdouble *jarr, jsize sz)*/
198 {
199         int i,j;
200         if (!$input)
201         {
202                 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
203                 return $null;
204         }
205         jsize sz = JCALL1(GetArrayLength, jenv, $input);
206         jdouble* jarr = JCALL2(GetDoubleArrayElements, jenv, $input, NULL);
207         
208         if (!jarr)
209         {
210                 //sinn? - modulo test 3
211                 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array (2)");
212                 return $null;
213         }
214         $1 = new TColgp_Array1OfPnt(1,sz/3);
215         for (i=1,j=0; i<=sz/3; i++,j=j+3) {
216           $1->SetValue(i,gp_Pnt(jarr[j],jarr[j+1],jarr[j+2]));
217         }
218         
219 }
220
221 %typemap(freearg) TColgp_Array1OfPnt, const TColgp_Array1OfPnt& 
222 {
223         delete $1;
224 }
225
226 /**
227  * TColgp_Array1OfPnt2d
228  */
229 %{#include <TColgp_Array1OfPnt2d.hxx>%}
230 %typemap(jni) TColgp_Array1OfPnt2d&  "jdoubleArray"
231 %typemap(jtype) TColgp_Array1OfPnt2d& "double[]"
232 %typemap(jstype) TColgp_Array1OfPnt2d& "double[]"
233 %typemap(javaout) TColgp_Array1OfPnt2d&
234 {
235         return $jnicall;
236 }
237
238 %typemap(out) TColgp_Array1OfPnt2d&
239 {
240     const TColgp_Array1OfPnt2d &Nodes2d = *$1;
241     int i,j,s;
242     s=Nodes2d.Length()*2;
243     jdouble * ns=(jdouble *)malloc(sizeof(jdouble)*s);
244     for(j=0,i=Nodes2d.Lower();i<=Nodes2d.Upper();j+=2,i++)
245     {
246         ns[j]=Nodes2d(i).X();
247         ns[j+1]=Nodes2d(i).Y();
248     }
249     jdoubleArray jarray=JCALL1(NewDoubleArray, jenv, s);
250         JCALL4(SetDoubleArrayRegion, jenv, jarray, 0, s, ns);
251     free(ns);
252     $result=jarray;
253 }
254
255
256 /**
257  * TColStd_Array1OfReal
258  */
259 %{#include <TColStd_Array1OfReal.hxx>%}
260 %typemap(jni) TColStd_Array1OfReal, const TColStd_Array1OfReal&  "jdoubleArray"
261 %typemap(jtype) TColStd_Array1OfReal, const TColStd_Array1OfReal& "double[]"
262 %typemap(jstype) TColStd_Array1OfReal, const TColStd_Array1OfReal& "double[]"
263 %typemap(javain) TColStd_Array1OfReal, const TColStd_Array1OfReal& "$javainput"
264 %typemap(javaout) TColStd_Array1OfReal, const TColStd_Array1OfReal&
265 {
266         return $jnicall;
267 }
268
269 %typemap(out) TColStd_Array1OfReal, const TColStd_Array1OfReal&
270 {
271     /*
272         const TColgp_Array1OfReal &Reals = *$1;
273     int i,j,s;
274     s=Reals.Length()*2;
275     jdouble * ns=(jdouble *)malloc(sizeof(jdouble)*s);
276     for(j=0,i=Reals.Lower();i<=reals.Upper();j+=2,i++)
277     {
278         //TODO
279                 ns[j]=Reals(i).X();
280         ns[j+1]=Reals(i).Y();
281     }
282     jdoubleArray jarray=JCALL1(NewDoubleArray, jenv, s);
283         JCALL4(SetDoubleArrayRegion, jenv, jarray, 0, s, ns);
284     free(ns);
285     $result=jarray;*/
286 }
287
288 %typemap(in) TColStd_Array1OfReal, const TColStd_Array1OfReal&
289 {
290         int i,j;
291         if (!$input)
292         {
293                 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
294                 return $null;
295         }
296         jsize sz = JCALL1(GetArrayLength, jenv, $input);
297         jdouble* jarr = JCALL2(GetDoubleArrayElements, jenv, $input, NULL);
298
299         $1 = new TColStd_Array1OfReal(1,sz);
300         for (i=1,j=0; i<=sz; i++,j++) {
301           $1->SetValue(i,Standard_Real(jarr[j]));
302         }
303         
304 }
305
306 %typemap(freearg) TColStd_Array1OfReal, const TColStd_Array1OfReal&
307 {
308         delete $1;
309 }