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 : #ifndef _COM_SUN_STAR_UNO_SEQUENCE_HXX_
20 : #define _COM_SUN_STAR_UNO_SEQUENCE_HXX_
21 :
22 : #include "sal/config.h"
23 :
24 : #include <cassert>
25 :
26 : #include "osl/interlck.h"
27 : #include "com/sun/star/uno/Sequence.h"
28 : #include "typelib/typedescription.h"
29 : #include "uno/data.h"
30 : #include "com/sun/star/uno/genfunc.hxx"
31 : #include "cppu/unotype.hxx"
32 :
33 : namespace com
34 : {
35 : namespace sun
36 : {
37 : namespace star
38 : {
39 : namespace uno
40 : {
41 :
42 : /// @cond INTERNAL
43 : template< class E >
44 : typelib_TypeDescriptionReference * Sequence< E >::s_pType = 0;
45 : /// @endcond
46 :
47 : //______________________________________________________________________________
48 : template< class E >
49 5480504 : inline Sequence< E >::Sequence() SAL_THROW(())
50 : {
51 5480504 : const Type & rType = ::cppu::getTypeFavourUnsigned( this );
52 5480504 : ::uno_type_sequence_construct(
53 : &_pSequence, rType.getTypeLibType(),
54 5480504 : 0, 0, (uno_AcquireFunc)cpp_acquire );
55 : // no bad_alloc, because empty sequence is statically allocated in cppu
56 5480504 : }
57 :
58 : //______________________________________________________________________________
59 : template< class E >
60 2974229 : inline Sequence< E >::Sequence( const Sequence< E > & rSeq ) SAL_THROW(())
61 : {
62 2974229 : osl_atomic_increment( &rSeq._pSequence->nRefCount );
63 2974229 : _pSequence = rSeq._pSequence;
64 2974229 : }
65 :
66 : //______________________________________________________________________________
67 : template< class E >
68 5925 : inline Sequence< E >::Sequence(
69 : uno_Sequence * pSequence, __sal_NoAcquire ) SAL_THROW(())
70 5925 : : _pSequence( pSequence )
71 : {
72 5925 : }
73 :
74 : //______________________________________________________________________________
75 : template< class E >
76 571990 : inline Sequence< E >::Sequence( const E * pElements, sal_Int32 len )
77 : {
78 571990 : const Type & rType = ::cppu::getTypeFavourUnsigned( this );
79 : #if ! defined EXCEPTIONS_OFF
80 : sal_Bool success =
81 : #endif
82 : ::uno_type_sequence_construct(
83 : &_pSequence, rType.getTypeLibType(),
84 571990 : const_cast< E * >( pElements ), len, (uno_AcquireFunc)cpp_acquire );
85 : #if ! defined EXCEPTIONS_OFF
86 571990 : if (! success)
87 0 : throw ::std::bad_alloc();
88 : #endif
89 571990 : }
90 :
91 : //______________________________________________________________________________
92 : template< class E >
93 3519023 : inline Sequence< E >::Sequence( sal_Int32 len )
94 : {
95 3519023 : const Type & rType = ::cppu::getTypeFavourUnsigned( this );
96 : #if ! defined EXCEPTIONS_OFF
97 : sal_Bool success =
98 : #endif
99 : ::uno_type_sequence_construct(
100 : &_pSequence, rType.getTypeLibType(),
101 3519023 : 0, len, (uno_AcquireFunc)cpp_acquire );
102 : #if ! defined EXCEPTIONS_OFF
103 3519023 : if (! success)
104 0 : throw ::std::bad_alloc();
105 : #endif
106 3519023 : }
107 :
108 : //______________________________________________________________________________
109 : template< class E >
110 12525422 : inline Sequence< E >::~Sequence() SAL_THROW(())
111 : {
112 12525422 : const Type & rType = ::cppu::getTypeFavourUnsigned( this );
113 12525424 : ::uno_type_destructData(
114 12525424 : this, rType.getTypeLibType(), (uno_ReleaseFunc)cpp_release );
115 12525424 : }
116 :
117 : //______________________________________________________________________________
118 : template< class E >
119 1430622 : inline Sequence< E > & Sequence< E >::operator = ( const Sequence< E > & rSeq ) SAL_THROW(())
120 : {
121 1430622 : const Type & rType = ::cppu::getTypeFavourUnsigned( this );
122 1430622 : ::uno_type_sequence_assign(
123 1430622 : &_pSequence, rSeq._pSequence, rType.getTypeLibType(), (uno_ReleaseFunc)cpp_release );
124 1430622 : return *this;
125 : }
126 :
127 : //______________________________________________________________________________
128 : template< class E >
129 113148 : inline sal_Bool Sequence< E >::operator == ( const Sequence< E > & rSeq ) const
130 : SAL_THROW(())
131 : {
132 113148 : if (_pSequence == rSeq._pSequence)
133 94363 : return sal_True;
134 18785 : const Type & rType = ::cppu::getTypeFavourUnsigned( this );
135 : return ::uno_type_equalData(
136 : const_cast< Sequence< E > * >( this ), rType.getTypeLibType(),
137 : const_cast< Sequence< E > * >( &rSeq ), rType.getTypeLibType(),
138 : (uno_QueryInterfaceFunc)cpp_queryInterface,
139 18785 : (uno_ReleaseFunc)cpp_release );
140 : }
141 :
142 : //______________________________________________________________________________
143 : template< class E >
144 264 : inline sal_Bool Sequence< E >::operator != ( const Sequence< E > & rSeq ) const
145 : SAL_THROW(())
146 : {
147 264 : return (! operator == ( rSeq ));
148 : }
149 :
150 : //______________________________________________________________________________
151 : template< class E >
152 31115886 : inline E * Sequence< E >::getArray()
153 : {
154 31115886 : const Type & rType = ::cppu::getTypeFavourUnsigned( this );
155 : #if ! defined EXCEPTIONS_OFF
156 : sal_Bool success =
157 : #endif
158 : ::uno_type_sequence_reference2One(
159 : &_pSequence, rType.getTypeLibType(),
160 31115886 : (uno_AcquireFunc)cpp_acquire, (uno_ReleaseFunc)cpp_release );
161 : #if ! defined EXCEPTIONS_OFF
162 31115886 : if (! success)
163 0 : throw ::std::bad_alloc();
164 : #endif
165 31115886 : return reinterpret_cast< E * >( _pSequence->elements );
166 : }
167 :
168 : //______________________________________________________________________________
169 : template< class E >
170 27597752 : inline E & Sequence< E >::operator [] ( sal_Int32 nIndex )
171 : {
172 : assert( nIndex >= 0 && nIndex < getLength() );
173 27597752 : return getArray()[ nIndex ];
174 : }
175 :
176 : //______________________________________________________________________________
177 : template< class E >
178 5984246 : inline const E & Sequence< E >::operator [] ( sal_Int32 nIndex ) const
179 : SAL_THROW(())
180 : {
181 : assert( nIndex >= 0 && nIndex < getLength() );
182 5984246 : return reinterpret_cast< const E * >( _pSequence->elements )[ nIndex ];
183 : }
184 :
185 : //______________________________________________________________________________
186 : template< class E >
187 2937896 : inline void Sequence< E >::realloc( sal_Int32 nSize )
188 : {
189 2937896 : const Type & rType = ::cppu::getTypeFavourUnsigned( this );
190 : #if !defined EXCEPTIONS_OFF
191 : sal_Bool success =
192 : #endif
193 : ::uno_type_sequence_realloc(
194 : &_pSequence, rType.getTypeLibType(), nSize,
195 2937896 : (uno_AcquireFunc)cpp_acquire, (uno_ReleaseFunc)cpp_release );
196 : #if !defined EXCEPTIONS_OFF
197 2937896 : if (!success)
198 0 : throw ::std::bad_alloc();
199 : #endif
200 2937896 : }
201 :
202 : //------------------------------------------------------------------------------
203 106140 : inline ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL toUnoSequence(
204 : const ::rtl::ByteSequence & rByteSequence ) SAL_THROW(())
205 : {
206 : return ::com::sun::star::uno::Sequence< sal_Int8 >(
207 106140 : * reinterpret_cast< const ::com::sun::star::uno::Sequence< sal_Int8 > * >( &rByteSequence ) );
208 : }
209 :
210 : }
211 : }
212 : }
213 : }
214 :
215 : namespace cppu {
216 :
217 : template< typename T > inline ::com::sun::star::uno::Type const &
218 59399447 : getTypeFavourUnsigned(
219 : SAL_UNUSED_PARAMETER ::com::sun::star::uno::Sequence< T > const *)
220 : {
221 59399447 : if (::com::sun::star::uno::Sequence< T >::s_pType == 0) {
222 23740 : ::typelib_static_sequence_type_init(
223 : &::com::sun::star::uno::Sequence< T >::s_pType,
224 : (::cppu::getTypeFavourUnsigned(
225 : static_cast<
226 : typename ::com::sun::star::uno::Sequence< T >::ElementType * >(
227 23740 : 0)).
228 23740 : getTypeLibType()));
229 : }
230 : return detail::getTypeFromTypeDescriptionReference(
231 59399447 : &::com::sun::star::uno::Sequence< T >::s_pType);
232 : }
233 :
234 : template< typename T > inline ::com::sun::star::uno::Type const &
235 45 : getTypeFavourChar(
236 : SAL_UNUSED_PARAMETER ::com::sun::star::uno::Sequence< T > const *)
237 : {
238 : //TODO On certain platforms with weak memory models, the following code can
239 : // result in some threads observing that td points to garbage:
240 : static typelib_TypeDescriptionReference * td = 0;
241 45 : if (td == 0) {
242 36 : ::typelib_static_sequence_type_init(
243 : &td,
244 : (::cppu::getTypeFavourChar(
245 : static_cast<
246 : typename ::com::sun::star::uno::Sequence< T >::ElementType * >(
247 36 : 0)).
248 36 : getTypeLibType()));
249 : }
250 45 : return detail::getTypeFromTypeDescriptionReference(&td);
251 : }
252 :
253 : }
254 :
255 : // generic sequence template
256 : template< class E >
257 : inline const ::com::sun::star::uno::Type &
258 63916 : SAL_CALL getCppuType(
259 : SAL_UNUSED_PARAMETER const ::com::sun::star::uno::Sequence< E > * )
260 : SAL_THROW(())
261 : {
262 : return ::cppu::getTypeFavourUnsigned(
263 63916 : static_cast< ::com::sun::star::uno::Sequence< E > * >(0));
264 : }
265 :
266 : // generic sequence template for given element type (e.g. C++ arrays)
267 : template< class E >
268 : inline const ::com::sun::star::uno::Type &
269 : SAL_CALL getCppuSequenceType( const ::com::sun::star::uno::Type & rElementType )
270 : SAL_THROW(())
271 : {
272 : if (! ::com::sun::star::uno::Sequence< E >::s_pType)
273 : {
274 : ::typelib_static_sequence_type_init(
275 : & ::com::sun::star::uno::Sequence< E >::s_pType,
276 : rElementType.getTypeLibType() );
277 : }
278 : return * reinterpret_cast< const ::com::sun::star::uno::Type * >(
279 : & ::com::sun::star::uno::Sequence< E >::s_pType );
280 : }
281 :
282 : #if (defined(__SUNPRO_CC) && (__SUNPRO_CC == 0x500))
283 : static typelib_TypeDescriptionReference * s_pType_com_sun_star_uno_Sequence_Char = 0;
284 : #endif
285 :
286 : // char sequence
287 : inline const ::com::sun::star::uno::Type &
288 : SAL_CALL getCharSequenceCppuType() SAL_THROW(())
289 : {
290 : #if !( defined(__SUNPRO_CC) && (__SUNPRO_CC == 0x500))
291 : static typelib_TypeDescriptionReference * s_pType_com_sun_star_uno_Sequence_Char = 0;
292 : #endif
293 : if (! s_pType_com_sun_star_uno_Sequence_Char)
294 : {
295 : const ::com::sun::star::uno::Type & rElementType = ::getCharCppuType();
296 : ::typelib_static_sequence_type_init(
297 : & s_pType_com_sun_star_uno_Sequence_Char,
298 : rElementType.getTypeLibType() );
299 : }
300 : return * reinterpret_cast< const ::com::sun::star::uno::Type * >(
301 : & s_pType_com_sun_star_uno_Sequence_Char );
302 : }
303 :
304 : #endif
305 :
306 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
