?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 5.0.4.1
[LibreOffice.git] / cppu / source / uno / sequence.cxx
blobcd536a85361406f034f55b24daf1792ab2fb8e84
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include "sal/config.h"
21
22 #include <cassert>
23 #include <string.h>
24
25 #include <rtl/alloc.h>
26 #include <osl/diagnose.h>
27 #include <osl/interlck.h>
28 #include <typelib/typedescription.h>
29 #include <uno/data.h>
30 #include <uno/dispatcher.h>
31 #include <uno/sequence2.h>
32
33 #include "constr.hxx"
34 #include "copy.hxx"
35 #include "destr.hxx"
36
37
38 using namespace cppu;
39
40 namespace cppu
41 {
42
43
44 static inline uno_Sequence * reallocSeq(
45 uno_Sequence * pReallocate, sal_Size nElementSize, sal_Int32 nElements )
46 {
47 OSL_ASSERT( nElements >= 0 );
48 uno_Sequence * pNew = 0;
49 sal_uInt32 nSize = calcSeqMemSize( nElementSize, nElements );
50 if (nSize > 0)
51 {
52 if (pReallocate == 0)
53 {
54 pNew = static_cast<uno_Sequence *>(rtl_allocateMemory( nSize ));
55 }
56 else
57 {
58 pNew = static_cast<uno_Sequence *>(rtl_reallocateMemory( pReallocate, nSize ));
59 }
60 if (pNew != 0)
61 {
62 // header init
63 pNew->nRefCount = 1;
64 pNew->nElements = nElements;
65 }
66 }
67 return pNew;
68 }
69
70
71 static inline bool idefaultConstructElements(
72 uno_Sequence ** ppSeq,
73 typelib_TypeDescriptionReference * pElementType,
74 sal_Int32 nStartIndex, sal_Int32 nStopIndex,
75 sal_Int32 nAlloc = -1 ) // >= 0 means (re)alloc memory for nAlloc elements
76 {
77 uno_Sequence * pSeq = *ppSeq;
78 switch (pElementType->eTypeClass)
79 {
80 case typelib_TypeClass_CHAR:
81 if (nAlloc >= 0)
82 pSeq = reallocSeq( pSeq, sizeof(sal_Unicode), nAlloc );
83 if (pSeq != 0)
84 {
85 memset(
86 pSeq->elements + (sizeof(sal_Unicode) * nStartIndex),
87 0,
88 sizeof(sal_Unicode) * (nStopIndex - nStartIndex) );
89 }
90 break;
91 case typelib_TypeClass_BOOLEAN:
92 if (nAlloc >= 0)
93 pSeq = reallocSeq( pSeq, sizeof(sal_Bool), nAlloc );
94 if (pSeq != 0)
95 {
96 memset(
97 pSeq->elements + (sizeof(sal_Bool) * nStartIndex),
98 0,
99 sizeof(sal_Bool) * (nStopIndex - nStartIndex) );
100 }
101 break;
102 case typelib_TypeClass_BYTE:
103 if (nAlloc >= 0)
104 pSeq = reallocSeq( pSeq, sizeof(sal_Int8), nAlloc );
105 if (pSeq != 0)
106 {
107 memset(
108 pSeq->elements + (sizeof(sal_Int8) * nStartIndex),
109 0,
110 sizeof(sal_Int8) * (nStopIndex - nStartIndex) );
111 }
112 break;
113 case typelib_TypeClass_SHORT:
114 case typelib_TypeClass_UNSIGNED_SHORT:
115 if (nAlloc >= 0)
116 pSeq = reallocSeq( pSeq, sizeof(sal_Int16), nAlloc );
117 if (pSeq != 0)
118 {
119 memset(
120 pSeq->elements + (sizeof(sal_Int16) * nStartIndex),
121 0,
122 sizeof(sal_Int16) * (nStopIndex - nStartIndex) );
123 }
124 break;
125 case typelib_TypeClass_LONG:
126 case typelib_TypeClass_UNSIGNED_LONG:
127 if (nAlloc >= 0)
128 pSeq = reallocSeq( pSeq, sizeof(sal_Int32), nAlloc );
129 if (pSeq != 0)
130 {
131 memset(
132 pSeq->elements + (sizeof(sal_Int32) * nStartIndex),
133 0,
134 sizeof(sal_Int32) * (nStopIndex - nStartIndex) );
135 }
136 break;
137 case typelib_TypeClass_HYPER:
138 case typelib_TypeClass_UNSIGNED_HYPER:
139 if (nAlloc >= 0)
140 pSeq = reallocSeq( pSeq, sizeof(sal_Int64), nAlloc );
141 if (pSeq != 0)
142 {
143 memset(
144 pSeq->elements + (sizeof(sal_Int64) * nStartIndex),
145 0,
146 sizeof(sal_Int64) * (nStopIndex - nStartIndex) );
147 }
148 break;
149 case typelib_TypeClass_FLOAT:
150 {
151 if (nAlloc >= 0)
152 pSeq = reallocSeq( pSeq, sizeof(float), nAlloc );
153 if (pSeq != 0)
154 {
155 float * pElements = reinterpret_cast<float *>(pSeq->elements);
156 for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
157 {
158 pElements[nPos] = 0.0;
159 }
160 }
161 break;
162 }
163 case typelib_TypeClass_DOUBLE:
164 {
165 if (nAlloc >= 0)
166 pSeq = reallocSeq( pSeq, sizeof(double), nAlloc );
167 if (pSeq != 0)
168 {
169 double * pElements = reinterpret_cast<double *>(pSeq->elements);
170 for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
171 {
172 pElements[nPos] = 0.0;
173 }
174 }
175 break;
176 }
177 case typelib_TypeClass_STRING:
178 {
179 if (nAlloc >= 0)
180 pSeq = reallocSeq( pSeq, sizeof(rtl_uString *), nAlloc );
181 if (pSeq != 0)
182 {
183 rtl_uString ** pElements = reinterpret_cast<rtl_uString **>(pSeq->elements);
184 for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
185 {
186 pElements[nPos] = 0;
187 rtl_uString_new( &pElements[nPos] );
188 }
189 }
190 break;
191 }
192 case typelib_TypeClass_TYPE:
193 {
194 if (nAlloc >= 0)
195 {
196 pSeq = reallocSeq(
197 pSeq, sizeof(typelib_TypeDescriptionReference *), nAlloc );
198 }
199 if (pSeq != 0)
200 {
201 typelib_TypeDescriptionReference ** pElements =
202 reinterpret_cast<typelib_TypeDescriptionReference **>(pSeq->elements);
203 for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
204 {
205 pElements[nPos] = _getVoidType();
206 }
207 }
208 break;
209 }
210 case typelib_TypeClass_ANY:
211 {
212 if (nAlloc >= 0)
213 pSeq = reallocSeq( pSeq, sizeof(uno_Any), nAlloc );
214 if (pSeq != 0)
215 {
216 uno_Any * pElements = reinterpret_cast<uno_Any *>(pSeq->elements);
217 for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
218 {
219 CONSTRUCT_EMPTY_ANY( &pElements[nPos] );
220 }
221 }
222 break;
223 }
224 case typelib_TypeClass_ENUM:
225 {
226 if (nAlloc >= 0)
227 pSeq = reallocSeq( pSeq, sizeof(sal_Int32), nAlloc );
228 if (pSeq != 0)
229 {
230 typelib_TypeDescription * pElementTypeDescr = 0;
231 TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
232 sal_Int32 eEnum =
233 reinterpret_cast<typelib_EnumTypeDescription *>(
234 pElementTypeDescr)->nDefaultEnumValue;
235 TYPELIB_DANGER_RELEASE( pElementTypeDescr );
236
237 sal_Int32 * pElements = reinterpret_cast<sal_Int32 *>(pSeq->elements);
238 for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
239 {
240 pElements[nPos] = eEnum;
241 }
242 }
243 break;
244 }
245 case typelib_TypeClass_STRUCT:
246 case typelib_TypeClass_EXCEPTION:
247 {
248 typelib_TypeDescription * pElementTypeDescr = 0;
249 TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
250 sal_Int32 nElementSize = pElementTypeDescr->nSize;
251
252 if (nAlloc >= 0)
253 pSeq = reallocSeq( pSeq, nElementSize, nAlloc );
254 if (pSeq != 0)
255 {
256 char * pElements = pSeq->elements;
257 for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
258 {
259 _defaultConstructStruct(
260 pElements + (nElementSize * nPos),
261 reinterpret_cast<typelib_CompoundTypeDescription *>(pElementTypeDescr) );
262 }
263 }
264
265 TYPELIB_DANGER_RELEASE( pElementTypeDescr );
266 break;
267 }
268 case typelib_TypeClass_SEQUENCE:
269 {
270 if (nAlloc >= 0)
271 {
272 // coverity[suspicious_sizeof] - sizeof(uno_Sequence*) is correct here
273 pSeq = reallocSeq(pSeq, sizeof(uno_Sequence*), nAlloc);
274 }
275 if (pSeq != 0)
276 {
277 uno_Sequence ** pElements =
278 reinterpret_cast<uno_Sequence **>(pSeq->elements);
279 for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
280 {
281 pElements[nPos] = createEmptySequence();
282 }
283 }
284 break;
285 }
286 case typelib_TypeClass_INTERFACE: // either C++ or C-UNO interface
287 if (nAlloc >= 0)
288 pSeq = reallocSeq( pSeq, sizeof(void *), nAlloc );
289 if (pSeq != 0)
290 {
291 memset(
292 pSeq->elements + (sizeof(void *) * nStartIndex),
293 0,
294 sizeof(void *) * (nStopIndex - nStartIndex) );
295 }
296 break;
297 default:
298 OSL_FAIL( "### unexpected element type!" );
299 pSeq = 0;
300 break;
301 }
302
303 if (pSeq == 0)
304 {
305 OSL_ASSERT( nAlloc >= 0 ); // must have been an allocation failure
306 return false;
307 }
308 else
309 {
310 *ppSeq = pSeq;
311 return true;
312 }
313 }
314
315
316 static inline bool icopyConstructFromElements(
317 uno_Sequence ** ppSeq, void * pSourceElements,
318 typelib_TypeDescriptionReference * pElementType,
319 sal_Int32 nStartIndex, sal_Int32 nStopIndex,
320 uno_AcquireFunc acquire,
321 sal_Int32 nAlloc = -1 ) // >= 0 means (re)alloc memory for nAlloc elements
322 {
323 uno_Sequence * pSeq = *ppSeq;
324 switch (pElementType->eTypeClass)
325 {
326 case typelib_TypeClass_CHAR:
327 if (nAlloc >= 0)
328 pSeq = reallocSeq( pSeq, sizeof(sal_Unicode), nAlloc );
329 if (pSeq != 0)
330 {
331 memcpy(
332 pSeq->elements + (sizeof(sal_Unicode) * nStartIndex),
333 static_cast<char *>(pSourceElements) + (sizeof(sal_Unicode) * nStartIndex),
334 sizeof(sal_Unicode) * (nStopIndex - nStartIndex) );
335 }
336 break;
337 case typelib_TypeClass_BOOLEAN:
338 if (nAlloc >= 0)
339 pSeq = reallocSeq( pSeq, sizeof(sal_Bool), nAlloc );
340 if (pSeq != 0)
341 {
342 memcpy(
343 pSeq->elements + (sizeof(sal_Bool) * nStartIndex),
344 static_cast<char *>(pSourceElements) + (sizeof(sal_Bool) * nStartIndex),
345 sizeof(sal_Bool) * (nStopIndex - nStartIndex) );
346 }
347 break;
348 case typelib_TypeClass_BYTE:
349 if (nAlloc >= 0)
350 pSeq = reallocSeq( pSeq, sizeof(sal_Int8), nAlloc );
351 if (pSeq != 0)
352 {
353 memcpy(
354 pSeq->elements + (sizeof(sal_Int8) * nStartIndex),
355 static_cast<char *>(pSourceElements) + (sizeof(sal_Int8) * nStartIndex),
356 sizeof(sal_Int8) * (nStopIndex - nStartIndex) );
357 }
358 break;
359 case typelib_TypeClass_SHORT:
360 case typelib_TypeClass_UNSIGNED_SHORT:
361 if (nAlloc >= 0)
362 pSeq = reallocSeq( pSeq, sizeof(sal_Int16), nAlloc );
363 if (pSeq != 0)
364 {
365 memcpy(
366 pSeq->elements + (sizeof(sal_Int16) * nStartIndex),
367 static_cast<char *>(pSourceElements) + (sizeof(sal_Int16) * nStartIndex),
368 sizeof(sal_Int16) * (nStopIndex - nStartIndex) );
369 }
370 break;
371 case typelib_TypeClass_LONG:
372 case typelib_TypeClass_UNSIGNED_LONG:
373 if (nAlloc >= 0)
374 pSeq = reallocSeq( pSeq, sizeof(sal_Int32), nAlloc );
375 if (pSeq != 0)
376 {
377 memcpy(
378 pSeq->elements + (sizeof(sal_Int32) * nStartIndex),
379 static_cast<char *>(pSourceElements) + (sizeof(sal_Int32) * nStartIndex),
380 sizeof(sal_Int32) * (nStopIndex - nStartIndex) );
381 }
382 break;
383 case typelib_TypeClass_HYPER:
384 case typelib_TypeClass_UNSIGNED_HYPER:
385 if (nAlloc >= 0)
386 pSeq = reallocSeq( pSeq, sizeof(sal_Int64), nAlloc );
387 if (pSeq != 0)
388 {
389 memcpy(
390 pSeq->elements + (sizeof(sal_Int64) * nStartIndex),
391 static_cast<char *>(pSourceElements) + (sizeof(sal_Int64) * nStartIndex),
392 sizeof(sal_Int64) * (nStopIndex - nStartIndex) );
393 }
394 break;
395 case typelib_TypeClass_FLOAT:
396 if (nAlloc >= 0)
397 pSeq = reallocSeq( pSeq, sizeof(float), nAlloc );
398 if (pSeq != 0)
399 {
400 memcpy(
401 pSeq->elements + (sizeof(float) * nStartIndex),
402 static_cast<char *>(pSourceElements) + (sizeof(float) * nStartIndex),
403 sizeof(float) * (nStopIndex - nStartIndex) );
404 }
405 break;
406 case typelib_TypeClass_DOUBLE:
407 if (nAlloc >= 0)
408 pSeq = reallocSeq( pSeq, sizeof(double), nAlloc );
409 if (pSeq != 0)
410 {
411 memcpy(
412 pSeq->elements + (sizeof(double) * nStartIndex),
413 static_cast<char *>(pSourceElements) + (sizeof(double) * nStartIndex),
414 sizeof(double) * (nStopIndex - nStartIndex) );
415 }
416 break;
417 case typelib_TypeClass_ENUM:
418 if (nAlloc >= 0)
419 pSeq = reallocSeq( pSeq, sizeof(sal_Int32), nAlloc );
420 if (pSeq != 0)
421 {
422 memcpy(
423 pSeq->elements + (sizeof(sal_Int32) * nStartIndex),
424 static_cast<char *>(pSourceElements) + (sizeof(sal_Int32) * nStartIndex),
425 sizeof(sal_Int32) * (nStopIndex - nStartIndex) );
426 }
427 break;
428 case typelib_TypeClass_STRING:
429 {
430 if (nAlloc >= 0)
431 pSeq = reallocSeq( pSeq, sizeof(rtl_uString *), nAlloc );
432 if (pSeq != 0)
433 {
434 rtl_uString ** pDestElements = reinterpret_cast<rtl_uString **>(pSeq->elements);
435 for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
436 {
437 // This code tends to trigger coverity's overrun-buffer-arg warning
438 // coverity[index_parm_via_loop_bound] - https://communities.coverity.com/thread/2993
439 ::rtl_uString_acquire(
440 static_cast<rtl_uString **>(pSourceElements)[nPos] );
441 pDestElements[nPos] = static_cast<rtl_uString **>(pSourceElements)[nPos];
442 }
443 }
444 break;
445 }
446 case typelib_TypeClass_TYPE:
447 {
448 if (nAlloc >= 0)
449 {
450 pSeq = reallocSeq(
451 pSeq, sizeof(typelib_TypeDescriptionReference *), nAlloc );
452 }
453 if (pSeq != 0)
454 {
455 typelib_TypeDescriptionReference ** pDestElements =
456 reinterpret_cast<typelib_TypeDescriptionReference **>(pSeq->elements);
457 for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
458 {
459 TYPE_ACQUIRE(
460 static_cast<typelib_TypeDescriptionReference **>(
461 pSourceElements)[nPos] );
462 pDestElements[nPos] =
463 static_cast<typelib_TypeDescriptionReference **>(
464 pSourceElements)[nPos];
465 }
466 }
467 break;
468 }
469 case typelib_TypeClass_ANY:
470 {
471 if (nAlloc >= 0)
472 pSeq = reallocSeq( pSeq, sizeof(uno_Any), nAlloc );
473 if (pSeq != 0)
474 {
475 uno_Any * pDestElements = reinterpret_cast<uno_Any *>(pSeq->elements);
476 for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
477 {
478 uno_Any * pSource = static_cast<uno_Any *>(pSourceElements) + nPos;
479 _copyConstructAny(
480 &pDestElements[nPos],
481 pSource->pData,
482 pSource->pType, 0,
483 acquire, 0 );
484 }
485 }
486 break;
487 }
488 case typelib_TypeClass_STRUCT:
489 case typelib_TypeClass_EXCEPTION:
490 {
491 typelib_TypeDescription * pElementTypeDescr = 0;
492 TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
493 sal_Int32 nElementSize = pElementTypeDescr->nSize;
494
495 if (nAlloc >= 0)
496 pSeq = reallocSeq( pSeq, nElementSize, nAlloc );
497 if (pSeq != 0)
498 {
499 char * pDestElements = pSeq->elements;
500
501 typelib_CompoundTypeDescription * pTypeDescr =
502 reinterpret_cast<typelib_CompoundTypeDescription *>(pElementTypeDescr);
503 for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
504 {
505 char * pDest =
506 pDestElements + (nElementSize * nPos);
507 char * pSource =
508 static_cast<char *>(pSourceElements) + (nElementSize * nPos);
509
510 if (pTypeDescr->pBaseTypeDescription)
511 {
512 // copy base value
513 _copyConstructStruct(
514 pDest, pSource,
515 pTypeDescr->pBaseTypeDescription, acquire, 0 );
516 }
517
518 // then copy members
519 typelib_TypeDescriptionReference ** ppTypeRefs =
520 pTypeDescr->ppTypeRefs;
521 sal_Int32 * pMemberOffsets = pTypeDescr->pMemberOffsets;
522 sal_Int32 nDescr = pTypeDescr->nMembers;
523
524 while (nDescr--)
525 {
526 ::uno_type_copyData(
527 pDest + pMemberOffsets[nDescr],
528 pSource + pMemberOffsets[nDescr],
529 ppTypeRefs[nDescr], acquire );
530 }
531 }
532 }
533
534 TYPELIB_DANGER_RELEASE( pElementTypeDescr );
535 break;
536 }
537 case typelib_TypeClass_SEQUENCE: // sequence of sequence
538 {
539 if (nAlloc >= 0)
540 {
541 // coverity[suspicious_sizeof] - sizeof(uno_Sequence*) is correct here
542 pSeq = reallocSeq(pSeq, sizeof(uno_Sequence*), nAlloc);
543 }
544 if (pSeq != 0)
545 {
546 typelib_TypeDescription * pElementTypeDescr = 0;
547 TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
548 typelib_TypeDescriptionReference * pSeqElementType =
549 reinterpret_cast<typelib_IndirectTypeDescription *>(pElementTypeDescr)->pType;
550 uno_Sequence ** pDestElements = reinterpret_cast<uno_Sequence **>(pSeq->elements);
551 for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
552 {
553 uno_Sequence * pNew = icopyConstructSequence(
554 static_cast<uno_Sequence **>(pSourceElements)[nPos],
555 pSeqElementType, acquire, 0 );
556 OSL_ASSERT( pNew != 0 );
557 // ought never be a memory allocation problem,
558 // because of reference counted sequence handles
559 pDestElements[ nPos ] = pNew;
560 }
561 TYPELIB_DANGER_RELEASE( pElementTypeDescr );
562 }
563 break;
564 }
565 case typelib_TypeClass_INTERFACE:
566 {
567 if (nAlloc >= 0)
568 pSeq = reallocSeq( pSeq, sizeof(void *), nAlloc );
569 if (pSeq != 0)
570 {
571 void ** pDestElements = reinterpret_cast<void **>(pSeq->elements);
572 for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
573 {
574 _acquire( pDestElements[nPos] =
575 static_cast<void **>(pSourceElements)[nPos], acquire );
576 }
577 }
578 break;
579 }
580 default:
581 OSL_FAIL( "### unexpected element type!" );
582 pSeq = 0;
583 break;
584 }
585
586 if (pSeq == 0)
587 {
588 OSL_ASSERT( nAlloc >= 0 ); // must have been an allocation failure
589 return false;
590 }
591 else
592 {
593 *ppSeq = pSeq;
594 return true;
595 }
596 }
597
598
599 static inline bool ireallocSequence(
600 uno_Sequence ** ppSequence,
601 typelib_TypeDescriptionReference * pElementType,
602 sal_Int32 nSize,
603 uno_AcquireFunc acquire, uno_ReleaseFunc release )
604 {
605 bool ret = true;
606 uno_Sequence * pSeq = *ppSequence;
607 sal_Int32 nElements = pSeq->nElements;
608
609 if (pSeq->nRefCount > 1 ||
610 // not mem-copyable elements?
611 typelib_TypeClass_ANY == pElementType->eTypeClass ||
612 typelib_TypeClass_STRUCT == pElementType->eTypeClass ||
613 typelib_TypeClass_EXCEPTION == pElementType->eTypeClass)
614 {
615 // split sequence and construct new one from scratch
616 uno_Sequence * pNew = 0;
617
618 sal_Int32 nRest = nSize - nElements;
619 sal_Int32 nCopy = (nRest > 0 ? nElements : nSize);
620
621 if (nCopy >= 0)
622 {
623 ret = icopyConstructFromElements(
624 &pNew, pSeq->elements, pElementType,
625 0, nCopy, acquire,
626 nSize ); // alloc to nSize
627 }
628 if (ret && nRest > 0)
629 {
630 ret = idefaultConstructElements(
631 &pNew, pElementType,
632 nCopy, nSize,
633 nCopy >= 0 ? -1 /* no mem allocation */ : nSize );
634 }
635
636 if (ret)
637 {
638 // destruct sequence
639 if (osl_atomic_decrement( &pSeq->nRefCount ) == 0)
640 {
641 if (nElements > 0)
642 {
643 idestructElements(
644 pSeq->elements, pElementType,
645 0, nElements, release );
646 }
647 rtl_freeMemory( pSeq );
648 }
649 *ppSequence = pNew;
650 }
651 }
652 else
653 {
654 OSL_ASSERT( pSeq->nRefCount == 1 );
655 if (nSize > nElements) // default construct the rest
656 {
657 ret = idefaultConstructElements(
658 ppSequence, pElementType,
659 nElements, nSize,
660 nSize ); // realloc to nSize
661 }
662 else // or destruct the rest and realloc mem
663 {
664 sal_Int32 nElementSize = idestructElements(
665 pSeq->elements, pElementType,
666 nSize, nElements, release );
667 // warning: it is assumed that the following will never fail,
668 // else this leads to a sequence null handle
669 *ppSequence = reallocSeq( pSeq, nElementSize, nSize );
670 OSL_ASSERT( *ppSequence != 0 );
671 ret = (*ppSequence != 0);
672 }
673 }
674
675 return ret;
676 }
677
678 }
679
680 extern "C"
681 {
682
683
684 sal_Bool SAL_CALL uno_type_sequence_construct(
685 uno_Sequence ** ppSequence, typelib_TypeDescriptionReference * pType,
686 void * pElements, sal_Int32 len,
687 uno_AcquireFunc acquire )
688 SAL_THROW_EXTERN_C()
689 {
690 assert( len >= 0 );
691 bool ret;
692 if (len)
693 {
694 typelib_TypeDescription * pTypeDescr = 0;
695 TYPELIB_DANGER_GET( &pTypeDescr, pType );
696
697 typelib_TypeDescriptionReference * pElementType =
698 reinterpret_cast<typelib_IndirectTypeDescription *>(pTypeDescr)->pType;
699
700 *ppSequence = 0;
701 if (pElements == 0)
702 {
703 ret = idefaultConstructElements(
704 ppSequence, pElementType,
705 0, len,
706 len ); // alloc to len
707 }
708 else
709 {
710 ret = icopyConstructFromElements(
711 ppSequence, pElements, pElementType,
712 0, len, acquire,
713 len ); // alloc to len
714 }
715
716 TYPELIB_DANGER_RELEASE( pTypeDescr );
717 }
718 else
719 {
720 *ppSequence = createEmptySequence();
721 ret = true;
722 }
723
724 OSL_ASSERT( (*ppSequence != 0) == ret );
725 return ret;
726 }
727
728
729 sal_Bool SAL_CALL uno_sequence_construct(
730 uno_Sequence ** ppSequence, typelib_TypeDescription * pTypeDescr,
731 void * pElements, sal_Int32 len,
732 uno_AcquireFunc acquire )
733 SAL_THROW_EXTERN_C()
734 {
735 bool ret;
736 if (len > 0)
737 {
738 typelib_TypeDescriptionReference * pElementType =
739 reinterpret_cast<typelib_IndirectTypeDescription *>(pTypeDescr)->pType;
740
741 *ppSequence = 0;
742 if (pElements == 0)
743 {
744 ret = idefaultConstructElements(
745 ppSequence, pElementType,
746 0, len,
747 len ); // alloc to len
748 }
749 else
750 {
751 ret = icopyConstructFromElements(
752 ppSequence, pElements, pElementType,
753 0, len, acquire,
754 len ); // alloc to len
755 }
756 }
757 else
758 {
759 *ppSequence = createEmptySequence();
760 ret = true;
761 }
762
763 OSL_ASSERT( (*ppSequence != 0) == ret );
764 return ret;
765 }
766
767
768 sal_Bool SAL_CALL uno_type_sequence_realloc(
769 uno_Sequence ** ppSequence, typelib_TypeDescriptionReference * pType,
770 sal_Int32 nSize, uno_AcquireFunc acquire, uno_ReleaseFunc release )
771 SAL_THROW_EXTERN_C()
772 {
773 OSL_ENSURE( ppSequence, "### null ptr!" );
774 OSL_ENSURE( nSize >= 0, "### new size must be at least 0!" );
775
776 bool ret = true;
777 if (nSize != (*ppSequence)->nElements)
778 {
779 typelib_TypeDescription * pTypeDescr = 0;
780 TYPELIB_DANGER_GET( &pTypeDescr, pType );
781 ret = ireallocSequence(
782 ppSequence, reinterpret_cast<typelib_IndirectTypeDescription *>(pTypeDescr)->pType,
783 nSize, acquire, release );
784 TYPELIB_DANGER_RELEASE( pTypeDescr );
785 }
786 return ret;
787 }
788
789
790 sal_Bool SAL_CALL uno_sequence_realloc(
791 uno_Sequence ** ppSequence, typelib_TypeDescription * pTypeDescr,
792 sal_Int32 nSize, uno_AcquireFunc acquire, uno_ReleaseFunc release )
793 SAL_THROW_EXTERN_C()
794 {
795 OSL_ENSURE( ppSequence, "### null ptr!" );
796 OSL_ENSURE( nSize >= 0, "### new size must be at least 0!" );
797
798 bool ret = true;
799 if (nSize != (*ppSequence)->nElements)
800 {
801 ret = ireallocSequence(
802 ppSequence, reinterpret_cast<typelib_IndirectTypeDescription *>(pTypeDescr)->pType,
803 nSize, acquire, release );
804 }
805 return ret;
806 }
807
808
809 sal_Bool SAL_CALL uno_type_sequence_reference2One(
810 uno_Sequence ** ppSequence,
811 typelib_TypeDescriptionReference * pType,
812 uno_AcquireFunc acquire, uno_ReleaseFunc release )
813 SAL_THROW_EXTERN_C()
814 {
815 OSL_ENSURE( ppSequence, "### null ptr!" );
816 bool ret = true;
817 uno_Sequence * pSequence = *ppSequence;
818 if (pSequence->nRefCount > 1)
819 {
820 uno_Sequence * pNew = 0;
821 if (pSequence->nElements > 0)
822 {
823 typelib_TypeDescription * pTypeDescr = 0;
824 TYPELIB_DANGER_GET( &pTypeDescr, pType );
825
826 ret = icopyConstructFromElements(
827 &pNew, pSequence->elements,
828 reinterpret_cast<typelib_IndirectTypeDescription *>(pTypeDescr)->pType,
829 0, pSequence->nElements, acquire,
830 pSequence->nElements ); // alloc nElements
831 if (ret)
832 {
833 idestructSequence( *ppSequence, pType, pTypeDescr, release );
834 *ppSequence = pNew;
835 }
836
837 TYPELIB_DANGER_RELEASE( pTypeDescr );
838 }
839 else
840 {
841 pNew = allocSeq( 0, 0 );
842 ret = (pNew != 0);
843 if (ret)
844 {
845 // easy destruction of empty sequence:
846 if (osl_atomic_decrement( &pSequence->nRefCount ) == 0)
847 rtl_freeMemory( pSequence );
848 *ppSequence = pNew;
849 }
850 }
851 }
852 return ret;
853 }
854
855
856 sal_Bool SAL_CALL uno_sequence_reference2One(
857 uno_Sequence ** ppSequence,
858 typelib_TypeDescription * pTypeDescr,
859 uno_AcquireFunc acquire, uno_ReleaseFunc release )
860 SAL_THROW_EXTERN_C()
861 {
862 OSL_ENSURE( ppSequence, "### null ptr!" );
863 bool ret = true;
864 uno_Sequence * pSequence = *ppSequence;
865 if (pSequence->nRefCount > 1)
866 {
867 uno_Sequence * pNew = 0;
868 if (pSequence->nElements > 0)
869 {
870 ret = icopyConstructFromElements(
871 &pNew, pSequence->elements,
872 reinterpret_cast<typelib_IndirectTypeDescription *>(pTypeDescr)->pType,
873 0, pSequence->nElements, acquire,
874 pSequence->nElements ); // alloc nElements
875 if (ret)
876 {
877 idestructSequence(
878 pSequence, pTypeDescr->pWeakRef, pTypeDescr, release );
879 *ppSequence = pNew;
880 }
881 }
882 else
883 {
884 pNew = allocSeq( 0, 0 );
885 ret = (pNew != 0);
886 if (ret)
887 {
888 // easy destruction of empty sequence:
889 if (osl_atomic_decrement( &pSequence->nRefCount ) == 0)
890 rtl_freeMemory( pSequence );
891 *ppSequence = pNew;
892 }
893 }
894
895 }
896 return ret;
897 }
898
899
900 void SAL_CALL uno_sequence_assign(
901 uno_Sequence ** ppDest,
902 uno_Sequence * pSource,
903 typelib_TypeDescription * pTypeDescr,
904 uno_ReleaseFunc release )
905 SAL_THROW_EXTERN_C()
906 {
907 if (*ppDest != pSource)
908 {
909 osl_atomic_increment( &pSource->nRefCount );
910 idestructSequence( *ppDest, pTypeDescr->pWeakRef, pTypeDescr, release );
911 *ppDest = pSource;
912 }
913 }
914
915
916 void SAL_CALL uno_type_sequence_assign(
917 uno_Sequence ** ppDest,
918 uno_Sequence * pSource,
919 typelib_TypeDescriptionReference * pType,
920 uno_ReleaseFunc release )
921 SAL_THROW_EXTERN_C()
922 {
923 if (*ppDest != pSource)
924 {
925 osl_atomic_increment( &pSource->nRefCount );
926 idestructSequence( *ppDest, pType, 0, release );
927 *ppDest = pSource;
928 }
929 }
930
931 void uno_type_sequence_destroy(
932 uno_Sequence * sequence, typelib_TypeDescriptionReference * type,
933 uno_ReleaseFunc release)
934 SAL_THROW_EXTERN_C()
935 {
936 idestroySequence(sequence, type, nullptr, release);
937 }
938
939 }
940
941 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE