LibreOffice: cppuhelper/proptypehlp.hxx Source File

LibreOffice LibreOffice 26.8 SDK C/C++ API Reference

Loading...
Searching...
No Matches
proptypehlp.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
20/*
21 * This file is part of LibreOffice published API.
22 */
23
24#ifndef INCLUDED_CPPUHELPER_PROPTYPEHLP_HXX
25#define INCLUDED_CPPUHELPER_PROPTYPEHLP_HXX
26
27#include "cppuhelper/proptypehlp.h"
28#include "com/sun/star/lang/IllegalArgumentException.hpp"
29#include "com/sun/star/uno/TypeClass.hpp"
30
31namespace cppu
32{
33
34template < class target >
35 inline void SAL_CALL convertPropertyValue( target &value , const css::uno::Any & a)
36{
37
38 if( !( a >>= value ) ) {
39 throw css::lang::IllegalArgumentException();
40 }
41}
42
43 void convertPropertyValue(bool & b, const css::uno::Any & a)
44{
45 if( a >>= b )
46 return;
47
48 switch( a.getValueTypeClass() ) {
49 case css::uno::TypeClass_BYTE:
50 b = a.get<sal_Int8>() != 0;
51 break;
52 case css::uno::TypeClass_SHORT:
53 b = a.get<sal_Int16>() != 0;
54 break;
55 case css::uno::TypeClass_UNSIGNED_SHORT:
56 {
57 sal_uInt16 i16 = 0;
58 a >>= i16;
59 b = i16 != 0;
60 break;
61 }
62 case css::uno::TypeClass_LONG:
63 b = a.get<sal_Int32>() != 0;
64 break;
65 case css::uno::TypeClass_UNSIGNED_LONG:
66 b = a.get<sal_uInt32>() != 0;
67 break;
68 case css::uno::TypeClass_CHAR:
69 {
70 sal_Unicode c = *static_cast<sal_Unicode const *>(a.getValue());
71 b = c != 0;
72 break;
73 }
74 default:
75 throw css::lang::IllegalArgumentException();
76 }
77}
78
79 void convertPropertyValue(sal_Bool & target, css::uno::Any const & source) {
80 bool b;
81 convertPropertyValue(b, source);
82 target = b;
83}
84
85 inline void SAL_CALL convertPropertyValue( sal_Int64 & i , const css::uno::Any & a )
86{
87 if( !(a >>= i) ) {
88 switch( a.getValueTypeClass() ) {
89 case css::uno::TypeClass_BOOLEAN:
90 i = static_cast<sal_Int64>(a.get<bool>());
91 break;
92 case css::uno::TypeClass_CHAR:
93 {
94 sal_Unicode c;
95 c = *static_cast<sal_Unicode const *>(a.getValue());
96 i = static_cast<sal_Int64>(c);
97 break;
98 }
99 default:
100 throw css::lang::IllegalArgumentException();
101 }
102 }
103}
104
105
106 inline void SAL_CALL convertPropertyValue( sal_uInt64 & i , const css::uno::Any & a )
107{
108 if( !(a >>= i) ) {
109 switch( a.getValueTypeClass() ) {
110 case css::uno::TypeClass_BOOLEAN:
111 i = static_cast<sal_uInt64>(a.get<bool>());
112 break;
113 case css::uno::TypeClass_CHAR:
114 {
115 sal_Unicode c;
116 c = *static_cast<sal_Unicode const *>(a.getValue());
117 i = static_cast<sal_uInt64>(c);
118 break;
119 }
120 default:
121 throw css::lang::IllegalArgumentException();
122 }
123 }
124}
125
126 inline void SAL_CALL convertPropertyValue( sal_Int32 & i , const css::uno::Any & a )
127{
128 if( !(a >>= i) ) {
129 switch( a.getValueTypeClass() ) {
130 case css::uno::TypeClass_BOOLEAN:
131 i = static_cast<sal_Int32>(a.get<bool>());
132 break;
133 case css::uno::TypeClass_CHAR:
134 {
135 sal_Unicode c;
136 c = *static_cast<sal_Unicode const *>(a.getValue());
137 i = static_cast<sal_Int32>(c);
138 break;
139 }
140 default:
141 throw css::lang::IllegalArgumentException();
142 }
143 }
144}
145
146 inline void SAL_CALL convertPropertyValue( sal_uInt32 & i , const css::uno::Any & a )
147{
148 if( !(a >>= i) ) {
149 switch( a.getValueTypeClass() ) {
150 case css::uno::TypeClass_BOOLEAN:
151 i = static_cast<sal_uInt32>(a.get<bool>());
152 break;
153 case css::uno::TypeClass_CHAR:
154 {
155 sal_Unicode c;
156 c = *static_cast<sal_Unicode const *>(a.getValue());
157 i = static_cast<sal_uInt32>(c);
158 break;
159 }
160 default:
161 throw css::lang::IllegalArgumentException();
162 }
163 }
164}
165
166 inline void SAL_CALL convertPropertyValue( sal_Int16 & i , const css::uno::Any & a )
167{
168 if( !(a >>= i) ) {
169 switch( a.getValueTypeClass() ) {
170 case css::uno::TypeClass_BOOLEAN:
171 i = static_cast<sal_Int16>(a.get<bool>());
172 break;
173 case css::uno::TypeClass_CHAR:
174 {
175 sal_Unicode c;
176 c = *static_cast<sal_Unicode const *>(a.getValue());
177 i = static_cast<sal_Int16>(c);
178 break;
179 }
180 default:
181 throw css::lang::IllegalArgumentException();
182 }
183 }
184}
185
186 inline void SAL_CALL convertPropertyValue( sal_uInt16 & i , const css::uno::Any & a )
187{
188 if( !(a >>= i) ) {
189 switch( a.getValueTypeClass() ) {
190 case css::uno::TypeClass_BOOLEAN:
191 i = static_cast<sal_uInt16>(a.get<bool>());
192 break;
193 case css::uno::TypeClass_CHAR:
194 {
195 sal_Unicode c;
196 c = *static_cast<sal_Unicode const *>(a.getValue());
197 i = static_cast<sal_Int16>(c);
198 break;
199 }
200 default:
201 throw css::lang::IllegalArgumentException();
202 }
203 }
204}
205
206 inline void SAL_CALL convertPropertyValue( sal_Int8 & i , const css::uno::Any & a )
207{
208 if( !(a >>= i) ) {
209 switch( a.getValueTypeClass() ) {
210 case css::uno::TypeClass_BOOLEAN:
211 i = static_cast<sal_Int8>(a.get<bool>());
212 break;
213 default:
214 throw css::lang::IllegalArgumentException();
215 }
216 }
217}
218
219 inline void SAL_CALL convertPropertyValue( float &f , const css::uno::Any &a )
220{
221 if( a >>= f )
222 return;
223
224 switch( a.getValueTypeClass() ) {
225 case css::uno::TypeClass_BOOLEAN:
226 f = static_cast<float>(a.get<bool>());
227 break;
228 case css::uno::TypeClass_LONG:
229 f = static_cast<float>(a.get<sal_Int32>());
230 break;
231 case css::uno::TypeClass_UNSIGNED_LONG:
232 f = static_cast<float>(a.get<sal_uInt32>());
233 break;
234 case css::uno::TypeClass_HYPER:
235 f = static_cast<float>(a.get<sal_Int64>());
236 break;
237 case css::uno::TypeClass_UNSIGNED_HYPER:
238 f = static_cast<float>(a.get<sal_uInt64>());
239 break;
240 case css::uno::TypeClass_DOUBLE:
241 f = static_cast<float>(a.get<double>());
242 break;
243 case css::uno::TypeClass_CHAR:
244 {
245 sal_Unicode c;
246 c = *static_cast<sal_Unicode const *>(a.getValue());
247 f = static_cast<float>(c);
248 break;
249 }
250 default:
251 throw css::lang::IllegalArgumentException();
252 }
253}
254
255 inline void SAL_CALL convertPropertyValue( double &d , const css::uno::Any &a )
256{
257 if( a >>= d )
258 return;
259
260 switch( a.getValueTypeClass() ) {
261 case css::uno::TypeClass_BOOLEAN:
262 d = static_cast<double>(a.get<bool>());
263 break;
264 case css::uno::TypeClass_HYPER:
265 d = static_cast<double>(a.get<sal_Int64>());
266 break;
267 case css::uno::TypeClass_UNSIGNED_HYPER:
268 d = static_cast<double>(a.get<sal_uInt64>());
269 break;
270 case css::uno::TypeClass_CHAR:
271 {
272 sal_Unicode c;
273 c = *static_cast<sal_Unicode const *>(a.getValue());
274 d = static_cast<double>(c);
275 break;
276 }
277 default:
278 throw css::lang::IllegalArgumentException();
279 }
280}
281
282} // end namespace cppu
283
284#endif
285
286/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
sal_Bool
unsigned char sal_Bool
Definition types.h:38
sal_Unicode
sal_uInt16 sal_Unicode
Definition types.h:123
sal_Int8
signed char sal_Int8
Definition types.h:43
proptypehlp.h
cppu
Definition Enterable.hxx:31
cppu::convertPropertyValue
void convertPropertyValue(target &value, const css::uno::Any &a)
Converts the value stored in an any to a concrete C++ type.
Definition proptypehlp.hxx:35
com::sun::star::uno::Any
C++ class representing an IDL any.
Definition Any.h:62
com::sun::star::uno::Any::get
T get() const
Provides a value of specified type, so you can easily write e.g.
Definition Any.hxx:666
com::sun::star::uno::Any::getValue
const void * getValue() const
Gets a pointer to the set value.
Definition Any.h:210
com::sun::star::uno::Any::getValueTypeClass
TypeClass getValueTypeClass() const
Gets the type class of the set value.
Definition Any.h:190