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
10 #include "xmlimprt.hxx"
11 #include "xmltransformationi.hxx"
12
13 #include <xmloff/xmltoken.hxx>
14 #include <xmloff/xmlnmspe.hxx>
15
16 #include <datamapper.hxx>
17 #include <document.hxx>
18
19 using namespace com::sun::star;
20 using namespace xmloff::token;
21
ScXMLTransformationsContext(ScXMLImport & rImport)22 ScXMLTransformationsContext::ScXMLTransformationsContext(ScXMLImport& rImport)
23 : ScXMLImportContext(rImport)
24 {
25 }
26
~ScXMLTransformationsContext()27 ScXMLTransformationsContext::~ScXMLTransformationsContext() {}
28
29 uno::Reference<xml::sax::XFastContextHandler>
createFastChildContext(sal_Int32 nElement,const uno::Reference<xml::sax::XFastAttributeList> & xAttrList)30 SAL_CALL ScXMLTransformationsContext::createFastChildContext(
31 sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
32 {
33 SvXMLImportContext* pContext = nullptr;
34 sax_fastparser::FastAttributeList* pAttribList
35 = sax_fastparser::FastAttributeList::castToFastAttributeList(xAttrList);
36
37 switch (nElement)
38 {
39 case XML_ELEMENT(CALC_EXT, XML_COLUMN_REMOVE_TRANSFORMATION):
40 {
41 pContext = new ScXMLColumnRemoveContext(GetScImport(), pAttribList);
42 }
43 break;
44 case XML_ELEMENT(CALC_EXT, XML_COLUMN_SPLIT_TRANSFORMATION):
45 {
46 pContext = new ScXMLColumnSplitContext(GetScImport(), pAttribList);
47 }
48 break;
49 case XML_ELEMENT(CALC_EXT, XML_COLUMN_MERGE_TRANSFORMATION):
50 {
51 pContext = new ScXMLColumnMergeContext(GetScImport(), pAttribList);
52 }
53 break;
54 case XML_ELEMENT(CALC_EXT, XML_COLUMN_SORT_TRANSFORMATION):
55 {
56 pContext = new ScXMLColumnSortContext(GetScImport(), pAttribList);
57 }
58 break;
59 case XML_ELEMENT(CALC_EXT, XML_COLUMN_TEXT_TRANSFORMATION):
60 {
61 pContext = new ScXMLColumnTextContext(GetScImport(), pAttribList);
62 }
63 break;
64 case XML_ELEMENT(CALC_EXT, XML_COLUMN_AGGREGATE_TRANSFORMATION):
65 {
66 pContext = new ScXMLColumnAggregateContext(GetScImport(), pAttribList);
67 }
68 break;
69 case XML_ELEMENT(CALC_EXT, XML_COLUMN_NUMBER_TRANSFORMATION):
70 {
71 pContext = new ScXMLColumnNumberContext(GetScImport(), pAttribList);
72 }
73 break;
74 case XML_ELEMENT(CALC_EXT, XML_COLUMN_REPLACENULL_TRANSFORMATION):
75 {
76 pContext = new ScXMLColumnRemoveNullContext(GetScImport(), pAttribList);
77 }
78 break;
79 }
80
81 if (!pContext)
82 pContext = new SvXMLImportContext(GetImport());
83
84 return pContext;
85 }
86
ScXMLColumnRemoveContext(ScXMLImport & rImport,const rtl::Reference<sax_fastparser::FastAttributeList> &)87 ScXMLColumnRemoveContext::ScXMLColumnRemoveContext(
88 ScXMLImport& rImport, const rtl::Reference<sax_fastparser::FastAttributeList>& /*rAttrList*/)
89 : ScXMLImportContext(rImport)
90 {
91 }
92
~ScXMLColumnRemoveContext()93 ScXMLColumnRemoveContext::~ScXMLColumnRemoveContext()
94 {
95 ScDocument* pDoc = GetScImport().GetDocument();
96 auto& rDataSources = pDoc->GetExternalDataMapper().getDataSources();
97 if (!rDataSources.empty())
98 {
99 rDataSources[rDataSources.size() - 1].AddDataTransformation(
100 std::make_shared<sc::ColumnRemoveTransformation>(maColumns));
101 }
102 }
103
104 uno::Reference<xml::sax::XFastContextHandler>
createFastChildContext(sal_Int32 nElement,const uno::Reference<xml::sax::XFastAttributeList> & xAttrList)105 SAL_CALL ScXMLColumnRemoveContext::createFastChildContext(
106 sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
107 {
108 sax_fastparser::FastAttributeList* pAttribList
109 = sax_fastparser::FastAttributeList::castToFastAttributeList(xAttrList);
110
111 const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList = pAttribList;
112
113 switch (nElement)
114 {
115 case XML_ELEMENT(CALC_EXT, XML_COLUMN):
116 {
117 if (rAttrList.is())
118 {
119 for (auto& aIter : *rAttrList)
120 {
121 switch (aIter.getToken())
122 {
123 case XML_ELEMENT(CALC_EXT, XML_COLUMN):
124 {
125 maColumns.insert(aIter.toInt32());
126 }
127 break;
128 }
129 }
130 }
131 }
132 break;
133 }
134
135 return new SvXMLImportContext(GetImport());
136 }
137
ScXMLColumnSplitContext(ScXMLImport & rImport,const rtl::Reference<sax_fastparser::FastAttributeList> & rAttrList)138 ScXMLColumnSplitContext::ScXMLColumnSplitContext(
139 ScXMLImport& rImport, const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList)
140 : ScXMLImportContext(rImport)
141 {
142 SCCOL mnCol = 0;
143 OUString cSeparator;
144
145 if (rAttrList.is())
146 {
147 for (auto& aIter : *rAttrList)
148 {
149 switch (aIter.getToken())
150 {
151 case XML_ELEMENT(CALC_EXT, XML_COLUMN):
152 {
153 mnCol = aIter.toInt32();
154 }
155 break;
156 case XML_ELEMENT(CALC_EXT, XML_SEPARATOR):
157 {
158 cSeparator = aIter.toString();
159 }
160 break;
161 }
162 }
163 }
164
165 if (mnCol > 0)
166 {
167 ScDocument* pDoc = GetScImport().GetDocument();
168 auto& rDataSources = pDoc->GetExternalDataMapper().getDataSources();
169 if (!rDataSources.empty())
170 {
171 rDataSources[rDataSources.size() - 1].AddDataTransformation(
172 std::make_shared<sc::SplitColumnTransformation>(mnCol, cSeparator.toChar()));
173 }
174 }
175 }
176
~ScXMLColumnSplitContext()177 ScXMLColumnSplitContext::~ScXMLColumnSplitContext() {}
178
ScXMLColumnMergeContext(ScXMLImport & rImport,const rtl::Reference<sax_fastparser::FastAttributeList> & rAttrList)179 ScXMLColumnMergeContext::ScXMLColumnMergeContext(
180 ScXMLImport& rImport, const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList)
181 : ScXMLImportContext(rImport)
182 {
183 if (rAttrList.is())
184 {
185 for (auto& aIter : *rAttrList)
186 {
187 switch (aIter.getToken())
188 {
189 case XML_ELEMENT(CALC_EXT, XML_MERGE_STRING):
190 {
191 maMergeString = aIter.toString();
192 }
193 break;
194 }
195 }
196 }
197 }
198
~ScXMLColumnMergeContext()199 ScXMLColumnMergeContext::~ScXMLColumnMergeContext()
200 {
201 ScDocument* pDoc = GetScImport().GetDocument();
202 auto& rDataSources = pDoc->GetExternalDataMapper().getDataSources();
203 if (!rDataSources.empty())
204 {
205 rDataSources[rDataSources.size() - 1].AddDataTransformation(
206 std::make_shared<sc::MergeColumnTransformation>(maColumns, maMergeString));
207 }
208 }
209
210 uno::Reference<xml::sax::XFastContextHandler>
createFastChildContext(sal_Int32 nElement,const uno::Reference<xml::sax::XFastAttributeList> & xAttrList)211 SAL_CALL ScXMLColumnMergeContext::createFastChildContext(
212 sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
213 {
214 sax_fastparser::FastAttributeList* pAttribList
215 = sax_fastparser::FastAttributeList::castToFastAttributeList(xAttrList);
216 const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList = pAttribList;
217 switch (nElement)
218 {
219 case XML_ELEMENT(CALC_EXT, XML_COLUMN):
220 {
221 if (rAttrList.is())
222 {
223 for (auto& aIter : *rAttrList)
224 {
225 switch (aIter.getToken())
226 {
227 case XML_ELEMENT(CALC_EXT, XML_COLUMN):
228 {
229 maColumns.insert(aIter.toInt32());
230 }
231 break;
232 }
233 }
234 }
235 }
236 break;
237 }
238 return new SvXMLImportContext(GetImport());
239 }
240
ScXMLColumnSortContext(ScXMLImport & rImport,const rtl::Reference<sax_fastparser::FastAttributeList> &)241 ScXMLColumnSortContext::ScXMLColumnSortContext(
242 ScXMLImport& rImport, const rtl::Reference<sax_fastparser::FastAttributeList>& /*rAttrList*/)
243 : ScXMLImportContext(rImport)
244 {
245 }
246
~ScXMLColumnSortContext()247 ScXMLColumnSortContext::~ScXMLColumnSortContext() {}
248
249 /*
250 uno::Reference<xml::sax::XFastContextHandler>
251 SAL_CALL ScXMLColumnSortContext::createFastChildContext(
252 sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
253 {
254
255 }
256 */
257
ScXMLColumnTextContext(ScXMLImport & rImport,const rtl::Reference<sax_fastparser::FastAttributeList> & rAttrList)258 ScXMLColumnTextContext::ScXMLColumnTextContext(
259 ScXMLImport& rImport, const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList)
260 : ScXMLImportContext(rImport)
261 , maType(sc::TEXT_TRANSFORM_TYPE::TO_LOWER)
262 {
263 OUString aType;
264
265 if (rAttrList.is())
266 {
267 for (auto& aIter : *rAttrList)
268 {
269 switch (aIter.getToken())
270 {
271 case XML_ELEMENT(CALC_EXT, XML_TYPE):
272 {
273 aType = aIter.toString();
274 }
275 break;
276 }
277 }
278 }
279
280 if (!aType.isEmpty())
281 {
282 if (aType == "lowercase")
283 maType = sc::TEXT_TRANSFORM_TYPE::TO_LOWER;
284 else if (aType == "uppercase")
285 maType = sc::TEXT_TRANSFORM_TYPE::TO_UPPER;
286 else if (aType == "capitalize")
287 maType = sc::TEXT_TRANSFORM_TYPE::CAPITALIZE;
288 else if (aType == "trim")
289 maType = sc::TEXT_TRANSFORM_TYPE::TRIM;
290 }
291 }
292
~ScXMLColumnTextContext()293 ScXMLColumnTextContext::~ScXMLColumnTextContext()
294 {
295 ScDocument* pDoc = GetScImport().GetDocument();
296 auto& rDataSources = pDoc->GetExternalDataMapper().getDataSources();
297 if (!rDataSources.empty())
298 {
299 rDataSources[rDataSources.size() - 1].AddDataTransformation(
300 std::make_shared<sc::TextTransformation>(maColumns, maType));
301 }
302 }
303
304 uno::Reference<xml::sax::XFastContextHandler>
createFastChildContext(sal_Int32 nElement,const uno::Reference<xml::sax::XFastAttributeList> & xAttrList)305 SAL_CALL ScXMLColumnTextContext::createFastChildContext(
306 sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
307 {
308 sax_fastparser::FastAttributeList* pAttribList
309 = sax_fastparser::FastAttributeList::castToFastAttributeList(xAttrList);
310
311 const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList = pAttribList;
312
313 switch (nElement)
314 {
315 case XML_ELEMENT(CALC_EXT, XML_COLUMN):
316 {
317 if (rAttrList.is())
318 {
319 for (auto& aIter : *rAttrList)
320 {
321 switch (aIter.getToken())
322 {
323 case XML_ELEMENT(CALC_EXT, XML_COLUMN):
324 {
325 maColumns.insert(aIter.toInt32());
326 }
327 break;
328 }
329 }
330 }
331 }
332 break;
333 }
334 return new SvXMLImportContext(GetImport());
335 }
336
ScXMLColumnAggregateContext(ScXMLImport & rImport,const rtl::Reference<sax_fastparser::FastAttributeList> & rAttrList)337 ScXMLColumnAggregateContext::ScXMLColumnAggregateContext(
338 ScXMLImport& rImport, const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList)
339 : ScXMLImportContext(rImport)
340 , maType(sc::AGGREGATE_FUNCTION::SUM)
341 {
342 OUString aType;
343
344 if (rAttrList.is())
345 {
346 for (auto& aIter : *rAttrList)
347 {
348 switch (aIter.getToken())
349 {
350 case XML_ELEMENT(CALC_EXT, XML_TYPE):
351 {
352 aType = aIter.toString();
353 }
354 break;
355 }
356 }
357 }
358
359 if (!aType.isEmpty())
360 {
361 if (aType == "sum")
362 maType = sc::AGGREGATE_FUNCTION::SUM;
363 else if (aType == "average")
364 maType = sc::AGGREGATE_FUNCTION::AVERAGE;
365 else if (aType == "min")
366 maType = sc::AGGREGATE_FUNCTION::MIN;
367 else if (aType == "max")
368 maType = sc::AGGREGATE_FUNCTION::MAX;
369 }
370 }
371
~ScXMLColumnAggregateContext()372 ScXMLColumnAggregateContext::~ScXMLColumnAggregateContext()
373 {
374 ScDocument* pDoc = GetScImport().GetDocument();
375 auto& rDataSources = pDoc->GetExternalDataMapper().getDataSources();
376 if (!rDataSources.empty())
377 {
378 rDataSources[rDataSources.size() - 1].AddDataTransformation(
379 std::make_shared<sc::AggregateFunction>(maColumns, maType));
380 }
381 }
382
383 uno::Reference<xml::sax::XFastContextHandler>
createFastChildContext(sal_Int32 nElement,const uno::Reference<xml::sax::XFastAttributeList> & xAttrList)384 SAL_CALL ScXMLColumnAggregateContext::createFastChildContext(
385 sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
386 {
387 sax_fastparser::FastAttributeList* pAttribList
388 = sax_fastparser::FastAttributeList::castToFastAttributeList(xAttrList);
389 const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList = pAttribList;
390
391 switch (nElement)
392 {
393 case XML_ELEMENT(CALC_EXT, XML_COLUMN):
394 {
395 if (rAttrList.is())
396 {
397 for (auto& aIter : *rAttrList)
398 {
399 switch (aIter.getToken())
400 {
401 case XML_ELEMENT(CALC_EXT, XML_COLUMN):
402 {
403 maColumns.insert(aIter.toInt32());
404 }
405 break;
406 }
407 }
408 }
409 }
410 break;
411 }
412 return new SvXMLImportContext(GetImport());
413 }
414
ScXMLColumnNumberContext(ScXMLImport & rImport,const rtl::Reference<sax_fastparser::FastAttributeList> & rAttrList)415 ScXMLColumnNumberContext::ScXMLColumnNumberContext(
416 ScXMLImport& rImport, const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList)
417 : ScXMLImportContext(rImport)
418 , maType(sc::NUMBER_TRANSFORM_TYPE::ROUND)
419 , maPrecision(0)
420 {
421 OUString aType;
422 if (rAttrList.is())
423 {
424 for (auto& aIter : *rAttrList)
425 {
426 switch (aIter.getToken())
427 {
428 case XML_ELEMENT(CALC_EXT, XML_TYPE):
429 {
430 aType = aIter.toString();
431 }
432 break;
433 case XML_ELEMENT(CALC_EXT, XML_PRECISION):
434 {
435 maPrecision = aIter.toInt32();
436 }
437 break;
438 }
439 }
440 }
441
442 if (!aType.isEmpty())
443 {
444 if (aType == "round")
445 maType = sc::NUMBER_TRANSFORM_TYPE::ROUND;
446 else if (aType == "round-up")
447 maType = sc::NUMBER_TRANSFORM_TYPE::ROUND_UP;
448 else if (aType == "round-down")
449 maType = sc::NUMBER_TRANSFORM_TYPE::ROUND_DOWN;
450 else if (aType == "abs")
451 maType = sc::NUMBER_TRANSFORM_TYPE::ABSOLUTE;
452 else if (aType == "log")
453 maType = sc::NUMBER_TRANSFORM_TYPE::LOG_E;
454 else if (aType == "log-base-10")
455 maType = sc::NUMBER_TRANSFORM_TYPE::LOG_10;
456 else if (aType == "cube")
457 maType = sc::NUMBER_TRANSFORM_TYPE::CUBE;
458 else if (aType == "number-square")
459 maType = sc::NUMBER_TRANSFORM_TYPE::SQUARE;
460 else if (aType == "square-root")
461 maType = sc::NUMBER_TRANSFORM_TYPE::SQUARE_ROOT;
462 else if (aType == "exponential")
463 maType = sc::NUMBER_TRANSFORM_TYPE::EXPONENT;
464 else if (aType == "even")
465 maType = sc::NUMBER_TRANSFORM_TYPE::IS_EVEN;
466 else if (aType == "odd")
467 maType = sc::NUMBER_TRANSFORM_TYPE::IS_ODD;
468 else if (aType == "sign")
469 maType = sc::NUMBER_TRANSFORM_TYPE::SIGN;
470 }
471 }
472
~ScXMLColumnNumberContext()473 ScXMLColumnNumberContext::~ScXMLColumnNumberContext()
474 {
475 ScDocument* pDoc = GetScImport().GetDocument();
476 auto& rDataSources = pDoc->GetExternalDataMapper().getDataSources();
477 if (!rDataSources.empty())
478 {
479 rDataSources[rDataSources.size() - 1].AddDataTransformation(
480 std::make_shared<sc::NumberTransformation>(maColumns, maType, maPrecision));
481 }
482 }
483
484 uno::Reference<xml::sax::XFastContextHandler>
createFastChildContext(sal_Int32 nElement,const uno::Reference<xml::sax::XFastAttributeList> & xAttrList)485 SAL_CALL ScXMLColumnNumberContext::createFastChildContext(
486 sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
487 {
488 sax_fastparser::FastAttributeList* pAttribList
489 = sax_fastparser::FastAttributeList::castToFastAttributeList(xAttrList);
490 const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList = pAttribList;
491
492 switch (nElement)
493 {
494 case XML_ELEMENT(CALC_EXT, XML_COLUMN):
495 {
496 if (rAttrList.is())
497 {
498 for (auto& aIter : *rAttrList)
499 {
500 switch (aIter.getToken())
501 {
502 case XML_ELEMENT(CALC_EXT, XML_COLUMN):
503 {
504 maColumns.insert(aIter.toInt32());
505 }
506 break;
507 }
508 }
509 }
510 }
511 break;
512 }
513 return new SvXMLImportContext(GetImport());
514 }
515
ScXMLColumnRemoveNullContext(ScXMLImport & rImport,const rtl::Reference<sax_fastparser::FastAttributeList> & rAttrList)516 ScXMLColumnRemoveNullContext::ScXMLColumnRemoveNullContext(
517 ScXMLImport& rImport, const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList)
518 : ScXMLImportContext(rImport)
519 {
520 if (rAttrList.is())
521 {
522 for (auto& aIter : *rAttrList)
523 {
524 switch (aIter.getToken())
525 {
526 case XML_ELEMENT(CALC_EXT, XML_REPLACE_STRING):
527 {
528 maReplaceString = aIter.toString();
529 }
530 break;
531 }
532 }
533 }
534 }
535
~ScXMLColumnRemoveNullContext()536 ScXMLColumnRemoveNullContext::~ScXMLColumnRemoveNullContext()
537 {
538 ScDocument* pDoc = GetScImport().GetDocument();
539 auto& rDataSources = pDoc->GetExternalDataMapper().getDataSources();
540 if (!rDataSources.empty())
541 {
542 rDataSources[rDataSources.size() - 1].AddDataTransformation(
543 std::make_shared<sc::ReplaceNullTransformation>(maColumns, maReplaceString));
544 }
545 }
546
547 uno::Reference<xml::sax::XFastContextHandler>
createFastChildContext(sal_Int32 nElement,const uno::Reference<xml::sax::XFastAttributeList> & xAttrList)548 SAL_CALL ScXMLColumnRemoveNullContext::createFastChildContext(
549 sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
550 {
551 sax_fastparser::FastAttributeList* pAttribList
552 = sax_fastparser::FastAttributeList::castToFastAttributeList(xAttrList);
553 const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList = pAttribList;
554 switch (nElement)
555 {
556 case XML_ELEMENT(CALC_EXT, XML_COLUMN):
557 {
558 if (rAttrList.is())
559 {
560 for (auto& aIter : *rAttrList)
561 {
562 switch (aIter.getToken())
563 {
564 case XML_ELEMENT(CALC_EXT, XML_COLUMN):
565 {
566 maColumns.insert(aIter.toInt32());
567 }
568 break;
569 }
570 }
571 }
572 }
573 break;
574 }
575 return new SvXMLImportContext(GetImport());
576 }
577
ScXMLDateTimeContext(ScXMLImport & rImport,const rtl::Reference<sax_fastparser::FastAttributeList> & rAttrList)578 ScXMLDateTimeContext::ScXMLDateTimeContext(
579 ScXMLImport& rImport, const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList)
580 : ScXMLImportContext(rImport)
581 , maType(sc::DATETIME_TRANSFORMATION_TYPE::DATE_STRING)
582 {
583 if (rAttrList.is())
584 {
585 for (auto& aIter : *rAttrList)
586 {
587 switch (aIter.getToken())
588 {
589 case XML_ELEMENT(CALC_EXT, XML_TYPE):
590 {
591 aType = aIter.toString();
592 }
593 break;
594 }
595 }
596 }
597
598 if (!aType.isEmpty())
599 {
600 if (aType == "date-string")
601 maType = sc::DATETIME_TRANSFORMATION_TYPE::DATE_STRING;
602 else if (aType == "year")
603 maType = sc::DATETIME_TRANSFORMATION_TYPE::YEAR;
604 else if (aType == "start-of-year")
605 maType = sc::DATETIME_TRANSFORMATION_TYPE::START_OF_YEAR;
606 else if (aType == "end-of-year")
607 maType = sc::DATETIME_TRANSFORMATION_TYPE::END_OF_YEAR;
608 else if (aType == "month")
609 maType = sc::DATETIME_TRANSFORMATION_TYPE::MONTH;
610 else if (aType == "month-name")
611 maType = sc::DATETIME_TRANSFORMATION_TYPE::MONTH_NAME;
612 else if (aType == "start-of-month")
613 maType = sc::DATETIME_TRANSFORMATION_TYPE::START_OF_MONTH;
614 else if (aType == "end-of-month")
615 maType = sc::DATETIME_TRANSFORMATION_TYPE::END_OF_MONTH;
616 else if (aType == "day")
617 maType = sc::DATETIME_TRANSFORMATION_TYPE::DAY;
618 else if (aType == "day-of-week")
619 maType = sc::DATETIME_TRANSFORMATION_TYPE::DAY_OF_WEEK;
620 else if (aType == "day-of-year")
621 maType = sc::DATETIME_TRANSFORMATION_TYPE::DAY_OF_YEAR;
622 else if (aType == "quarter")
623 maType = sc::DATETIME_TRANSFORMATION_TYPE::QUARTER;
624 else if (aType == "start-of-quarter")
625 maType = sc::DATETIME_TRANSFORMATION_TYPE::START_OF_QUARTER;
626 else if (aType == "end-of-quarter")
627 maType = sc::DATETIME_TRANSFORMATION_TYPE::END_OF_QUARTER;
628 else if (aType == "time")
629 maType = sc::DATETIME_TRANSFORMATION_TYPE::TIME;
630 else if (aType == "hour")
631 maType = sc::DATETIME_TRANSFORMATION_TYPE::HOUR;
632 else if (aType == "minute")
633 maType = sc::DATETIME_TRANSFORMATION_TYPE::MINUTE;
634 else if (aType == "seconds")
635 maType = sc::DATETIME_TRANSFORMATION_TYPE::SECOND;
636 }
637 }
638
~ScXMLDateTimeContext()639 ScXMLDateTimeContext::~ScXMLDateTimeContext()
640 {
641 ScDocument* pDoc = GetScImport().GetDocument();
642 auto& rDataSources = pDoc->GetExternalDataMapper().getDataSources();
643 if (!rDataSources.empty())
644 {
645 rDataSources[rDataSources.size() - 1].AddDataTransformation(
646 std::make_shared<sc::DateTimeTransformation>(maColumns, maType));
647 }
648 }
649
createFastChildContext(sal_Int32 nElement,const uno::Reference<xml::sax::XFastAttributeList> & xAttrList)650 uno::Reference<xml::sax::XFastContextHandler> SAL_CALL ScXMLDateTimeContext::createFastChildContext(
651 sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
652 {
653 sax_fastparser::FastAttributeList* pAttribList
654 = sax_fastparser::FastAttributeList::castToFastAttributeList(xAttrList);
655 const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList = pAttribList;
656
657 switch (nElement)
658 {
659 case XML_ELEMENT(CALC_EXT, XML_COLUMN):
660 {
661 if (rAttrList.is())
662 {
663 for (auto& aIter : *rAttrList)
664 {
665 switch (aIter.getToken())
666 {
667 case XML_ELEMENT(CALC_EXT, XML_COLUMN):
668 {
669 maColumns.insert(aIter.toInt32());
670 }
671 break;
672 }
673 }
674 }
675 }
676 break;
677 }
678 return new SvXMLImportContext(GetImport());
679 }
680
681 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
682