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