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