LibreOffice
LibreOffice 5.0 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 INCLUDED_COM_SUN_STAR_UNO_SEQUENCE_HXX
20 #define INCLUDED_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 template< class E >
49 {
50  const Type & rType = ::cppu::getTypeFavourUnsigned( this );
52  &_pSequence, rType.getTypeLibType(),
54  // no bad_alloc, because empty sequence is statically allocated in cppu
55 }
56 
57 template< class E >
58 inline Sequence< E >::Sequence( const Sequence< E > & rSeq )
59 {
60  osl_atomic_increment( &rSeq._pSequence->nRefCount );
61  _pSequence = rSeq._pSequence;
62 }
63 
64 template< class E >
66  uno_Sequence * pSequence, __sal_NoAcquire )
67  : _pSequence( pSequence )
68 {
69 }
70 
71 template< class E >
72 inline Sequence< E >::Sequence( const E * pElements, sal_Int32 len )
73 {
74  const Type & rType = ::cppu::getTypeFavourUnsigned( this );
75  bool success =
77  &_pSequence, rType.getTypeLibType(),
78  const_cast< E * >( pElements ), len, (uno_AcquireFunc)cpp_acquire );
79  if (! success)
80  throw ::std::bad_alloc();
81 }
82 
83 template< class E >
84 inline Sequence< E >::Sequence( sal_Int32 len )
85 {
86  const Type & rType = ::cppu::getTypeFavourUnsigned( this );
87  bool success =
89  &_pSequence, rType.getTypeLibType(),
90  0, len, (uno_AcquireFunc)cpp_acquire );
91  if (! success)
92  throw ::std::bad_alloc();
93 }
94 
95 #if defined LIBO_INTERNAL_ONLY
96 template<typename E> Sequence<E>::Sequence(std::initializer_list<E> init) {
98  &_pSequence, cppu::getTypeFavourUnsigned(this).getTypeLibType(),
99  const_cast<E *>(init.begin()), init.size(), cpp_acquire))
100  {
101  throw std::bad_alloc();
102  }
103 }
104 #endif
105 
106 template< class E >
108 {
109  if (osl_atomic_decrement( &_pSequence->nRefCount ) == 0)
110  {
111  const Type & rType = ::cppu::getTypeFavourUnsigned( this );
113  _pSequence, rType.getTypeLibType(), (uno_ReleaseFunc)cpp_release );
114  }
115 }
116 
117 template< class E >
119 {
120  const Type & rType = ::cppu::getTypeFavourUnsigned( this );
122  &_pSequence, rSeq._pSequence, rType.getTypeLibType(), (uno_ReleaseFunc)cpp_release );
123  return *this;
124 }
125 
126 template< class E >
127 inline bool Sequence< E >::operator == ( const Sequence< E > & rSeq ) const
128 {
129  if (_pSequence == rSeq._pSequence)
130  return true;
131  const Type & rType = ::cppu::getTypeFavourUnsigned( this );
133  const_cast< Sequence< E > * >( this ), rType.getTypeLibType(),
134  const_cast< Sequence< E > * >( &rSeq ), rType.getTypeLibType(),
137 }
138 
139 template< class E >
140 inline bool Sequence< E >::operator != ( const Sequence< E > & rSeq ) const
141 {
142  return (! operator == ( rSeq ));
143 }
144 
145 template< class E >
147 {
148  const Type & rType = ::cppu::getTypeFavourUnsigned( this );
149  bool success =
151  &_pSequence, rType.getTypeLibType(),
153  if (! success)
154  throw ::std::bad_alloc();
155  return reinterpret_cast< E * >( _pSequence->elements );
156 }
157 
158 template<class E> E * Sequence<E>::begin() { return getArray(); }
159 
160 template<class E> E const * Sequence<E>::begin() const
161 { return getConstArray(); }
162 
163 template<class E> E * Sequence<E>::end() { return begin() + getLength(); }
164 
165 template<class E> E const * Sequence<E>::end() const
166 { return begin() + getLength(); }
167 
168 template< class E >
169 inline E & Sequence< E >::operator [] ( sal_Int32 nIndex )
170 {
171  // silence spurious -Werror=strict-overflow warnings from GCC 4.8.2
172  assert(nIndex >= 0 && static_cast<sal_uInt32>(nIndex) < static_cast<sal_uInt32>(getLength()));
173  return getArray()[ nIndex ];
174 }
175 
176 template< class E >
177 inline const E & Sequence< E >::operator [] ( sal_Int32 nIndex ) const
178 {
179  // silence spurious -Werror=strict-overflow warnings from GCC 4.8.2
180  assert(nIndex >= 0 && static_cast<sal_uInt32>(nIndex) < static_cast<sal_uInt32>(getLength()));
181  return reinterpret_cast< const E * >( _pSequence->elements )[ nIndex ];
182 }
183 
184 template< class E >
185 inline void Sequence< E >::realloc( sal_Int32 nSize )
186 {
187  const Type & rType = ::cppu::getTypeFavourUnsigned( this );
188  bool success =
190  &_pSequence, rType.getTypeLibType(), nSize,
192  if (!success)
193  throw ::std::bad_alloc();
194 }
195 
196 inline ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL toUnoSequence(
197  const ::rtl::ByteSequence & rByteSequence )
198 {
199  return ::com::sun::star::uno::Sequence< sal_Int8 >(
200  * reinterpret_cast< const ::com::sun::star::uno::Sequence< sal_Int8 > * >( &rByteSequence ) );
201 }
202 
203 }
204 }
205 }
206 }
207 
208 namespace cppu {
209 
210 template< typename T > inline ::com::sun::star::uno::Type const &
212  SAL_UNUSED_PARAMETER ::com::sun::star::uno::Sequence< T > const *)
213 {
218  static_cast<
219  typename ::com::sun::star::uno::Sequence< T >::ElementType * >(
220  0)).
221  getTypeLibType()));
222  }
225 }
226 
227 template< typename T > inline ::com::sun::star::uno::Type const &
229  SAL_UNUSED_PARAMETER ::com::sun::star::uno::Sequence< T > const *)
230 {
231  //TODO On certain platforms with weak memory models, the following code can
232  // result in some threads observing that td points to garbage:
233  static typelib_TypeDescriptionReference * td = 0;
234  if (td == 0) {
236  &td,
238  static_cast<
239  typename ::com::sun::star::uno::Sequence< T >::ElementType * >(
240  0)).
241  getTypeLibType()));
242  }
244 }
245 
246 }
247 
248 // generic sequence template
249 template< class E >
250 inline const ::com::sun::star::uno::Type &
251 SAL_CALL getCppuType(
252  SAL_UNUSED_PARAMETER const ::com::sun::star::uno::Sequence< E > * )
253 {
255  static_cast< ::com::sun::star::uno::Sequence< E > * >(0));
256 }
257 
258 // generic sequence template for given element type (e.g. C++ arrays)
259 template< class E >
260 inline const ::com::sun::star::uno::Type &
261 SAL_CALL getCppuSequenceType( const ::com::sun::star::uno::Type & rElementType )
262 {
264  {
267  rElementType.getTypeLibType() );
268  }
269  return * reinterpret_cast< const ::com::sun::star::uno::Type * >(
271 }
272 
273 // char sequence
274 inline const ::com::sun::star::uno::Type &
276 {
277  static typelib_TypeDescriptionReference * s_pType_com_sun_star_uno_Sequence_Char = 0;
278  if (! s_pType_com_sun_star_uno_Sequence_Char)
279  {
280  const ::com::sun::star::uno::Type & rElementType = cppu::UnoType<cppu::UnoCharType>::get();
282  & s_pType_com_sun_star_uno_Sequence_Char,
283  rElementType.getTypeLibType() );
284  }
285  return * reinterpret_cast< const ::com::sun::star::uno::Type * >(
286  & s_pType_com_sun_star_uno_Sequence_Char );
287 }
288 
289 #endif
290 
291 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */