1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#pragma once
#include <map>
#include <memory>
#include <string_view>
#include <rtl/ustring.hxx>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/beans/XMultiPropertySet.hpp>
#include <utility>
/** @descr MultiPropertySetHandler handles the two slightly different
interfaces XPropertySet and XMultiPropertySet for accessing
properties of an object.
It uses the classes PropertyWrapperBase and the template
PropertyWrapper for a type safe access to single properties.
The function class OUStringComparison is used by a STL map to
sort the properties by names.
*/
/** @descr Base class for the templated property wrappers.
Having a common base class allows to set a variable to the
property's value without explicit knowledge of its type.
*/
class PropertyWrapperBase
{
public:
/** @descr Create a class instance and store the given name.
@param rName The name of the property.
*/
explicit PropertyWrapperBase (OUString aName)
: msName (std::move(aName))
{}
virtual ~PropertyWrapperBase()
{}
/** @descr Abstract interface of a method for setting a variables
value to that of the property.
*/
virtual void SetValue (const css::uno::Any & rValue) = 0;
const OUString msName;
};
/** @descr For every property type there will be one instantiation of this
template class with its own and type specific version of SetValue.
*/
template<class T> class PropertyWrapper : public PropertyWrapperBase
{
public:
/** @descr Create a wrapper for a property of type T.
*/
PropertyWrapper (const OUString & rName, T & rValue)
: PropertyWrapperBase (rName),
mrValue (rValue)
{}
/** descr Set the given value inside an Any to the variable referenced
by the data member.
*/
virtual void SetValue (const css::uno::Any & rValue) override
{
rValue >>= mrValue;
}
private:
/// Reference to a variable. Its value can be modified by a call to SetValue.
T & mrValue;
};
/** @descr Function object for comparing two OUStrings.
*/
class OUStringComparison
{
public:
/// Compare two strings. Returns true if the first is before the second.
bool operator() (std::u16string_view a, std::u16string_view b) const
{
return (a.compare (b) < 0);
}
};
/** @descr This class lets you get the values from an object that either
supports the interface XPropertySet or XMultiPropertySet. If it
supports both interfaces then XMultiPropertySet is preferred.
Using it works in three steps.
1. Create an instance and pass a reference to the object from which to
get the property values.
2. Make all properties whose values you want to get known to the object
by using the Add method. This creates instances of a template class
that stores the properties name and a reference to the variable in
which to store its value.
3. Finally call GetProperties to store the properties values into the
variables specified in step 2. This uses either the XPropertySet or
(preferred) the XMultiPropertySet interface.
*/
class MultiPropertySetHandler
{
public:
/** @descr Create a handler of the property set of the given
object.
@param xObject A reference to any of the object's interfaces.
not necessarily XPropertySet or XMultiPropertySet. It
is casted later to one of the two of them.
*/
explicit MultiPropertySetHandler (css::uno::Reference<
css::uno::XInterface> xObject);
/** @descr Add a property to handle. The type given implicitly by the
reference to a variable is used to create an instance of
the PropertyWrapper template class.
@param sName Name of the property.
@param rValue Reference to a variable whose value is set by the
call to GetProperties to the property's value.
*/
template<class T> void Add (const OUString & sName, T& rValue)
{
aPropertyList[sName] = std::make_unique<PropertyWrapper<T>>(sName, rValue);
}
/** @descr Try to get the values for all properties added with the Add
method. If possible it uses the XMultiPropertySet. If that fails
(i.e. for an UnknownPropertyExcption) or if the interface is not
supported it uses the XPropertySet interface.
@return If none of the two interfaces is supported or using them both
fails then sal_False is returned. Else True is returned.
*/
inline bool GetProperties();
private:
/** @descr Try to use the XMultiPropertySet interface to get the property
values.
@param rNameList A precomputed and sorted sequence of OUStrings
containing the properties names.
@return True if values could be derived.
*/
inline bool MultiGet (const css::uno::Sequence<
OUString> & rNameList);
/** @descr Try to use the XPropertySet interface to get the property
values.
@param rNameList A precomputed and sorted sequence of OUStrings
containing the properties names.
@return True if values could be derived.
*/
inline bool SingleGet (const css::uno::Sequence<
OUString> & rNameList);
/** @descr STL map that maps from property names to polymorphic instances of
PropertyWrapper. It uses OUStringComparison for sorting
the property names.
*/
::std::map< OUString, std::unique_ptr<PropertyWrapperBase>, OUStringComparison> aPropertyList;
/// The object from which to get the property values.
css::uno::Reference< css::uno::XInterface> mxObject;
};
MultiPropertySetHandler::MultiPropertySetHandler (css::uno::Reference<
css::uno::XInterface> xObject)
: mxObject (std::move(xObject))
{
}
bool MultiPropertySetHandler::GetProperties()
{
css::uno::Sequence< OUString> aNameList (aPropertyList.size());
auto aNameListRange = asNonConstRange(aNameList);
int i = 0;
for (const auto& rProperty : aPropertyList)
aNameListRange[i++] = rProperty.second->msName;
if ( ! MultiGet(aNameList))
if ( ! SingleGet(aNameList))
return false;
return true;
}
bool MultiPropertySetHandler::MultiGet (const css::uno::Sequence<
OUString> & rNameList)
{
css::uno::Reference< css::beans::XMultiPropertySet> xMultiSet (
mxObject, css::uno::UNO_QUERY);
if (xMultiSet.is())
try
{
int i = 0;
css::uno::Sequence< css::uno::Any> aValueList =
xMultiSet->getPropertyValues (rNameList);
for (auto& rProperty : aPropertyList)
rProperty.second->SetValue (aValueList[i++]);
}
catch (const css::beans::UnknownPropertyException&)
{
return false;
}
else
return false;
return true;
}
bool MultiPropertySetHandler::SingleGet (const css::uno::Sequence<
OUString> & rNameList)
{
css::uno::Reference< css::beans::XPropertySet> xSingleSet (
mxObject, css::uno::UNO_QUERY);
if (xSingleSet.is())
try
{
int i = 0;
for (auto& rProperty : aPropertyList)
rProperty.second->SetValue (xSingleSet->getPropertyValue (rNameList[i++]));
}
catch (const css::beans::UnknownPropertyException&)
{
return false;
}
else
return false;
return true;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
