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
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
|
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: updatedata.hxx,v $
* $Revision: 1.10 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#ifndef CONFIGMGR_BACKEND_UPDATEDATA_HXX
#define CONFIGMGR_BACKEND_UPDATEDATA_HXX
#include <com/sun/star/uno/Any.hxx>
#include <com/sun/star/uno/Type.hxx>
#include <rtl/ref.hxx>
#include <rtl/ustring.hxx>
#include <salhelper/simplereferenceobject.hxx>
#include "utility.hxx"
#ifndef INCLUDED_SET
#include <set>
#define INCLUDED_SET
#endif
#ifndef INCLUDED_MAP
#include <map>
#define INCLUDED_MAP
#endif
namespace com { namespace sun { namespace star { namespace configuration { namespace backend {
class XLayerHandler;
} } } } }
// -----------------------------------------------------------------------------
namespace configmgr
{
// -----------------------------------------------------------------------------
namespace backend
{
// -----------------------------------------------------------------------------
namespace uno = ::com::sun::star::uno;
namespace backenduno = ::com::sun::star::configuration::backend;
// -----------------------------------------------------------------------------
class ElementUpdate;
class NodeUpdate;
class NodeModification;
class NodeReplace;
class NodeDrop;
class PropertyUpdate;
class PropertyAdd;
class PropertyReset;
// -----------------------------------------------------------------------------
class NamedUpdate : public salhelper::SimpleReferenceObject
{
rtl::OUString const m_aName;
protected:
explicit
NamedUpdate(rtl::OUString const & _aName)
: m_aName(_aName)
{}
~NamedUpdate() {};
public:
rtl::OUString const & getName() const { return m_aName; }
};
// -----------------------------------------------------------------------------
class ElementUpdate : public NamedUpdate
{
NodeUpdate * m_pParent;
sal_Int16 m_nFlags;
sal_Int16 m_nFlagsMask;
protected:
ElementUpdate(NodeUpdate * _pParent, rtl::OUString const & _aName, sal_Int16 _nFlags, sal_Int16 _nFlagsMask);
public:
virtual NodeUpdate * asNodeUpdate(bool _bMerged = false);
virtual PropertyUpdate * asPropertyUpdate();
virtual void writeToLayer(backenduno::XLayerHandler * _pLayer) = 0;
public:
NodeUpdate * getParent() const { return m_pParent; }
sal_Int16 changedFlags() const { return m_nFlagsMask; }
sal_Int16 updateFlags(sal_Int16 _nFlags = 0) const;
};
// -----------------------------------------------------------------------------
class NodeUpdate : public ElementUpdate
{
typedef std::map< rtl::OUString, rtl::Reference<ElementUpdate> > ElementList;
public:
enum Op { modify, reset, replace };
protected:
NodeUpdate(NodeUpdate * _pParent, rtl::OUString const & _aName, sal_Int16 _nFlags, sal_Int16 _nFlagsMask, Op _op);
virtual NodeUpdate * asNodeUpdate(bool _bMerged);
public:
bool addNodeUpdate (rtl::Reference<ElementUpdate> const & _aNode);
bool addPropertyUpdate (rtl::Reference<ElementUpdate> const & _aProp);
void removeNodeByName (rtl::OUString const & _aName);
void removePropertyByName (rtl::OUString const & _aName);
Op getOperation() const { return m_op; }
rtl::Reference<ElementUpdate> getNodeByName (rtl::OUString const & _aName) const;
rtl::Reference<ElementUpdate> getPropertyByName (rtl::OUString const & _aName) const;
ElementList::const_iterator beginNodes() const { return m_aNodes.begin(); }
ElementList::const_iterator endNodes() const { return m_aNodes.end(); };
ElementList::const_iterator beginProperties() const { return m_aProperties.begin(); };
ElementList::const_iterator endProperties() const { return m_aProperties.end(); };
bool hasChildren() const { return !m_aNodes.empty() || !m_aProperties.empty(); }
void writeChildrenToLayer(backenduno::XLayerHandler * _pLayer);
private:
ElementList m_aNodes;
ElementList m_aProperties;
ElementList m_aRemovedElements;
Op m_op;
};
// -----------------------------------------------------------------------------
class NodeModification : public NodeUpdate
{
public:
NodeModification(NodeUpdate * _pParent, rtl::OUString const & _aName, sal_Int16 _nFlags, sal_Int16 _nFlagsMask, sal_Bool _bReset);
virtual void writeToLayer(backenduno::XLayerHandler * _pLayer);
};
// -----------------------------------------------------------------------------
class NodeReplace : public NodeUpdate
{
public:
NodeReplace(NodeUpdate * _pParent, rtl::OUString const & _aName, sal_Int16 _nFlags);
NodeReplace(NodeUpdate * _pParent, rtl::OUString const & _aName, sal_Int16 _nFlags, rtl::OUString const & _aTemplateName, rtl::OUString const & _aTemplateComponent);
bool hasTemplate() const;
rtl::OUString getTemplateName() const { return m_aTemplateName; }
rtl::OUString getTemplateComponent() const { return m_aTemplateComponent; }
virtual void writeToLayer(backenduno::XLayerHandler * _pLayer);
private:
rtl::OUString m_aTemplateName;
rtl::OUString m_aTemplateComponent;
};
// -----------------------------------------------------------------------------
class NodeDrop : public ElementUpdate
{
public:
NodeDrop(NodeUpdate * _pParent, rtl::OUString const & _aName);
virtual void writeToLayer(backenduno::XLayerHandler * _pLayer);
};
// -----------------------------------------------------------------------------
class PropertyUpdate : public ElementUpdate
{
typedef std::map< rtl::OUString, uno::Any > ValueList;
ValueList m_aValues;
uno::Type m_aType;
public:
PropertyUpdate(NodeUpdate * _pParent, rtl::OUString const & _aName, sal_Int16 _nFlags, sal_Int16 _nFlagsMask, uno::Type const & _aType);
bool setValueFor(rtl::OUString const & _aLocale, uno::Any const & _aValueUpdate);
bool resetValueFor(rtl::OUString const & _aLocale);
void removeValueFor(rtl::OUString const & _aLocale);
bool setValue(uno::Any const & _aValueUpdate) { return setValueFor(primarySlot(), _aValueUpdate); }
bool resetValue() { return resetValueFor(primarySlot()); }
void removeValue() { removeValueFor(primarySlot()); }
void finishValue();
uno::Type const & getValueType() const { return m_aType; }
bool hasValueFor(rtl::OUString const & _aLocale) const;
bool hasValue() const { return hasValueFor(primarySlot()); }
bool hasResetFor(rtl::OUString const & _aLocale) const;
bool hasReset() const { return hasResetFor(primarySlot()); }
bool hasChangeFor(rtl::OUString const & _aLocale) const;
bool hasChange() const { return hasChangeFor(primarySlot()); }
uno::Any getValueFor(rtl::OUString const & _aLocale) const;
uno::Any getValue() const { return getValueFor(primarySlot()); }
ValueList::const_iterator beginValues() const { return m_aValues.begin(); }
ValueList::const_iterator endValues() const { return m_aValues.end(); }
void writeValueToLayerFor(backenduno::XLayerHandler * _pLayer, uno::Any const & _aValue, rtl::OUString const & _aLocale);
void writeValueToLayer(backenduno::XLayerHandler * _pLayer, uno::Any const & _aValue);
void writeValuesToLayer(backenduno::XLayerHandler * _pLayer);
virtual void writeToLayer(backenduno::XLayerHandler * _pLayer);
private:
rtl::OUString primarySlot() const { return rtl::OUString(); }
static uno::Any const & getResetMarker();
static inline bool isResetMarker(uno::Any const & _aValue);
virtual PropertyUpdate * asPropertyUpdate();
};
// -----------------------------------------------------------------------------
class PropertyAdd : public ElementUpdate
{
uno::Type m_aValueType;
uno::Any m_aValue;
public:
PropertyAdd(NodeUpdate * _pParent, rtl::OUString const & _aName, sal_Int16 _nFlags, uno::Type const & _aType);
PropertyAdd(NodeUpdate * _pParent, rtl::OUString const & _aName, sal_Int16 _nFlags, uno::Any const & _aValue);
bool hasValue() const { return !! m_aValue.hasValue(); }
uno::Any const & getValue() const { return m_aValue; }
uno::Type const & getValueType() const { return m_aValueType; }
virtual void writeToLayer(backenduno::XLayerHandler * _pLayer);
};
// -----------------------------------------------------------------------------
class PropertyReset : public ElementUpdate
{
public:
PropertyReset(NodeUpdate * _pParent, rtl::OUString const & _aName);
virtual void writeToLayer(backenduno::XLayerHandler * _pLayer);
};
// -----------------------------------------------------------------------------
} // namespace backend
// -----------------------------------------------------------------------------
} // namespace configmgr
#endif
|
