sc/source/core/data/dpitemdata.cxx

   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 size_t ScDPItemData::Hash::operator() (const ScDPItemData& rVal) const
  33 {
  34     switch (rVal.GetType())
  35     {
  36         case GroupValue:
  37         case Value:
  38         case RangeStart:
  39             return (size_t)(rVal.mfValue);
  40         case String:
  41         case Error:
  42         {
  43             if (!rVal.mpString)
  44                 return 0;
  45
  46             if (rVal.mbStringInterned)
  47                 return reinterpret_cast<size_t>(rVal.mpString);
  48
  49             OUStringHash aStrHasher;
  50             return aStrHasher(*rVal.mpString);
  51         }
  52         default:
  53             ;
  54     }
  55
  56     return 0;
  57 }
  58
  59 sal_Int32 ScDPItemData::Compare(const ScDPItemData& rA, const ScDPItemData& rB)
  60 {
  61     if (rA.meType != rB.meType)
  62     {
  63         // group value, value and string in this order. Ensure that the empty
  64         // type comes last.
  65         return rA.meType < rB.meType ? -1 : 1;
  66     }
  67
  68     switch (rA.meType)
  69     {
  70         case GroupValue:
  71         {
  72             if (rA.maGroupValue.mnGroupType == rB.maGroupValue.mnGroupType)
  73             {
  74                 if (rA.maGroupValue.mnValue == rB.maGroupValue.mnValue)
  75                     return 0;
  76
  77                 return rA.maGroupValue.mnValue < rB.maGroupValue.mnValue ? -1 : 1;
  78             }
  79
  80             return rA.maGroupValue.mnGroupType < rB.maGroupValue.mnGroupType ? -1 : 1;
  81         }
  82         case Value:
  83         case RangeStart:
  84         {
  85             if (rA.mfValue == rB.mfValue)
  86                 return 0;
  87
  88             return rA.mfValue < rB.mfValue ? -1 : 1;
  89         }
  90         case String:
  91         case Error:
  92             if (rA.mpString == rB.mpString)
  93                 // strings may be interned.
  94                 return 0;
  95
  96             return ScGlobal::GetCollator()->compareString(rA.GetString(), rB.GetString());
  97         default:
  98             ;
  99     }
 100     return 0;
 101 }
 102
 103 ScDPItemData::ScDPItemData() :
 104     mfValue(0.0), meType(Empty), mbStringInterned(false) {}
 105
 106 ScDPItemData::ScDPItemData(const ScDPItemData& r) :
 107     meType(r.meType), mbStringInterned(r.mbStringInterned)
 108 {
 109     switch (r.meType)
 110     {
 111         case String:
 112         case Error:
 113             mpString = mbStringInterned ? r.mpString :  new OUString(*r.mpString);
 114         break;
 115         case Value:
 116         case RangeStart:
 117             mfValue = r.mfValue;
 118         break;
 119         case GroupValue:
 120             maGroupValue.mnGroupType = r.maGroupValue.mnGroupType;
 121             maGroupValue.mnValue = r.maGroupValue.mnValue;
 122         break;
 123         case Empty:
 124         default:
 125             mfValue = 0.0;
 126     }
 127 }
 128
 129 void ScDPItemData::DisposeString()
 130 {
 131     if (!mbStringInterned)
 132     {
 133         if (meType == String || meType == Error)
 134             delete mpString;
 135     }
 136
 137     mbStringInterned = false;
 138 }
 139
 140 ScDPItemData::ScDPItemData(const OUString& rStr) :
 141     mpString(new OUString(rStr)), meType(String), mbStringInterned(false) {}
 142
 143 ScDPItemData::ScDPItemData(sal_Int32 nGroupType, sal_Int32 nValue) :
 144     meType(GroupValue), mbStringInterned(false)
 145 {
 146     maGroupValue.mnGroupType = nGroupType;
 147     maGroupValue.mnValue = nValue;
 148 }
 149
 150 ScDPItemData::~ScDPItemData()
 151 {
 152     DisposeString();
 153 }
 154
 155 void ScDPItemData::SetEmpty()
 156 {
 157     DisposeString();
 158     meType = Empty;
 159 }
 160
 161 void ScDPItemData::SetString(const OUString& rS)
 162 {
 163     DisposeString();
 164     mpString = new OUString(rS);
 165     meType = String;
 166 }
 167
 168 void ScDPItemData::SetString(const OUString* pS)
 169 {
 170     DisposeString();
 171     mpString = pS;
 172     meType = String;
 173     mbStringInterned = true;
 174 }
 175
 176 void ScDPItemData::SetValue(double fVal)
 177 {
 178     DisposeString();
 179     mfValue = fVal;
 180     meType = Value;
 181 }
 182
 183 void ScDPItemData::SetRangeStart(double fVal)
 184 {
 185     DisposeString();
 186     mfValue = fVal;
 187     meType = RangeStart;
 188 }
 189
 190 void ScDPItemData::SetRangeFirst()
 191 {
 192     DisposeString();
 193     rtl::math::setInf(&mfValue, true);
 194     meType = RangeStart;
 195 }
 196
 197 void ScDPItemData::SetRangeLast()
 198 {
 199     DisposeString();
 200     rtl::math::setInf(&mfValue, false);
 201     meType = RangeStart;
 202 }
 203
 204 void ScDPItemData::SetErrorString(const OUString* pS)
 205 {
 206     SetString(pS);
 207     meType = Error;
 208 }
 209
 210 bool ScDPItemData::IsCaseInsEqual(const ScDPItemData& r) const
 211 {
 212     if (meType != r.meType)
 213         return false;
 214
 215     switch (meType)
 216     {
 217         case Value:
 218         case RangeStart:
 219             return rtl::math::approxEqual(mfValue, r.mfValue);
 220         case GroupValue:
 221             return maGroupValue.mnGroupType == r.maGroupValue.mnGroupType &&
 222                 maGroupValue.mnValue == r.maGroupValue.mnValue;
 223         default:
 224             ;
 225     }
 226
 227     if (mpString == r.mpString)
 228         // Fast equality check for interned strings.
 229         return true;
 230
 231     return ScGlobal::GetpTransliteration()->isEqual(GetString(), r.GetString());
 232 }
 233
 234 bool ScDPItemData::operator== (const ScDPItemData& r) const
 235 {
 236     if (meType != r.meType)
 237         return false;
 238
 239     switch (meType)
 240     {
 241         case Value:
 242         case RangeStart:
 243             return rtl::math::approxEqual(mfValue, r.mfValue);
 244         case GroupValue:
 245             return maGroupValue.mnGroupType == r.maGroupValue.mnGroupType &&
 246                 maGroupValue.mnValue == r.maGroupValue.mnValue;
 247         default:
 248             ;
 249     }
 250
 251     // need exact equality until we have a safe case insensitive string hash
 252     return GetString() == r.GetString();
 253 }
 254
 255 bool ScDPItemData::operator!= (const ScDPItemData& r) const
 256 {
 257     return !operator== (r);
 258 }
 259
 260 bool ScDPItemData::operator< (const ScDPItemData& r) const
 261 {
 262     return Compare(*this, r) == -1;
 263 }
 264
 265 ScDPItemData& ScDPItemData::operator= (const ScDPItemData& r)
 266 {
 267     DisposeString();
 268     meType = r.meType;
 269     mbStringInterned = false;
 270     switch (r.meType)
 271     {
 272         case String:
 273         case Error:
 274             mpString = r.mbStringInterned ? r.mpString : new OUString(*r.mpString);
 275             mbStringInterned = r.mbStringInterned;
 276         break;
 277         case Value:
 278         case RangeStart:
 279             mfValue = r.mfValue;
 280         break;
 281         case GroupValue:
 282             maGroupValue.mnGroupType = r.maGroupValue.mnGroupType;
 283             maGroupValue.mnValue = r.maGroupValue.mnValue;
 284         break;
 285         case Empty:
 286         default:
 287             mfValue = 0.0;
 288     }
 289     return *this;
 290 }
 291
 292 ScDPValue::Type ScDPItemData::GetCellType() const
 293 {
 294     switch (meType)
 295     {
 296         case Error:
 297             return ScDPValue::Error;
 298         case Empty:
 299             return ScDPValue::Empty;
 300         case Value:
 301             return ScDPValue::Value;
 302         default:
 303             ;
 304     }
 305
 306     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 bool ScDPItemData::IsEmpty() const
 345 {
 346     return meType == Empty;
 347 }
 348
 349 bool ScDPItemData::IsValue() const
 350 {
 351     return meType == Value;
 352 }
 353
 354 OUString ScDPItemData::GetString() const
 355 {
 356     switch (meType)
 357     {
 358         case String:
 359         case Error:
 360             return *mpString;
 361         case Value:
 362         case RangeStart:
 363             return OUString::number(mfValue);
 364         case GroupValue:
 365             return OUString::number(maGroupValue.mnValue);
 366         case Empty:
 367         default:
 368             ;
 369     }
 370
 371     return OUString();
 372 }
 373
 374 double ScDPItemData::GetValue() const
 375 {
 376     if (meType == Value || meType == RangeStart)
 377         return mfValue;
 378
 379     return 0.0;
 380 }
 381
 382 ScDPItemData::GroupValueAttr ScDPItemData::GetGroupValue() const
 383 {
 384     if (meType == GroupValue)
 385         return maGroupValue;
 386
 387     GroupValueAttr aGV;
 388     aGV.mnGroupType = -1;
 389     aGV.mnValue = -1;
 390     return aGV;
 391 }
 392
 393 bool ScDPItemData::HasStringData() const
 394 {
 395     return meType == String || meType == Error;
 396 }
 397
 398 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */