LibreOffice
LibreOffice 4.1 SDK C/C++ API Reference
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Sequence.hxx
Go to the documentation of this file.
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"
29 #include "uno/data.h"
31 #include "cppu/unotype.hxx"
32 
33 namespace com
34 {
35 namespace sun
36 {
37 namespace star
38 {
39 namespace uno
40 {
41 
43 template< class E >
44 typelib_TypeDescriptionReference * Sequence< E >::s_pType = 0;
46 
47 //______________________________________________________________________________
48 template< class E >
50 {
51  const Type & rType = ::cppu::getTypeFavourUnsigned( this );
53  &_pSequence, rType.getTypeLibType(),
55  // no bad_alloc, because empty sequence is statically allocated in cppu
56 }
57 
58 //______________________________________________________________________________
59 template< class E >
61 {
62  osl_atomic_increment( &rSeq._pSequence->nRefCount );
63  _pSequence = rSeq._pSequence;
64 }
65 
66 //______________________________________________________________________________
67 template< class E >
69  uno_Sequence * pSequence, __sal_NoAcquire ) SAL_THROW(())
70  : _pSequence( pSequence )
71 {
72 }
73 
74 //______________________________________________________________________________
75 template< class E >
76 inline Sequence< E >::Sequence( const E * pElements, sal_Int32 len )
77 {
78  const Type & rType = ::cppu::getTypeFavourUnsigned( this );
79 #if ! defined EXCEPTIONS_OFF
80  sal_Bool success =
81 #endif
83  &_pSequence, rType.getTypeLibType(),
84  const_cast< E * >( pElements ), len, (uno_AcquireFunc)cpp_acquire );
85 #if ! defined EXCEPTIONS_OFF
86  if (! success)
87  throw ::std::bad_alloc();
88 #endif
89 }
90 
91 //______________________________________________________________________________
92 template< class E >
93 inline Sequence< E >::Sequence( sal_Int32 len )
94 {
95  const Type & rType = ::cppu::getTypeFavourUnsigned( this );
96 #if ! defined EXCEPTIONS_OFF
97  sal_Bool success =
98 #endif
100  &_pSequence, rType.getTypeLibType(),
101  0, len, (uno_AcquireFunc)cpp_acquire );
102 #if ! defined EXCEPTIONS_OFF
103  if (! success)
104  throw ::std::bad_alloc();
105 #endif
106 }
107 
108 //______________________________________________________________________________
109 template< class E >
111 {
112  const Type & rType = ::cppu::getTypeFavourUnsigned( this );
114  this, rType.getTypeLibType(), (uno_ReleaseFunc)cpp_release );
115 }
116 
117 //______________________________________________________________________________
118 template< class E >
120 {
121  const Type & rType = ::cppu::getTypeFavourUnsigned( this );
123  &_pSequence, rSeq._pSequence, rType.getTypeLibType(), (uno_ReleaseFunc)cpp_release );
124  return *this;
125 }
126 
127 //______________________________________________________________________________
128 template< class E >
130  SAL_THROW(())
131 {
132  if (_pSequence == rSeq._pSequence)
133  return sal_True;
134  const Type & rType = ::cppu::getTypeFavourUnsigned( this );
136  const_cast< Sequence< E > * >( this ), rType.getTypeLibType(),
137  const_cast< Sequence< E > * >( &rSeq ), rType.getTypeLibType(),
140 }
141 
142 //______________________________________________________________________________
143 template< class E >
145  SAL_THROW(())
146 {
147  return (! operator == ( rSeq ));
148 }
149 
150 //______________________________________________________________________________
151 template< class E >
153 {
154  const Type & rType = ::cppu::getTypeFavourUnsigned( this );
155 #if ! defined EXCEPTIONS_OFF
156  sal_Bool success =
157 #endif
159  &_pSequence, rType.getTypeLibType(),
161 #if ! defined EXCEPTIONS_OFF
162  if (! success)
163  throw ::std::bad_alloc();
164 #endif
165  return reinterpret_cast< E * >( _pSequence->elements );
166 }
167 
168 //______________________________________________________________________________
169 template< class E >
170 inline E & Sequence< E >::operator [] ( sal_Int32 nIndex )
171 {
172  assert( nIndex >= 0 && nIndex < getLength() );
173  return getArray()[ nIndex ];
174 }
175 
176 //______________________________________________________________________________
177 template< class E >
178 inline const E & Sequence< E >::operator [] ( sal_Int32 nIndex ) const
179  SAL_THROW(())
180 {
181  assert( nIndex >= 0 && nIndex < getLength() );
182  return reinterpret_cast< const E * >( _pSequence->elements )[ nIndex ];
183 }
184 
185 //______________________________________________________________________________
186 template< class E >
187 inline void Sequence< E >::realloc( sal_Int32 nSize )
188 {
189  const Type & rType = ::cppu::getTypeFavourUnsigned( this );
190 #if !defined EXCEPTIONS_OFF
191  sal_Bool success =
192 #endif
194  &_pSequence, rType.getTypeLibType(), nSize,
196 #if !defined EXCEPTIONS_OFF
197  if (!success)
198  throw ::std::bad_alloc();
199 #endif
200 }
201 
202 //------------------------------------------------------------------------------
203 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  * 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 &
219  SAL_UNUSED_PARAMETER ::com::sun::star::uno::Sequence< T > const *)
220 {
225  static_cast<
226  typename ::com::sun::star::uno::Sequence< T >::ElementType * >(
227  0)).
228  getTypeLibType()));
229  }
232 }
233 
234 template< typename T > inline ::com::sun::star::uno::Type const &
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  if (td == 0) {
243  &td,
245  static_cast<
246  typename ::com::sun::star::uno::Sequence< T >::ElementType * >(
247  0)).
248  getTypeLibType()));
249  }
251 }
252 
253 }
254 
255 // generic sequence template
256 template< class E >
257 inline const ::com::sun::star::uno::Type &
258 SAL_CALL getCppuType(
259  SAL_UNUSED_PARAMETER const ::com::sun::star::uno::Sequence< E > * )
260  SAL_THROW(())
261 {
263  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 {
273  {
276  rElementType.getTypeLibType() );
277  }
278  return * reinterpret_cast< const ::com::sun::star::uno::Type * >(
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 &
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();
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: */