Line data Source code
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 "queryparam.hxx"
21 : #include "queryentry.hxx"
22 : #include "scmatrix.hxx"
23 :
24 : #include <svl/sharedstringpool.hxx>
25 :
26 : namespace {
27 :
28 : const size_t MAXQUERY = 8;
29 :
30 : class FindByField : public std::unary_function<ScQueryEntry, bool>
31 : {
32 : SCCOLROW mnField;
33 : public:
34 6 : FindByField(SCCOLROW nField) : mnField(nField) {}
35 34 : bool operator() (const ScQueryEntry& rEntry) const
36 : {
37 34 : return rEntry.bDoQuery && rEntry.nField == mnField;
38 : }
39 : };
40 :
41 : struct FindUnused : public std::unary_function<ScQueryEntry, bool>
42 : {
43 20 : bool operator() (const ScQueryEntry& rEntry) const
44 : {
45 20 : return !rEntry.bDoQuery;
46 : }
47 : };
48 :
49 : }
50 :
51 1494 : ScQueryParamBase::const_iterator ScQueryParamBase::begin() const
52 : {
53 1494 : return maEntries.begin();
54 : }
55 :
56 1494 : ScQueryParamBase::const_iterator ScQueryParamBase::end() const
57 : {
58 1494 : return maEntries.end();
59 : }
60 :
61 1077 : ScQueryParamBase::ScQueryParamBase() :
62 : bHasHeader(true),
63 : bByRow(true),
64 : bInplace(true),
65 : bCaseSens(false),
66 : bRegExp(false),
67 : bDuplicate(false),
68 1077 : mbRangeLookup(false)
69 : {
70 9693 : for (size_t i = 0; i < MAXQUERY; ++i)
71 8616 : maEntries.push_back(new ScQueryEntry);
72 1077 : }
73 :
74 2552 : ScQueryParamBase::ScQueryParamBase(const ScQueryParamBase& r) :
75 : bHasHeader(r.bHasHeader), bByRow(r.bByRow), bInplace(r.bInplace), bCaseSens(r.bCaseSens),
76 : bRegExp(r.bRegExp), bDuplicate(r.bDuplicate), mbRangeLookup(r.mbRangeLookup),
77 2552 : maEntries(r.maEntries)
78 : {
79 2552 : }
80 :
81 3569 : ScQueryParamBase::~ScQueryParamBase()
82 : {
83 3569 : }
84 :
85 0 : bool ScQueryParamBase::IsValidFieldIndex() const
86 : {
87 0 : return true;
88 : }
89 :
90 5759 : SCSIZE ScQueryParamBase::GetEntryCount() const
91 : {
92 5759 : return maEntries.size();
93 : }
94 :
95 4976 : const ScQueryEntry& ScQueryParamBase::GetEntry(SCSIZE n) const
96 : {
97 4976 : return maEntries[n];
98 : }
99 :
100 12882 : ScQueryEntry& ScQueryParamBase::GetEntry(SCSIZE n)
101 : {
102 12882 : return maEntries[n];
103 : }
104 :
105 18 : ScQueryEntry& ScQueryParamBase::AppendEntry()
106 : {
107 : // Find the first unused entry.
108 : EntriesType::iterator itr = std::find_if(
109 18 : maEntries.begin(), maEntries.end(), FindUnused());
110 :
111 18 : if (itr != maEntries.end())
112 : // Found!
113 18 : return *itr;
114 :
115 : // Add a new entry to the end.
116 0 : maEntries.push_back(new ScQueryEntry);
117 0 : return maEntries.back();
118 : }
119 :
120 0 : ScQueryEntry* ScQueryParamBase::FindEntryByField(SCCOLROW nField, bool bNew)
121 : {
122 : EntriesType::iterator itr = std::find_if(
123 0 : maEntries.begin(), maEntries.end(), FindByField(nField));
124 :
125 0 : if (itr != maEntries.end())
126 : {
127 : // existing entry found!
128 0 : return &(*itr);
129 : }
130 :
131 0 : if (!bNew)
132 : // no existing entry found, and we are not creating a new one.
133 0 : return NULL;
134 :
135 0 : return &AppendEntry();
136 : }
137 :
138 6 : void ScQueryParamBase::RemoveEntryByField(SCCOLROW nField)
139 : {
140 : EntriesType::iterator itr = std::find_if(
141 6 : maEntries.begin(), maEntries.end(), FindByField(nField));
142 :
143 6 : if (itr != maEntries.end())
144 : {
145 2 : maEntries.erase(itr);
146 2 : if (maEntries.size() < MAXQUERY)
147 : // Make sure that we have at least MAXQUERY number of entries at
148 : // all times.
149 2 : maEntries.push_back(new ScQueryEntry);
150 : }
151 6 : }
152 :
153 106 : void ScQueryParamBase::Resize(size_t nNew)
154 : {
155 106 : if (nNew < MAXQUERY)
156 76 : nNew = MAXQUERY; // never less than MAXQUERY
157 :
158 106 : if (nNew < maEntries.size())
159 : {
160 18 : size_t n = maEntries.size() - nNew;
161 54 : for (size_t i = 0; i < n; ++i)
162 36 : maEntries.pop_back();
163 : }
164 88 : else if (nNew > maEntries.size())
165 : {
166 28 : size_t n = nNew - maEntries.size();
167 116 : for (size_t i = 0; i < n; ++i)
168 88 : maEntries.push_back(new ScQueryEntry);
169 : }
170 106 : }
171 :
172 84 : void ScQueryParamBase::FillInExcelSyntax(
173 : svl::SharedStringPool& rPool, const OUString& rStr, SCSIZE nIndex)
174 : {
175 84 : const OUString aCellStr = rStr;
176 84 : if (nIndex >= maEntries.size())
177 0 : Resize(nIndex+1);
178 :
179 84 : ScQueryEntry& rEntry = GetEntry(nIndex);
180 84 : ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
181 :
182 84 : if (aCellStr.isEmpty())
183 2 : rItem.maString = svl::SharedString::getEmptyString();
184 : else
185 : {
186 82 : rEntry.bDoQuery = true;
187 : // Operatoren herausfiltern
188 82 : if (aCellStr[0] == '<')
189 : {
190 2 : if (aCellStr[1] == '>')
191 : {
192 0 : rItem.maString = rPool.intern(aCellStr.copy(2));
193 0 : rEntry.eOp = SC_NOT_EQUAL;
194 : }
195 2 : else if (aCellStr[1] == '=')
196 : {
197 0 : rItem.maString = rPool.intern(aCellStr.copy(2));
198 0 : rEntry.eOp = SC_LESS_EQUAL;
199 : }
200 : else
201 : {
202 2 : rItem.maString = rPool.intern(aCellStr.copy(1));
203 2 : rEntry.eOp = SC_LESS;
204 : }
205 : }
206 80 : else if (aCellStr[0]== '>')
207 : {
208 28 : if (aCellStr[1] == '=')
209 : {
210 14 : rItem.maString = rPool.intern(aCellStr.copy(2));
211 14 : rEntry.eOp = SC_GREATER_EQUAL;
212 : }
213 : else
214 : {
215 14 : rItem.maString = rPool.intern(aCellStr.copy(1));
216 14 : rEntry.eOp = SC_GREATER;
217 : }
218 : }
219 : else
220 : {
221 52 : if (aCellStr[0] == '=')
222 0 : rItem.maString = rPool.intern(aCellStr.copy(1));
223 : else
224 52 : rItem.maString = rPool.intern(aCellStr);
225 52 : rEntry.eOp = SC_EQUAL;
226 : }
227 84 : }
228 84 : }
229 :
230 1077 : ScQueryParamTable::ScQueryParamTable() :
231 1077 : nCol1(0),nRow1(0),nCol2(0),nRow2(0),nTab(0)
232 : {
233 1077 : }
234 :
235 2552 : ScQueryParamTable::ScQueryParamTable(const ScQueryParamTable& r) :
236 2552 : nCol1(r.nCol1),nRow1(r.nRow1),nCol2(r.nCol2),nRow2(r.nRow2),nTab(r.nTab)
237 : {
238 2552 : }
239 :
240 3569 : ScQueryParamTable::~ScQueryParamTable()
241 : {
242 3569 : }
243 :
244 1037 : ScQueryParam::ScQueryParam() :
245 : ScQueryParamBase(),
246 : ScQueryParamTable(),
247 : bDestPers(true),
248 : nDestTab(0),
249 : nDestCol(0),
250 1037 : nDestRow(0)
251 : {
252 1037 : Clear();
253 1037 : }
254 :
255 2296 : ScQueryParam::ScQueryParam( const ScQueryParam& r ) :
256 : ScQueryParamBase(r),
257 : ScQueryParamTable(r),
258 2296 : bDestPers(r.bDestPers), nDestTab(r.nDestTab), nDestCol(r.nDestCol), nDestRow(r.nDestRow)
259 : {
260 2296 : }
261 :
262 256 : ScQueryParam::ScQueryParam( const ScDBQueryParamInternal& r ) :
263 : ScQueryParamBase(r),
264 : ScQueryParamTable(r),
265 : bDestPers(true),
266 : nDestTab(0),
267 : nDestCol(0),
268 256 : nDestRow(0)
269 : {
270 256 : }
271 :
272 5012 : ScQueryParam::~ScQueryParam()
273 : {
274 5012 : }
275 :
276 1037 : void ScQueryParam::Clear()
277 : {
278 1037 : nCol1=nCol2 = 0;
279 1037 : nRow1=nRow2 = 0;
280 1037 : nTab = SCTAB_MAX;
281 1037 : bHasHeader = bCaseSens = bRegExp = false;
282 1037 : bInplace = bByRow = bDuplicate = true;
283 :
284 1037 : boost::ptr_vector<ScQueryEntry>::iterator itr = maEntries.begin(), itrEnd = maEntries.end();
285 9333 : for (; itr != itrEnd; ++itr)
286 8296 : itr->Clear();
287 :
288 1037 : ClearDestParams();
289 1037 : }
290 :
291 1037 : void ScQueryParam::ClearDestParams()
292 : {
293 1037 : bDestPers = true;
294 1037 : nDestTab = 0;
295 1037 : nDestCol = 0;
296 1037 : nDestRow = 0;
297 1037 : }
298 :
299 793 : ScQueryParam& ScQueryParam::operator=( const ScQueryParam& r )
300 : {
301 793 : nCol1 = r.nCol1;
302 793 : nRow1 = r.nRow1;
303 793 : nCol2 = r.nCol2;
304 793 : nRow2 = r.nRow2;
305 793 : nTab = r.nTab;
306 793 : nDestTab = r.nDestTab;
307 793 : nDestCol = r.nDestCol;
308 793 : nDestRow = r.nDestRow;
309 793 : bHasHeader = r.bHasHeader;
310 793 : bInplace = r.bInplace;
311 793 : bCaseSens = r.bCaseSens;
312 793 : bRegExp = r.bRegExp;
313 793 : bDuplicate = r.bDuplicate;
314 793 : bByRow = r.bByRow;
315 793 : bDestPers = r.bDestPers;
316 :
317 793 : maEntries = r.maEntries.clone();
318 :
319 793 : return *this;
320 : }
321 :
322 4 : bool ScQueryParam::operator==( const ScQueryParam& rOther ) const
323 : {
324 4 : bool bEqual = false;
325 :
326 : // Anzahl der Queries gleich?
327 4 : SCSIZE nUsed = 0;
328 4 : SCSIZE nOtherUsed = 0;
329 4 : SCSIZE nEntryCount = GetEntryCount();
330 4 : SCSIZE nOtherEntryCount = rOther.GetEntryCount();
331 :
332 4 : while ( nUsed<nEntryCount && maEntries[nUsed].bDoQuery ) ++nUsed;
333 8 : while ( nOtherUsed<nOtherEntryCount && rOther.maEntries[nOtherUsed].bDoQuery )
334 0 : ++nOtherUsed;
335 :
336 4 : if ( (nUsed == nOtherUsed)
337 0 : && (nCol1 == rOther.nCol1)
338 0 : && (nRow1 == rOther.nRow1)
339 0 : && (nCol2 == rOther.nCol2)
340 0 : && (nRow2 == rOther.nRow2)
341 0 : && (nTab == rOther.nTab)
342 0 : && (bHasHeader == rOther.bHasHeader)
343 0 : && (bByRow == rOther.bByRow)
344 0 : && (bInplace == rOther.bInplace)
345 0 : && (bCaseSens == rOther.bCaseSens)
346 0 : && (bRegExp == rOther.bRegExp)
347 0 : && (bDuplicate == rOther.bDuplicate)
348 0 : && (bDestPers == rOther.bDestPers)
349 0 : && (nDestTab == rOther.nDestTab)
350 0 : && (nDestCol == rOther.nDestCol)
351 0 : && (nDestRow == rOther.nDestRow) )
352 : {
353 0 : bEqual = true;
354 0 : for ( SCSIZE i=0; i<nUsed && bEqual; i++ )
355 0 : bEqual = maEntries[i] == rOther.maEntries[i];
356 : }
357 4 : return bEqual;
358 : }
359 :
360 0 : void ScQueryParam::MoveToDest()
361 : {
362 0 : if (!bInplace)
363 : {
364 0 : SCsCOL nDifX = ((SCsCOL) nDestCol) - ((SCsCOL) nCol1);
365 0 : SCsROW nDifY = ((SCsROW) nDestRow) - ((SCsROW) nRow1);
366 0 : SCsTAB nDifZ = ((SCsTAB) nDestTab) - ((SCsTAB) nTab);
367 :
368 0 : nCol1 = sal::static_int_cast<SCCOL>( nCol1 + nDifX );
369 0 : nRow1 = sal::static_int_cast<SCROW>( nRow1 + nDifY );
370 0 : nCol2 = sal::static_int_cast<SCCOL>( nCol2 + nDifX );
371 0 : nRow2 = sal::static_int_cast<SCROW>( nRow2 + nDifY );
372 0 : nTab = sal::static_int_cast<SCTAB>( nTab + nDifZ );
373 0 : size_t n = maEntries.size();
374 0 : for (size_t i=0; i<n; i++)
375 0 : maEntries[i].nField += nDifX;
376 :
377 0 : bInplace = true;
378 : }
379 : else
380 : {
381 : OSL_FAIL("MoveToDest, bInplace == TRUE");
382 : }
383 0 : }
384 :
385 40 : ScDBQueryParamBase::ScDBQueryParamBase(DataType eType) :
386 : ScQueryParamBase(),
387 : mnField(-1),
388 : mbSkipString(true),
389 40 : meType(eType)
390 : {
391 40 : }
392 :
393 40 : ScDBQueryParamBase::~ScDBQueryParamBase()
394 : {
395 40 : }
396 :
397 40 : ScDBQueryParamInternal::ScDBQueryParamInternal() :
398 : ScDBQueryParamBase(ScDBQueryParamBase::INTERNAL),
399 40 : ScQueryParamTable()
400 : {
401 40 : }
402 :
403 80 : ScDBQueryParamInternal::~ScDBQueryParamInternal()
404 : {
405 80 : }
406 :
407 28 : bool ScDBQueryParamInternal::IsValidFieldIndex() const
408 : {
409 28 : return nCol1 <= mnField && mnField <= nCol2;
410 : }
411 :
412 0 : ScDBQueryParamMatrix::ScDBQueryParamMatrix() :
413 0 : ScDBQueryParamBase(ScDBQueryParamBase::MATRIX)
414 : {
415 0 : }
416 :
417 0 : bool ScDBQueryParamMatrix::IsValidFieldIndex() const
418 : {
419 : SCSIZE nC, nR;
420 0 : mpMatrix->GetDimensions(nC, nR);
421 0 : return 0 <= mnField && mnField <= static_cast<SCCOL>(nC);
422 : }
423 :
424 0 : ScDBQueryParamMatrix::~ScDBQueryParamMatrix()
425 : {
426 228 : }
427 :
428 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
