sc/source/core/tool/queryparam.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 <memory>
  21 #include <interpretercontext.hxx>
  22 #include <queryparam.hxx>
  23 #include <queryentry.hxx>
  24 #include <scmatrix.hxx>
  25
  26 #include <svl/sharedstringpool.hxx>
  27 #include <svl/numformat.hxx>
  28 #include <o3tl/safeint.hxx>
  29 #include <osl/diagnose.h>
  30
  31 #include <algorithm>
  32
  33 namespace {
  34
  35 const size_t MAXQUERY = 8;
  36
  37 class FindByField
  38 {
  39     SCCOLROW mnField;
  40 public:
  41     explicit FindByField(SCCOLROW nField) : mnField(nField) {}
  42     bool operator() (const ScQueryEntry& rpEntry) const
  43     {
  44         return rpEntry.bDoQuery && rpEntry.nField == mnField;
  45     }
  46 };
  47
  48 struct FindUnused
  49 {
  50     bool operator() (const ScQueryEntry& rpEntry) const
  51     {
  52         return !rpEntry.bDoQuery;
  53     }
  54 };
  55
  56 }
  57
  58 ScQueryParamBase::const_iterator ScQueryParamBase::begin() const
  59 {
  60     return m_Entries.begin();
  61 }
  62
  63 ScQueryParamBase::const_iterator ScQueryParamBase::end() const
  64 {
  65     return m_Entries.end();
  66 }
  67
  68 ScQueryParamBase::ScQueryParamBase() :
  69     eSearchType(utl::SearchParam::SearchType::Normal),
  70     bHasHeader(true),
  71     bHasTotals(false),
  72     bByRow(true),
  73     bInplace(true),
  74     bCaseSens(false),
  75     bDuplicate(false),
  76     mbRangeLookup(false)
  77 {
  78     m_Entries.resize(MAXQUERY);
  79 }
  80
  81 ScQueryParamBase::ScQueryParamBase(const ScQueryParamBase& r) :
  82     eSearchType(r.eSearchType), bHasHeader(r.bHasHeader), bHasTotals(r.bHasTotals), bByRow(r.bByRow),
  83     bInplace(r.bInplace), bCaseSens(r.bCaseSens), bDuplicate(r.bDuplicate),
  84     mbRangeLookup(r.mbRangeLookup), m_Entries(r.m_Entries)
  85 {
  86 }
  87
  88 ScQueryParamBase& ScQueryParamBase::operator=(const ScQueryParamBase& r)
  89 {
  90     if (this != &r)
  91     {
  92         eSearchType = r.eSearchType;
  93         bHasHeader  = r.bHasHeader;
  94         bHasTotals = r.bHasTotals;
  95         bByRow = r.bByRow;
  96         bInplace = r.bInplace;
  97         bCaseSens = r.bCaseSens;
  98         bDuplicate = r.bDuplicate;
  99         mbRangeLookup = r.mbRangeLookup;
 100         m_Entries = r.m_Entries;
 101     }
 102     return *this;
 103 }
 104
 105 ScQueryParamBase::~ScQueryParamBase()
 106 {
 107 }
 108
 109 bool ScQueryParamBase::IsValidFieldIndex() const
 110 {
 111     return true;
 112 }
 113
 114 SCSIZE ScQueryParamBase::GetEntryCount() const
 115 {
 116     return m_Entries.size();
 117 }
 118
 119 const ScQueryEntry& ScQueryParamBase::GetEntry(SCSIZE n) const
 120 {
 121     return m_Entries[n];
 122 }
 123
 124 ScQueryEntry& ScQueryParamBase::GetEntry(SCSIZE n)
 125 {
 126     return m_Entries[n];
 127 }
 128
 129 ScQueryEntry& ScQueryParamBase::AppendEntry()
 130 {
 131     // Find the first unused entry.
 132     EntriesType::iterator itr = std::find_if(
 133         m_Entries.begin(), m_Entries.end(), FindUnused());
 134
 135     if (itr != m_Entries.end())
 136         // Found!
 137         return *itr;
 138
 139     // Add a new entry to the end.
 140     m_Entries.push_back(ScQueryEntry());
 141     return m_Entries.back();
 142 }
 143
 144 ScQueryEntry* ScQueryParamBase::FindEntryByField(SCCOLROW nField, bool bNew)
 145 {
 146     EntriesType::iterator itr = std::find_if(
 147         m_Entries.begin(), m_Entries.end(), FindByField(nField));
 148
 149     if (itr != m_Entries.end())
 150     {
 151         // existing entry found!
 152         return &*itr;
 153     }
 154
 155     if (!bNew)
 156         // no existing entry found, and we are not creating a new one.
 157         return nullptr;
 158
 159     return &AppendEntry();
 160 }
 161
 162 std::vector<ScQueryEntry*> ScQueryParamBase::FindAllEntriesByField(SCCOLROW nField)
 163 {
 164     std::vector<ScQueryEntry*> aEntries;
 165
 166     auto fFind = FindByField(nField);
 167
 168     for (auto& rxEntry : m_Entries)
 169         if (fFind(rxEntry))
 170             aEntries.push_back(&rxEntry);
 171
 172     return aEntries;
 173 }
 174
 175 bool ScQueryParamBase::RemoveEntryByField(SCCOLROW nField)
 176 {
 177     EntriesType::iterator itr = std::find_if(
 178         m_Entries.begin(), m_Entries.end(), FindByField(nField));
 179     bool bRet = false;
 180
 181     if (itr != m_Entries.end())
 182     {
 183         m_Entries.erase(itr);
 184         if (m_Entries.size() < MAXQUERY)
 185             // Make sure that we have at least MAXQUERY number of entries at
 186             // all times.
 187             m_Entries.resize(MAXQUERY);
 188         bRet = true;
 189     }
 190
 191     return bRet;
 192 }
 193
 194 void ScQueryParamBase::RemoveAllEntriesByField(SCCOLROW nField)
 195 {
 196     while( RemoveEntryByField( nField ) ) {}
 197 }
 198
 199 void ScQueryParamBase::Resize(size_t nNew)
 200 {
 201     if (nNew < MAXQUERY)
 202         nNew = MAXQUERY;                // never less than MAXQUERY
 203
 204     m_Entries.resize(nNew);
 205 }
 206
 207 void ScQueryParamBase::FillInExcelSyntax(
 208     svl::SharedStringPool& rPool, const OUString& rCellStr, SCSIZE nIndex, ScInterpreterContext* pContext )
 209 {
 210     if (nIndex >= m_Entries.size())
 211         Resize(nIndex+1);
 212
 213     ScQueryEntry& rEntry = GetEntry(nIndex);
 214     ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
 215     bool bByEmpty = false;
 216     bool bByNonEmpty = false;
 217
 218     if (rCellStr.isEmpty())
 219         rItem.maString = svl::SharedString::getEmptyString();
 220     else
 221     {
 222         rEntry.bDoQuery = true;
 223         // Operatoren herausfiltern
 224         if (rCellStr[0] == '<')
 225         {
 226             if (rCellStr.getLength() > 1 && rCellStr[1] == '>')
 227             {
 228                 rItem.maString = rPool.intern(rCellStr.copy(2));
 229                 rEntry.eOp   = SC_NOT_EQUAL;
 230                 if (rCellStr.getLength() == 2)
 231                     bByNonEmpty = true;
 232             }
 233             else if (rCellStr.getLength() > 1 && rCellStr[1] == '=')
 234             {
 235                 rItem.maString = rPool.intern(rCellStr.copy(2));
 236                 rEntry.eOp   = SC_LESS_EQUAL;
 237             }
 238             else
 239             {
 240                 rItem.maString = rPool.intern(rCellStr.copy(1));
 241                 rEntry.eOp   = SC_LESS;
 242             }
 243         }
 244         else if (rCellStr[0]== '>')
 245         {
 246             if (rCellStr.getLength() > 1 && rCellStr[1] == '=')
 247             {
 248                 rItem.maString = rPool.intern(rCellStr.copy(2));
 249                 rEntry.eOp   = SC_GREATER_EQUAL;
 250             }
 251             else
 252             {
 253                 rItem.maString = rPool.intern(rCellStr.copy(1));
 254                 rEntry.eOp   = SC_GREATER;
 255             }
 256         }
 257         else
 258         {
 259             if (rCellStr[0] == '=')
 260             {
 261                 rItem.maString = rPool.intern(rCellStr.copy(1));
 262                 if (rCellStr.getLength() == 1)
 263                     bByEmpty = true;
 264             }
 265             else
 266                 rItem.maString = rPool.intern(rCellStr);
 267             rEntry.eOp = SC_EQUAL;
 268         }
 269     }
 270
 271     if (!pContext)
 272         return;
 273
 274     /* TODO: pContext currently is also used as a flag whether matching
 275      * empty cells with an empty string is triggered from the interpreter.
 276      * This could be handled independently if all queries should support
 277      * it, needs to be evaluated if that actually is desired. */
 278
 279     // Interpreter queries have only one query, also QueryByEmpty and
 280     // QueryByNonEmpty rely on that.
 281     if (nIndex != 0)
 282         return;
 283
 284     // (empty = empty) is a match, and (empty <> not-empty) also is a
 285     // match. (empty = 0) is not a match.
 286     rItem.mbMatchEmpty = ((rEntry.eOp == SC_EQUAL && rItem.maString.isEmpty())
 287             || (rEntry.eOp == SC_NOT_EQUAL && !rItem.maString.isEmpty()));
 288
 289     // SetQueryBy override item members with special values, so do this last.
 290     if (bByEmpty)
 291         rEntry.SetQueryByEmpty();
 292     else if (bByNonEmpty)
 293         rEntry.SetQueryByNonEmpty();
 294     else
 295     {
 296         sal_uInt32 nFormat = 0;
 297         bool bNumber = pContext->NFIsNumberFormat( rItem.maString.getString(), nFormat, rItem.mfVal);
 298         rItem.meType = bNumber ? ScQueryEntry::ByValue : ScQueryEntry::ByString;
 299     }
 300 }
 301
 302 ScQueryParamTable::ScQueryParamTable() :
 303     nCol1(0),nRow1(0),nCol2(0),nRow2(0),nTab(0)
 304 {
 305 }
 306
 307 ScQueryParamTable::~ScQueryParamTable()
 308 {
 309 }
 310
 311 ScQueryParam::ScQueryParam() :
 312     bDestPers(true),
 313     nDestTab(0),
 314     nDestCol(0),
 315     nDestRow(0)
 316 {
 317     Clear();
 318 }
 319
 320 ScQueryParam::ScQueryParam( const ScQueryParam& ) = default;
 321
 322 ScQueryParam::ScQueryParam( const ScDBQueryParamInternal& r ) :
 323     ScQueryParamBase(r),
 324     ScQueryParamTable(r),
 325     bDestPers(true),
 326     nDestTab(0),
 327     nDestCol(0),
 328     nDestRow(0)
 329 {
 330 }
 331
 332 ScQueryParam::~ScQueryParam()
 333 {
 334 }
 335
 336 void ScQueryParam::Clear()
 337 {
 338     nCol1=nCol2 = 0;
 339     nRow1=nRow2 = 0;
 340     nTab = SCTAB_MAX;
 341     eSearchType = utl::SearchParam::SearchType::Normal;
 342     bHasHeader = bHasTotals = bCaseSens = false;
 343     bInplace = bByRow = bDuplicate = true;
 344
 345     for (auto & itr : m_Entries)
 346     {
 347         itr.Clear();
 348     }
 349
 350     ClearDestParams();
 351 }
 352
 353 void ScQueryParam::ClearDestParams()
 354 {
 355     bDestPers = true;
 356     nDestTab = 0;
 357     nDestCol = 0;
 358     nDestRow = 0;
 359 }
 360
 361 ScQueryParam& ScQueryParam::operator=( const ScQueryParam& ) = default;
 362
 363 bool ScQueryParam::operator==( const ScQueryParam& rOther ) const
 364 {
 365     bool bEqual = false;
 366
 367     // Are the number of queries equal?
 368     SCSIZE nUsed      = 0;
 369     SCSIZE nOtherUsed = 0;
 370     SCSIZE nEntryCount = GetEntryCount();
 371     SCSIZE nOtherEntryCount = rOther.GetEntryCount();
 372
 373     while (nUsed<nEntryCount && m_Entries[nUsed].bDoQuery) ++nUsed;
 374     while (nOtherUsed<nOtherEntryCount && rOther.m_Entries[nOtherUsed].bDoQuery)
 375         ++nOtherUsed;
 376
 377     if (   (nUsed       == nOtherUsed)
 378         && (nCol1       == rOther.nCol1)
 379         && (nRow1       == rOther.nRow1)
 380         && (nCol2       == rOther.nCol2)
 381         && (nRow2       == rOther.nRow2)
 382         && (nTab        == rOther.nTab)
 383         && (bHasHeader  == rOther.bHasHeader)
 384         && (bHasTotals  == rOther.bHasTotals)
 385         && (bByRow      == rOther.bByRow)
 386         && (bInplace    == rOther.bInplace)
 387         && (bCaseSens   == rOther.bCaseSens)
 388         && (eSearchType == rOther.eSearchType)
 389         && (bDuplicate  == rOther.bDuplicate)
 390         && (bDestPers   == rOther.bDestPers)
 391         && (nDestTab    == rOther.nDestTab)
 392         && (nDestCol    == rOther.nDestCol)
 393         && (nDestRow    == rOther.nDestRow) )
 394     {
 395         bEqual = true;
 396         for ( SCSIZE i=0; i<nUsed && bEqual; i++ )
 397             bEqual = m_Entries[i] == rOther.m_Entries[i];
 398     }
 399     return bEqual;
 400 }
 401
 402 void ScQueryParam::MoveToDest()
 403 {
 404     if (!bInplace)
 405     {
 406         SCCOL nDifX = nDestCol - nCol1;
 407         SCROW nDifY = nDestRow - nRow1;
 408         SCTAB nDifZ = nDestTab - nTab;
 409
 410         nCol1 = sal::static_int_cast<SCCOL>( nCol1 + nDifX );
 411         nRow1 = sal::static_int_cast<SCROW>( nRow1 + nDifY );
 412         nCol2 = sal::static_int_cast<SCCOL>( nCol2 + nDifX );
 413         nRow2 = sal::static_int_cast<SCROW>( nRow2 + nDifY );
 414         nTab  = sal::static_int_cast<SCTAB>( nTab  + nDifZ );
 415         size_t n = m_Entries.size();
 416         for (size_t i=0; i<n; i++)
 417             m_Entries[i].nField += nDifX;
 418
 419         bInplace = true;
 420     }
 421     else
 422     {
 423         OSL_FAIL("MoveToDest, bInplace == TRUE");
 424     }
 425 }
 426
 427 ScDBQueryParamBase::ScDBQueryParamBase(DataType eType) :
 428     mnField(-1),
 429     mbSkipString(true),
 430     meType(eType)
 431 {
 432 }
 433
 434 ScDBQueryParamBase::~ScDBQueryParamBase()
 435 {
 436 }
 437
 438 ScDBQueryParamInternal::ScDBQueryParamInternal() :
 439     ScDBQueryParamBase(ScDBQueryParamBase::INTERNAL)
 440 {
 441 }
 442
 443 ScDBQueryParamInternal::~ScDBQueryParamInternal()
 444 {
 445 }
 446
 447 bool ScDBQueryParamInternal::IsValidFieldIndex() const
 448 {
 449     return nCol1 <= mnField && mnField <= nCol2;
 450 }
 451
 452 ScDBQueryParamMatrix::ScDBQueryParamMatrix() :
 453     ScDBQueryParamBase(ScDBQueryParamBase::MATRIX)
 454 {
 455 }
 456
 457 bool ScDBQueryParamMatrix::IsValidFieldIndex() const
 458 {
 459     SCSIZE nC, nR;
 460     mpMatrix->GetDimensions(nC, nR);
 461     return 0 <= mnField && o3tl::make_unsigned(mnField) <= nC;
 462 }
 463
 464 ScDBQueryParamMatrix::~ScDBQueryParamMatrix()
 465 {
 466 }
 467
 468 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */