Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*************************************************************************
3 : : *
4 : : * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 : : *
6 : : * Copyright 2008 by Sun Microsystems, Inc.
7 : : *
8 : : * OpenOffice.org - a multi-platform office productivity suite
9 : : *
10 : : * This file is part of OpenOffice.org.
11 : : *
12 : : * OpenOffice.org is free software: you can redistribute it and/or modify
13 : : * it under the terms of the GNU Lesser General Public License version 3
14 : : * only, as published by the Free Software Foundation.
15 : : *
16 : : * OpenOffice.org is distributed in the hope that it will be useful,
17 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 : : * GNU Lesser General Public License version 3 for more details
20 : : * (a copy is included in the LICENSE file that accompanied this code).
21 : : *
22 : : * You should have received a copy of the GNU Lesser General Public License
23 : : * version 3 along with OpenOffice.org. If not, see
24 : : * <http://www.openoffice.org/license.html>
25 : : * for a copy of the LGPLv3 License.
26 : : *
27 : : ************************************************************************/
28 : :
29 : : #include "queryparam.hxx"
30 : : #include "queryentry.hxx"
31 : :
32 : : namespace {
33 : :
34 : : const size_t MAXQUERY = 8;
35 : :
36 : : class FindByField : public std::unary_function<ScQueryEntry, bool>
37 : : {
38 : : SCCOLROW mnField;
39 : : public:
40 : 0 : FindByField(SCCOLROW nField) : mnField(nField) {}
41 : 0 : bool operator() (const ScQueryEntry& rEntry) const
42 : : {
43 [ # # ][ # # ]: 0 : return rEntry.bDoQuery && rEntry.nField == mnField;
44 : : }
45 : : };
46 : :
47 : : struct FindUnused : public std::unary_function<ScQueryEntry, bool>
48 : : {
49 : 35 : bool operator() (const ScQueryEntry& rEntry) const
50 : : {
51 : 35 : return !rEntry.bDoQuery;
52 : : }
53 : : };
54 : :
55 : : }
56 : :
57 : 1709 : ScQueryParamBase::const_iterator ScQueryParamBase::begin() const
58 : : {
59 : 1709 : return maEntries.begin();
60 : : }
61 : :
62 : 1709 : ScQueryParamBase::const_iterator ScQueryParamBase::end() const
63 : : {
64 : 1709 : return maEntries.end();
65 : : }
66 : :
67 : 927 : ScQueryParamBase::ScQueryParamBase() :
68 : : bHasHeader(true),
69 : : bByRow(true),
70 : : bInplace(true),
71 : : bCaseSens(false),
72 : : bRegExp(false),
73 : 927 : bDuplicate(false)
74 : : {
75 [ + + ]: 8343 : for (size_t i = 0; i < MAXQUERY; ++i)
76 [ + - ][ + - ]: 7416 : maEntries.push_back(new ScQueryEntry);
[ + - ]
77 : 927 : }
78 : :
79 : 2019 : ScQueryParamBase::ScQueryParamBase(const ScQueryParamBase& r) :
80 : : bHasHeader(r.bHasHeader), bByRow(r.bByRow), bInplace(r.bInplace), bCaseSens(r.bCaseSens),
81 : : bRegExp(r.bRegExp), bDuplicate(r.bDuplicate),
82 : 2019 : maEntries(r.maEntries)
83 : : {
84 : 2019 : }
85 : :
86 : 2901 : ScQueryParamBase::~ScQueryParamBase()
87 : : {
88 [ - + ]: 2901 : }
89 : :
90 : 0 : bool ScQueryParamBase::IsValidFieldIndex() const
91 : : {
92 : 0 : return true;
93 : : }
94 : :
95 : 8225 : SCSIZE ScQueryParamBase::GetEntryCount() const
96 : : {
97 : 8225 : return maEntries.size();
98 : : }
99 : :
100 : 10268 : const ScQueryEntry& ScQueryParamBase::GetEntry(SCSIZE n) const
101 : : {
102 : 10268 : return maEntries[n];
103 : : }
104 : :
105 : 9630 : ScQueryEntry& ScQueryParamBase::GetEntry(SCSIZE n)
106 : : {
107 : 9630 : return maEntries[n];
108 : : }
109 : :
110 : 33 : ScQueryEntry& ScQueryParamBase::AppendEntry()
111 : : {
112 : : // Find the first unused entry.
113 : : EntriesType::iterator itr = std::find_if(
114 [ + - ][ + - ]: 33 : maEntries.begin(), maEntries.end(), FindUnused());
[ + - ]
115 : :
116 [ + - ][ + - ]: 33 : if (itr != maEntries.end())
[ + - ]
117 : : // Found!
118 [ + - ]: 33 : return *itr;
119 : :
120 : : // Add a new entry to the end.
121 [ # # ][ # # ]: 0 : maEntries.push_back(new ScQueryEntry);
[ # # ]
122 [ # # ]: 33 : return maEntries.back();
123 : : }
124 : :
125 : 0 : ScQueryEntry* ScQueryParamBase::FindEntryByField(SCCOLROW nField, bool bNew)
126 : : {
127 : : EntriesType::iterator itr = std::find_if(
128 [ # # ][ # # ]: 0 : maEntries.begin(), maEntries.end(), FindByField(nField));
[ # # ]
129 : :
130 [ # # ][ # # ]: 0 : if (itr != maEntries.end())
[ # # ]
131 : : {
132 : : // existing entry found!
133 [ # # ]: 0 : return &(*itr);
134 : : }
135 : :
136 [ # # ]: 0 : if (!bNew)
137 : : // no existing entry found, and we are not creating a new one.
138 : 0 : return NULL;
139 : :
140 [ # # ]: 0 : return &AppendEntry();
141 : : }
142 : :
143 : 0 : void ScQueryParamBase::RemoveEntryByField(SCCOLROW nField)
144 : : {
145 : : EntriesType::iterator itr = std::find_if(
146 [ # # ][ # # ]: 0 : maEntries.begin(), maEntries.end(), FindByField(nField));
[ # # ]
147 : :
148 [ # # ][ # # ]: 0 : if (itr != maEntries.end())
[ # # ]
149 : : {
150 [ # # ]: 0 : maEntries.erase(itr);
151 [ # # ]: 0 : if (maEntries.size() < MAXQUERY)
152 : : // Make sure that we have at least MAXQUERY number of entries at
153 : : // all times.
154 [ # # ][ # # ]: 0 : maEntries.push_back(new ScQueryEntry);
[ # # ]
155 : : }
156 : 0 : }
157 : :
158 : 59 : void ScQueryParamBase::Resize(size_t nNew)
159 : : {
160 [ + - ]: 59 : if (nNew < MAXQUERY)
161 : 59 : nNew = MAXQUERY; // never less than MAXQUERY
162 : :
163 [ - + ]: 59 : if (nNew < maEntries.size())
164 : : {
165 : 0 : size_t n = maEntries.size() - nNew;
166 [ # # ]: 0 : for (size_t i = 0; i < n; ++i)
167 : 0 : maEntries.pop_back();
168 : : }
169 [ - + ]: 59 : else if (nNew > maEntries.size())
170 : : {
171 : 0 : size_t n = nNew - maEntries.size();
172 [ # # ]: 0 : for (size_t i = 0; i < n; ++i)
173 [ # # ]: 0 : maEntries.push_back(new ScQueryEntry);
174 : : }
175 : 59 : }
176 : :
177 : 123 : void ScQueryParamBase::FillInExcelSyntax(const rtl::OUString& rStr, SCSIZE nIndex)
178 : : {
179 [ + - ]: 123 : const String aCellStr = rStr;
180 [ + - ]: 123 : if (aCellStr.Len() > 0)
181 : : {
182 [ - + ]: 123 : if ( nIndex >= maEntries.size() )
183 [ # # ]: 0 : Resize( nIndex+1 );
184 : :
185 [ + - ]: 123 : ScQueryEntry& rEntry = GetEntry(nIndex);
186 [ + - ]: 123 : ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
187 : :
188 : 123 : rEntry.bDoQuery = sal_True;
189 : : // Operatoren herausfiltern
190 [ + + ]: 123 : if (aCellStr.GetChar(0) == '<')
191 : : {
192 [ - + ]: 10 : if (aCellStr.GetChar(1) == '>')
193 : : {
194 [ # # ][ # # ]: 0 : rItem.maString = aCellStr.Copy(2);
[ # # ]
195 : 0 : rEntry.eOp = SC_NOT_EQUAL;
196 : : }
197 [ - + ]: 10 : else if (aCellStr.GetChar(1) == '=')
198 : : {
199 [ # # ][ # # ]: 0 : rItem.maString = aCellStr.Copy(2);
[ # # ]
200 : 0 : rEntry.eOp = SC_LESS_EQUAL;
201 : : }
202 : : else
203 : : {
204 [ + - ][ + - ]: 10 : rItem.maString = aCellStr.Copy(1);
[ + - ]
205 : 10 : rEntry.eOp = SC_LESS;
206 : : }
207 : : }
208 [ + + ]: 113 : else if (aCellStr.GetChar(0) == '>')
209 : : {
210 [ + + ]: 80 : if (aCellStr.GetChar(1) == '=')
211 : : {
212 [ + - ][ + - ]: 40 : rItem.maString = aCellStr.Copy(2);
[ + - ]
213 : 40 : rEntry.eOp = SC_GREATER_EQUAL;
214 : : }
215 : : else
216 : : {
217 [ + - ][ + - ]: 40 : rItem.maString = aCellStr.Copy(1);
[ + - ]
218 : 40 : rEntry.eOp = SC_GREATER;
219 : : }
220 : : }
221 : : else
222 : : {
223 [ - + ]: 33 : if (aCellStr.GetChar(0) == '=')
224 [ # # ][ # # ]: 0 : rItem.maString = aCellStr.Copy(1);
[ # # ]
225 : : else
226 [ + - ]: 33 : rItem.maString = aCellStr;
227 : 33 : rEntry.eOp = SC_EQUAL;
228 : : }
229 [ + - ]: 123 : }
230 : 123 : }
231 : :
232 : : // ============================================================================
233 : :
234 : 927 : ScQueryParamTable::ScQueryParamTable()
235 : : {
236 : 927 : }
237 : :
238 : 2019 : ScQueryParamTable::ScQueryParamTable(const ScQueryParamTable& r) :
239 : 2019 : nCol1(r.nCol1),nRow1(r.nRow1),nCol2(r.nCol2),nRow2(r.nRow2),nTab(r.nTab)
240 : : {
241 : 2019 : }
242 : :
243 : 2901 : ScQueryParamTable::~ScQueryParamTable()
244 : : {
245 [ - + ]: 2901 : }
246 : :
247 : : // ============================================================================
248 : :
249 : 887 : ScQueryParam::ScQueryParam() :
250 : : ScQueryParamBase(),
251 : : ScQueryParamTable(),
252 : : bDestPers(true),
253 : : nDestTab(0),
254 : : nDestCol(0),
255 : 887 : nDestRow(0)
256 : : {
257 [ + - ]: 887 : Clear();
258 : 887 : }
259 : :
260 : : //------------------------------------------------------------------------
261 : :
262 : 1879 : ScQueryParam::ScQueryParam( const ScQueryParam& r ) :
263 : : ScQueryParamBase(r),
264 : : ScQueryParamTable(r),
265 : 1879 : bDestPers(r.bDestPers), nDestTab(r.nDestTab), nDestCol(r.nDestCol), nDestRow(r.nDestRow)
266 : : {
267 : 1879 : }
268 : :
269 : 140 : ScQueryParam::ScQueryParam( const ScDBQueryParamInternal& r ) :
270 : : ScQueryParamBase(r),
271 : : ScQueryParamTable(r),
272 : : bDestPers(true),
273 : : nDestTab(0),
274 : : nDestCol(0),
275 : 140 : nDestRow(0)
276 : : {
277 : 140 : }
278 : :
279 : :
280 : : //------------------------------------------------------------------------
281 : :
282 : 2861 : ScQueryParam::~ScQueryParam()
283 : : {
284 [ - + ]: 4166 : }
285 : :
286 : : //------------------------------------------------------------------------
287 : :
288 : 887 : void ScQueryParam::Clear()
289 : : {
290 : 887 : nCol1=nCol2 = 0;
291 : 887 : nRow1=nRow2 = 0;
292 : 887 : nTab = SCTAB_MAX;
293 : 887 : bHasHeader = bCaseSens = bRegExp = false;
294 : 887 : bInplace = bByRow = bDuplicate = sal_True;
295 : :
296 [ + - ][ + - ]: 887 : boost::ptr_vector<ScQueryEntry>::iterator itr = maEntries.begin(), itrEnd = maEntries.end();
297 [ + - ][ + - ]: 7983 : for (; itr != itrEnd; ++itr)
[ + + ]
298 [ + - ][ + - ]: 7096 : itr->Clear();
299 : :
300 [ + - ]: 887 : ClearDestParams();
301 : 887 : }
302 : :
303 : 887 : void ScQueryParam::ClearDestParams()
304 : : {
305 : 887 : bDestPers = true;
306 : 887 : nDestTab = 0;
307 : 887 : nDestCol = 0;
308 : 887 : nDestRow = 0;
309 : 887 : }
310 : :
311 : : //------------------------------------------------------------------------
312 : :
313 : 470 : ScQueryParam& ScQueryParam::operator=( const ScQueryParam& r )
314 : : {
315 : 470 : nCol1 = r.nCol1;
316 : 470 : nRow1 = r.nRow1;
317 : 470 : nCol2 = r.nCol2;
318 : 470 : nRow2 = r.nRow2;
319 : 470 : nTab = r.nTab;
320 : 470 : nDestTab = r.nDestTab;
321 : 470 : nDestCol = r.nDestCol;
322 : 470 : nDestRow = r.nDestRow;
323 : 470 : bHasHeader = r.bHasHeader;
324 : 470 : bInplace = r.bInplace;
325 : 470 : bCaseSens = r.bCaseSens;
326 : 470 : bRegExp = r.bRegExp;
327 : 470 : bDuplicate = r.bDuplicate;
328 : 470 : bByRow = r.bByRow;
329 : 470 : bDestPers = r.bDestPers;
330 : :
331 [ + - ][ + - ]: 470 : maEntries = r.maEntries.clone();
332 : :
333 : 470 : return *this;
334 : : }
335 : :
336 : : //------------------------------------------------------------------------
337 : :
338 : 6 : bool ScQueryParam::operator==( const ScQueryParam& rOther ) const
339 : : {
340 : 6 : bool bEqual = false;
341 : :
342 : : // Anzahl der Queries gleich?
343 : 6 : SCSIZE nUsed = 0;
344 : 6 : SCSIZE nOtherUsed = 0;
345 : 6 : SCSIZE nEntryCount = GetEntryCount();
346 : 6 : SCSIZE nOtherEntryCount = rOther.GetEntryCount();
347 : :
348 [ + - ][ + + ]: 13 : while ( nUsed<nEntryCount && maEntries[nUsed].bDoQuery ) ++nUsed;
[ + + ]
349 [ + - ][ - + ]: 6 : while ( nOtherUsed<nOtherEntryCount && rOther.maEntries[nOtherUsed].bDoQuery )
[ - + ]
350 : 0 : ++nOtherUsed;
351 : :
352 [ - + ][ # # ]: 6 : if ( (nUsed == nOtherUsed)
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
353 : : && (nCol1 == rOther.nCol1)
354 : : && (nRow1 == rOther.nRow1)
355 : : && (nCol2 == rOther.nCol2)
356 : : && (nRow2 == rOther.nRow2)
357 : : && (nTab == rOther.nTab)
358 : : && (bHasHeader == rOther.bHasHeader)
359 : : && (bByRow == rOther.bByRow)
360 : : && (bInplace == rOther.bInplace)
361 : : && (bCaseSens == rOther.bCaseSens)
362 : : && (bRegExp == rOther.bRegExp)
363 : : && (bDuplicate == rOther.bDuplicate)
364 : : && (bDestPers == rOther.bDestPers)
365 : : && (nDestTab == rOther.nDestTab)
366 : : && (nDestCol == rOther.nDestCol)
367 : : && (nDestRow == rOther.nDestRow) )
368 : : {
369 : 0 : bEqual = true;
370 [ # # ][ # # ]: 0 : for ( SCSIZE i=0; i<nUsed && bEqual; i++ )
[ # # ]
371 : 0 : bEqual = maEntries[i] == rOther.maEntries[i];
372 : : }
373 : 6 : return bEqual;
374 : : }
375 : :
376 : : //------------------------------------------------------------------------
377 : :
378 : 0 : void ScQueryParam::MoveToDest()
379 : : {
380 [ # # ]: 0 : if (!bInplace)
381 : : {
382 : 0 : SCsCOL nDifX = ((SCsCOL) nDestCol) - ((SCsCOL) nCol1);
383 : 0 : SCsROW nDifY = ((SCsROW) nDestRow) - ((SCsROW) nRow1);
384 : 0 : SCsTAB nDifZ = ((SCsTAB) nDestTab) - ((SCsTAB) nTab);
385 : :
386 : 0 : nCol1 = sal::static_int_cast<SCCOL>( nCol1 + nDifX );
387 : 0 : nRow1 = sal::static_int_cast<SCROW>( nRow1 + nDifY );
388 : 0 : nCol2 = sal::static_int_cast<SCCOL>( nCol2 + nDifX );
389 : 0 : nRow2 = sal::static_int_cast<SCROW>( nRow2 + nDifY );
390 : 0 : nTab = sal::static_int_cast<SCTAB>( nTab + nDifZ );
391 : 0 : size_t n = maEntries.size();
392 [ # # ]: 0 : for (size_t i=0; i<n; i++)
393 : 0 : maEntries[i].nField += nDifX;
394 : :
395 : 0 : bInplace = sal_True;
396 : : }
397 : : else
398 : : {
399 : : OSL_FAIL("MoveToDest, bInplace == TRUE");
400 : : }
401 : 0 : }
402 : :
403 : : // ============================================================================
404 : :
405 : 40 : ScDBQueryParamBase::ScDBQueryParamBase(DataType eType) :
406 : : ScQueryParamBase(),
407 : : mnField(-1),
408 : : mbSkipString(true),
409 : 40 : meType(eType)
410 : : {
411 : 40 : }
412 : :
413 : 40 : ScDBQueryParamBase::~ScDBQueryParamBase()
414 : : {
415 [ - + ]: 40 : }
416 : :
417 : 40 : ScDBQueryParamBase::DataType ScDBQueryParamBase::GetType() const
418 : : {
419 : 40 : return meType;
420 : : }
421 : :
422 : : // ============================================================================
423 : :
424 : 40 : ScDBQueryParamInternal::ScDBQueryParamInternal() :
425 : : ScDBQueryParamBase(ScDBQueryParamBase::INTERNAL),
426 : 40 : ScQueryParamTable()
427 : : {
428 : 40 : }
429 : :
430 : 40 : ScDBQueryParamInternal::~ScDBQueryParamInternal()
431 : : {
432 [ - + ]: 80 : }
433 : :
434 : 20 : bool ScDBQueryParamInternal::IsValidFieldIndex() const
435 : : {
436 [ + - ][ + - ]: 20 : return nCol1 <= mnField && mnField <= nCol2;
437 : : }
438 : :
439 : : // ============================================================================
440 : :
441 : 0 : ScDBQueryParamMatrix::ScDBQueryParamMatrix() :
442 : 0 : ScDBQueryParamBase(ScDBQueryParamBase::MATRIX)
443 : : {
444 : 0 : }
445 : :
446 : 0 : bool ScDBQueryParamMatrix::IsValidFieldIndex() const
447 : : {
448 : : SCSIZE nC, nR;
449 [ # # ]: 0 : mpMatrix->GetDimensions(nC, nR);
450 [ # # ][ # # ]: 0 : return 0 <= mnField && mnField <= static_cast<SCCOL>(nC);
451 : : }
452 : :
453 [ # # ]: 0 : ScDBQueryParamMatrix::~ScDBQueryParamMatrix()
454 : : {
455 [ # # ]: 0 : }
456 : :
457 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
