xref: /aoo41x/main/sc/source/core/tool/queryparam.cxx (revision b3f79822)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sc.hxx"
26 
27 // INCLUDE ---------------------------------------------------------------
28 
29 #include "queryparam.hxx"
30 
31 using ::std::vector;
32 
33 // ============================================================================
34 
ScQueryParamBase()35 ScQueryParamBase::ScQueryParamBase()
36 {
37     Resize( MAXQUERY );
38     for (sal_uInt16 i=0; i<MAXQUERY; i++)
39         maEntries[i].Clear();
40 }
41 
ScQueryParamBase(const ScQueryParamBase & r)42 ScQueryParamBase::ScQueryParamBase(const ScQueryParamBase& r) :
43     bHasHeader(r.bHasHeader), bByRow(r.bByRow), bInplace(r.bInplace), bCaseSens(r.bCaseSens),
44     bRegExp(r.bRegExp), bDuplicate(r.bDuplicate), bMixedComparison(r.bMixedComparison),
45     maEntries(r.maEntries)
46 {
47 }
48 
~ScQueryParamBase()49 ScQueryParamBase::~ScQueryParamBase()
50 {
51 }
52 
GetEntryCount() const53 SCSIZE ScQueryParamBase::GetEntryCount() const
54 {
55     return maEntries.size();
56 }
57 
GetEntry(SCSIZE n) const58 ScQueryEntry& ScQueryParamBase::GetEntry(SCSIZE n) const
59 {
60     return maEntries[n];
61 }
62 
Resize(SCSIZE nNew)63 void ScQueryParamBase::Resize(SCSIZE nNew)
64 {
65     if ( nNew < MAXQUERY )
66         nNew = MAXQUERY;                // nie weniger als MAXQUERY
67 
68     vector<ScQueryEntry> aNewEntries(nNew);
69     SCSIZE nCopy = ::std::min(maEntries.size(), nNew);
70     for (SCSIZE i=0; i<nCopy; i++)
71         aNewEntries[i] = maEntries[i];
72 
73     maEntries.swap(aNewEntries);
74 }
75 
DeleteQuery(SCSIZE nPos)76 void ScQueryParamBase::DeleteQuery( SCSIZE nPos )
77 {
78     if (nPos >= maEntries.size())
79         return;
80 
81     size_t n = maEntries.size();
82     vector<ScQueryEntry> aNewEntries;
83     aNewEntries.reserve(n);
84     for (size_t i = 0; i < n; ++i)
85         if (i != nPos)
86             aNewEntries.push_back(maEntries[i]);
87 
88     // Don't forget to append an empty entry to make up for the removed one.
89     // The size of the entries is not supposed to change.
90     aNewEntries.push_back(ScQueryEntry());
91 
92     maEntries.swap(aNewEntries);
93 }
94 
FillInExcelSyntax(String & aCellStr,SCSIZE nIndex)95 void ScQueryParamBase::FillInExcelSyntax(String& aCellStr, SCSIZE nIndex)
96 {
97     if (aCellStr.Len() > 0)
98     {
99         if ( nIndex >= maEntries.size() )
100             Resize( nIndex+1 );
101 
102         ScQueryEntry& rEntry = GetEntry(nIndex);
103 
104         rEntry.bDoQuery = sal_True;
105         // Operatoren herausfiltern
106         if (aCellStr.GetChar(0) == '<')
107         {
108             if (aCellStr.GetChar(1) == '>')
109             {
110                 *rEntry.pStr = aCellStr.Copy(2);
111                 rEntry.eOp   = SC_NOT_EQUAL;
112             }
113             else if (aCellStr.GetChar(1) == '=')
114             {
115                 *rEntry.pStr = aCellStr.Copy(2);
116                 rEntry.eOp   = SC_LESS_EQUAL;
117             }
118             else
119             {
120                 *rEntry.pStr = aCellStr.Copy(1);
121                 rEntry.eOp   = SC_LESS;
122             }
123         }
124         else if (aCellStr.GetChar(0) == '>')
125         {
126             if (aCellStr.GetChar(1) == '=')
127             {
128                 *rEntry.pStr = aCellStr.Copy(2);
129                 rEntry.eOp   = SC_GREATER_EQUAL;
130             }
131             else
132             {
133                 *rEntry.pStr = aCellStr.Copy(1);
134                 rEntry.eOp   = SC_GREATER;
135             }
136         }
137         else
138         {
139             if (aCellStr.GetChar(0) == '=')
140                 *rEntry.pStr = aCellStr.Copy(1);
141             else
142                 *rEntry.pStr = aCellStr;
143             rEntry.eOp = SC_EQUAL;
144         }
145     }
146 }
147 
148 // ============================================================================
149 
ScQueryParamTable()150 ScQueryParamTable::ScQueryParamTable()
151 {
152 }
153 
ScQueryParamTable(const ScQueryParamTable & r)154 ScQueryParamTable::ScQueryParamTable(const ScQueryParamTable& r) :
155     nCol1(r.nCol1),nRow1(r.nRow1),nCol2(r.nCol2),nRow2(r.nRow2),nTab(r.nTab)
156 {
157 }
158 
~ScQueryParamTable()159 ScQueryParamTable::~ScQueryParamTable()
160 {
161 }
162 
163 // ============================================================================
164 
ScQueryParam()165 ScQueryParam::ScQueryParam() :
166     ScQueryParamBase(),
167     ScQueryParamTable(),
168     bDestPers(true),
169     nDestTab(0),
170     nDestCol(0),
171     nDestRow(0)
172 {
173     Clear();
174 }
175 
176 //------------------------------------------------------------------------
177 
ScQueryParam(const ScQueryParam & r)178 ScQueryParam::ScQueryParam( const ScQueryParam& r ) :
179     ScQueryParamBase(r),
180     ScQueryParamTable(r),
181     bDestPers(r.bDestPers), nDestTab(r.nDestTab), nDestCol(r.nDestCol), nDestRow(r.nDestRow)
182 {
183 }
184 
ScQueryParam(const ScDBQueryParamInternal & r)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 {
193 }
194 
195 
196 //------------------------------------------------------------------------
197 
~ScQueryParam()198 ScQueryParam::~ScQueryParam()
199 {
200 }
201 
202 //------------------------------------------------------------------------
203 
Clear()204 void ScQueryParam::Clear()
205 {
206     nCol1=nCol2 = 0;
207     nRow1=nRow2 = 0;
208     nTab = SCTAB_MAX;
209     bHasHeader = bCaseSens = bRegExp = bMixedComparison = sal_False;
210     bInplace = bByRow = bDuplicate = sal_True;
211 
212     Resize( MAXQUERY );
213     for (sal_uInt16 i=0; i<MAXQUERY; i++)
214         maEntries[i].Clear();
215 
216     ClearDestParams();
217 }
218 
ClearDestParams()219 void ScQueryParam::ClearDestParams()
220 {
221     bDestPers = true;
222     nDestTab = 0;
223     nDestCol = 0;
224     nDestRow = 0;
225 }
226 
227 //------------------------------------------------------------------------
228 
operator =(const ScQueryParam & r)229 ScQueryParam& ScQueryParam::operator=( const ScQueryParam& r )
230 {
231     nCol1       = r.nCol1;
232     nRow1       = r.nRow1;
233     nCol2       = r.nCol2;
234     nRow2       = r.nRow2;
235     nTab        = r.nTab;
236     nDestTab    = r.nDestTab;
237     nDestCol    = r.nDestCol;
238     nDestRow    = r.nDestRow;
239     bHasHeader  = r.bHasHeader;
240     bInplace    = r.bInplace;
241     bCaseSens   = r.bCaseSens;
242     bRegExp     = r.bRegExp;
243     bMixedComparison = r.bMixedComparison;
244     bDuplicate  = r.bDuplicate;
245     bByRow      = r.bByRow;
246     bDestPers   = r.bDestPers;
247 
248     maEntries = r.maEntries;
249 
250     return *this;
251 }
252 
253 //------------------------------------------------------------------------
254 
operator ==(const ScQueryParam & rOther) const255 sal_Bool ScQueryParam::operator==( const ScQueryParam& rOther ) const
256 {
257     sal_Bool bEqual = sal_False;
258 
259     // Anzahl der Queries gleich?
260     SCSIZE nUsed      = 0;
261     SCSIZE nOtherUsed = 0;
262     SCSIZE nEntryCount = GetEntryCount();
263     SCSIZE nOtherEntryCount = rOther.GetEntryCount();
264 
265     while ( nUsed<nEntryCount && maEntries[nUsed].bDoQuery ) ++nUsed;
266     while ( nOtherUsed<nOtherEntryCount && rOther.maEntries[nOtherUsed].bDoQuery )
267         ++nOtherUsed;
268 
269     if (   (nUsed       == nOtherUsed)
270         && (nCol1       == rOther.nCol1)
271         && (nRow1       == rOther.nRow1)
272         && (nCol2       == rOther.nCol2)
273         && (nRow2       == rOther.nRow2)
274         && (nTab        == rOther.nTab)
275         && (bHasHeader  == rOther.bHasHeader)
276         && (bByRow      == rOther.bByRow)
277         && (bInplace    == rOther.bInplace)
278         && (bCaseSens   == rOther.bCaseSens)
279         && (bRegExp     == rOther.bRegExp)
280         && (bMixedComparison == rOther.bMixedComparison)
281         && (bDuplicate  == rOther.bDuplicate)
282         && (bDestPers   == rOther.bDestPers)
283         && (nDestTab    == rOther.nDestTab)
284         && (nDestCol    == rOther.nDestCol)
285         && (nDestRow    == rOther.nDestRow) )
286     {
287         bEqual = sal_True;
288         for ( SCSIZE i=0; i<nUsed && bEqual; i++ )
289             bEqual = maEntries[i] == rOther.maEntries[i];
290     }
291     return bEqual;
292 }
293 
294 //------------------------------------------------------------------------
295 
MoveToDest()296 void ScQueryParam::MoveToDest()
297 {
298     if (!bInplace)
299     {
300         SCsCOL nDifX = ((SCsCOL) nDestCol) - ((SCsCOL) nCol1);
301         SCsROW nDifY = ((SCsROW) nDestRow) - ((SCsROW) nRow1);
302         SCsTAB nDifZ = ((SCsTAB) nDestTab) - ((SCsTAB) nTab);
303 
304         nCol1 = sal::static_int_cast<SCCOL>( nCol1 + nDifX );
305         nRow1 = sal::static_int_cast<SCROW>( nRow1 + nDifY );
306         nCol2 = sal::static_int_cast<SCCOL>( nCol2 + nDifX );
307         nRow2 = sal::static_int_cast<SCROW>( nRow2 + nDifY );
308         nTab  = sal::static_int_cast<SCTAB>( nTab  + nDifZ );
309         size_t n = maEntries.size();
310         for (size_t i=0; i<n; i++)
311             maEntries[i].nField += nDifX;
312 
313         bInplace = sal_True;
314     }
315     else
316     {
317         DBG_ERROR("MoveToDest, bInplace == TRUE");
318     }
319 }
320 
321 // ============================================================================
322 
ScDBQueryParamBase(DataType eType)323 ScDBQueryParamBase::ScDBQueryParamBase(DataType eType) :
324     ScQueryParamBase(),
325     mnField(-1),
326     mbSkipString(true),
327     meType(eType)
328 {
329 }
330 
~ScDBQueryParamBase()331 ScDBQueryParamBase::~ScDBQueryParamBase()
332 {
333 }
334 
GetType() const335 ScDBQueryParamBase::DataType ScDBQueryParamBase::GetType() const
336 {
337     return meType;
338 }
339 
340 // ============================================================================
341 
ScDBQueryParamInternal()342 ScDBQueryParamInternal::ScDBQueryParamInternal() :
343     ScDBQueryParamBase(ScDBQueryParamBase::INTERNAL),
344     ScQueryParamTable()
345 {
346 }
347 
~ScDBQueryParamInternal()348 ScDBQueryParamInternal::~ScDBQueryParamInternal()
349 {
350 }
351 
352 // ============================================================================
353 
ScDBQueryParamMatrix()354 ScDBQueryParamMatrix::ScDBQueryParamMatrix() :
355     ScDBQueryParamBase(ScDBQueryParamBase::MATRIX)
356 {
357 }
358 
~ScDBQueryParamMatrix()359 ScDBQueryParamMatrix::~ScDBQueryParamMatrix()
360 {
361 }
362 
363