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