Line data Source code
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 : #include "dpitemdata.hxx"
21 :
22 : #include "document.hxx"
23 : #include "dpobject.hxx"
24 : #include "formulacell.hxx"
25 : #include "globstr.hrc"
26 : #include "dptabdat.hxx"
27 : #include <rtl/math.hxx>
28 :
29 : const sal_Int32 ScDPItemData::DateFirst = -1;
30 : const sal_Int32 ScDPItemData::DateLast = 10000;
31 :
32 0 : size_t ScDPItemData::Hash::operator() (const ScDPItemData& rVal) const
33 : {
34 0 : switch (rVal.GetType())
35 : {
36 : case GroupValue:
37 : case Value:
38 : case RangeStart:
39 0 : return (size_t)(rVal.mfValue);
40 : case String:
41 : case Error:
42 : {
43 0 : if (!rVal.mpString)
44 0 : return 0;
45 :
46 0 : if (rVal.mbStringInterned)
47 0 : return reinterpret_cast<size_t>(rVal.mpString);
48 :
49 : OUStringHash aStrHasher;
50 0 : return aStrHasher(*rVal.mpString);
51 : }
52 : default:
53 : ;
54 : }
55 :
56 0 : return 0;
57 : }
58 :
59 10438 : sal_Int32 ScDPItemData::Compare(const ScDPItemData& rA, const ScDPItemData& rB)
60 : {
61 10438 : if (rA.meType != rB.meType)
62 : {
63 : // group value, value and string in this order. Ensure that the empty
64 : // type comes last.
65 1 : return rA.meType < rB.meType ? -1 : 1;
66 : }
67 :
68 10437 : switch (rA.meType)
69 : {
70 : case GroupValue:
71 : {
72 75 : if (rA.maGroupValue.mnGroupType == rB.maGroupValue.mnGroupType)
73 : {
74 75 : if (rA.maGroupValue.mnValue == rB.maGroupValue.mnValue)
75 0 : return 0;
76 :
77 75 : return rA.maGroupValue.mnValue < rB.maGroupValue.mnValue ? -1 : 1;
78 : }
79 :
80 0 : return rA.maGroupValue.mnGroupType < rB.maGroupValue.mnGroupType ? -1 : 1;
81 : }
82 : case Value:
83 : case RangeStart:
84 : {
85 6119 : if (rA.mfValue == rB.mfValue)
86 2506 : return 0;
87 :
88 3613 : return rA.mfValue < rB.mfValue ? -1 : 1;
89 : }
90 : case String:
91 : case Error:
92 4197 : if (rA.mpString == rB.mpString)
93 : // strings may be interned.
94 1849 : return 0;
95 :
96 2348 : return ScGlobal::GetCollator()->compareString(rA.GetString(), rB.GetString());
97 : default:
98 : ;
99 : }
100 46 : return 0;
101 : }
102 :
103 8306 : ScDPItemData::ScDPItemData() :
104 8306 : mfValue(0.0), meType(Empty), mbStringInterned(false) {}
105 :
106 37195 : ScDPItemData::ScDPItemData(const ScDPItemData& r) :
107 37195 : meType(r.meType), mbStringInterned(r.mbStringInterned)
108 : {
109 37195 : switch (r.meType)
110 : {
111 : case String:
112 : case Error:
113 7641 : mpString = mbStringInterned ? r.mpString : new OUString(*r.mpString);
114 7641 : break;
115 : case Value:
116 : case RangeStart:
117 27417 : mfValue = r.mfValue;
118 27417 : break;
119 : case GroupValue:
120 1960 : maGroupValue.mnGroupType = r.maGroupValue.mnGroupType;
121 1960 : maGroupValue.mnValue = r.maGroupValue.mnValue;
122 1960 : break;
123 : case Empty:
124 : default:
125 177 : mfValue = 0.0;
126 : }
127 37195 : }
128 :
129 83890 : void ScDPItemData::DisposeString()
130 : {
131 83890 : if (!mbStringInterned)
132 : {
133 63035 : if (meType == String || meType == Error)
134 380 : delete mpString;
135 : }
136 :
137 83890 : mbStringInterned = false;
138 83890 : }
139 :
140 14 : ScDPItemData::ScDPItemData(const OUString& rStr) :
141 14 : mpString(new OUString(rStr)), meType(String), mbStringInterned(false) {}
142 :
143 850 : ScDPItemData::ScDPItemData(sal_Int32 nGroupType, sal_Int32 nValue) :
144 850 : meType(GroupValue), mbStringInterned(false)
145 : {
146 850 : maGroupValue.mnGroupType = nGroupType;
147 850 : maGroupValue.mnValue = nValue;
148 850 : }
149 :
150 46343 : ScDPItemData::~ScDPItemData()
151 : {
152 46343 : DisposeString();
153 46343 : }
154 :
155 56 : void ScDPItemData::SetEmpty()
156 : {
157 56 : DisposeString();
158 56 : meType = Empty;
159 56 : }
160 :
161 145 : void ScDPItemData::SetString(const OUString& rS)
162 : {
163 145 : DisposeString();
164 145 : mpString = new OUString(rS);
165 145 : meType = String;
166 145 : }
167 :
168 937 : void ScDPItemData::SetString(const OUString* pS)
169 : {
170 937 : DisposeString();
171 937 : mpString = pS;
172 937 : meType = String;
173 937 : mbStringInterned = true;
174 937 : }
175 :
176 1496 : void ScDPItemData::SetValue(double fVal)
177 : {
178 1496 : DisposeString();
179 1496 : mfValue = fVal;
180 1496 : meType = Value;
181 1496 : }
182 :
183 24 : void ScDPItemData::SetRangeStart(double fVal)
184 : {
185 24 : DisposeString();
186 24 : mfValue = fVal;
187 24 : meType = RangeStart;
188 24 : }
189 :
190 2 : void ScDPItemData::SetRangeFirst()
191 : {
192 2 : DisposeString();
193 2 : rtl::math::setInf(&mfValue, true);
194 2 : meType = RangeStart;
195 2 : }
196 :
197 2 : void ScDPItemData::SetRangeLast()
198 : {
199 2 : DisposeString();
200 2 : rtl::math::setInf(&mfValue, false);
201 2 : meType = RangeStart;
202 2 : }
203 :
204 0 : void ScDPItemData::SetErrorString(const OUString* pS)
205 : {
206 0 : SetString(pS);
207 0 : meType = Error;
208 0 : }
209 :
210 2461 : bool ScDPItemData::IsCaseInsEqual(const ScDPItemData& r) const
211 : {
212 2461 : if (meType != r.meType)
213 1 : return false;
214 :
215 2460 : switch (meType)
216 : {
217 : case Value:
218 : case RangeStart:
219 1376 : return rtl::math::approxEqual(mfValue, r.mfValue);
220 : case GroupValue:
221 0 : return maGroupValue.mnGroupType == r.maGroupValue.mnGroupType &&
222 0 : maGroupValue.mnValue == r.maGroupValue.mnValue;
223 : default:
224 : ;
225 : }
226 :
227 1084 : if (mpString == r.mpString)
228 : // Fast equality check for interned strings.
229 706 : return true;
230 :
231 378 : return ScGlobal::GetpTransliteration()->isEqual(GetString(), r.GetString());
232 : }
233 :
234 4369 : bool ScDPItemData::operator== (const ScDPItemData& r) const
235 : {
236 4369 : if (meType != r.meType)
237 416 : return false;
238 :
239 3953 : switch (meType)
240 : {
241 : case Value:
242 : case RangeStart:
243 3646 : return rtl::math::approxEqual(mfValue, r.mfValue);
244 : case GroupValue:
245 236 : return maGroupValue.mnGroupType == r.maGroupValue.mnGroupType &&
246 236 : maGroupValue.mnValue == r.maGroupValue.mnValue;
247 : default:
248 : ;
249 : }
250 :
251 : // need exact equality until we have a safe case insensitive string hash
252 189 : return GetString() == r.GetString();
253 : }
254 :
255 0 : bool ScDPItemData::operator!= (const ScDPItemData& r) const
256 : {
257 0 : return !operator== (r);
258 : }
259 :
260 10249 : bool ScDPItemData::operator< (const ScDPItemData& r) const
261 : {
262 10249 : return Compare(*this, r) == -1;
263 : }
264 :
265 34885 : ScDPItemData& ScDPItemData::operator= (const ScDPItemData& r)
266 : {
267 34885 : DisposeString();
268 34885 : meType = r.meType;
269 34885 : mbStringInterned = false;
270 34885 : switch (r.meType)
271 : {
272 : case String:
273 : case Error:
274 12512 : mpString = r.mbStringInterned ? r.mpString : new OUString(*r.mpString);
275 12512 : mbStringInterned = r.mbStringInterned;
276 12512 : break;
277 : case Value:
278 : case RangeStart:
279 22157 : mfValue = r.mfValue;
280 22157 : break;
281 : case GroupValue:
282 68 : maGroupValue.mnGroupType = r.maGroupValue.mnGroupType;
283 68 : maGroupValue.mnValue = r.maGroupValue.mnValue;
284 68 : break;
285 : case Empty:
286 : default:
287 148 : mfValue = 0.0;
288 : }
289 34885 : return *this;
290 : }
291 :
292 512 : ScDPValue::Type ScDPItemData::GetCellType() const
293 : {
294 512 : switch (meType)
295 : {
296 : case Error:
297 0 : return ScDPValue::Error;
298 : case Empty:
299 2 : return ScDPValue::Empty;
300 : case Value:
301 510 : return ScDPValue::Value;
302 : default:
303 : ;
304 : }
305 :
306 0 : return ScDPValue::String;
307 : }
308 :
309 : #if DEBUG_PIVOT_TABLE
310 :
311 : void ScDPItemData::Dump(const char* msg) const
312 : {
313 : printf("--- (%s)\n", msg);
314 : switch (meType)
315 : {
316 : case Empty:
317 : printf("empty\n");
318 : break;
319 : case Error:
320 : printf("error: %s\n",
321 : OUStringToOString(*mpString, RTL_TEXTENCODING_UTF8).getStr());
322 : break;
323 : case GroupValue:
324 : printf("group value: group type = %d value = %d\n",
325 : maGroupValue.mnGroupType, maGroupValue.mnValue);
326 : break;
327 : case String:
328 : printf("string: %s\n",
329 : OUStringToOString(*mpString, RTL_TEXTENCODING_UTF8).getStr());
330 : break;
331 : case Value:
332 : printf("value: %g\n", mfValue);
333 : break;
334 : case RangeStart:
335 : printf("range start: %g\n", mfValue);
336 : break;
337 : default:
338 : printf("unknown type\n");
339 : }
340 : printf("---\n");
341 : }
342 : #endif
343 :
344 2490 : bool ScDPItemData::IsEmpty() const
345 : {
346 2490 : return meType == Empty;
347 : }
348 :
349 9023 : bool ScDPItemData::IsValue() const
350 : {
351 9023 : return meType == Value;
352 : }
353 :
354 6965 : OUString ScDPItemData::GetString() const
355 : {
356 6965 : switch (meType)
357 : {
358 : case String:
359 : case Error:
360 6909 : return *mpString;
361 : case Value:
362 : case RangeStart:
363 0 : return OUString::number(mfValue);
364 : case GroupValue:
365 0 : return OUString::number(maGroupValue.mnValue);
366 : case Empty:
367 : default:
368 : ;
369 : }
370 :
371 56 : return OUString();
372 : }
373 :
374 12433 : double ScDPItemData::GetValue() const
375 : {
376 12433 : if (meType == Value || meType == RangeStart)
377 12433 : return mfValue;
378 :
379 0 : return 0.0;
380 : }
381 :
382 958 : ScDPItemData::GroupValueAttr ScDPItemData::GetGroupValue() const
383 : {
384 958 : if (meType == GroupValue)
385 958 : return maGroupValue;
386 :
387 : GroupValueAttr aGV;
388 0 : aGV.mnGroupType = -1;
389 0 : aGV.mnValue = -1;
390 0 : return aGV;
391 : }
392 :
393 0 : bool ScDPItemData::HasStringData() const
394 : {
395 0 : return meType == String || meType == Error;
396 156 : }
397 :
398 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
