Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <sal/config.h>
21 :
22 : #include <cassert>
23 :
24 : #include "jni_bridge.h"
25 :
26 : #include "o3tl/heap_ptr.hxx"
27 : #include "rtl/strbuf.hxx"
28 : #include "uno/sequence2.h"
29 :
30 : using namespace ::rtl;
31 :
32 : namespace jni_uno
33 : {
34 :
35 :
36 0 : inline rtl_mem * seq_allocate( sal_Int32 nElements, sal_Int32 nSize )
37 : {
38 : o3tl::heap_ptr< rtl_mem > seq(
39 0 : rtl_mem::allocate( SAL_SEQUENCE_HEADER_SIZE + (nElements * nSize) ) );
40 0 : uno_Sequence * p = (uno_Sequence *)seq.get();
41 0 : p->nRefCount = 1;
42 0 : p->nElements = nElements;
43 0 : return seq.release();
44 : }
45 :
46 :
47 : namespace {
48 :
49 0 : void createDefaultUnoValue(
50 : JNI_context const & jni, void * uno_data,
51 : typelib_TypeDescriptionReference * type,
52 : JNI_type_info const * info /* maybe 0 */, bool assign)
53 : {
54 0 : switch (type->eTypeClass) {
55 : case typelib_TypeClass_BOOLEAN:
56 0 : *static_cast< sal_Bool * >(uno_data) = false;
57 0 : break;
58 :
59 : case typelib_TypeClass_BYTE:
60 0 : *static_cast< sal_Int8 * >(uno_data) = 0;
61 0 : break;
62 :
63 : case typelib_TypeClass_SHORT:
64 0 : *static_cast< sal_Int16 * >(uno_data) = 0;
65 0 : break;
66 :
67 : case typelib_TypeClass_UNSIGNED_SHORT:
68 0 : *static_cast< sal_uInt16 * >(uno_data) = 0;
69 0 : break;
70 :
71 : case typelib_TypeClass_LONG:
72 0 : *static_cast< sal_Int32 * >(uno_data) = 0;
73 0 : break;
74 :
75 : case typelib_TypeClass_UNSIGNED_LONG:
76 0 : *static_cast< sal_uInt32 * >(uno_data) = 0;
77 0 : break;
78 :
79 : case typelib_TypeClass_HYPER:
80 0 : *static_cast< sal_Int64 * >(uno_data) = 0;
81 0 : break;
82 :
83 : case typelib_TypeClass_UNSIGNED_HYPER:
84 0 : *static_cast< sal_uInt64 * >(uno_data) = 0;
85 0 : break;
86 :
87 : case typelib_TypeClass_FLOAT:
88 0 : *static_cast< float * >(uno_data) = 0;
89 0 : break;
90 :
91 : case typelib_TypeClass_DOUBLE:
92 0 : *static_cast< double * >(uno_data) = 0;
93 0 : break;
94 :
95 : case typelib_TypeClass_CHAR:
96 0 : *static_cast< sal_Unicode * >(uno_data) = 0;
97 0 : break;
98 :
99 : case typelib_TypeClass_STRING:
100 0 : if (!assign) {
101 0 : *static_cast< rtl_uString ** >(uno_data) = 0;
102 : }
103 0 : rtl_uString_new(static_cast< rtl_uString ** >(uno_data));
104 0 : break;
105 :
106 : case typelib_TypeClass_TYPE:
107 0 : if (assign) {
108 : typelib_typedescriptionreference_release(
109 0 : *static_cast< typelib_TypeDescriptionReference ** >(uno_data));
110 : }
111 : *static_cast< typelib_TypeDescriptionReference ** >(uno_data)
112 0 : = *typelib_static_type_getByTypeClass(typelib_TypeClass_VOID);
113 : assert(
114 : *static_cast< typelib_TypeDescriptionReference ** >(uno_data) != 0);
115 : typelib_typedescriptionreference_acquire(
116 0 : *static_cast< typelib_TypeDescriptionReference ** >(uno_data));
117 0 : break;
118 :
119 : case typelib_TypeClass_ANY:
120 0 : if (assign) {
121 0 : uno_any_destruct(static_cast< uno_Any * >(uno_data), 0);
122 : }
123 : uno_any_construct(
124 : static_cast< uno_Any * >(uno_data), 0,
125 0 : jni.get_info()->m_XInterface_type_info->m_td.get(), 0);
126 0 : break;
127 :
128 : case typelib_TypeClass_SEQUENCE:
129 : {
130 0 : o3tl::heap_ptr< rtl_mem > seq(seq_allocate(0, 0));
131 0 : if (assign) {
132 0 : uno_type_destructData(uno_data, type, 0);
133 : }
134 : *static_cast< uno_Sequence ** >(uno_data)
135 0 : = reinterpret_cast< uno_Sequence * >(seq.release());
136 0 : break;
137 : }
138 :
139 : case typelib_TypeClass_ENUM:
140 : {
141 0 : typelib_TypeDescription * td = 0;
142 0 : TYPELIB_DANGER_GET(&td, type);
143 : *static_cast< sal_Int32 * >(uno_data)
144 : = (reinterpret_cast< typelib_EnumTypeDescription * >(td)->
145 0 : nDefaultEnumValue);
146 0 : TYPELIB_DANGER_RELEASE(td);
147 0 : break;
148 : }
149 :
150 : case typelib_TypeClass_STRUCT:
151 : {
152 0 : if (info == 0) {
153 0 : info = jni.get_info()->get_type_info(jni, type);
154 : }
155 : JNI_compound_type_info const * comp_info
156 0 : = static_cast< JNI_compound_type_info const * >(info);
157 : typelib_CompoundTypeDescription * comp_td
158 : = reinterpret_cast< typelib_CompoundTypeDescription * >(
159 0 : comp_info->m_td.get());
160 0 : sal_Int32 nPos = 0;
161 0 : sal_Int32 nMembers = comp_td->nMembers;
162 : try {
163 0 : if (comp_td->pBaseTypeDescription != 0) {
164 : createDefaultUnoValue(
165 : jni, uno_data,
166 : comp_td->pBaseTypeDescription->aBase.pWeakRef,
167 0 : comp_info->m_base, assign);
168 : }
169 0 : for (; nPos < nMembers; ++nPos) {
170 : createDefaultUnoValue(
171 : jni,
172 : (static_cast< char * >(uno_data)
173 0 : + comp_td->pMemberOffsets[nPos]),
174 0 : comp_td->ppTypeRefs[nPos], 0, assign);
175 : }
176 0 : } catch (...) {
177 0 : if (!assign) {
178 0 : for (sal_Int32 i = 0; i < nPos; ++i) {
179 : uno_type_destructData(
180 : (static_cast< char * >(uno_data)
181 0 : + comp_td->pMemberOffsets[i]),
182 0 : comp_td->ppTypeRefs[i], 0);
183 : }
184 0 : if (comp_td->pBaseTypeDescription != 0) {
185 : uno_destructData(
186 0 : uno_data, &comp_td->pBaseTypeDescription->aBase, 0);
187 : }
188 : }
189 0 : throw;
190 : }
191 : }
192 0 : break;
193 :
194 : case typelib_TypeClass_INTERFACE:
195 0 : if (assign) {
196 0 : uno_Interface * p = *static_cast< uno_Interface ** >(uno_data);
197 0 : if (p != 0) {
198 0 : (*p->release)(p);
199 : }
200 : }
201 0 : *static_cast< uno_Interface ** >(uno_data) = 0;
202 0 : break;
203 :
204 : default:
205 : assert(false);
206 0 : break;
207 : }
208 0 : }
209 :
210 : }
211 :
212 0 : void Bridge::map_to_uno(
213 : JNI_context const & jni,
214 : void * uno_data, jvalue java_data,
215 : typelib_TypeDescriptionReference * type,
216 : JNI_type_info const * info /* maybe 0 */,
217 : bool assign, bool out_param,
218 : bool special_wrapped_integral_types ) const
219 : {
220 : assert(
221 : !out_param ||
222 : (1 == jni->GetArrayLength( (jarray) java_data.l )) );
223 :
224 0 : switch (type->eTypeClass)
225 : {
226 : case typelib_TypeClass_CHAR:
227 0 : if (out_param)
228 : {
229 : jni->GetCharArrayRegion(
230 0 : (jcharArray) java_data.l, 0, 1, (jchar *) uno_data );
231 0 : jni.ensure_no_exception();
232 : }
233 0 : else if (special_wrapped_integral_types)
234 : {
235 : *(jchar *) uno_data = jni->CallCharMethodA(
236 0 : java_data.l, m_jni_info->m_method_Character_charValue, 0 );
237 0 : jni.ensure_no_exception();
238 : }
239 : else
240 : {
241 0 : *(jchar *) uno_data = java_data.c;
242 : }
243 0 : break;
244 : case typelib_TypeClass_BOOLEAN:
245 0 : if (out_param)
246 : {
247 : jni->GetBooleanArrayRegion(
248 0 : (jbooleanArray) java_data.l, 0, 1, (jboolean *) uno_data );
249 0 : jni.ensure_no_exception();
250 : }
251 0 : else if (special_wrapped_integral_types)
252 : {
253 : *(jboolean *) uno_data = jni->CallBooleanMethodA(
254 0 : java_data.l, m_jni_info->m_method_Boolean_booleanValue, 0 );
255 0 : jni.ensure_no_exception();
256 : }
257 : else
258 : {
259 0 : *(jboolean *) uno_data = java_data.z;
260 : }
261 0 : break;
262 : case typelib_TypeClass_BYTE:
263 0 : if (out_param)
264 : {
265 : jni->GetByteArrayRegion(
266 0 : (jbyteArray) java_data.l, 0, 1, (jbyte *) uno_data );
267 0 : jni.ensure_no_exception();
268 : }
269 0 : else if (special_wrapped_integral_types)
270 : {
271 : *(jbyte *) uno_data = jni->CallByteMethodA(
272 0 : java_data.l, m_jni_info->m_method_Byte_byteValue, 0 );
273 0 : jni.ensure_no_exception();
274 : }
275 : else
276 : {
277 0 : *(jbyte *) uno_data = java_data.b;
278 : }
279 0 : break;
280 : case typelib_TypeClass_SHORT:
281 : case typelib_TypeClass_UNSIGNED_SHORT:
282 0 : if (out_param)
283 : {
284 : jni->GetShortArrayRegion(
285 0 : (jshortArray) java_data.l, 0, 1, (jshort *) uno_data );
286 0 : jni.ensure_no_exception();
287 : }
288 0 : else if (special_wrapped_integral_types)
289 : {
290 : *(jshort *) uno_data = jni->CallShortMethodA(
291 0 : java_data.l, m_jni_info->m_method_Short_shortValue, 0 );
292 0 : jni.ensure_no_exception();
293 : }
294 : else
295 : {
296 0 : *(jshort *) uno_data = java_data.s;
297 : }
298 0 : break;
299 : case typelib_TypeClass_LONG:
300 : case typelib_TypeClass_UNSIGNED_LONG:
301 0 : if (out_param)
302 : {
303 : jni->GetIntArrayRegion(
304 0 : (jintArray) java_data.l, 0, 1, (jint *) uno_data );
305 0 : jni.ensure_no_exception();
306 : }
307 0 : else if (special_wrapped_integral_types)
308 : {
309 : *(jint *) uno_data = jni->CallIntMethodA(
310 0 : java_data.l, m_jni_info->m_method_Integer_intValue, 0 );
311 0 : jni.ensure_no_exception();
312 : }
313 : else
314 : {
315 0 : *(jint *) uno_data = java_data.i;
316 : }
317 0 : break;
318 : case typelib_TypeClass_HYPER:
319 : case typelib_TypeClass_UNSIGNED_HYPER:
320 0 : if (out_param)
321 : {
322 : jni->GetLongArrayRegion(
323 0 : (jlongArray) java_data.l, 0, 1, (jlong *) uno_data );
324 0 : jni.ensure_no_exception();
325 : }
326 0 : else if (special_wrapped_integral_types)
327 : {
328 : *(jlong *) uno_data = jni->CallLongMethodA(
329 0 : java_data.l, m_jni_info->m_method_Long_longValue, 0 );
330 0 : jni.ensure_no_exception();
331 : }
332 : else
333 : {
334 0 : *(jlong *) uno_data = java_data.j;
335 : }
336 0 : break;
337 : case typelib_TypeClass_FLOAT:
338 0 : if (out_param)
339 : {
340 : jni->GetFloatArrayRegion(
341 0 : (jfloatArray) java_data.l, 0, 1, (jfloat *) uno_data );
342 0 : jni.ensure_no_exception();
343 : }
344 0 : else if (special_wrapped_integral_types)
345 : {
346 : *(jfloat *) uno_data = jni->CallFloatMethodA(
347 0 : java_data.l, m_jni_info->m_method_Float_floatValue, 0 );
348 0 : jni.ensure_no_exception();
349 : }
350 : else
351 : {
352 0 : *(jfloat *) uno_data = java_data.f;
353 : }
354 0 : break;
355 : case typelib_TypeClass_DOUBLE:
356 0 : if (out_param)
357 : {
358 : jni->GetDoubleArrayRegion(
359 0 : (jdoubleArray) java_data.l, 0, 1, (jdouble *) uno_data );
360 0 : jni.ensure_no_exception();
361 : }
362 0 : else if (special_wrapped_integral_types)
363 : {
364 : *(jdouble *) uno_data = jni->CallDoubleMethodA(
365 0 : java_data.l, m_jni_info->m_method_Double_doubleValue, 0 );
366 0 : jni.ensure_no_exception();
367 : }
368 : else
369 : {
370 0 : *(jdouble *) uno_data = java_data.d;
371 : }
372 0 : break;
373 : case typelib_TypeClass_STRING:
374 : {
375 0 : JLocalAutoRef jo_out_holder( jni );
376 0 : if (out_param)
377 : {
378 : jo_out_holder.reset(
379 0 : jni->GetObjectArrayElement( (jobjectArray) java_data.l, 0 ) );
380 0 : jni.ensure_no_exception();
381 0 : java_data.l = jo_out_holder.get();
382 : }
383 0 : if (0 == java_data.l)
384 : {
385 : throw BridgeRuntimeError(
386 0 : "[map_to_uno():" + OUString::unacquired( &type->pTypeName )
387 0 : + "] null-ref given!" + jni.get_stack_trace() );
388 : }
389 0 : if (! assign)
390 0 : *(rtl_uString **)uno_data = 0;
391 : jstring_to_ustring(
392 0 : jni, (rtl_uString **)uno_data, (jstring) java_data.l );
393 0 : break;
394 : }
395 : case typelib_TypeClass_TYPE:
396 : {
397 0 : JLocalAutoRef jo_out_holder( jni );
398 0 : if (out_param)
399 : {
400 : jo_out_holder.reset(
401 0 : jni->GetObjectArrayElement( (jobjectArray) java_data.l, 0 ) );
402 0 : jni.ensure_no_exception();
403 0 : java_data.l = jo_out_holder.get();
404 : }
405 0 : if (0 == java_data.l)
406 : {
407 : throw BridgeRuntimeError(
408 0 : "[map_to_uno():" + OUString::unacquired( &type->pTypeName )
409 0 : + "] null-ref given!" + jni.get_stack_trace() );
410 : }
411 :
412 : // type name
413 : JLocalAutoRef jo_type_name(
414 : jni, jni->GetObjectField(
415 0 : java_data.l, m_jni_info->m_field_Type__typeName ) );
416 0 : if (! jo_type_name.is())
417 : {
418 : throw BridgeRuntimeError(
419 0 : "[map_to_uno():" + OUString::unacquired( &type->pTypeName )
420 0 : + "] incomplete type object: no type name!"
421 0 : + jni.get_stack_trace() );
422 : }
423 : OUString type_name(
424 0 : jstring_to_oustring( jni, (jstring) jo_type_name.get() ) );
425 0 : ::com::sun::star::uno::TypeDescription td( type_name );
426 0 : if (! td.is())
427 : {
428 : throw BridgeRuntimeError(
429 0 : "[map_to_uno():" + OUString::unacquired( &type->pTypeName )
430 0 : + "] UNO type not found: " + type_name
431 0 : + jni.get_stack_trace() );
432 : }
433 0 : typelib_typedescriptionreference_acquire( td.get()->pWeakRef );
434 0 : if (assign)
435 : {
436 : typelib_typedescriptionreference_release(
437 0 : *(typelib_TypeDescriptionReference **)uno_data );
438 : }
439 0 : *(typelib_TypeDescriptionReference **)uno_data = td.get()->pWeakRef;
440 0 : break;
441 : }
442 : case typelib_TypeClass_ANY:
443 : {
444 0 : JLocalAutoRef jo_out_holder( jni );
445 0 : if (out_param)
446 : {
447 : jo_out_holder.reset(
448 0 : jni->GetObjectArrayElement( (jobjectArray) java_data.l, 0 ) );
449 0 : jni.ensure_no_exception();
450 0 : java_data.l = jo_out_holder.get();
451 : }
452 :
453 0 : uno_Any * pAny = (uno_Any *)uno_data;
454 0 : if (0 == java_data.l) // null-ref maps to XInterface null-ref
455 : {
456 0 : if (assign)
457 0 : uno_any_destruct( pAny, 0 );
458 : uno_any_construct(
459 0 : pAny, 0, m_jni_info->m_XInterface_type_info->m_td.get(), 0 );
460 0 : break;
461 : }
462 :
463 0 : JLocalAutoRef jo_type( jni );
464 0 : JLocalAutoRef jo_wrapped_holder( jni );
465 :
466 0 : if (JNI_FALSE != jni->IsInstanceOf(
467 0 : java_data.l, m_jni_info->m_class_Any ))
468 : {
469 : // boxed any
470 : jo_type.reset( jni->GetObjectField(
471 0 : java_data.l, m_jni_info->m_field_Any__type ) );
472 0 : if (! jo_type.is())
473 : {
474 : throw BridgeRuntimeError(
475 0 : "[map_to_uno():" + OUString::unacquired( &type->pTypeName )
476 0 : + "] no type set at com.sun.star.uno.Any!"
477 0 : + jni.get_stack_trace() );
478 : }
479 : // wrapped value
480 : jo_wrapped_holder.reset(
481 : jni->GetObjectField(
482 0 : java_data.l, m_jni_info->m_field_Any__object ) );
483 0 : java_data.l = jo_wrapped_holder.get();
484 : }
485 : else
486 : {
487 : // create type out of class
488 0 : JLocalAutoRef jo_class( jni, jni->GetObjectClass( java_data.l ) );
489 0 : jo_type.reset( create_type( jni, (jclass) jo_class.get() ) );
490 : }
491 :
492 : // get type name
493 : JLocalAutoRef jo_type_name(
494 : jni, jni->GetObjectField(
495 0 : jo_type.get(), m_jni_info->m_field_Type__typeName ) );
496 0 : jni.ensure_no_exception();
497 : OUString type_name(
498 0 : jstring_to_oustring( jni, (jstring) jo_type_name.get() ) );
499 :
500 0 : ::com::sun::star::uno::TypeDescription value_td( type_name );
501 0 : if (! value_td.is())
502 : {
503 : throw BridgeRuntimeError(
504 0 : "[map_to_uno():" + OUString::unacquired( &type->pTypeName )
505 0 : + "] UNO type not found: " + type_name
506 0 : + jni.get_stack_trace() );
507 : }
508 0 : typelib_TypeClass type_class = value_td.get()->eTypeClass;
509 :
510 0 : if (assign)
511 : {
512 0 : uno_any_destruct( pAny, 0 );
513 : }
514 : try
515 : {
516 0 : switch (type_class)
517 : {
518 : case typelib_TypeClass_VOID:
519 0 : pAny->pData = &pAny->pReserved;
520 0 : break;
521 : case typelib_TypeClass_CHAR:
522 0 : pAny->pData = &pAny->pReserved;
523 : *(jchar *) pAny->pData = jni->CallCharMethodA(
524 0 : java_data.l, m_jni_info->m_method_Character_charValue, 0 );
525 0 : jni.ensure_no_exception();
526 0 : break;
527 : case typelib_TypeClass_BOOLEAN:
528 0 : pAny->pData = &pAny->pReserved;
529 : *(jboolean *) pAny->pData = jni->CallBooleanMethodA(
530 0 : java_data.l, m_jni_info->m_method_Boolean_booleanValue, 0 );
531 0 : jni.ensure_no_exception();
532 0 : break;
533 : case typelib_TypeClass_BYTE:
534 0 : pAny->pData = &pAny->pReserved;
535 : *(jbyte *) pAny->pData = jni->CallByteMethodA(
536 0 : java_data.l, m_jni_info->m_method_Byte_byteValue, 0 );
537 0 : jni.ensure_no_exception();
538 0 : break;
539 : case typelib_TypeClass_SHORT:
540 : case typelib_TypeClass_UNSIGNED_SHORT:
541 0 : pAny->pData = &pAny->pReserved;
542 : *(jshort *) pAny->pData = jni->CallShortMethodA(
543 0 : java_data.l, m_jni_info->m_method_Short_shortValue, 0 );
544 0 : jni.ensure_no_exception();
545 0 : break;
546 : case typelib_TypeClass_LONG:
547 : case typelib_TypeClass_UNSIGNED_LONG:
548 0 : pAny->pData = &pAny->pReserved;
549 : *(jint *) pAny->pData = jni->CallIntMethodA(
550 0 : java_data.l, m_jni_info->m_method_Integer_intValue, 0 );
551 0 : jni.ensure_no_exception();
552 0 : break;
553 : case typelib_TypeClass_HYPER:
554 : case typelib_TypeClass_UNSIGNED_HYPER:
555 : if (sizeof (sal_Int64) <= sizeof (void *))
556 : {
557 : pAny->pData = &pAny->pReserved;
558 : *(jlong *) pAny->pData = jni->CallLongMethodA(
559 : java_data.l, m_jni_info->m_method_Long_longValue, 0 );
560 : jni.ensure_no_exception();
561 : }
562 : else
563 : {
564 : o3tl::heap_ptr< rtl_mem > mem(
565 0 : rtl_mem::allocate( sizeof (sal_Int64) ) );
566 0 : *(jlong *) mem.get() = jni->CallLongMethodA(
567 0 : java_data.l, m_jni_info->m_method_Long_longValue, 0 );
568 0 : jni.ensure_no_exception();
569 0 : pAny->pData = mem.release();
570 : }
571 0 : break;
572 : case typelib_TypeClass_FLOAT:
573 : if (sizeof (float) <= sizeof (void *))
574 : {
575 0 : pAny->pData = &pAny->pReserved;
576 : *(jfloat *) pAny->pData = jni->CallFloatMethodA(
577 0 : java_data.l, m_jni_info->m_method_Float_floatValue, 0 );
578 0 : jni.ensure_no_exception();
579 : }
580 : else
581 : {
582 : o3tl::heap_ptr< rtl_mem > mem(
583 : rtl_mem::allocate( sizeof (float) ) );
584 : *(jfloat *) mem.get() = jni->CallFloatMethodA(
585 : java_data.l, m_jni_info->m_method_Float_floatValue, 0 );
586 : jni.ensure_no_exception();
587 : pAny->pData = mem.release();
588 : }
589 0 : break;
590 : case typelib_TypeClass_DOUBLE:
591 : if (sizeof (double) <= sizeof (void *))
592 : {
593 : pAny->pData = &pAny->pReserved;
594 : *(jdouble *) pAny->pData =
595 : jni->CallDoubleMethodA(
596 : java_data.l,
597 : m_jni_info->m_method_Double_doubleValue, 0 );
598 : jni.ensure_no_exception();
599 : }
600 : else
601 : {
602 : o3tl::heap_ptr< rtl_mem > mem(
603 0 : rtl_mem::allocate( sizeof (double) ) );
604 0 : *(jdouble *) mem.get() =
605 : jni->CallDoubleMethodA(
606 : java_data.l,
607 0 : m_jni_info->m_method_Double_doubleValue, 0 );
608 0 : jni.ensure_no_exception();
609 0 : pAny->pData = mem.release();
610 : }
611 0 : break;
612 : case typelib_TypeClass_STRING:
613 : // opt: anies often contain strings; copy string directly
614 0 : pAny->pReserved = 0;
615 0 : pAny->pData = &pAny->pReserved;
616 : jstring_to_ustring(
617 : jni, (rtl_uString **)pAny->pData,
618 0 : (jstring) java_data.l );
619 0 : break;
620 : case typelib_TypeClass_TYPE:
621 : case typelib_TypeClass_ENUM:
622 : case typelib_TypeClass_SEQUENCE:
623 : case typelib_TypeClass_INTERFACE:
624 0 : pAny->pData = &pAny->pReserved;
625 : map_to_uno(
626 : jni, pAny->pData, java_data,
627 0 : value_td.get()->pWeakRef, 0,
628 0 : false /* no assign */, false /* no out param */ );
629 0 : break;
630 : case typelib_TypeClass_STRUCT:
631 : case typelib_TypeClass_EXCEPTION:
632 : {
633 : o3tl::heap_ptr< rtl_mem > mem(
634 0 : rtl_mem::allocate( value_td.get()->nSize ) );
635 : map_to_uno(
636 0 : jni, mem.get(), java_data, value_td.get()->pWeakRef, 0,
637 0 : false /* no assign */, false /* no out param */ );
638 0 : pAny->pData = mem.release();
639 0 : break;
640 : }
641 : default:
642 : {
643 : throw BridgeRuntimeError(
644 0 : "[map_to_uno():" + type_name
645 0 : + "] unsupported value type of any!"
646 0 : + jni.get_stack_trace() );
647 : }
648 : }
649 : }
650 0 : catch (...)
651 : {
652 0 : if (assign)
653 : {
654 : // restore to valid any
655 0 : uno_any_construct( pAny, 0, 0, 0 );
656 : }
657 0 : throw;
658 : }
659 0 : typelib_typedescriptionreference_acquire( value_td.get()->pWeakRef );
660 0 : pAny->pType = value_td.get()->pWeakRef;
661 0 : break;
662 : }
663 : case typelib_TypeClass_ENUM:
664 : {
665 0 : JLocalAutoRef jo_out_holder( jni );
666 0 : if (out_param)
667 : {
668 : jo_out_holder.reset(
669 0 : jni->GetObjectArrayElement( (jobjectArray) java_data.l, 0 ) );
670 0 : jni.ensure_no_exception();
671 0 : java_data.l = jo_out_holder.get();
672 : }
673 0 : if (0 == java_data.l)
674 : {
675 : throw BridgeRuntimeError(
676 0 : "[map_to_uno():" + OUString::unacquired( &type->pTypeName )
677 0 : + "] null-ref given!" + jni.get_stack_trace() );
678 : }
679 :
680 : *(jint *) uno_data = jni->GetIntField(
681 0 : java_data.l, m_jni_info->m_field_Enum_m_value );
682 0 : break;
683 : }
684 : case typelib_TypeClass_STRUCT:
685 : case typelib_TypeClass_EXCEPTION:
686 : {
687 0 : JLocalAutoRef jo_out_holder( jni );
688 0 : if (out_param)
689 : {
690 : jo_out_holder.reset(
691 0 : jni->GetObjectArrayElement( (jobjectArray) java_data.l, 0 ) );
692 0 : jni.ensure_no_exception();
693 0 : java_data.l = jo_out_holder.get();
694 : }
695 0 : if (0 == java_data.l)
696 : {
697 : throw BridgeRuntimeError(
698 0 : "[map_to_uno():" + OUString::unacquired( &type->pTypeName )
699 0 : + "] null-ref given!" + jni.get_stack_trace() );
700 : }
701 :
702 0 : if (0 == info)
703 0 : info = m_jni_info->get_type_info( jni, type );
704 : JNI_compound_type_info const * comp_info =
705 0 : static_cast< JNI_compound_type_info const * >( info );
706 :
707 : typelib_CompoundTypeDescription * comp_td =
708 0 : (typelib_CompoundTypeDescription *)comp_info->m_td.get();
709 : bool polymorphic
710 0 : = comp_td->aBase.eTypeClass == typelib_TypeClass_STRUCT
711 0 : && reinterpret_cast< typelib_StructTypeDescription * >(
712 0 : comp_td)->pParameterizedTypes != 0;
713 :
714 0 : sal_Int32 nPos = 0;
715 0 : sal_Int32 nMembers = comp_td->nMembers;
716 : try
717 : {
718 0 : if (0 != comp_td->pBaseTypeDescription)
719 : {
720 : map_to_uno(
721 : jni, uno_data, java_data,
722 : ((typelib_TypeDescription *) comp_td->pBaseTypeDescription)
723 : ->pWeakRef,
724 : comp_info->m_base,
725 0 : assign, false /* no out param */ );
726 : }
727 :
728 0 : for ( ; nPos < nMembers; ++nPos )
729 : {
730 0 : void * p = (char *)uno_data + comp_td->pMemberOffsets[ nPos ];
731 : typelib_TypeDescriptionReference * member_type =
732 0 : comp_td->ppTypeRefs[ nPos ];
733 0 : jfieldID field_id = comp_info->m_fields[ nPos ];
734 : bool parameterizedType = polymorphic
735 0 : && reinterpret_cast< typelib_StructTypeDescription * >(
736 0 : comp_td)->pParameterizedTypes[nPos];
737 0 : switch (member_type->eTypeClass)
738 : {
739 : case typelib_TypeClass_CHAR:
740 0 : if (parameterizedType) {
741 : JLocalAutoRef jo(
742 0 : jni, jni->GetObjectField( java_data.l, field_id ) );
743 0 : if ( jo.get() == 0 ) {
744 0 : *(jchar *) p = 0;
745 : } else {
746 : jvalue val;
747 0 : val.l = jo.get();
748 : map_to_uno(
749 : jni, p, val, member_type, 0, assign, false,
750 0 : true );
751 0 : }
752 : } else {
753 : *(jchar *) p = jni->GetCharField(
754 0 : java_data.l, field_id );
755 : }
756 0 : break;
757 : case typelib_TypeClass_BOOLEAN:
758 0 : if (parameterizedType) {
759 : JLocalAutoRef jo(
760 0 : jni, jni->GetObjectField( java_data.l, field_id ) );
761 0 : if ( jo.get() == 0 ) {
762 0 : *(jboolean *) p = false;
763 : } else {
764 : jvalue val;
765 0 : val.l = jo.get();
766 : map_to_uno(
767 : jni, p, val, member_type, 0, assign, false,
768 0 : true );
769 0 : }
770 : } else {
771 : *(jboolean *) p = jni->GetBooleanField(
772 0 : java_data.l, field_id );
773 : }
774 0 : break;
775 : case typelib_TypeClass_BYTE:
776 0 : if (parameterizedType) {
777 : JLocalAutoRef jo(
778 0 : jni, jni->GetObjectField( java_data.l, field_id ) );
779 0 : if ( jo.get() == 0 ) {
780 0 : *(jbyte *) p = 0;
781 : } else {
782 : jvalue val;
783 0 : val.l = jo.get();
784 : map_to_uno(
785 : jni, p, val, member_type, 0, assign, false,
786 0 : true );
787 0 : }
788 : } else {
789 : *(jbyte *) p = jni->GetByteField(
790 0 : java_data.l, field_id );
791 : }
792 0 : break;
793 : case typelib_TypeClass_SHORT:
794 : case typelib_TypeClass_UNSIGNED_SHORT:
795 0 : if (parameterizedType) {
796 : JLocalAutoRef jo(
797 0 : jni, jni->GetObjectField( java_data.l, field_id ) );
798 0 : if ( jo.get() == 0 ) {
799 0 : *(jshort *) p = 0;
800 : } else {
801 : jvalue val;
802 0 : val.l = jo.get();
803 : map_to_uno(
804 : jni, p, val, member_type, 0, assign, false,
805 0 : true );
806 0 : }
807 : } else {
808 : *(jshort *) p = jni->GetShortField(
809 0 : java_data.l, field_id );
810 : }
811 0 : break;
812 : case typelib_TypeClass_LONG:
813 : case typelib_TypeClass_UNSIGNED_LONG:
814 0 : if (parameterizedType) {
815 : JLocalAutoRef jo(
816 0 : jni, jni->GetObjectField( java_data.l, field_id ) );
817 0 : if ( jo.get() == 0 ) {
818 0 : *(jint *) p = 0;
819 : } else {
820 : jvalue val;
821 0 : val.l = jo.get();
822 : map_to_uno(
823 : jni, p, val, member_type, 0, assign, false,
824 0 : true );
825 0 : }
826 : } else {
827 0 : *(jint *) p = jni->GetIntField( java_data.l, field_id );
828 : }
829 0 : break;
830 : case typelib_TypeClass_HYPER:
831 : case typelib_TypeClass_UNSIGNED_HYPER:
832 0 : if (parameterizedType) {
833 : JLocalAutoRef jo(
834 0 : jni, jni->GetObjectField( java_data.l, field_id ) );
835 0 : if ( jo.get() == 0 ) {
836 0 : *(jlong *) p = 0;
837 : } else {
838 : jvalue val;
839 0 : val.l = jo.get();
840 : map_to_uno(
841 : jni, p, val, member_type, 0, assign, false,
842 0 : true );
843 0 : }
844 : } else {
845 : *(jlong *) p = jni->GetLongField(
846 0 : java_data.l, field_id );
847 : }
848 0 : break;
849 : case typelib_TypeClass_FLOAT:
850 0 : if (parameterizedType) {
851 : JLocalAutoRef jo(
852 0 : jni, jni->GetObjectField( java_data.l, field_id ) );
853 0 : if ( jo.get() == 0 ) {
854 0 : *(jfloat *) p = 0;
855 : } else {
856 : jvalue val;
857 0 : val.l = jo.get();
858 : map_to_uno(
859 : jni, p, val, member_type, 0, assign, false,
860 0 : true );
861 0 : }
862 : } else {
863 : *(jfloat *) p = jni->GetFloatField(
864 0 : java_data.l, field_id );
865 : }
866 0 : break;
867 : case typelib_TypeClass_DOUBLE:
868 0 : if (parameterizedType) {
869 : JLocalAutoRef jo(
870 0 : jni, jni->GetObjectField( java_data.l, field_id ) );
871 0 : if ( jo.get() == 0 ) {
872 0 : *(jdouble *) p = 0;
873 : } else {
874 : jvalue val;
875 0 : val.l = jo.get();
876 : map_to_uno(
877 : jni, p, val, member_type, 0, assign, false,
878 0 : true );
879 0 : }
880 : } else {
881 : *(jdouble *) p = jni->GetDoubleField(
882 0 : java_data.l, field_id );
883 : }
884 0 : break;
885 : default:
886 : {
887 0 : JLocalAutoRef jo_field( jni );
888 : bool checkNull;
889 0 : if (0 == field_id)
890 : {
891 : // special for Message: call Throwable.getMessage()
892 : assert(
893 : type_equals(
894 : type,
895 : m_jni_info->m_Exception_type.getTypeLibType() )
896 : || type_equals(
897 : type,
898 : m_jni_info->m_RuntimeException_type.
899 : getTypeLibType() ) );
900 : assert( 0 == nPos ); // first member
901 : // call getMessage()
902 : jo_field.reset(
903 : jni->CallObjectMethodA(
904 : java_data.l,
905 : m_jni_info->m_method_Throwable_getMessage, 0 )
906 0 : );
907 0 : jni.ensure_no_exception();
908 0 : checkNull = true;
909 : }
910 : else
911 : {
912 : jo_field.reset(
913 0 : jni->GetObjectField( java_data.l, field_id ) );
914 0 : checkNull = parameterizedType;
915 : }
916 0 : if (checkNull && !jo_field.is()) {
917 0 : createDefaultUnoValue(jni, p, member_type, 0, assign);
918 : } else {
919 : jvalue val;
920 0 : val.l = jo_field.get();
921 : map_to_uno(
922 : jni, p, val, member_type, 0,
923 0 : assign, false /* no out param */ );
924 : }
925 0 : break;
926 : }
927 : }
928 : }
929 : }
930 0 : catch (...)
931 : {
932 0 : if (! assign)
933 : {
934 : // cleanup
935 0 : for ( sal_Int32 nCleanup = 0; nCleanup < nPos; ++nCleanup )
936 : {
937 : void * p =
938 0 : (char *)uno_data + comp_td->pMemberOffsets[ nCleanup ];
939 : uno_type_destructData(
940 0 : p, comp_td->ppTypeRefs[ nCleanup ], 0 );
941 : }
942 0 : if (0 != comp_td->pBaseTypeDescription)
943 : {
944 : uno_destructData(
945 : uno_data,
946 : (typelib_TypeDescription *) comp_td
947 0 : ->pBaseTypeDescription, 0 );
948 : }
949 : }
950 0 : throw;
951 : }
952 0 : break;
953 : }
954 : case typelib_TypeClass_SEQUENCE:
955 : {
956 0 : JLocalAutoRef jo_out_holder( jni );
957 0 : if (out_param)
958 : {
959 : jo_out_holder.reset(
960 0 : jni->GetObjectArrayElement( (jobjectArray) java_data.l, 0 ) );
961 0 : jni.ensure_no_exception();
962 0 : java_data.l = jo_out_holder.get();
963 : }
964 0 : if (0 == java_data.l)
965 : {
966 : throw BridgeRuntimeError(
967 0 : "[map_to_uno():" + OUString::unacquired( &type->pTypeName )
968 0 : + "] null-ref given!" + jni.get_stack_trace() );
969 : }
970 :
971 0 : TypeDescr td( type );
972 : typelib_TypeDescriptionReference * element_type =
973 0 : ((typelib_IndirectTypeDescription *)td.get())->pType;
974 :
975 0 : o3tl::heap_ptr< rtl_mem > seq;
976 0 : sal_Int32 nElements = jni->GetArrayLength( (jarray) java_data.l );
977 :
978 0 : switch (element_type->eTypeClass)
979 : {
980 : case typelib_TypeClass_CHAR:
981 0 : seq.reset( seq_allocate( nElements, sizeof (sal_Unicode) ) );
982 : jni->GetCharArrayRegion(
983 : (jcharArray) java_data.l, 0, nElements,
984 0 : (jchar *) ((uno_Sequence *) seq.get())->elements );
985 0 : jni.ensure_no_exception();
986 0 : break;
987 : case typelib_TypeClass_BOOLEAN:
988 0 : seq.reset( seq_allocate( nElements, sizeof (sal_Bool) ) );
989 : jni->GetBooleanArrayRegion(
990 : (jbooleanArray) java_data.l, 0, nElements,
991 0 : (jboolean *) ((uno_Sequence *) seq.get())->elements );
992 0 : jni.ensure_no_exception();
993 0 : break;
994 : case typelib_TypeClass_BYTE:
995 0 : seq.reset( seq_allocate( nElements, sizeof (sal_Int8) ) );
996 : jni->GetByteArrayRegion(
997 : (jbyteArray) java_data.l, 0, nElements,
998 0 : (jbyte *) ((uno_Sequence *) seq.get())->elements );
999 0 : jni.ensure_no_exception();
1000 0 : break;
1001 : case typelib_TypeClass_SHORT:
1002 : case typelib_TypeClass_UNSIGNED_SHORT:
1003 0 : seq.reset( seq_allocate( nElements, sizeof (sal_Int16) ) );
1004 : jni->GetShortArrayRegion(
1005 : (jshortArray) java_data.l, 0, nElements,
1006 0 : (jshort *) ((uno_Sequence *) seq.get())->elements );
1007 0 : jni.ensure_no_exception();
1008 0 : break;
1009 : case typelib_TypeClass_LONG:
1010 : case typelib_TypeClass_UNSIGNED_LONG:
1011 0 : seq.reset( seq_allocate( nElements, sizeof (sal_Int32) ) );
1012 : jni->GetIntArrayRegion(
1013 : (jintArray) java_data.l, 0, nElements,
1014 0 : (jint *) ((uno_Sequence *) seq.get())->elements );
1015 0 : jni.ensure_no_exception();
1016 0 : break;
1017 : case typelib_TypeClass_HYPER:
1018 : case typelib_TypeClass_UNSIGNED_HYPER:
1019 0 : seq.reset( seq_allocate( nElements, sizeof (sal_Int64) ) );
1020 : jni->GetLongArrayRegion(
1021 : (jlongArray) java_data.l, 0, nElements,
1022 0 : (jlong *) ((uno_Sequence *) seq.get())->elements );
1023 0 : jni.ensure_no_exception();
1024 0 : break;
1025 : case typelib_TypeClass_FLOAT:
1026 0 : seq.reset( seq_allocate( nElements, sizeof (float) ) );
1027 : jni->GetFloatArrayRegion(
1028 : (jfloatArray) java_data.l, 0, nElements,
1029 0 : (jfloat *)((uno_Sequence *)seq.get())->elements );
1030 0 : jni.ensure_no_exception();
1031 0 : break;
1032 : case typelib_TypeClass_DOUBLE:
1033 0 : seq.reset( seq_allocate( nElements, sizeof (double) ) );
1034 : jni->GetDoubleArrayRegion(
1035 : (jdoubleArray) java_data.l, 0, nElements,
1036 0 : (jdouble *) ((uno_Sequence *) seq.get())->elements );
1037 0 : jni.ensure_no_exception();
1038 0 : break;
1039 : case typelib_TypeClass_STRING:
1040 : case typelib_TypeClass_TYPE:
1041 : case typelib_TypeClass_ANY:
1042 : case typelib_TypeClass_ENUM:
1043 : case typelib_TypeClass_STRUCT:
1044 : case typelib_TypeClass_EXCEPTION:
1045 : case typelib_TypeClass_SEQUENCE:
1046 : case typelib_TypeClass_INTERFACE:
1047 : {
1048 0 : TypeDescr element_td( element_type );
1049 0 : seq.reset( seq_allocate( nElements, element_td.get()->nSize ) );
1050 :
1051 : JNI_type_info const * element_info;
1052 0 : if (typelib_TypeClass_STRUCT == element_type->eTypeClass ||
1053 0 : typelib_TypeClass_EXCEPTION == element_type->eTypeClass ||
1054 0 : typelib_TypeClass_INTERFACE == element_type->eTypeClass)
1055 : {
1056 : element_info =
1057 0 : m_jni_info->get_type_info( jni, element_td.get() );
1058 : }
1059 : else
1060 : {
1061 0 : element_info = 0;
1062 : }
1063 :
1064 0 : for ( sal_Int32 nPos = 0; nPos < nElements; ++nPos )
1065 : {
1066 : try
1067 : {
1068 : JLocalAutoRef jo(
1069 : jni, jni->GetObjectArrayElement(
1070 0 : (jobjectArray) java_data.l, nPos ) );
1071 0 : jni.ensure_no_exception();
1072 : jvalue val;
1073 0 : val.l = jo.get();
1074 : void * p =
1075 0 : ((uno_Sequence *)seq.get())->elements +
1076 0 : (nPos * element_td.get()->nSize);
1077 : map_to_uno(
1078 0 : jni, p, val, element_td.get()->pWeakRef, element_info,
1079 0 : false /* no assign */, false /* no out param */ );
1080 : }
1081 0 : catch (...)
1082 : {
1083 : // cleanup
1084 0 : for ( sal_Int32 nCleanPos = 0;
1085 : nCleanPos < nPos; ++nCleanPos )
1086 : {
1087 : void * p =
1088 0 : ((uno_Sequence *)seq.get())->elements +
1089 0 : (nCleanPos * element_td.get()->nSize);
1090 0 : uno_destructData( p, element_td.get(), 0 );
1091 : }
1092 0 : throw;
1093 : }
1094 : }
1095 0 : break;
1096 : }
1097 : default:
1098 : {
1099 : throw BridgeRuntimeError(
1100 0 : "[map_to_uno():" + OUString::unacquired( &type->pTypeName )
1101 0 : + "] unsupported sequence element type: "
1102 0 : + OUString::unacquired( &element_type->pTypeName )
1103 0 : + jni.get_stack_trace() );
1104 : }
1105 : }
1106 :
1107 0 : if (assign)
1108 0 : uno_destructData( uno_data, td.get(), 0 );
1109 0 : *(uno_Sequence **)uno_data = (uno_Sequence *)seq.release();
1110 0 : break;
1111 : }
1112 : case typelib_TypeClass_INTERFACE:
1113 : {
1114 0 : JLocalAutoRef jo_out_holder( jni );
1115 0 : if (out_param)
1116 : {
1117 : jo_out_holder.reset(
1118 0 : jni->GetObjectArrayElement( (jobjectArray) java_data.l, 0 ) );
1119 0 : jni.ensure_no_exception();
1120 0 : java_data.l = jo_out_holder.get();
1121 : }
1122 :
1123 0 : if (0 == java_data.l) // null-ref
1124 : {
1125 0 : if (assign)
1126 : {
1127 0 : uno_Interface * p = *(uno_Interface **)uno_data;
1128 0 : if (0 != p)
1129 0 : (*p->release)( p );
1130 : }
1131 0 : *(uno_Interface **)uno_data = 0;
1132 : }
1133 : else
1134 : {
1135 0 : if (0 == info)
1136 0 : info = m_jni_info->get_type_info( jni, type );
1137 : JNI_interface_type_info const * iface_info =
1138 0 : static_cast< JNI_interface_type_info const * >( info );
1139 0 : uno_Interface * pUnoI = map_to_uno( jni, java_data.l, iface_info );
1140 0 : if (assign)
1141 : {
1142 0 : uno_Interface * p = *(uno_Interface **)uno_data;
1143 0 : if (0 != p)
1144 0 : (*p->release)( p );
1145 : }
1146 0 : *(uno_Interface **)uno_data = pUnoI;
1147 : }
1148 0 : break;
1149 : }
1150 : default:
1151 : {
1152 : throw BridgeRuntimeError(
1153 0 : "[map_to_uno():" + OUString::unacquired( &type->pTypeName )
1154 0 : + "] unsupported type!" + jni.get_stack_trace() );
1155 : }
1156 : }
1157 0 : }
1158 :
1159 :
1160 :
1161 0 : void Bridge::map_to_java(
1162 : JNI_context const & jni,
1163 : jvalue * java_data, void const * uno_data,
1164 : typelib_TypeDescriptionReference * type,
1165 : JNI_type_info const * info /* maybe 0 */,
1166 : bool in_param, bool out_param,
1167 : bool special_wrapped_integral_types ) const
1168 : {
1169 0 : switch (type->eTypeClass)
1170 : {
1171 : case typelib_TypeClass_CHAR:
1172 0 : if (out_param)
1173 : {
1174 0 : if (0 == java_data->l)
1175 : {
1176 0 : JLocalAutoRef jo_ar( jni, jni->NewCharArray( 1 ) );
1177 0 : jni.ensure_no_exception();
1178 0 : if (in_param)
1179 : {
1180 : jni->SetCharArrayRegion(
1181 0 : (jcharArray) jo_ar.get(), 0, 1, (jchar *) uno_data );
1182 0 : jni.ensure_no_exception();
1183 : }
1184 0 : java_data->l = jo_ar.release();
1185 : }
1186 : else
1187 : {
1188 0 : if (in_param)
1189 : {
1190 : jni->SetCharArrayRegion(
1191 0 : (jcharArray) java_data->l, 0, 1, (jchar *) uno_data );
1192 0 : jni.ensure_no_exception();
1193 : }
1194 : }
1195 : }
1196 0 : else if (special_wrapped_integral_types)
1197 : {
1198 : jvalue arg;
1199 0 : arg.c = *(jchar const *) uno_data;
1200 : java_data->l = jni->NewObjectA(
1201 : m_jni_info->m_class_Character,
1202 0 : m_jni_info->m_ctor_Character_with_char, &arg );
1203 0 : jni.ensure_no_exception();
1204 : }
1205 : else
1206 : {
1207 0 : java_data->c = *(jchar const *) uno_data;
1208 : }
1209 0 : break;
1210 : case typelib_TypeClass_BOOLEAN:
1211 0 : if (out_param)
1212 : {
1213 0 : if (0 == java_data->l)
1214 : {
1215 0 : JLocalAutoRef jo_ar( jni, jni->NewBooleanArray( 1 ) );
1216 0 : jni.ensure_no_exception();
1217 0 : if (in_param)
1218 : {
1219 : jni->SetBooleanArrayRegion(
1220 0 : (jbooleanArray) jo_ar.get(),
1221 0 : 0, 1, (jboolean *) uno_data );
1222 0 : jni.ensure_no_exception();
1223 : }
1224 0 : java_data->l = jo_ar.release();
1225 : }
1226 : else
1227 : {
1228 0 : if (in_param)
1229 : {
1230 : jni->SetBooleanArrayRegion(
1231 : (jbooleanArray) java_data->l,
1232 0 : 0, 1, (jboolean *) uno_data );
1233 0 : jni.ensure_no_exception();
1234 : }
1235 : }
1236 : }
1237 0 : else if (special_wrapped_integral_types)
1238 : {
1239 : jvalue arg;
1240 0 : arg.z = *(jboolean const *) uno_data;
1241 : java_data->l = jni->NewObjectA(
1242 : m_jni_info->m_class_Boolean,
1243 0 : m_jni_info->m_ctor_Boolean_with_boolean, &arg );
1244 0 : jni.ensure_no_exception();
1245 : }
1246 : else
1247 : {
1248 0 : java_data->z = *(jboolean const *) uno_data;
1249 : }
1250 0 : break;
1251 : case typelib_TypeClass_BYTE:
1252 0 : if (out_param)
1253 : {
1254 0 : if (0 == java_data->l)
1255 : {
1256 0 : JLocalAutoRef jo_ar( jni, jni->NewByteArray( 1 ) );
1257 0 : jni.ensure_no_exception();
1258 0 : if (in_param)
1259 : {
1260 : jni->SetByteArrayRegion(
1261 0 : (jbyteArray) jo_ar.get(), 0, 1, (jbyte *) uno_data );
1262 0 : jni.ensure_no_exception();
1263 : }
1264 0 : java_data->l = jo_ar.release();
1265 : }
1266 : else
1267 : {
1268 0 : if (in_param)
1269 : {
1270 : jni->SetByteArrayRegion(
1271 0 : (jbyteArray) java_data->l, 0, 1, (jbyte *) uno_data );
1272 0 : jni.ensure_no_exception();
1273 : }
1274 : }
1275 : }
1276 0 : else if (special_wrapped_integral_types)
1277 : {
1278 : jvalue arg;
1279 0 : arg.b = *(jbyte const *) uno_data;
1280 : java_data->l = jni->NewObjectA(
1281 : m_jni_info->m_class_Byte,
1282 0 : m_jni_info->m_ctor_Byte_with_byte, &arg );
1283 0 : jni.ensure_no_exception();
1284 : }
1285 : else
1286 : {
1287 0 : java_data->b = *(jbyte const *) uno_data;
1288 : }
1289 0 : break;
1290 : case typelib_TypeClass_SHORT:
1291 : case typelib_TypeClass_UNSIGNED_SHORT:
1292 0 : if (out_param)
1293 : {
1294 0 : if (0 == java_data->l)
1295 : {
1296 0 : JLocalAutoRef jo_ar( jni, jni->NewShortArray( 1 ) );
1297 0 : jni.ensure_no_exception();
1298 0 : if (in_param)
1299 : {
1300 : jni->SetShortArrayRegion(
1301 0 : (jshortArray) jo_ar.get(), 0, 1, (jshort *) uno_data );
1302 0 : jni.ensure_no_exception();
1303 : }
1304 0 : java_data->l = jo_ar.release();
1305 : }
1306 : else
1307 : {
1308 0 : if (in_param)
1309 : {
1310 : jni->SetShortArrayRegion(
1311 0 : (jshortArray) java_data->l, 0, 1, (jshort *) uno_data );
1312 0 : jni.ensure_no_exception();
1313 : }
1314 : }
1315 : }
1316 0 : else if (special_wrapped_integral_types)
1317 : {
1318 : jvalue arg;
1319 0 : arg.s = *(jshort const *) uno_data;
1320 : java_data->l = jni->NewObjectA(
1321 : m_jni_info->m_class_Short,
1322 0 : m_jni_info->m_ctor_Short_with_short, &arg );
1323 0 : jni.ensure_no_exception();
1324 : }
1325 : else
1326 : {
1327 0 : java_data->s = *(jshort const *) uno_data;
1328 : }
1329 0 : break;
1330 : case typelib_TypeClass_LONG:
1331 : case typelib_TypeClass_UNSIGNED_LONG:
1332 0 : if (out_param)
1333 : {
1334 0 : if (0 == java_data->l)
1335 : {
1336 0 : JLocalAutoRef jo_ar( jni, jni->NewIntArray( 1 ) );
1337 0 : jni.ensure_no_exception();
1338 0 : if (in_param)
1339 : {
1340 : jni->SetIntArrayRegion(
1341 0 : (jintArray) jo_ar.get(), 0, 1, (jint *) uno_data );
1342 0 : jni.ensure_no_exception();
1343 : }
1344 0 : java_data->l = jo_ar.release();
1345 : }
1346 : else
1347 : {
1348 0 : if (in_param)
1349 : {
1350 : jni->SetIntArrayRegion(
1351 0 : (jintArray) java_data->l, 0, 1, (jint *) uno_data );
1352 0 : jni.ensure_no_exception();
1353 : }
1354 : }
1355 : }
1356 0 : else if (special_wrapped_integral_types)
1357 : {
1358 : jvalue arg;
1359 0 : arg.i = *(jint const *) uno_data;
1360 : java_data->l = jni->NewObjectA(
1361 : m_jni_info->m_class_Integer,
1362 0 : m_jni_info->m_ctor_Integer_with_int, &arg );
1363 0 : jni.ensure_no_exception();
1364 : }
1365 : else
1366 : {
1367 0 : java_data->i = *(jint const *) uno_data;
1368 : }
1369 0 : break;
1370 : case typelib_TypeClass_HYPER:
1371 : case typelib_TypeClass_UNSIGNED_HYPER:
1372 0 : if (out_param)
1373 : {
1374 0 : if (0 == java_data->l)
1375 : {
1376 0 : JLocalAutoRef jo_ar( jni, jni->NewLongArray( 1 ) );
1377 0 : jni.ensure_no_exception();
1378 0 : if (in_param)
1379 : {
1380 : jni->SetLongArrayRegion(
1381 0 : (jlongArray)jo_ar.get(), 0, 1, (jlong *) uno_data );
1382 0 : jni.ensure_no_exception();
1383 : }
1384 0 : java_data->l = jo_ar.release();
1385 : }
1386 : else
1387 : {
1388 0 : if (in_param)
1389 : {
1390 : jni->SetLongArrayRegion(
1391 0 : (jlongArray)java_data->l, 0, 1, (jlong *) uno_data );
1392 0 : jni.ensure_no_exception();
1393 : }
1394 : }
1395 : }
1396 0 : else if (special_wrapped_integral_types)
1397 : {
1398 : jvalue arg;
1399 0 : arg.j = *(jlong const *) uno_data;
1400 : java_data->l = jni->NewObjectA(
1401 : m_jni_info->m_class_Long,
1402 0 : m_jni_info->m_ctor_Long_with_long, &arg );
1403 0 : jni.ensure_no_exception();
1404 : }
1405 : else
1406 : {
1407 0 : java_data->j = *(jlong const *) uno_data;
1408 : }
1409 0 : break;
1410 : case typelib_TypeClass_FLOAT:
1411 0 : if (out_param)
1412 : {
1413 0 : if (0 == java_data->l)
1414 : {
1415 0 : JLocalAutoRef jo_ar( jni, jni->NewFloatArray( 1 ) );
1416 0 : jni.ensure_no_exception();
1417 0 : if (in_param)
1418 : {
1419 : jni->SetFloatArrayRegion(
1420 0 : (jfloatArray) jo_ar.get(), 0, 1, (jfloat *) uno_data );
1421 0 : jni.ensure_no_exception();
1422 : }
1423 0 : java_data->l = jo_ar.release();
1424 : }
1425 : else
1426 : {
1427 0 : if (in_param)
1428 : {
1429 : jni->SetFloatArrayRegion(
1430 0 : (jfloatArray) java_data->l, 0, 1, (jfloat *) uno_data );
1431 0 : jni.ensure_no_exception();
1432 : }
1433 : }
1434 : }
1435 0 : else if (special_wrapped_integral_types)
1436 : {
1437 : jvalue arg;
1438 0 : arg.f = *(jfloat const *) uno_data;
1439 : java_data->l = jni->NewObjectA(
1440 : m_jni_info->m_class_Float,
1441 0 : m_jni_info->m_ctor_Float_with_float, &arg );
1442 0 : jni.ensure_no_exception();
1443 : }
1444 : else
1445 : {
1446 0 : java_data->f = *(jfloat const *) uno_data;
1447 : }
1448 0 : break;
1449 : case typelib_TypeClass_DOUBLE:
1450 0 : if (out_param)
1451 : {
1452 0 : if (0 == java_data->l)
1453 : {
1454 0 : JLocalAutoRef jo_ar( jni, jni->NewDoubleArray( 1 ) );
1455 0 : jni.ensure_no_exception();
1456 0 : if (in_param)
1457 : {
1458 : jni->SetDoubleArrayRegion(
1459 0 : (jdoubleArray) jo_ar.get(),
1460 0 : 0, 1, (jdouble *) uno_data );
1461 0 : jni.ensure_no_exception();
1462 : }
1463 0 : java_data->l = jo_ar.release();
1464 : }
1465 : else
1466 : {
1467 0 : if (in_param)
1468 : {
1469 : jni->SetDoubleArrayRegion(
1470 : (jdoubleArray) java_data->l,
1471 0 : 0, 1, (jdouble *) uno_data );
1472 0 : jni.ensure_no_exception();
1473 : }
1474 : }
1475 : }
1476 0 : else if (special_wrapped_integral_types)
1477 : {
1478 : jvalue arg;
1479 0 : arg.d = *(double const *)uno_data;
1480 : java_data->l = jni->NewObjectA(
1481 : m_jni_info->m_class_Double,
1482 0 : m_jni_info->m_ctor_Double_with_double, &arg );
1483 0 : jni.ensure_no_exception();
1484 : }
1485 : else
1486 : {
1487 0 : java_data->d = *(jdouble const *) uno_data;
1488 : }
1489 0 : break;
1490 : case typelib_TypeClass_STRING:
1491 : {
1492 0 : if (out_param)
1493 : {
1494 0 : JLocalAutoRef jo_in( jni );
1495 0 : if (in_param)
1496 : {
1497 : jo_in.reset(
1498 : ustring_to_jstring(
1499 0 : jni, *(rtl_uString * const *) uno_data ) );
1500 : }
1501 0 : if (0 == java_data->l)
1502 : {
1503 : java_data->l = jni->NewObjectArray(
1504 0 : 1, m_jni_info->m_class_String, jo_in.get() );
1505 0 : jni.ensure_no_exception();
1506 : }
1507 : else
1508 : {
1509 : jni->SetObjectArrayElement(
1510 0 : (jobjectArray) java_data->l, 0, jo_in.get() );
1511 0 : jni.ensure_no_exception();
1512 0 : }
1513 : }
1514 : else
1515 : {
1516 : assert( in_param );
1517 : java_data->l =
1518 0 : ustring_to_jstring( jni, *(rtl_uString * const *) uno_data );
1519 : }
1520 0 : break;
1521 : }
1522 : case typelib_TypeClass_TYPE:
1523 : {
1524 0 : if (out_param)
1525 : {
1526 0 : JLocalAutoRef jo_in( jni );
1527 0 : if (in_param)
1528 : {
1529 : jo_in.reset(
1530 : create_type(
1531 : jni,
1532 : *(typelib_TypeDescriptionReference * const *) uno_data )
1533 0 : );
1534 : }
1535 0 : if (0 == java_data->l)
1536 : {
1537 : java_data->l = jni->NewObjectArray(
1538 0 : 1, m_jni_info->m_class_Type, jo_in.get() );
1539 0 : jni.ensure_no_exception();
1540 : }
1541 : else
1542 : {
1543 : jni->SetObjectArrayElement(
1544 0 : (jobjectArray) java_data->l, 0, jo_in.get() );
1545 0 : jni.ensure_no_exception();
1546 0 : }
1547 : }
1548 : else
1549 : {
1550 : assert( in_param );
1551 : java_data->l =
1552 : create_type(
1553 : jni,
1554 0 : *(typelib_TypeDescriptionReference * const *) uno_data );
1555 : }
1556 0 : break;
1557 : }
1558 : case typelib_TypeClass_ANY:
1559 : {
1560 0 : JLocalAutoRef jo_any( jni );
1561 0 : if (in_param)
1562 : {
1563 0 : uno_Any const * pAny = (uno_Any const *)uno_data;
1564 0 : switch (pAny->pType->eTypeClass)
1565 : {
1566 : case typelib_TypeClass_VOID:
1567 : jo_any.reset(
1568 0 : jni->NewLocalRef( m_jni_info->m_object_Any_VOID ) );
1569 0 : break;
1570 : case typelib_TypeClass_UNSIGNED_SHORT:
1571 : {
1572 : jvalue args[ 2 ];
1573 0 : args[ 0 ].s = *(jshort const *) pAny->pData;
1574 : JLocalAutoRef jo_val(
1575 : jni, jni->NewObjectA(
1576 : m_jni_info->m_class_Short,
1577 0 : m_jni_info->m_ctor_Short_with_short, args ) );
1578 0 : jni.ensure_no_exception();
1579 : // box up in com.sun.star.uno.Any
1580 0 : args[ 0 ].l = m_jni_info->m_object_Type_UNSIGNED_SHORT;
1581 0 : args[ 1 ].l = jo_val.get();
1582 : jo_any.reset(
1583 : jni->NewObjectA(
1584 : m_jni_info->m_class_Any,
1585 0 : m_jni_info->m_ctor_Any_with_Type_Object, args ) );
1586 0 : jni.ensure_no_exception();
1587 0 : break;
1588 : }
1589 : case typelib_TypeClass_UNSIGNED_LONG:
1590 : {
1591 : jvalue args[ 2 ];
1592 0 : args[ 0 ].i = *(jint const *) pAny->pData;
1593 : JLocalAutoRef jo_val(
1594 : jni, jni->NewObjectA(
1595 : m_jni_info->m_class_Integer,
1596 0 : m_jni_info->m_ctor_Integer_with_int, args ) );
1597 0 : jni.ensure_no_exception();
1598 : // box up in com.sun.star.uno.Any
1599 0 : args[ 0 ].l = m_jni_info->m_object_Type_UNSIGNED_LONG;
1600 0 : args[ 1 ].l = jo_val.get();
1601 : jo_any.reset(
1602 : jni->NewObjectA(
1603 : m_jni_info->m_class_Any,
1604 0 : m_jni_info->m_ctor_Any_with_Type_Object, args ) );
1605 0 : jni.ensure_no_exception();
1606 0 : break;
1607 : }
1608 : case typelib_TypeClass_UNSIGNED_HYPER:
1609 : {
1610 : jvalue args[ 2 ];
1611 0 : args[ 0 ].j = *(jlong const *) pAny->pData;
1612 : JLocalAutoRef jo_val(
1613 : jni, jni->NewObjectA(
1614 : m_jni_info->m_class_Long,
1615 0 : m_jni_info->m_ctor_Long_with_long, args ) );
1616 0 : jni.ensure_no_exception();
1617 : // box up in com.sun.star.uno.Any
1618 0 : args[ 0 ].l = m_jni_info->m_object_Type_UNSIGNED_HYPER;
1619 0 : args[ 1 ].l = jo_val.get();
1620 : jo_any.reset(
1621 : jni->NewObjectA(
1622 : m_jni_info->m_class_Any,
1623 0 : m_jni_info->m_ctor_Any_with_Type_Object, args ) );
1624 0 : jni.ensure_no_exception();
1625 0 : break;
1626 : }
1627 : case typelib_TypeClass_STRING: // opt strings
1628 : jo_any.reset( ustring_to_jstring(
1629 0 : jni, (rtl_uString *) pAny->pReserved ) );
1630 0 : break;
1631 : case typelib_TypeClass_SEQUENCE:
1632 : {
1633 : jvalue java_data2;
1634 : // prefetch sequence td
1635 0 : TypeDescr seq_td( pAny->pType );
1636 : map_to_java(
1637 0 : jni, &java_data2, pAny->pData, seq_td.get()->pWeakRef, 0,
1638 : true /* in */, false /* no out */,
1639 0 : true /* create integral wrappers */ );
1640 0 : jo_any.reset( java_data2.l );
1641 :
1642 : // determine inner element type
1643 : ::com::sun::star::uno::Type element_type(
1644 0 : ((typelib_IndirectTypeDescription *)seq_td.get())->pType );
1645 0 : while (typelib_TypeClass_SEQUENCE ==
1646 0 : element_type.getTypeLibType()->eTypeClass)
1647 : {
1648 0 : TypeDescr element_td( element_type.getTypeLibType() );
1649 : typelib_typedescriptionreference_assign(
1650 : reinterpret_cast< typelib_TypeDescriptionReference ** >(
1651 : &element_type ),
1652 0 : ((typelib_IndirectTypeDescription *)element_td.get())
1653 0 : ->pType );
1654 0 : }
1655 : // box up only if unsigned element type
1656 0 : switch (element_type.getTypeLibType()->eTypeClass)
1657 : {
1658 : case typelib_TypeClass_UNSIGNED_SHORT:
1659 : case typelib_TypeClass_UNSIGNED_LONG:
1660 : case typelib_TypeClass_UNSIGNED_HYPER:
1661 : {
1662 : jvalue args[ 2 ];
1663 : JLocalAutoRef jo_type(
1664 0 : jni, create_type( jni, seq_td.get()->pWeakRef ) );
1665 0 : args[ 0 ].l = jo_type.get();
1666 0 : args[ 1 ].l = jo_any.get();
1667 : jo_any.reset(
1668 : jni->NewObjectA(
1669 : m_jni_info->m_class_Any,
1670 0 : m_jni_info->m_ctor_Any_with_Type_Object, args ) );
1671 0 : jni.ensure_no_exception();
1672 0 : break;
1673 : }
1674 : default:
1675 0 : break;
1676 : }
1677 0 : break;
1678 : }
1679 : case typelib_TypeClass_INTERFACE:
1680 : {
1681 0 : uno_Interface * pUnoI = (uno_Interface *)pAny->pReserved;
1682 0 : if (is_XInterface( pAny->pType ))
1683 : {
1684 0 : if (0 != pUnoI)
1685 : {
1686 : jo_any.reset(
1687 : map_to_java(
1688 : jni, pUnoI,
1689 0 : m_jni_info->m_XInterface_type_info ) );
1690 : }
1691 : // else: empty XInterface ref maps to null-ref
1692 : }
1693 : else
1694 : {
1695 : JNI_interface_type_info const * iface_info =
1696 : static_cast< JNI_interface_type_info const * >(
1697 0 : m_jni_info->get_type_info( jni, pAny->pType ) );
1698 0 : if (0 != pUnoI)
1699 : {
1700 0 : jo_any.reset( map_to_java( jni, pUnoI, iface_info ) );
1701 : }
1702 : // box up in com.sun.star.uno.Any
1703 : jvalue args[ 2 ];
1704 0 : args[ 0 ].l = iface_info->m_type;
1705 0 : args[ 1 ].l = jo_any.get();
1706 : jo_any.reset(
1707 : jni->NewObjectA(
1708 : m_jni_info->m_class_Any,
1709 0 : m_jni_info->m_ctor_Any_with_Type_Object, args ) );
1710 0 : jni.ensure_no_exception();
1711 : }
1712 0 : break;
1713 : }
1714 : case typelib_TypeClass_STRUCT:
1715 : {
1716 : // Do not lose information about type arguments of instantiated
1717 : // polymorphic struct types:
1718 : OUString const & name = OUString::unacquired(
1719 0 : &pAny->pType->pTypeName);
1720 : assert(!name.isEmpty());
1721 0 : if (name[name.getLength() - 1] == '>')
1722 : {
1723 : // Box up in com.sun.star.uno.Any:
1724 0 : JLocalAutoRef jo_type(jni, create_type(jni, pAny->pType));
1725 : jvalue java_data2;
1726 : map_to_java(
1727 : jni, &java_data2, pAny->pData, pAny->pType, 0, true,
1728 0 : false);
1729 0 : jo_any.reset(java_data2.l);
1730 : jvalue args[2];
1731 0 : args[0].l = jo_type.get();
1732 0 : args[1].l = jo_any.get();
1733 : jo_any.reset(
1734 : jni->NewObjectA(
1735 : m_jni_info->m_class_Any,
1736 0 : m_jni_info->m_ctor_Any_with_Type_Object, args));
1737 0 : jni.ensure_no_exception();
1738 0 : break;
1739 : }
1740 : // fall through
1741 : }
1742 : default:
1743 : {
1744 : jvalue java_data2;
1745 : map_to_java(
1746 : jni, &java_data2, pAny->pData, pAny->pType, 0,
1747 : true /* in */, false /* no out */,
1748 0 : true /* create integral wrappers */ );
1749 0 : jo_any.reset( java_data2.l );
1750 0 : break;
1751 : }
1752 : }
1753 : }
1754 :
1755 0 : if (out_param)
1756 : {
1757 0 : if (0 == java_data->l)
1758 : {
1759 : java_data->l = jni->NewObjectArray(
1760 0 : 1, m_jni_info->m_class_Object, jo_any.get() );
1761 0 : jni.ensure_no_exception();
1762 : }
1763 : else
1764 : {
1765 : jni->SetObjectArrayElement(
1766 0 : (jobjectArray) java_data->l, 0, jo_any.get() );
1767 0 : jni.ensure_no_exception();
1768 : }
1769 : }
1770 : else
1771 : {
1772 0 : java_data->l = jo_any.release();
1773 : }
1774 0 : break;
1775 : }
1776 : case typelib_TypeClass_ENUM:
1777 : {
1778 0 : OUString const & type_name = OUString::unacquired( &type->pTypeName );
1779 : OString class_name(
1780 0 : OUStringToOString( type_name, RTL_TEXTENCODING_JAVA_UTF8 ) );
1781 : JLocalAutoRef jo_enum_class(
1782 0 : jni, find_class( jni, class_name.getStr() ) );
1783 :
1784 0 : JLocalAutoRef jo_enum( jni );
1785 0 : if (in_param)
1786 : {
1787 : // call static <enum_class>.fromInt( int )
1788 0 : OStringBuffer sig_buf( 5 + class_name.getLength() );
1789 0 : sig_buf.append( "(I)L" );
1790 0 : sig_buf.append( class_name.replace( '.', '/' ) );
1791 0 : sig_buf.append( ';' );
1792 0 : OString sig( sig_buf.makeStringAndClear() );
1793 : jmethodID method_id = jni->GetStaticMethodID(
1794 0 : (jclass) jo_enum_class.get(), "fromInt", sig.getStr() );
1795 0 : jni.ensure_no_exception();
1796 : assert( 0 != method_id );
1797 :
1798 : jvalue arg;
1799 0 : arg.i = *(jint const *) uno_data;
1800 : jo_enum.reset(
1801 : jni->CallStaticObjectMethodA(
1802 0 : (jclass) jo_enum_class.get(), method_id, &arg ) );
1803 0 : jni.ensure_no_exception();
1804 : }
1805 0 : if (out_param)
1806 : {
1807 0 : if (0 == java_data->l)
1808 : {
1809 : java_data->l = jni->NewObjectArray(
1810 0 : 1, (jclass) jo_enum_class.get(), jo_enum.get() );
1811 0 : jni.ensure_no_exception();
1812 : }
1813 : else
1814 : {
1815 : jni->SetObjectArrayElement(
1816 0 : (jobjectArray) java_data->l, 0, jo_enum.get() );
1817 0 : jni.ensure_no_exception();
1818 : }
1819 : }
1820 : else
1821 : {
1822 0 : java_data->l = jo_enum.release();
1823 : }
1824 0 : break;
1825 : }
1826 : case typelib_TypeClass_STRUCT:
1827 : case typelib_TypeClass_EXCEPTION:
1828 : {
1829 0 : if (0 == info)
1830 0 : info = m_jni_info->get_type_info( jni, type );
1831 : JNI_compound_type_info const * comp_info =
1832 0 : static_cast< JNI_compound_type_info const * >( info );
1833 :
1834 0 : JLocalAutoRef jo_comp( jni );
1835 0 : if (in_param)
1836 : {
1837 0 : if (typelib_TypeClass_EXCEPTION == type->eTypeClass)
1838 : {
1839 : JLocalAutoRef jo_message(
1840 0 : jni, ustring_to_jstring( jni, *(rtl_uString **)uno_data ) );
1841 : jvalue arg;
1842 0 : arg.l = jo_message.get();
1843 : jo_comp.reset(
1844 : jni->NewObjectA(
1845 0 : comp_info->m_class, comp_info->m_exc_ctor, &arg ) );
1846 0 : jni.ensure_no_exception();
1847 : }
1848 : else
1849 : {
1850 0 : jo_comp.reset( jni->AllocObject( comp_info->m_class ) );
1851 0 : jni.ensure_no_exception();
1852 : }
1853 :
1854 0 : for ( JNI_compound_type_info const * linfo = comp_info;
1855 : 0 != linfo;
1856 : linfo = static_cast< JNI_compound_type_info const * >(
1857 : linfo->m_base ) )
1858 : {
1859 : typelib_CompoundTypeDescription * comp_td =
1860 0 : (typelib_CompoundTypeDescription *)linfo->m_td.get();
1861 : typelib_TypeDescriptionReference ** ppMemberTypeRefs =
1862 0 : comp_td->ppTypeRefs;
1863 0 : sal_Int32 * pMemberOffsets = comp_td->pMemberOffsets;
1864 : bool polymorphic
1865 0 : = comp_td->aBase.eTypeClass == typelib_TypeClass_STRUCT
1866 0 : && reinterpret_cast< typelib_StructTypeDescription * >(
1867 0 : comp_td)->pParameterizedTypes != 0;
1868 0 : for ( sal_Int32 nPos = comp_td->nMembers; nPos--; )
1869 : {
1870 0 : jfieldID field_id = linfo->m_fields[ nPos ];
1871 0 : if (0 != field_id)
1872 : {
1873 : void const * p =
1874 0 : (char const *)uno_data + pMemberOffsets[ nPos ];
1875 : typelib_TypeDescriptionReference * member_type =
1876 0 : ppMemberTypeRefs[ nPos ];
1877 : bool parameterizedType = polymorphic
1878 0 : && (reinterpret_cast<
1879 : typelib_StructTypeDescription * >(comp_td)->
1880 0 : pParameterizedTypes[nPos]);
1881 0 : switch (member_type->eTypeClass)
1882 : {
1883 : case typelib_TypeClass_CHAR:
1884 0 : if (parameterizedType) {
1885 : jvalue arg;
1886 0 : arg.c = *(jchar const *) p;
1887 : JLocalAutoRef jo(
1888 : jni,
1889 : jni->NewObjectA(
1890 : m_jni_info->m_class_Character,
1891 : m_jni_info->m_ctor_Character_with_char,
1892 0 : &arg ) );
1893 0 : jni.ensure_no_exception();
1894 : jni->SetObjectField(
1895 0 : jo_comp.get(), field_id, jo.get() );
1896 : } else {
1897 : jni->SetCharField(
1898 : jo_comp.get(),
1899 0 : field_id, *(jchar const *) p );
1900 : }
1901 0 : break;
1902 : case typelib_TypeClass_BOOLEAN:
1903 0 : if (parameterizedType) {
1904 : jvalue arg;
1905 0 : arg.z = *(jboolean const *) p;
1906 : JLocalAutoRef jo(
1907 : jni,
1908 : jni->NewObjectA(
1909 : m_jni_info->m_class_Boolean,
1910 : m_jni_info->m_ctor_Boolean_with_boolean,
1911 0 : &arg ) );
1912 0 : jni.ensure_no_exception();
1913 : jni->SetObjectField(
1914 0 : jo_comp.get(), field_id, jo.get() );
1915 : } else {
1916 : jni->SetBooleanField(
1917 : jo_comp.get(),
1918 0 : field_id, *(jboolean const *) p );
1919 : }
1920 0 : break;
1921 : case typelib_TypeClass_BYTE:
1922 0 : if (parameterizedType) {
1923 : jvalue arg;
1924 0 : arg.b = *(jbyte const *) p;
1925 : JLocalAutoRef jo(
1926 : jni,
1927 : jni->NewObjectA(
1928 : m_jni_info->m_class_Byte,
1929 : m_jni_info->m_ctor_Byte_with_byte,
1930 0 : &arg ) );
1931 0 : jni.ensure_no_exception();
1932 : jni->SetObjectField(
1933 0 : jo_comp.get(), field_id, jo.get() );
1934 : } else {
1935 : jni->SetByteField(
1936 : jo_comp.get(),
1937 0 : field_id, *(jbyte const *) p );
1938 : }
1939 0 : break;
1940 : case typelib_TypeClass_SHORT:
1941 : case typelib_TypeClass_UNSIGNED_SHORT:
1942 0 : if (parameterizedType) {
1943 : jvalue arg;
1944 0 : arg.s = *(jshort const *) p;
1945 : JLocalAutoRef jo(
1946 : jni,
1947 : jni->NewObjectA(
1948 : m_jni_info->m_class_Short,
1949 : m_jni_info->m_ctor_Short_with_short,
1950 0 : &arg ) );
1951 0 : jni.ensure_no_exception();
1952 : jni->SetObjectField(
1953 0 : jo_comp.get(), field_id, jo.get() );
1954 : } else {
1955 : jni->SetShortField(
1956 : jo_comp.get(),
1957 0 : field_id, *(jshort const *) p );
1958 : }
1959 0 : break;
1960 : case typelib_TypeClass_LONG:
1961 : case typelib_TypeClass_UNSIGNED_LONG:
1962 0 : if (parameterizedType) {
1963 : jvalue arg;
1964 0 : arg.i = *(jint const *) p;
1965 : JLocalAutoRef jo(
1966 : jni,
1967 : jni->NewObjectA(
1968 : m_jni_info->m_class_Integer,
1969 : m_jni_info->m_ctor_Integer_with_int,
1970 0 : &arg ) );
1971 0 : jni.ensure_no_exception();
1972 : jni->SetObjectField(
1973 0 : jo_comp.get(), field_id, jo.get() );
1974 : } else {
1975 : jni->SetIntField(
1976 : jo_comp.get(),
1977 0 : field_id, *(jint const *) p );
1978 : }
1979 0 : break;
1980 : case typelib_TypeClass_HYPER:
1981 : case typelib_TypeClass_UNSIGNED_HYPER:
1982 0 : if (parameterizedType) {
1983 : jvalue arg;
1984 0 : arg.j = *(jlong const *) p;
1985 : JLocalAutoRef jo(
1986 : jni,
1987 : jni->NewObjectA(
1988 : m_jni_info->m_class_Long,
1989 : m_jni_info->m_ctor_Long_with_long,
1990 0 : &arg ) );
1991 0 : jni.ensure_no_exception();
1992 : jni->SetObjectField(
1993 0 : jo_comp.get(), field_id, jo.get() );
1994 : } else {
1995 : jni->SetLongField(
1996 : jo_comp.get(),
1997 0 : field_id, *(jlong const *) p );
1998 : }
1999 0 : break;
2000 : case typelib_TypeClass_FLOAT:
2001 0 : if (parameterizedType) {
2002 : jvalue arg;
2003 0 : arg.f = *(jfloat const *) p;
2004 : JLocalAutoRef jo(
2005 : jni,
2006 : jni->NewObjectA(
2007 : m_jni_info->m_class_Float,
2008 : m_jni_info->m_ctor_Float_with_float,
2009 0 : &arg ) );
2010 0 : jni.ensure_no_exception();
2011 : jni->SetObjectField(
2012 0 : jo_comp.get(), field_id, jo.get() );
2013 : } else {
2014 : jni->SetFloatField(
2015 : jo_comp.get(),
2016 0 : field_id, *(jfloat const *) p );
2017 : }
2018 0 : break;
2019 : case typelib_TypeClass_DOUBLE:
2020 0 : if (parameterizedType) {
2021 : jvalue arg;
2022 0 : arg.d = *(jdouble const *) p;
2023 : JLocalAutoRef jo(
2024 : jni,
2025 : jni->NewObjectA(
2026 : m_jni_info->m_class_Double,
2027 : m_jni_info->m_ctor_Double_with_double,
2028 0 : &arg ) );
2029 0 : jni.ensure_no_exception();
2030 : jni->SetObjectField(
2031 0 : jo_comp.get(), field_id, jo.get() );
2032 : } else {
2033 : jni->SetDoubleField(
2034 : jo_comp.get(),
2035 0 : field_id, *(jdouble const *) p );
2036 : }
2037 0 : break;
2038 : case typelib_TypeClass_STRING: // string opt here
2039 : {
2040 : JLocalAutoRef jo_string(
2041 : jni, ustring_to_jstring(
2042 0 : jni, *(rtl_uString * const *) p ) );
2043 : jni->SetObjectField(
2044 0 : jo_comp.get(), field_id, jo_string.get() );
2045 0 : break;
2046 : }
2047 : default:
2048 : {
2049 : jvalue java_data2;
2050 : map_to_java(
2051 : jni, &java_data2, p, member_type, 0,
2052 0 : true /* in */, false /* no out */ );
2053 0 : JLocalAutoRef jo_obj( jni, java_data2.l );
2054 : jni->SetObjectField(
2055 0 : jo_comp.get(), field_id, jo_obj.get() );
2056 0 : break;
2057 : }
2058 : }
2059 : }
2060 : }
2061 : }
2062 : }
2063 0 : if (out_param)
2064 : {
2065 0 : if (0 == java_data->l)
2066 : {
2067 : java_data->l =
2068 0 : jni->NewObjectArray( 1, comp_info->m_class, jo_comp.get() );
2069 0 : jni.ensure_no_exception();
2070 : }
2071 : else
2072 : {
2073 : jni->SetObjectArrayElement(
2074 0 : (jobjectArray) java_data->l, 0, jo_comp.get() );
2075 0 : jni.ensure_no_exception();
2076 : }
2077 : }
2078 : else
2079 : {
2080 0 : java_data->l = jo_comp.release();
2081 : }
2082 0 : break;
2083 : }
2084 : case typelib_TypeClass_SEQUENCE:
2085 : {
2086 : // xxx todo: possible opt for pure out sequences
2087 0 : JLocalAutoRef jo_ar( jni );
2088 :
2089 : sal_Int32 nElements;
2090 0 : uno_Sequence const * seq = 0;
2091 0 : if (in_param)
2092 : {
2093 0 : seq = *(uno_Sequence * const *)uno_data;
2094 0 : nElements = seq->nElements;
2095 : }
2096 : else
2097 : {
2098 0 : nElements = 0;
2099 : }
2100 :
2101 0 : TypeDescr td( type );
2102 : typelib_TypeDescriptionReference * element_type =
2103 0 : ((typelib_IndirectTypeDescription *)td.get())->pType;
2104 :
2105 0 : switch (element_type->eTypeClass)
2106 : {
2107 : case typelib_TypeClass_CHAR:
2108 0 : jo_ar.reset( jni->NewCharArray( nElements ) );
2109 0 : jni.ensure_no_exception();
2110 0 : if (0 < nElements)
2111 : {
2112 : jni->SetCharArrayRegion(
2113 0 : (jcharArray) jo_ar.get(),
2114 0 : 0, nElements, (jchar *) seq->elements );
2115 0 : jni.ensure_no_exception();
2116 : }
2117 0 : break;
2118 : case typelib_TypeClass_BOOLEAN:
2119 0 : jo_ar.reset( jni->NewBooleanArray( nElements ) );
2120 0 : jni.ensure_no_exception();
2121 0 : if (0 < nElements)
2122 : {
2123 : jni->SetBooleanArrayRegion(
2124 0 : (jbooleanArray) jo_ar.get(),
2125 0 : 0, nElements, (jboolean *) seq->elements );
2126 0 : jni.ensure_no_exception();
2127 : }
2128 0 : break;
2129 : case typelib_TypeClass_BYTE:
2130 0 : jo_ar.reset( jni->NewByteArray( nElements ) );
2131 0 : jni.ensure_no_exception();
2132 0 : if (0 < nElements)
2133 : {
2134 : jni->SetByteArrayRegion(
2135 0 : (jbyteArray) jo_ar.get(),
2136 0 : 0, nElements, (jbyte *) seq->elements );
2137 0 : jni.ensure_no_exception();
2138 : }
2139 0 : break;
2140 : case typelib_TypeClass_SHORT:
2141 : case typelib_TypeClass_UNSIGNED_SHORT:
2142 0 : jo_ar.reset( jni->NewShortArray( nElements ) );
2143 0 : jni.ensure_no_exception();
2144 0 : if (0 < nElements)
2145 : {
2146 : jni->SetShortArrayRegion(
2147 0 : (jshortArray) jo_ar.get(),
2148 0 : 0, nElements, (jshort *) seq->elements );
2149 0 : jni.ensure_no_exception();
2150 : }
2151 0 : break;
2152 : case typelib_TypeClass_LONG:
2153 : case typelib_TypeClass_UNSIGNED_LONG:
2154 0 : jo_ar.reset( jni->NewIntArray( nElements ) );
2155 0 : jni.ensure_no_exception();
2156 0 : if (0 < nElements)
2157 : {
2158 : jni->SetIntArrayRegion(
2159 0 : (jintArray) jo_ar.get(),
2160 0 : 0, nElements, (jint *) seq->elements );
2161 0 : jni.ensure_no_exception();
2162 : }
2163 0 : break;
2164 : case typelib_TypeClass_HYPER:
2165 : case typelib_TypeClass_UNSIGNED_HYPER:
2166 0 : jo_ar.reset( jni->NewLongArray( nElements ) );
2167 0 : jni.ensure_no_exception();
2168 0 : if (0 < nElements)
2169 : {
2170 : jni->SetLongArrayRegion(
2171 0 : (jlongArray) jo_ar.get(),
2172 0 : 0, nElements, (jlong *) seq->elements );
2173 0 : jni.ensure_no_exception();
2174 : }
2175 0 : break;
2176 : case typelib_TypeClass_FLOAT:
2177 0 : jo_ar.reset( jni->NewFloatArray( nElements ) );
2178 0 : jni.ensure_no_exception();
2179 0 : if (0 < nElements)
2180 : {
2181 : jni->SetFloatArrayRegion(
2182 0 : (jfloatArray) jo_ar.get(),
2183 0 : 0, nElements, (jfloat *) seq->elements );
2184 0 : jni.ensure_no_exception();
2185 : }
2186 0 : break;
2187 : case typelib_TypeClass_DOUBLE:
2188 0 : jo_ar.reset( jni->NewDoubleArray( nElements ) );
2189 0 : jni.ensure_no_exception();
2190 0 : if (0 < nElements)
2191 : {
2192 : jni->SetDoubleArrayRegion(
2193 0 : (jdoubleArray) jo_ar.get(),
2194 0 : 0, nElements, (jdouble *) seq->elements );
2195 0 : jni.ensure_no_exception();
2196 : }
2197 0 : break;
2198 : case typelib_TypeClass_STRING:
2199 : jo_ar.reset(
2200 : jni->NewObjectArray(
2201 0 : nElements, m_jni_info->m_class_String, 0 ) );
2202 0 : jni.ensure_no_exception();
2203 0 : if (in_param)
2204 : {
2205 : rtl_uString * const * pp =
2206 0 : (rtl_uString * const *) seq->elements;
2207 0 : for ( sal_Int32 nPos = 0; nPos < nElements; ++nPos )
2208 : {
2209 : JLocalAutoRef jo_string(
2210 0 : jni, ustring_to_jstring( jni, pp[ nPos ] ) );
2211 : jni->SetObjectArrayElement(
2212 0 : (jobjectArray) jo_ar.get(), nPos, jo_string.get() );
2213 0 : jni.ensure_no_exception();
2214 0 : }
2215 : }
2216 0 : break;
2217 : case typelib_TypeClass_TYPE:
2218 : jo_ar.reset(
2219 0 : jni->NewObjectArray( nElements, m_jni_info->m_class_Type, 0 ) );
2220 0 : jni.ensure_no_exception();
2221 0 : if (in_param)
2222 : {
2223 : typelib_TypeDescriptionReference * const * pp =
2224 0 : (typelib_TypeDescriptionReference * const *)seq->elements;
2225 0 : for ( sal_Int32 nPos = 0; nPos < nElements; ++nPos )
2226 : {
2227 : jvalue val;
2228 : map_to_java(
2229 0 : jni, &val, &pp[ nPos ], element_type, 0,
2230 0 : true /* in */, false /* no out */ );
2231 0 : JLocalAutoRef jo_element( jni, val.l );
2232 : jni->SetObjectArrayElement(
2233 0 : (jobjectArray) jo_ar.get(), nPos, jo_element.get() );
2234 0 : jni.ensure_no_exception();
2235 0 : }
2236 : }
2237 0 : break;
2238 : case typelib_TypeClass_ANY:
2239 : jo_ar.reset(
2240 : jni->NewObjectArray(
2241 0 : nElements, m_jni_info->m_class_Object, 0 ) );
2242 0 : jni.ensure_no_exception();
2243 0 : if (in_param)
2244 : {
2245 0 : uno_Any const * p = (uno_Any const *)seq->elements;
2246 0 : for ( sal_Int32 nPos = 0; nPos < nElements; ++nPos )
2247 : {
2248 : jvalue val;
2249 : map_to_java(
2250 0 : jni, &val, &p[ nPos ], element_type, 0,
2251 0 : true /* in */, false /* no out */ );
2252 0 : JLocalAutoRef jo_element( jni, val.l );
2253 : jni->SetObjectArrayElement(
2254 0 : (jobjectArray) jo_ar.get(), nPos, jo_element.get() );
2255 0 : jni.ensure_no_exception();
2256 0 : }
2257 : }
2258 0 : break;
2259 : case typelib_TypeClass_ENUM:
2260 : {
2261 : OUString const & element_type_name =
2262 0 : OUString::unacquired( &element_type->pTypeName );
2263 : OString class_name(
2264 : OUStringToOString(
2265 0 : element_type_name, RTL_TEXTENCODING_JAVA_UTF8 ) );
2266 : JLocalAutoRef jo_enum_class(
2267 0 : jni, find_class( jni, class_name.getStr() ) );
2268 :
2269 : jo_ar.reset(
2270 : jni->NewObjectArray(
2271 0 : nElements, (jclass) jo_enum_class.get(), 0 ) );
2272 0 : jni.ensure_no_exception();
2273 :
2274 0 : if (0 < nElements)
2275 : {
2276 : // call static <enum_class>.fromInt( int )
2277 0 : OStringBuffer sig_buf( 5 + class_name.getLength() );
2278 0 : sig_buf.append( "(I)L" );
2279 0 : sig_buf.append( class_name.replace( '.', '/' ) );
2280 0 : sig_buf.append( ';' );
2281 0 : OString sig( sig_buf.makeStringAndClear() );
2282 : jmethodID method_id = jni->GetStaticMethodID(
2283 0 : (jclass) jo_enum_class.get(), "fromInt", sig.getStr() );
2284 0 : jni.ensure_no_exception();
2285 : assert( 0 != method_id );
2286 :
2287 0 : sal_Int32 const * p = (sal_Int32 const *)seq->elements;
2288 0 : for ( sal_Int32 nPos = 0; nPos < nElements; ++nPos )
2289 : {
2290 : jvalue arg;
2291 0 : arg.i = p[ nPos ];
2292 : JLocalAutoRef jo_enum(
2293 : jni, jni->CallStaticObjectMethodA(
2294 0 : (jclass) jo_enum_class.get(), method_id, &arg ) );
2295 0 : jni.ensure_no_exception();
2296 : jni->SetObjectArrayElement(
2297 0 : (jobjectArray) jo_ar.get(), nPos, jo_enum.get() );
2298 0 : jni.ensure_no_exception();
2299 0 : }
2300 : }
2301 0 : break;
2302 : }
2303 : case typelib_TypeClass_STRUCT:
2304 : case typelib_TypeClass_EXCEPTION:
2305 : {
2306 : JNI_type_info const * element_info =
2307 0 : m_jni_info->get_type_info( jni, element_type );
2308 :
2309 : jo_ar.reset(
2310 0 : jni->NewObjectArray( nElements, element_info->m_class, 0 ) );
2311 0 : jni.ensure_no_exception();
2312 :
2313 0 : if (0 < nElements)
2314 : {
2315 0 : char * p = (char *)seq->elements;
2316 0 : sal_Int32 nSize = element_info->m_td.get()->nSize;
2317 0 : for ( sal_Int32 nPos = 0; nPos < nElements; ++nPos )
2318 : {
2319 : jvalue val;
2320 : map_to_java(
2321 0 : jni, &val, p + (nSize * nPos),
2322 : element_type, element_info,
2323 0 : true /* in */, false /* no out */ );
2324 0 : JLocalAutoRef jo_element( jni, val.l );
2325 : jni->SetObjectArrayElement(
2326 0 : (jobjectArray) jo_ar.get(), nPos, jo_element.get() );
2327 0 : jni.ensure_no_exception();
2328 0 : }
2329 : }
2330 0 : break;
2331 : }
2332 : case typelib_TypeClass_SEQUENCE:
2333 : {
2334 0 : OStringBuffer buf( 64 );
2335 : JNI_info::append_sig(
2336 : &buf, element_type, false /* use class XInterface */,
2337 0 : false /* '.' instead of '/' */ );
2338 0 : OString class_name( buf.makeStringAndClear() );
2339 : JLocalAutoRef jo_seq_class(
2340 0 : jni, find_class( jni, class_name.getStr() ) );
2341 :
2342 : jo_ar.reset(
2343 : jni->NewObjectArray(
2344 0 : nElements, (jclass) jo_seq_class.get(), 0 ) );
2345 0 : jni.ensure_no_exception();
2346 :
2347 0 : if (0 < nElements)
2348 : {
2349 0 : TypeDescr element_td( element_type );
2350 0 : uno_Sequence ** elements = (uno_Sequence **) seq->elements;
2351 0 : for ( sal_Int32 nPos = 0; nPos < nElements; ++nPos )
2352 : {
2353 : jvalue java_data2;
2354 : map_to_java(
2355 : jni, &java_data2, elements + nPos, element_type, 0,
2356 0 : true /* in */, false /* no out */ );
2357 0 : JLocalAutoRef jo_seq( jni, java_data2.l );
2358 : jni->SetObjectArrayElement(
2359 0 : (jobjectArray) jo_ar.get(), nPos, jo_seq.get() );
2360 0 : jni.ensure_no_exception();
2361 0 : }
2362 : }
2363 0 : break;
2364 : }
2365 : case typelib_TypeClass_INTERFACE:
2366 : {
2367 : JNI_interface_type_info const * iface_info =
2368 : static_cast< JNI_interface_type_info const * >(
2369 0 : m_jni_info->get_type_info( jni, element_type ) );
2370 :
2371 : jo_ar.reset(
2372 0 : jni->NewObjectArray( nElements, iface_info->m_class, 0 ) );
2373 0 : jni.ensure_no_exception();
2374 :
2375 0 : if (0 < nElements)
2376 : {
2377 0 : uno_Interface ** pp = (uno_Interface **)seq->elements;
2378 0 : for ( sal_Int32 nPos = 0; nPos < nElements; ++nPos )
2379 : {
2380 0 : uno_Interface * pUnoI = pp[ nPos ];
2381 0 : if (0 != pUnoI)
2382 : {
2383 : JLocalAutoRef jo_element(
2384 0 : jni, map_to_java( jni, pUnoI, iface_info ) );
2385 : jni->SetObjectArrayElement(
2386 0 : (jobjectArray) jo_ar.get(),
2387 0 : nPos, jo_element.get() );
2388 0 : jni.ensure_no_exception();
2389 : }
2390 : }
2391 : }
2392 0 : break;
2393 : }
2394 : default:
2395 : {
2396 : throw BridgeRuntimeError(
2397 0 : "[map_to_java():" + OUString::unacquired( &type->pTypeName )
2398 0 : + "] unsupported element type: "
2399 0 : + OUString::unacquired( &element_type->pTypeName )
2400 0 : + jni.get_stack_trace() );
2401 : }
2402 : }
2403 :
2404 0 : if (out_param)
2405 : {
2406 0 : if (0 == java_data->l)
2407 : {
2408 : JLocalAutoRef jo_element_class(
2409 0 : jni, jni->GetObjectClass( jo_ar.get() ) );
2410 0 : if (in_param)
2411 : {
2412 : java_data->l = jni->NewObjectArray(
2413 0 : 1, (jclass) jo_element_class.get(), jo_ar.get() );
2414 : }
2415 : else
2416 : {
2417 : java_data->l = jni->NewObjectArray(
2418 0 : 1, (jclass) jo_element_class.get(), 0 );
2419 : }
2420 0 : jni.ensure_no_exception();
2421 : }
2422 : else
2423 : {
2424 : jni->SetObjectArrayElement(
2425 0 : (jobjectArray) java_data->l, 0, jo_ar.get() );
2426 0 : jni.ensure_no_exception();
2427 : }
2428 : }
2429 : else
2430 : {
2431 0 : java_data->l = jo_ar.release();
2432 : }
2433 0 : break;
2434 : }
2435 : case typelib_TypeClass_INTERFACE:
2436 : {
2437 0 : JLocalAutoRef jo_iface( jni );
2438 0 : if (in_param)
2439 : {
2440 0 : uno_Interface * pUnoI = *(uno_Interface * const *)uno_data;
2441 0 : if (0 != pUnoI)
2442 : {
2443 0 : if (0 == info)
2444 0 : info = m_jni_info->get_type_info( jni, type );
2445 : JNI_interface_type_info const * iface_info =
2446 0 : static_cast< JNI_interface_type_info const * >( info );
2447 0 : jo_iface.reset( map_to_java( jni, pUnoI, iface_info ) );
2448 : }
2449 : }
2450 0 : if (out_param)
2451 : {
2452 0 : if (0 == java_data->l)
2453 : {
2454 0 : if (0 == info)
2455 0 : info = m_jni_info->get_type_info( jni, type );
2456 : java_data->l =
2457 0 : jni->NewObjectArray( 1, info->m_class, jo_iface.get() );
2458 0 : jni.ensure_no_exception();
2459 : }
2460 : else
2461 : {
2462 : jni->SetObjectArrayElement(
2463 0 : (jobjectArray) java_data->l, 0, jo_iface.get() );
2464 0 : jni.ensure_no_exception();
2465 : }
2466 : }
2467 : else
2468 : {
2469 0 : java_data->l = jo_iface.release();
2470 : }
2471 0 : break;
2472 : }
2473 : default:
2474 : {
2475 : throw BridgeRuntimeError(
2476 0 : "[map_to_java():" + OUString::unacquired( &type->pTypeName )
2477 0 : + "] unsupported type!" + jni.get_stack_trace() );
2478 : }
2479 : }
2480 0 : }
2481 :
2482 : }
2483 :
2484 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
