sc/source/core/tool/queryparam.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: interpr4.cxx,v $
  10  * $Revision: 1.57.92.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33
  34 // INCLUDE ---------------------------------------------------------------
  35
  36 #include "queryparam.hxx"
  37
  38 using ::std::vector;
  39
  40 // ============================================================================
  41
  42 ScQueryParamBase::ScQueryParamBase()
  43 {
  44     Resize( MAXQUERY );
  45     for (USHORT i=0; i<MAXQUERY; i++)
  46         maEntries[i].Clear();
  47 }
  48
  49 ScQueryParamBase::ScQueryParamBase(const ScQueryParamBase& r) :
  50     bHasHeader(r.bHasHeader), bByRow(r.bByRow), bInplace(r.bInplace), bCaseSens(r.bCaseSens),
  51     bRegExp(r.bRegExp), bDuplicate(r.bDuplicate), bMixedComparison(r.bMixedComparison),
  52     maEntries(r.maEntries)
  53 {
  54 }
  55
  56 ScQueryParamBase::~ScQueryParamBase()
  57 {
  58 }
  59
  60 SCSIZE ScQueryParamBase::GetEntryCount() const
  61 {
  62     return maEntries.size();
  63 }
  64
  65 ScQueryEntry& ScQueryParamBase::GetEntry(SCSIZE n) const
  66 {
  67     return maEntries[n];
  68 }
  69
  70 void ScQueryParamBase::Resize(SCSIZE nNew)
  71 {
  72     if ( nNew < MAXQUERY )
  73         nNew = MAXQUERY;                // nie weniger als MAXQUERY
  74
  75     vector<ScQueryEntry> aNewEntries(nNew);
  76     SCSIZE nCopy = ::std::min(maEntries.size(), nNew);
  77     for (SCSIZE i=0; i<nCopy; i++)
  78         aNewEntries[i] = maEntries[i];
  79
  80     maEntries.swap(aNewEntries);
  81 }
  82
  83 void ScQueryParamBase::DeleteQuery( SCSIZE nPos )
  84 {
  85     if (nPos >= maEntries.size())
  86         return;
  87
  88     size_t n = maEntries.size();
  89     vector<ScQueryEntry> aNewEntries;
  90     aNewEntries.reserve(n-1);
  91     for (size_t i = 0; i < n; ++i)
  92         if (i != nPos)
  93             aNewEntries.push_back(maEntries[i]);
  94
  95     maEntries.swap(aNewEntries);
  96 }
  97
  98 void ScQueryParamBase::FillInExcelSyntax(String& aCellStr, SCSIZE nIndex)
  99 {
 100     if (aCellStr.Len() > 0)
 101     {
 102         if ( nIndex >= maEntries.size() )
 103             Resize( nIndex+1 );
 104
 105         ScQueryEntry& rEntry = GetEntry(nIndex);
 106
 107         rEntry.bDoQuery = TRUE;
 108         // Operatoren herausfiltern
 109         if (aCellStr.GetChar(0) == '<')
 110         {
 111             if (aCellStr.GetChar(1) == '>')
 112             {
 113                 *rEntry.pStr = aCellStr.Copy(2);
 114                 rEntry.eOp   = SC_NOT_EQUAL;
 115             }
 116             else if (aCellStr.GetChar(1) == '=')
 117             {
 118                 *rEntry.pStr = aCellStr.Copy(2);
 119                 rEntry.eOp   = SC_LESS_EQUAL;
 120             }
 121             else
 122             {
 123                 *rEntry.pStr = aCellStr.Copy(1);
 124                 rEntry.eOp   = SC_LESS;
 125             }
 126         }
 127         else if (aCellStr.GetChar(0) == '>')
 128         {
 129             if (aCellStr.GetChar(1) == '=')
 130             {
 131                 *rEntry.pStr = aCellStr.Copy(2);
 132                 rEntry.eOp   = SC_GREATER_EQUAL;
 133             }
 134             else
 135             {
 136                 *rEntry.pStr = aCellStr.Copy(1);
 137                 rEntry.eOp   = SC_GREATER;
 138             }
 139         }
 140         else
 141         {
 142             if (aCellStr.GetChar(0) == '=')
 143                 *rEntry.pStr = aCellStr.Copy(1);
 144             else
 145                 *rEntry.pStr = aCellStr;
 146             rEntry.eOp = SC_EQUAL;
 147         }
 148     }
 149 }
 150
 151 // ============================================================================
 152
 153 ScQueryParamTable::ScQueryParamTable()
 154 {
 155 }
 156
 157 ScQueryParamTable::ScQueryParamTable(const ScQueryParamTable& r) :
 158     nCol1(r.nCol1),nRow1(r.nRow1),nCol2(r.nCol2),nRow2(r.nRow2),nTab(r.nTab)
 159 {
 160 }
 161
 162 ScQueryParamTable::~ScQueryParamTable()
 163 {
 164 }
 165
 166 // ============================================================================
 167
 168 ScQueryParam::ScQueryParam() :
 169     ScQueryParamBase(),
 170     ScQueryParamTable()
 171 {
 172     Clear();
 173 }
 174
 175 //------------------------------------------------------------------------
 176
 177 ScQueryParam::ScQueryParam( const ScQueryParam& r ) :
 178     ScQueryParamBase(r),
 179     ScQueryParamTable(r),
 180     bDestPers(r.bDestPers), nDestTab(r.nDestTab), nDestCol(r.nDestCol), nDestRow(r.nDestRow),
 181     nDynamicEndRow(r.nDynamicEndRow), bUseDynamicRange(r.bUseDynamicRange)
 182 {
 183 }
 184
 185 ScQueryParam::ScQueryParam( const ScDBQueryParamInternal& r ) :
 186     ScQueryParamBase(r),
 187     ScQueryParamTable(r),
 188     bDestPers(true),
 189     nDestTab(0),
 190     nDestCol(0),
 191     nDestRow(0),
 192     nDynamicEndRow(0),
 193     bUseDynamicRange(false)
 194 {
 195 }
 196
 197
 198 //------------------------------------------------------------------------
 199
 200 ScQueryParam::~ScQueryParam()
 201 {
 202 }
 203
 204 //------------------------------------------------------------------------
 205
 206 void ScQueryParam::Clear()
 207 {
 208     nCol1=nCol2 = 0;
 209     nRow1=nRow2 = 0;
 210     nTab = SCTAB_MAX;
 211     bHasHeader = bCaseSens = bRegExp = bMixedComparison = FALSE;
 212     bInplace = bByRow = bDuplicate = TRUE;
 213
 214     Resize( MAXQUERY );
 215     for (USHORT i=0; i<MAXQUERY; i++)
 216         maEntries[i].Clear();
 217
 218     ClearDestParams();
 219 }
 220
 221 void ScQueryParam::ClearDestParams()
 222 {
 223     bDestPers = true;
 224     nDestTab = 0;
 225     nDestCol = 0;
 226     nDestRow = 0;
 227     nDynamicEndRow = 0;
 228     bUseDynamicRange = false;
 229 }
 230
 231 //------------------------------------------------------------------------
 232
 233 ScQueryParam& ScQueryParam::operator=( const ScQueryParam& r )
 234 {
 235     nCol1       = r.nCol1;
 236     nRow1       = r.nRow1;
 237     nCol2       = r.nCol2;
 238     nRow2       = r.nRow2;
 239     nTab        = r.nTab;
 240     nDestTab    = r.nDestTab;
 241     nDestCol    = r.nDestCol;
 242     nDestRow    = r.nDestRow;
 243     bHasHeader  = r.bHasHeader;
 244     bInplace    = r.bInplace;
 245     bCaseSens   = r.bCaseSens;
 246     bRegExp     = r.bRegExp;
 247     bMixedComparison = r.bMixedComparison;
 248     bDuplicate  = r.bDuplicate;
 249     bByRow      = r.bByRow;
 250     bDestPers   = r.bDestPers;
 251     nDynamicEndRow = r.nDynamicEndRow;
 252     bUseDynamicRange = r.bUseDynamicRange;
 253
 254     maEntries = r.maEntries;
 255
 256     return *this;
 257 }
 258
 259 //------------------------------------------------------------------------
 260
 261 BOOL ScQueryParam::operator==( const ScQueryParam& rOther ) const
 262 {
 263     BOOL bEqual = FALSE;
 264
 265     // Anzahl der Queries gleich?
 266     SCSIZE nUsed      = 0;
 267     SCSIZE nOtherUsed = 0;
 268     SCSIZE nEntryCount = GetEntryCount();
 269     SCSIZE nOtherEntryCount = rOther.GetEntryCount();
 270
 271     while ( nUsed<nEntryCount && maEntries[nUsed].bDoQuery ) ++nUsed;
 272     while ( nOtherUsed<nOtherEntryCount && rOther.maEntries[nOtherUsed].bDoQuery )
 273         ++nOtherUsed;
 274
 275     if (   (nUsed       == nOtherUsed)
 276         && (nCol1       == rOther.nCol1)
 277         && (nRow1       == rOther.nRow1)
 278         && (nCol2       == rOther.nCol2)
 279         && (nRow2       == rOther.nRow2)
 280         && (nTab        == rOther.nTab)
 281         && (bHasHeader  == rOther.bHasHeader)
 282         && (bByRow      == rOther.bByRow)
 283         && (bInplace    == rOther.bInplace)
 284         && (bCaseSens   == rOther.bCaseSens)
 285         && (bRegExp     == rOther.bRegExp)
 286         && (bMixedComparison == rOther.bMixedComparison)
 287         && (bDuplicate  == rOther.bDuplicate)
 288         && (bDestPers   == rOther.bDestPers)
 289         && (nDestTab    == rOther.nDestTab)
 290         && (nDestCol    == rOther.nDestCol)
 291         && (nDestRow    == rOther.nDestRow)
 292         && (nDynamicEndRow == rOther.nDynamicEndRow)
 293         && (bUseDynamicRange == rOther.bUseDynamicRange) )
 294     {
 295         bEqual = TRUE;
 296         for ( SCSIZE i=0; i<nUsed && bEqual; i++ )
 297             bEqual = maEntries[i] == rOther.maEntries[i];
 298     }
 299     return bEqual;
 300 }
 301
 302 //------------------------------------------------------------------------
 303
 304 void ScQueryParam::MoveToDest()
 305 {
 306     if (!bInplace)
 307     {
 308         SCsCOL nDifX = ((SCsCOL) nDestCol) - ((SCsCOL) nCol1);
 309         SCsROW nDifY = ((SCsROW) nDestRow) - ((SCsROW) nRow1);
 310         SCsTAB nDifZ = ((SCsTAB) nDestTab) - ((SCsTAB) nTab);
 311
 312         nCol1 = sal::static_int_cast<SCCOL>( nCol1 + nDifX );
 313         nRow1 = sal::static_int_cast<SCROW>( nRow1 + nDifY );
 314         nCol2 = sal::static_int_cast<SCCOL>( nCol2 + nDifX );
 315         nRow2 = sal::static_int_cast<SCROW>( nRow2 + nDifY );
 316         nTab  = sal::static_int_cast<SCTAB>( nTab  + nDifZ );
 317         nDynamicEndRow = sal::static_int_cast<SCROW>( nDynamicEndRow + nDifY );
 318         size_t n = maEntries.size();
 319         for (size_t i=0; i<n; i++)
 320             maEntries[i].nField += nDifX;
 321
 322         bInplace = TRUE;
 323     }
 324     else
 325     {
 326         DBG_ERROR("MoveToDest, bInplace == TRUE");
 327     }
 328 }
 329
 330 // ============================================================================
 331
 332 ScDBQueryParamBase::ScDBQueryParamBase(DataType eType) :
 333     ScQueryParamBase(),
 334     mnField(-1),
 335     mbSkipString(true),
 336     meType(eType)
 337 {
 338 }
 339
 340 ScDBQueryParamBase::~ScDBQueryParamBase()
 341 {
 342 }
 343
 344 ScDBQueryParamBase::DataType ScDBQueryParamBase::GetType() const
 345 {
 346     return meType;
 347 }
 348
 349 // ============================================================================
 350
 351 ScDBQueryParamInternal::ScDBQueryParamInternal() :
 352     ScDBQueryParamBase(ScDBQueryParamBase::INTERNAL),
 353     ScQueryParamTable()
 354 {
 355 }
 356
 357 ScDBQueryParamInternal::~ScDBQueryParamInternal()
 358 {
 359 }
 360
 361 // ============================================================================
 362
 363 ScDBQueryParamMatrix::ScDBQueryParamMatrix() :
 364     ScDBQueryParamBase(ScDBQueryParamBase::MATRIX)
 365 {
 366 }
 367
 368 ScDBQueryParamMatrix::~ScDBQueryParamMatrix()
 369 {
 370 }
 371