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