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