/home/maarten/src/libreoffice/core/include/com/sun/star/uno/Any.hxx

Bug Summary

File:	home/maarten/src/libreoffice/core/include/com/sun/star/uno/Any.hxx
Warning:	line 577, column 17 Dereference of null pointer

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name animationexport.cxx -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D XMLOFF_DLLIMPLEMENTATION -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/xmloff/inc -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/officecfg/registry -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/xmloff/generated -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-missing-braces -std=c++17 -fdeprecated-macro -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c++ /home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx

/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/


21#include <com/sun/star/animations/XAnimateColor.hpp>
22#include <com/sun/star/animations/XCommand.hpp>
23#include <com/sun/star/animations/Timing.hpp>
24#include <com/sun/star/animations/Event.hpp>
25#include <com/sun/star/animations/XAnimateMotion.hpp>
26#include <com/sun/star/animations/XAnimatePhysics.hpp>
27#include <com/sun/star/animations/XAnimateTransform.hpp>
28#include <com/sun/star/animations/XTransitionFilter.hpp>
29#include <com/sun/star/animations/XIterateContainer.hpp>
30#include <com/sun/star/animations/XAudio.hpp>
31#include <com/sun/star/animations/AnimationColorSpace.hpp>
32#include <com/sun/star/animations/AnimationNodeType.hpp>
33#include <com/sun/star/animations/AnimationRestart.hpp>
34#include <com/sun/star/animations/EventTrigger.hpp>
35#include <com/sun/star/animations/AnimationFill.hpp>
36#include <com/sun/star/animations/AnimationEndSync.hpp>
37#include <com/sun/star/animations/AnimationCalcMode.hpp>
38#include <com/sun/star/animations/AnimationAdditiveMode.hpp>
39#include <com/sun/star/animations/AnimationTransformType.hpp>
40#include <com/sun/star/animations/TransitionType.hpp>
41#include <com/sun/star/animations/TransitionSubType.hpp>
42#include <com/sun/star/animations/ValuePair.hpp>
43#include <com/sun/star/container/XEnumerationAccess.hpp>
44#include <com/sun/star/beans/NamedValue.hpp>
45#include <com/sun/star/beans/XPropertySet.hpp>
46#include <com/sun/star/document/XStorageBasedDocument.hpp>
47#include <com/sun/star/embed/ElementModes.hpp>
48#include <com/sun/star/embed/XTransactedObject.hpp>
49#include <com/sun/star/presentation/EffectNodeType.hpp>
50#include <com/sun/star/presentation/EffectPresetClass.hpp>
51#include <com/sun/star/presentation/ParagraphTarget.hpp>
52#include <com/sun/star/presentation/TextAnimationType.hpp>
53#include <com/sun/star/presentation/ShapeAnimationSubType.hpp>
54#include <com/sun/star/presentation/EffectCommands.hpp>
55#include <o3tl/any.hxx>
56#include <sax/tools/converter.hxx>
57#include <sal/log.hxx>
58#include <tools/diagnose_ex.h>

60#include <xmloff/unointerfacetouniqueidentifiermapper.hxx>
61#include "sdpropls.hxx"
62#include <xmlsdtypes.hxx>
63#include <xmloff/xmltoken.hxx>
64#include <xmloff/xmlnamespace.hxx>
65#include <xmloff/xmluconv.hxx>
66#include <xmloff/xmlexp.hxx>
67#include <xmloff/xmlement.hxx>
68#include <xmloff/xmlprhdl.hxx>

70#include <animations.hxx>
71#include <xmloff/animationexport.hxx>

73using namespace css;
74using namespace ::std;
75using namespace ::cppu;
76using namespace ::com::sun::star::animations;
77using namespace ::com::sun::star::presentation;
78using namespace ::com::sun::star::drawing;
79using namespace ::com::sun::star::beans;
80using namespace ::xmloff::token;

82using ::com::sun::star::uno::Any;
83using ::com::sun::star::uno::UNO_QUERY;
84using ::com::sun::star::uno::UNO_QUERY_THROW;
85using ::com::sun::star::uno::Reference;
86using ::com::sun::star::uno::Sequence;
87using ::com::sun::star::uno::Exception;
88using ::com::sun::star::uno::RuntimeException;
89using ::com::sun::star::uno::XInterface;
90using ::com::sun::star::beans::NamedValue;
91using ::com::sun::star::container::XEnumerationAccess;
92using ::com::sun::star::container::XEnumeration;

94namespace xmloff
95{

97const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_Fill[] =
98{
  { XML_DEFAULT,      AnimationFill::DEFAULT },
  { XML_REMOVE,       AnimationFill::REMOVE },
  { XML_FREEZE,       AnimationFill::FREEZE },
  { XML_HOLD,         AnimationFill::HOLD },
  { XML_TRANSITION,   AnimationFill::TRANSITION },
  { XML_AUTO,         AnimationFill::AUTO },
  { XML_TOKEN_INVALID, 0 }
106};
107const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_FillDefault[] =
108{
  { XML_INHERIT,      AnimationFill::INHERIT },
  { XML_REMOVE,       AnimationFill::REMOVE },
  { XML_FREEZE,       AnimationFill::FREEZE },
  { XML_HOLD,         AnimationFill::HOLD },
  { XML_TRANSITION,   AnimationFill::TRANSITION },
  { XML_AUTO,         AnimationFill::AUTO },
  { XML_TOKEN_INVALID, 0 }
116};
117const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_Restart[] =
118{
  { XML_DEFAULT,      AnimationRestart::DEFAULT },
  { XML_ALWAYS,       AnimationRestart::ALWAYS },
  { XML_WHENNOTACTIVE,AnimationRestart::WHEN_NOT_ACTIVE },
  { XML_NEVER,        AnimationRestart::NEVER },
  { XML_TOKEN_INVALID, 0 }
124};
125const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_RestartDefault[] =
126{
  { XML_INHERIT,      AnimationRestart::INHERIT },
  { XML_ALWAYS,       AnimationRestart::ALWAYS },
  { XML_WHENNOTACTIVE,AnimationRestart::WHEN_NOT_ACTIVE },
  { XML_NEVER,        AnimationRestart::NEVER },
  { XML_TOKEN_INVALID, 0 }
132};
133const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_Endsync[] =
134{
  { XML_FIRST,        AnimationEndSync::FIRST },
  { XML_LAST,         AnimationEndSync::LAST },
  { XML_ALL,          AnimationEndSync::ALL },
  { XML_MEDIA,        AnimationEndSync::MEDIA },
  { XML_TOKEN_INVALID, 0 }
140};
141const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_CalcMode[] =
142{
  { XML_DISCRETE,     AnimationCalcMode::DISCRETE },
  { XML_LINEAR,       AnimationCalcMode::LINEAR },
  { XML_PACED,        AnimationCalcMode::PACED },
  { XML_SPLINE,       AnimationCalcMode::SPLINE },
  { XML_TOKEN_INVALID, 0 }
148};
149const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_AdditiveMode[] =
150{
  { XML_BASE,         AnimationAdditiveMode::BASE },
  { XML_SUM,          AnimationAdditiveMode::SUM },
  { XML_REPLACE,      AnimationAdditiveMode::REPLACE },
  { XML_MULTIPLY,     AnimationAdditiveMode::MULTIPLY },
  { XML_NONE,         AnimationAdditiveMode::NONE },
  { XML_TOKEN_INVALID, 0 }
157};
158const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_TransformType[] =
159{
  { XML_TRANSLATE,    AnimationTransformType::TRANSLATE },
  { XML_SCALE,        AnimationTransformType::SCALE },
  { XML_ROTATE,       AnimationTransformType::ROTATE },
  { XML_SKEWX,        AnimationTransformType::SKEWX },
  { XML_SKEWY,        AnimationTransformType::SKEWY },
  { XML_TOKEN_INVALID, 0 }
166};
167const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_TransitionType[] =
168{
  { XML_BARWIPE,          TransitionType::BARWIPE },
  { XML_BOXWIPE,          TransitionType::BOXWIPE },
  { XML_FOURBOXWIPE,      TransitionType::FOURBOXWIPE },
  { XML_BARNDOORWIPE,     TransitionType::BARNDOORWIPE },
  { XML_DIAGONALWIPE,     TransitionType::DIAGONALWIPE },
  { XML_BOWTIEWIPE,       TransitionType::BOWTIEWIPE },
  { XML_MISCDIAGONALWIPE, TransitionType::MISCDIAGONALWIPE },
  { XML_VEEWIPE,          TransitionType::VEEWIPE },
  { XML_BARNVEEWIPE,      TransitionType::BARNVEEWIPE },
  { XML_ZIGZAGWIPE,       TransitionType::ZIGZAGWIPE },
  { XML_BARNZIGZAGWIPE,   TransitionType::BARNZIGZAGWIPE },
  { XML_IRISWIPE,         TransitionType::IRISWIPE },
  { XML_TRIANGLEWIPE,     TransitionType::TRIANGLEWIPE },
  { XML_ARROWHEADWIPE,    TransitionType::ARROWHEADWIPE },
  { XML_PENTAGONWIPE,     TransitionType::PENTAGONWIPE },
  { XML_HEXAGONWIPE,      TransitionType::HEXAGONWIPE },
  { XML_ELLIPSEWIPE,      TransitionType::ELLIPSEWIPE },
  { XML_EYEWIPE,          TransitionType::EYEWIPE },
  { XML_ROUNDRECTWIPE,    TransitionType::ROUNDRECTWIPE },
  { XML_STARWIPE,         TransitionType::STARWIPE },
  { XML_MISCSHAPEWIPE,    TransitionType::MISCSHAPEWIPE },
  { XML_CLOCKWIPE,        TransitionType::CLOCKWIPE },
  { XML_PINWHEELWIPE,     TransitionType::PINWHEELWIPE },
  { XML_SINGLESWEEPWIPE,  TransitionType::SINGLESWEEPWIPE },
  { XML_FANWIPE,          TransitionType::FANWIPE },
  { XML_DOUBLEFANWIPE,    TransitionType::DOUBLEFANWIPE },
  { XML_DOUBLESWEEPWIPE,  TransitionType::DOUBLESWEEPWIPE },
  { XML_SALOONDOORWIPE,   TransitionType::SALOONDOORWIPE },
  { XML_WINDSHIELDWIPE,   TransitionType::WINDSHIELDWIPE },
  { XML_SNAKEWIPE,        TransitionType::SNAKEWIPE },
  { XML_SPIRALWIPE,       TransitionType::SPIRALWIPE },
  { XML_PARALLELSNAKESWIPE,TransitionType::PARALLELSNAKESWIPE },
  { XML_BOXSNAKESWIPE,    TransitionType::BOXSNAKESWIPE },
  { XML_WATERFALLWIPE,    TransitionType::WATERFALLWIPE },
  { XML_PUSHWIPE,         TransitionType::PUSHWIPE },
  { XML_SLIDEWIPE,        TransitionType::SLIDEWIPE },
  { XML_FADE,             TransitionType::FADE },
  { XML_RANDOMBARWIPE,    TransitionType::RANDOMBARWIPE },
  { XML_CHECKERBOARDWIPE, TransitionType::CHECKERBOARDWIPE },
  { XML_DISSOLVE,         TransitionType::DISSOLVE },
  { XML_BLINDSWIPE,       TransitionType::BLINDSWIPE },
  { XML_RANDOM,           TransitionType::RANDOM },
  { XML_ZOOM,             TransitionType::ZOOM },
  { XML_TOKEN_INVALID, 0 }
213};
214const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_TransitionSubType[] =
215{
  { XML_DEFAULT,              TransitionSubType::DEFAULT },
  { XML_LEFTTORIGHT,          TransitionSubType::LEFTTORIGHT },
  { XML_TOPTOBOTTOM,          TransitionSubType::TOPTOBOTTOM },
  { XML_TOPLEFT,              TransitionSubType::TOPLEFT },
  { XML_TOPRIGHT,             TransitionSubType::TOPRIGHT },
  { XML_BOTTOMRIGHT,          TransitionSubType::BOTTOMRIGHT },
  { XML_BOTTOMLEFT,           TransitionSubType::BOTTOMLEFT },
  { XML_TOPCENTER,            TransitionSubType::TOPCENTER },
  { XML_RIGHTCENTER,          TransitionSubType::RIGHTCENTER },
  { XML_BOTTOMCENTER,         TransitionSubType::BOTTOMCENTER },
  { XML_LEFTCENTER,           TransitionSubType::LEFTCENTER },
  { XML_CORNERSIN,            TransitionSubType::CORNERSIN },
  { XML_CORNERSOUT,           TransitionSubType::CORNERSOUT },
  { XML_VERTICAL,             TransitionSubType::VERTICAL },
  { XML_HORIZONTAL,           TransitionSubType::HORIZONTAL },
  { XML_DIAGONALBOTTOMLEFT,   TransitionSubType::DIAGONALBOTTOMLEFT },
  { XML_DIAGONALTOPLEFT,      TransitionSubType::DIAGONALTOPLEFT },
  { XML_DOUBLEBARNDOOR,       TransitionSubType::DOUBLEBARNDOOR },
  { XML_DOUBLEDIAMOND,        TransitionSubType::DOUBLEDIAMOND },
  { XML_DOWN,                 TransitionSubType::DOWN },
  { XML_LEFT,                 TransitionSubType::LEFT },
  { XML_UP,                   TransitionSubType::UP },
  { XML_RIGHT,                TransitionSubType::RIGHT },
  { XML_RECTANGLE,            TransitionSubType::RECTANGLE },
  { XML_DIAMOND,              TransitionSubType::DIAMOND },
  { XML_CIRCLE,               TransitionSubType::CIRCLE },
  { XML_FOURPOINT,            TransitionSubType::FOURPOINT },
  { XML_FIVEPOINT,            TransitionSubType::FIVEPOINT },
  { XML_SIXPOINT,             TransitionSubType::SIXPOINT },
  { XML_HEART,                TransitionSubType::HEART },
  { XML_KEYHOLE,              TransitionSubType::KEYHOLE },
  { XML_CLOCKWISETWELVE,      TransitionSubType::CLOCKWISETWELVE },
  { XML_CLOCKWISETHREE,       TransitionSubType::CLOCKWISETHREE },
  { XML_CLOCKWISESIX,         TransitionSubType::CLOCKWISESIX },
  { XML_CLOCKWISENINE,        TransitionSubType::CLOCKWISENINE },
  { XML_TWOBLADEVERTICAL,     TransitionSubType::TWOBLADEVERTICAL },
  { XML_TWOBLADEHORIZONTAL,   TransitionSubType::TWOBLADEHORIZONTAL },
  { XML_FOURBLADE,            TransitionSubType::FOURBLADE },
  { XML_CLOCKWISETOP,         TransitionSubType::CLOCKWISETOP },
  { XML_CLOCKWISERIGHT,       TransitionSubType::CLOCKWISERIGHT },
  { XML_CLOCKWISEBOTTOM,      TransitionSubType::CLOCKWISEBOTTOM },
  { XML_CLOCKWISELEFT,        TransitionSubType::CLOCKWISELEFT },
  { XML_CLOCKWISETOPLEFT,     TransitionSubType::CLOCKWISETOPLEFT },
  { XML_COUNTERCLOCKWISEBOTTOMLEFT,TransitionSubType::COUNTERCLOCKWISEBOTTOMLEFT },
  { XML_CLOCKWISEBOTTOMRIGHT, TransitionSubType::CLOCKWISEBOTTOMRIGHT },
  { XML_COUNTERCLOCKWISETOPRIGHT,TransitionSubType::COUNTERCLOCKWISETOPRIGHT },
  { XML_CENTERTOP,            TransitionSubType::CENTERTOP },
  { XML_CENTERRIGHT,          TransitionSubType::CENTERRIGHT },
  { XML_TOP,                  TransitionSubType::TOP },
  { XML_BOTTOM,               TransitionSubType::BOTTOM },
  { XML_FANOUTVERTICAL,       TransitionSubType::FANOUTVERTICAL },
  { XML_FANOUTHORIZONTAL,     TransitionSubType::FANOUTHORIZONTAL },
  { XML_FANINVERTICAL,        TransitionSubType::FANINVERTICAL },
  { XML_FANINHORIZONTAL,      TransitionSubType::FANINHORIZONTAL },
  { XML_PARALLELVERTICAL,     TransitionSubType::PARALLELVERTICAL },
  { XML_PARALLELDIAGONAL,     TransitionSubType::PARALLELDIAGONAL },
  { XML_OPPOSITEVERTICAL,     TransitionSubType::OPPOSITEVERTICAL },
  { XML_OPPOSITEHORIZONTAL,   TransitionSubType::OPPOSITEHORIZONTAL },
  { XML_PARALLELDIAGONALTOPLEFT,TransitionSubType::PARALLELDIAGONALTOPLEFT },
  { XML_PARALLELDIAGONALBOTTOMLEFT,TransitionSubType::PARALLELDIAGONALBOTTOMLEFT },
  { XML_TOPLEFTHORIZONTAL,    TransitionSubType::TOPLEFTHORIZONTAL },
  { XML_TOPLEFTDIAGONAL,      TransitionSubType::TOPLEFTDIAGONAL },
  { XML_TOPRIGHTDIAGONAL,     TransitionSubType::TOPRIGHTDIAGONAL },
  { XML_BOTTOMRIGHTDIAGONAL,  TransitionSubType::BOTTOMRIGHTDIAGONAL },
  { XML_BOTTOMLEFTDIAGONAL,   TransitionSubType::BOTTOMLEFTDIAGONAL },
  { XML_TOPLEFTCLOCKWISE,     TransitionSubType::TOPLEFTCLOCKWISE },
  { XML_TOPRIGHTCLOCKWISE,    TransitionSubType::TOPRIGHTCLOCKWISE },
  { XML_BOTTOMRIGHTCLOCKWISE, TransitionSubType::BOTTOMRIGHTCLOCKWISE },
  { XML_BOTTOMLEFTCLOCKWISE,  TransitionSubType::BOTTOMLEFTCLOCKWISE },
  { XML_TOPLEFTCOUNTERCLOCKWISE,TransitionSubType::TOPLEFTCOUNTERCLOCKWISE },
  { XML_TOPRIGHTCOUNTERCLOCKWISE,TransitionSubType::TOPRIGHTCOUNTERCLOCKWISE },
  { XML_BOTTOMRIGHTCOUNTERCLOCKWISE,TransitionSubType::BOTTOMRIGHTCOUNTERCLOCKWISE },
  { XML_BOTTOMLEFTCOUNTERCLOCKWISE,TransitionSubType::BOTTOMLEFTCOUNTERCLOCKWISE },
  { XML_VERTICALTOPSAME,      TransitionSubType::VERTICALTOPSAME },
  { XML_VERTICALBOTTOMSAME,   TransitionSubType::VERTICALBOTTOMSAME },
  { XML_VERTICALTOPLEFTOPPOSITE,TransitionSubType::VERTICALTOPLEFTOPPOSITE },
  { XML_VERTICALBOTTOMLEFTOPPOSITE,TransitionSubType::VERTICALBOTTOMLEFTOPPOSITE },
  { XML_HORIZONTALLEFTSAME,   TransitionSubType::HORIZONTALLEFTSAME },
  { XML_HORIZONTALRIGHTSAME,  TransitionSubType::HORIZONTALRIGHTSAME },
  { XML_HORIZONTALTOPLEFTOPPOSITE,TransitionSubType::HORIZONTALTOPLEFTOPPOSITE },
  { XML_HORIZONTALTOPRIGHTOPPOSITE,TransitionSubType::HORIZONTALTOPRIGHTOPPOSITE },
  { XML_DIAGONALBOTTOMLEFTOPPOSITE,TransitionSubType::DIAGONALBOTTOMLEFTOPPOSITE },
  { XML_DIAGONALTOPLEFTOPPOSITE,TransitionSubType::DIAGONALTOPLEFTOPPOSITE },
  { XML_TWOBOXTOP,            TransitionSubType::TWOBOXTOP },
  { XML_TWOBOXBOTTOM,         TransitionSubType::TWOBOXBOTTOM },
  { XML_TWOBOXLEFT,           TransitionSubType::TWOBOXLEFT },
  { XML_TWOBOXRIGHT,          TransitionSubType::TWOBOXRIGHT },
  { XML_FOURBOXVERTICAL,      TransitionSubType::FOURBOXVERTICAL },
  { XML_FOURBOXHORIZONTAL,    TransitionSubType::FOURBOXHORIZONTAL },
  { XML_VERTICALLEFT,         TransitionSubType::VERTICALLEFT },
  { XML_VERTICALRIGHT,        TransitionSubType::VERTICALRIGHT },
  { XML_HORIZONTALLEFT,       TransitionSubType::HORIZONTALLEFT },
  { XML_HORIZONTALRIGHT,      TransitionSubType::HORIZONTALRIGHT },
  { XML_FROMLEFT,             TransitionSubType::FROMLEFT },
  { XML_FROMTOP,              TransitionSubType::FROMTOP },
  { XML_FROMRIGHT,            TransitionSubType::FROMRIGHT },
  { XML_FROMBOTTOM,           TransitionSubType::FROMBOTTOM },
  { XML_CROSSFADE,            TransitionSubType::CROSSFADE },
  { XML_FADETOCOLOR,          TransitionSubType::FADETOCOLOR },
  { XML_FADEFROMCOLOR,        TransitionSubType::FADEFROMCOLOR },
  { XML_FADEOVERCOLOR,        TransitionSubType::FADEOVERCOLOR },
  { XML_THREEBLADE,           TransitionSubType::THREEBLADE },
  { XML_EIGHTBLADE,           TransitionSubType::EIGHTBLADE },
  { XML_ONEBLADE,             TransitionSubType::ONEBLADE },
  { XML_ACROSS,               TransitionSubType::ACROSS },
  { XML_TOPLEFTVERTICAL,      TransitionSubType::TOPLEFTVERTICAL },
  { XML_COMBHORIZONTAL,       TransitionSubType::COMBHORIZONTAL },
  { XML_COMBVERTICAL,         TransitionSubType::COMBVERTICAL },
  { XML_IN,                   TransitionSubType::IN },
  { XML_OUT,                  TransitionSubType::OUT },
  { XML_ROTATEIN,             TransitionSubType::ROTATEIN },
  { XML_ROTATEOUT,            TransitionSubType::ROTATEOUT },
  { XML_FROMTOPLEFT,          TransitionSubType::FROMTOPLEFT },
  { XML_FROMTOPRIGHT,         TransitionSubType::FROMTOPRIGHT },
  { XML_FROMBOTTOMLEFT,       TransitionSubType::FROMBOTTOMLEFT },
  { XML_FROMBOTTOMRIGHT,      TransitionSubType::FROMBOTTOMRIGHT },

  { XML_TOKEN_INVALID, 0 }
334};
335const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_EventTrigger[] =
336{
  { XML_ONBEGIN,          EventTrigger::ON_BEGIN },
  { XML_ONEND,            EventTrigger::ON_END },
  { XML_BEGIN,            EventTrigger::BEGIN_EVENT },
  { XML_END,              EventTrigger::END_EVENT },
  { XML_CLICK,            EventTrigger::ON_CLICK },
  { XML_DOUBLECLICK,      EventTrigger::ON_DBL_CLICK },
  { XML_MOUSEOVER,        EventTrigger::ON_MOUSE_ENTER },
  { XML_MOUSEOUT,         EventTrigger::ON_MOUSE_LEAVE },
  { XML_NEXT,             EventTrigger::ON_NEXT },
  { XML_PREVIOUS,         EventTrigger::ON_PREV },
  { XML_STOP_AUDIO,       EventTrigger::ON_STOP_AUDIO },
  { XML_REPEAT,           EventTrigger::REPEAT },
  { XML_TOKEN_INVALID, 0 }
350};
351const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_EffectPresetClass[] =
352{
  { XML_CUSTOM,       EffectPresetClass::CUSTOM },
  { XML_ENTRANCE,     EffectPresetClass::ENTRANCE },
  { XML_EXIT,         EffectPresetClass::EXIT },
  { XML_EMPHASIS,     EffectPresetClass::EMPHASIS },
  { XML_MOTION_PATH,  EffectPresetClass::MOTIONPATH },
  { XML_OLE_ACTION,   EffectPresetClass::OLEACTION },
  { XML_MEDIA_CALL,   EffectPresetClass::MEDIACALL },
  { XML_TOKEN_INVALID, 0 }
361};
362const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_EffectNodeType[] =
363{
  { XML_DEFAULT,                  EffectNodeType::DEFAULT },
  { XML_ON_CLICK,                 EffectNodeType::ON_CLICK },
  { XML_WITH_PREVIOUS,            EffectNodeType::WITH_PREVIOUS },
  { XML_AFTER_PREVIOUS,           EffectNodeType::AFTER_PREVIOUS },
  { XML_MAIN_SEQUENCE,            EffectNodeType::MAIN_SEQUENCE },
  { XML_TIMING_ROOT,              EffectNodeType::TIMING_ROOT },
  { XML_INTERACTIVE_SEQUENCE,     EffectNodeType::INTERACTIVE_SEQUENCE },
  { XML_TOKEN_INVALID, 0 }
372};
373const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_SubItem[] =
374{
  { XML_WHOLE,                    ShapeAnimationSubType::AS_WHOLE },
  { XML_BACKGROUND,               ShapeAnimationSubType::ONLY_BACKGROUND },
  { XML_TEXT,                     ShapeAnimationSubType::ONLY_TEXT },
  { XML_TOKEN_INVALID, 0 }
379};
380const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_IterateType[] =
381{
  { XML_BY_PARAGRAPH,             TextAnimationType::BY_PARAGRAPH },
  { XML_BY_WORD,                  TextAnimationType::BY_WORD },
  { XML_BY_LETTER,                TextAnimationType::BY_LETTER },
  { XML_TOKEN_INVALID, 0 }
386};
387const SvXMLEnumMapEntry<sal_Int16> aAnimations_EnumMap_Command[] =
388{
  { XML_CUSTOM,                   EffectCommands::CUSTOM },
  { XML_VERB,                     EffectCommands::VERB },
  { XML_PLAY,                     EffectCommands::PLAY },
  { XML_TOGGLE_PAUSE,             EffectCommands::TOGGLEPAUSE },
  { XML_STOP,                     EffectCommands::STOP },
  { XML_STOP_AUDIO,               EffectCommands::STOPAUDIO },
  { XML_TOKEN_INVALID, 0 }
396};

398const struct ImplAttributeNameConversion* getAnimationAttributeNamesConversionList()
399{
  static const struct ImplAttributeNameConversion gImplConversionList[] =
  {
      { XML_X,                        "X" },
      { XML_Y,                        "Y" },
      { XML_WIDTH,                    "Width" },
      { XML_HEIGHT,                   "Height" },
      { XML_ROTATE,                   "Rotate" },
      { XML_SKEWX,                    "SkewX" },
      { XML_FILL_COLOR,               "FillColor" },
      { XML_FILL,                     "FillStyle" },
      { XML_STROKE_COLOR,             "LineColor" },
      { XML_STROKE,                   "LineStyle" },
      { XML_COLOR,                    "CharColor" },
      { XML_TEXT_ROTATION_ANGLE,      "CharRotation" },
      { XML_FONT_WEIGHT,              "CharWeight" },
      { XML_TEXT_UNDERLINE,           "CharUnderline" },
      { XML_FONT_FAMILY,              "CharFontName" },
      { XML_FONT_SIZE,                "CharHeight" },
      { XML_FONT_STYLE,               "CharPosture" },
      { XML_VISIBILITY,               "Visibility" },
      { XML_OPACITY,                  "Opacity" },
      { XML_DIM,                      "DimColor" },
      { XML_TOKEN_INVALID,            nullptr }
  };

  return gImplConversionList;
426}


429class AnimationsExporterImpl
430{
431public:
  AnimationsExporterImpl( SvXMLExport& rExport, const Reference< XPropertySet >& xPageProps );

  void prepareNode( const Reference< XAnimationNode >& xNode );
  void exportNode( const Reference< XAnimationNode >& xNode );

  void exportContainer( const Reference< XTimeContainer >& xNode, sal_Int16 nContainerNodeType );
  void exportAnimate( const Reference< XAnimate >& xNode );
  void exportAudio( const Reference< XAudio >& xAudio );
  void exportCommand( const Reference< XCommand >& xCommand );

  static Reference< XInterface > getParagraphTarget( const ParagraphTarget& pTarget );

  static void convertPath( OUStringBuffer& sTmp, const Any& rPath );
  void convertValue( XMLTokenEnum eAttributeName, OUStringBuffer& sTmp, const Any& rValue ) const;
  void convertTiming( OUStringBuffer& sTmp, const Any& rTiming ) const;
  void convertTarget( OUStringBuffer& sTmp, const Any& rTarget ) const;

  void prepareValue( const Any& rValue );

  void exportTransitionNode();
  void prepareTransitionNode();

  bool mbHasTransition;
455private:
  rtl::Reference<SvXMLExport> mxExport;
  Reference< XPropertySet > mxPageProps;
  rtl::Reference<XMLSdPropHdlFactory> mxSdPropHdlFactory;
459};

461AnimationsExporterImpl::AnimationsExporterImpl( SvXMLExport& rExport, const Reference< XPropertySet >& xPageProps )
mbHasTransition(false)
463, mxExport( &rExport )
464, mxPageProps( xPageProps )
465, mxSdPropHdlFactory(new XMLSdPropHdlFactory( rExport.GetModel(), rExport ))
466{
467}


470/** split a uri hierarchy into first segment and rest */
471static bool splitPath(OUString const & i_rPath,
  OUString & o_rDir, OUString& o_rRest)
473{
  const sal_Int32 idx(i_rPath.indexOf(u'/'));
  if (idx < 0 || idx >= i_rPath.getLength()) {
      o_rDir = OUString();
      o_rRest = i_rPath;
      return true;
  } else if (idx == 0 || idx == i_rPath.getLength() - 1) {
      // input must not start or end with '/'
      return false;
  } else {
      o_rDir  = i_rPath.copy(0, idx);
      o_rRest = i_rPath.copy(idx+1);
      return true;
  }
487}

489static void lcl_CopyStream(
      uno::Reference<embed::XStorage> const& xSource,
      uno::Reference<embed::XStorage> const& xTarget,
       OUString const& rPath)
493{
  OUString dir;
  OUString rest;
  if (!splitPath(rPath, dir, rest))
      throw uno::RuntimeException();

  if (dir.getLength() == 0)
      xSource->copyElementTo(rPath, xTarget, rPath);
  else
  {
      uno::Reference<embed::XStorage> const xSubSource(
          xSource->openStorageElement(dir, embed::ElementModes::READ));
      uno::Reference<embed::XStorage> const xSubTarget(
          xTarget->openStorageElement(dir, embed::ElementModes::WRITE));
      lcl_CopyStream(xSubSource, xSubTarget, rest);
  }
  uno::Reference<embed::XTransactedObject> const xTransaction(xTarget, uno::UNO_QUERY);
  if (xTransaction.is())
      xTransaction->commit();
512}

514char const s_PkgScheme[] = "vnd.sun.star.Package:";

516static OUString lcl_StoreMediaAndGetURL(SvXMLExport & rExport, OUString const& rURL)
517{
  OUString urlPath;
  if (rURL.startsWithIgnoreAsciiCase(s_PkgScheme, &urlPath))
  {
      try // video is embedded
      {
          // copy the media stream from document storage to target storage
          // (not sure if this is the best way to store these?)
          uno::Reference<document::XStorageBasedDocument> const xSBD(
                  rExport.GetModel(), uno::UNO_QUERY_THROW);
          uno::Reference<embed::XStorage> const xSource(
                  xSBD->getDocumentStorage(), uno::UNO_SET_THROW);
          uno::Reference<embed::XStorage> const xTarget(
                  rExport.GetTargetStorage(), uno::UNO_SET_THROW);

          urlPath = rURL.copy(SAL_N_ELEMENTS(s_PkgScheme)(sizeof(sal_n_array_size(s_PkgScheme)))-1);

          lcl_CopyStream(xSource, xTarget, urlPath);

          return urlPath;
      }
      catch (uno::Exception const&)
      {
          TOOLS_INFO_EXCEPTION("xmloff", "exception while storing embedded media")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "xmloff")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "exception while storing embedded media"
 << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), (
"xmloff"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "540" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "exception while storing embedded media"
 << " " << exceptionToString(tools_warn_exception
)), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "exception while storing embedded media" << " "
 << exceptionToString(tools_warn_exception); ::sal::detail
::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("xmloff"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "540" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "exception while storing embedded media" <<
 " " << exceptionToString(tools_warn_exception)) == 1) {
 ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("xmloff"),
 ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "540" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "exception while storing embedded media"
 << " " << exceptionToString(tools_warn_exception
)), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "exception while storing embedded media" << " "
 << exceptionToString(tools_warn_exception); ::sal::detail
::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("xmloff"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "540" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
      }
      return OUString();
  }
  else
  {
      return rExport.GetRelativeReference(rURL); // linked
  }
548}

550void AnimationsExporterImpl::exportTransitionNode()
551{
  if( !(mbHasTransition && mxPageProps.is()) )
      return;

  sal_Int16 nTransition = 0;
  mxPageProps->getPropertyValue("TransitionType") >>= nTransition;

  Any aSound( mxPageProps->getPropertyValue("Sound") );
  OUString sSoundURL;
  aSound >>= sSoundURL;
  bool bStopSound = false;
  if( !(aSound >>= bStopSound) )
      bStopSound = false;


  OUStringBuffer sTmp;
  if( !((nTransition != 0) || !sSoundURL.isEmpty() || bStopSound) )
      return;

  Reference< XInterface > xSource( mxPageProps.get() );
  Event aEvent;
  aEvent.Source <<= xSource;
  aEvent.Trigger = EventTrigger::BEGIN_EVENT;
  aEvent.Repeat = 0;

  convertTiming( sTmp, Any( aEvent ) );
  mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_BEGIN, sTmp.makeStringAndClear() );

  SvXMLElementExport aElement( *mxExport, XML_NAMESPACE_ANIMATION, XML_PAR, true, true );

  if( nTransition != 0 )
  {
      sal_Int16 nSubtype = 0;
      bool bDirection = false;
      sal_Int32 nFadeColor = 0;
      double fDuration = 0.0;
      mxPageProps->getPropertyValue("TransitionSubtype") >>= nSubtype;
      mxPageProps->getPropertyValue("TransitionDirection") >>= bDirection;
      mxPageProps->getPropertyValue("TransitionFadeColor") >>= nFadeColor;
      mxPageProps->getPropertyValue("TransitionDuration") >>= fDuration;

      ::sax::Converter::convertDouble( sTmp, fDuration );
      sTmp.append( 's');
      mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_DUR, sTmp.makeStringAndClear() );

      SvXMLUnitConverter::convertEnum( sTmp, nTransition, aAnimations_EnumMap_TransitionType );
      mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_TYPE, sTmp.makeStringAndClear() );

      if( nSubtype != TransitionSubType::DEFAULT )
      {
          SvXMLUnitConverter::convertEnum( sTmp, nSubtype, aAnimations_EnumMap_TransitionSubType );
          mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_SUBTYPE, sTmp.makeStringAndClear() );
      }

      if( !bDirection )
          mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_DIRECTION, XML_REVERSE );

      if( (nTransition == TransitionType::FADE) && ((nSubtype == TransitionSubType::FADETOCOLOR) || (nSubtype == TransitionSubType::FADEFROMCOLOR) ))
      {
          ::sax::Converter::convertColor( sTmp, nFadeColor );
          mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_FADECOLOR, sTmp.makeStringAndClear() );
      }
      SvXMLElementExport aElement2( *mxExport, XML_NAMESPACE_ANIMATION, XML_TRANSITIONFILTER, true, true );
  }

  if( bStopSound )
  {
      mxExport->AddAttribute( XML_NAMESPACE_ANIMATION, XML_COMMAND, XML_STOP_AUDIO );
      SvXMLElementExport aElement2( *mxExport, XML_NAMESPACE_ANIMATION, XML_COMMAND, true, true );
  }
  else if( !sSoundURL.isEmpty())
  {
      sSoundURL = lcl_StoreMediaAndGetURL(*mxExport, sSoundURL);
      mxExport->AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, sSoundURL );

      bool bLoopSound = false;
      mxPageProps->getPropertyValue("LoopSound") >>= bLoopSound;

      if( bLoopSound )
          mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_REPEATCOUNT, XML_INDEFINITE );
      SvXMLElementExport aElement2( *mxExport, XML_NAMESPACE_ANIMATION, XML_AUDIO, true, true );
  }
633}

635void AnimationsExporterImpl::prepareTransitionNode()
636{
  if( !mxPageProps.is() )
      return;

  try
  {
      sal_Int16 nTransition = 0;
      mxPageProps->getPropertyValue("TransitionType") >>= nTransition;

      bool bStopSound = false;
      OUString sSoundURL;

      if( nTransition == 0 )
      {
          Any aSound( mxPageProps->getPropertyValue("Sound") );
          aSound >>= sSoundURL;

          if( !(aSound >>= bStopSound) )
              bStopSound = false;
      }

      if( (nTransition != 0) || !sSoundURL.isEmpty() || bStopSound )
      {
          mbHasTransition = true;
          Reference< XInterface > xInt( mxPageProps.get() );
          mxExport->getInterfaceToIdentifierMapper().registerReference( xInt );
      }
  }
  catch (const Exception&)
  {
      TOOLS_WARN_EXCEPTION("xmloff.draw", "")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "xmloff.draw")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break;
 case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "" << " " <<
 exceptionToString(tools_warn_exception)) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "666" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "666" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "" << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "666" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "666" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
  }
668}

670void AnimationsExporterImpl::prepareNode( const Reference< XAnimationNode >& xNode )
671{
  try
  {
      prepareValue( xNode->getBegin() );
      prepareValue( xNode->getEnd() );

      sal_Int16 nNodeType = xNode->getType();
      switch( nNodeType )
      {
      case AnimationNodeType::ITERATE:
      {
          Reference< XIterateContainer > xIter( xNode, UNO_QUERY_THROW );
          prepareValue( xIter->getTarget() );
          [[fallthrough]];
      }
      case AnimationNodeType::PAR:
      case AnimationNodeType::SEQ:
      {
          Reference< XEnumerationAccess > xEnumerationAccess( xNode, UNO_QUERY_THROW );
          Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), css::uno::UNO_SET_THROW );
          while( xEnumeration->hasMoreElements() )
          {
              Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
              prepareNode( xChildNode );
          }
      }
      break;

      case AnimationNodeType::ANIMATE:
      case AnimationNodeType::SET:
      case AnimationNodeType::ANIMATEMOTION:
      case AnimationNodeType::ANIMATEPHYSICS:
      case AnimationNodeType::ANIMATECOLOR:
      case AnimationNodeType::ANIMATETRANSFORM:
      case AnimationNodeType::TRANSITIONFILTER:
      {
          Reference< XAnimate > xAnimate( xNode, UNO_QUERY_THROW );
          prepareValue( xAnimate->getTarget() );
      }
      break;

      case AnimationNodeType::COMMAND:
      {
          Reference< XCommand > xCommand( xNode, UNO_QUERY_THROW );
          prepareValue( xCommand->getTarget() );
      }
      break;

      case AnimationNodeType::AUDIO:
      {
          Reference< XAudio > xAudio( xNode, UNO_QUERY_THROW );
          prepareValue( xAudio->getSource() );
      }
      break;
      }

      const Sequence< NamedValue > aUserData( xNode->getUserData() );
      for( const auto& rValue : aUserData )
      {
          if( IsXMLToken( rValue.Name, XML_MASTER_ELEMENT ) )
          {
              Reference< XInterface > xMaster;
              rValue.Value >>= xMaster;
              if( xMaster.is() )
                  mxExport->getInterfaceToIdentifierMapper().registerReference( xMaster );
          }
      }
  }
  catch (const Exception&)
  {
      TOOLS_WARN_EXCEPTION("xmloff.draw", "")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "xmloff.draw")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break;
 case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "" << " " <<
 exceptionToString(tools_warn_exception)) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "741" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "741" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "" << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "741" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "741" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
  }
743}

745void AnimationsExporterImpl::exportNode( const Reference< XAnimationNode >& xNode )
746{
  try
  {
      OUStringBuffer sTmp;

      const OUString& rExportIdentifier = mxExport->getInterfaceToIdentifierMapper().getIdentifier( xNode );
      if( !rExportIdentifier.isEmpty() )
1
Taking false branch→
      {
          mxExport->AddAttributeIdLegacy(
              XML_NAMESPACE_ANIMATION, rExportIdentifier);
      }

      Any aTemp( xNode->getBegin() );
2
←
Value assigned to 'aTemp.pData'→
      if( aTemp.hasValue() )
3
←
Taking true branch→
      {
          convertTiming( sTmp, aTemp );
4
←
Calling 'AnimationsExporterImpl::convertTiming'→
          mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_BEGIN, sTmp.makeStringAndClear() );
      }

      double fTemp = 0;
      sal_Int16 nTemp;

      aTemp = xNode->getDuration();
      if( aTemp.hasValue() )
      {
          if( aTemp >>= fTemp )
          {
              ::sax::Converter::convertDouble( sTmp, fTemp );
              sTmp.append( 's');
              mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_DUR, sTmp.makeStringAndClear() );
          }
          else
          {
              Timing eTiming;
              if( aTemp >>= eTiming )
                  mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_DUR, eTiming == Timing_INDEFINITE ? XML_INDEFINITE : XML_MEDIA );
          }
      }

      aTemp = xNode->getEnd();
      if( aTemp.hasValue() )
      {
          convertTiming( sTmp, aTemp );
          mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_END, sTmp.makeStringAndClear() );
      }

      nTemp = xNode->getFill();
      if( nTemp != AnimationFill::DEFAULT )
      {
          SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_Fill );
          mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_FILL, sTmp.makeStringAndClear() );
      }

      nTemp = xNode->getFillDefault();
      if( nTemp != AnimationFill::INHERIT )
      {
          SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_FillDefault );
          mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_FILLDEFAULT, sTmp.makeStringAndClear() );
      }

      nTemp = xNode->getRestart();
      if( nTemp != AnimationRestart::DEFAULT )
      {
          SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_Restart );
          mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_RESTART, sTmp.makeStringAndClear() );
      }

      nTemp = xNode->getRestartDefault();
      if( nTemp != AnimationRestart::INHERIT )
      {
          SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_RestartDefault );
          mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_RESTARTDEFAULT, sTmp.makeStringAndClear() );
      }

      fTemp = xNode->getAcceleration();
      if( fTemp != 0.0 )
      {
          ::sax::Converter::convertDouble( sTmp, fTemp );
          mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_ACCELERATE, sTmp.makeStringAndClear() );
      }

      fTemp = xNode->getDecelerate();
      if( fTemp != 0.0 )
      {
          ::sax::Converter::convertDouble( sTmp, fTemp );
          mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_DECELERATE, sTmp.makeStringAndClear() );
      }

      bool bTemp = xNode->getAutoReverse();
      if( bTemp )
      {
          ::sax::Converter::convertBool( sTmp, bTemp );
          mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_AUTOREVERSE, sTmp.makeStringAndClear() );
      }

      aTemp = xNode->getRepeatCount();
      if( aTemp.hasValue() )
      {
          Timing eTiming;
          if( (aTemp >>= eTiming ) && (eTiming == Timing_INDEFINITE ) )
              mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_REPEATCOUNT, XML_INDEFINITE );
          else if( aTemp >>= fTemp )
          {
              ::sax::Converter::convertDouble( sTmp, fTemp );
              mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_REPEATCOUNT, sTmp.makeStringAndClear() );
          }
      }

      aTemp = xNode->getRepeatDuration();
      if( aTemp.hasValue() )
      {
          Timing eTiming;
          if( ( aTemp >>= eTiming ) && (eTiming == Timing_INDEFINITE) )
          {
              mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_REPEATDUR, XML_INDEFINITE );
          }
          else if( aTemp >>= fTemp )
          {
              ::sax::Converter::convertDouble( sTmp, fTemp );
              mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_REPEATDUR, sTmp.makeStringAndClear() );
          }
      }

      aTemp = xNode->getEndSync();
      if( aTemp.hasValue() && (aTemp >>= nTemp) )
      {
          SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_Endsync );
          mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_ENDSYNC, sTmp.makeStringAndClear() );
      }

      sal_Int16 nContainerNodeType = EffectNodeType::DEFAULT;
      OUString aPresetId;
      const Sequence< NamedValue > aUserData( xNode->getUserData() );
      for( const auto& rValue : aUserData )
      {
          if( IsXMLToken( rValue.Name, XML_NODE_TYPE ) )
          {
              if( (rValue.Value >>= nContainerNodeType) && (nContainerNodeType != EffectNodeType::DEFAULT) )
              {
                  SvXMLUnitConverter::convertEnum( sTmp, nContainerNodeType, aAnimations_EnumMap_EffectNodeType );
                  mxExport->AddAttribute( XML_NAMESPACE_PRESENTATION, XML_NODE_TYPE, sTmp.makeStringAndClear() );
              }
          }
          else if( IsXMLToken( rValue.Name, XML_PRESET_ID ) )
          {
              if( rValue.Value >>= aPresetId )
              {
                  mxExport->AddAttribute( XML_NAMESPACE_PRESENTATION, XML_PRESET_ID, aPresetId );
              }
          }
          else if( IsXMLToken( rValue.Name, XML_PRESET_SUB_TYPE ) )
          {
              OUString aPresetSubType;
              if( rValue.Value >>= aPresetSubType )
              {
                  mxExport->AddAttribute( XML_NAMESPACE_PRESENTATION, XML_PRESET_SUB_TYPE, aPresetSubType );
              }
          }
          else if( IsXMLToken( rValue.Name, XML_PRESET_CLASS ) )
          {
              sal_Int16 nEffectPresetClass = sal_uInt16();
              if( rValue.Value >>= nEffectPresetClass )
              {
                  SvXMLUnitConverter::convertEnum( sTmp, nEffectPresetClass, aAnimations_EnumMap_EffectPresetClass );
                  mxExport->AddAttribute( XML_NAMESPACE_PRESENTATION, XML_PRESET_CLASS, sTmp.makeStringAndClear() );
              }
          }
          else if( IsXMLToken( rValue.Name, XML_MASTER_ELEMENT ) )
          {
              Reference< XInterface > xMaster;
              rValue.Value >>= xMaster;
              if( xMaster.is() )
              {
                  const OUString& rIdentifier = mxExport->getInterfaceToIdentifierMapper().getIdentifier(xMaster);
                  if( !rIdentifier.isEmpty() )
                      mxExport->AddAttribute( XML_NAMESPACE_PRESENTATION, XML_MASTER_ELEMENT, rIdentifier );
              }
          }
          else if( IsXMLToken( rValue.Name, XML_GROUP_ID ) )
          {
              sal_Int32 nGroupId = 0;
              if( rValue.Value >>= nGroupId )
                  mxExport->AddAttribute( XML_NAMESPACE_PRESENTATION, XML_GROUP_ID, OUString::number( nGroupId ) );
          }
          else
          {
              OUString aTmp;
              if( rValue.Value >>= aTmp )
                  mxExport->AddAttribute( XML_NAMESPACE_PRESENTATION, rValue.Name, aTmp );
          }
      }

      nTemp = xNode->getType();
      switch( nTemp )
      {
      case AnimationNodeType::PAR:
      case AnimationNodeType::SEQ:
      case AnimationNodeType::ITERATE:
      {
          Reference< XTimeContainer > xContainer( xNode, UNO_QUERY_THROW );
          exportContainer( xContainer, nContainerNodeType );
      }
      break;

      case AnimationNodeType::ANIMATE:
      case AnimationNodeType::SET:
      case AnimationNodeType::ANIMATEMOTION:
      case AnimationNodeType::ANIMATEPHYSICS:
      case AnimationNodeType::ANIMATECOLOR:
      case AnimationNodeType::ANIMATETRANSFORM:
      case AnimationNodeType::TRANSITIONFILTER:
      {
          Reference< XAnimate > xAnimate( xNode, UNO_QUERY_THROW );
          exportAnimate( xAnimate );
      }
      break;
      case AnimationNodeType::AUDIO:
      {
          Reference< XAudio > xAudio( xNode, UNO_QUERY_THROW );
          exportAudio( xAudio );
      }
      break;
      case AnimationNodeType::COMMAND:
      {
          Reference< XCommand > xCommand( xNode, UNO_QUERY_THROW );
          exportCommand( xCommand );
      }
      break;
      default:
          OSL_FAIL( "xmloff::AnimationsExporterImpl::exportNode(), invalid AnimationNodeType!" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "975" ": "), "%s", "xmloff::AnimationsExporterImpl::exportNode(), invalid AnimationNodeType!"
); } } while (false);
      }
  }
  catch (const RuntimeException&)
  {
      TOOLS_WARN_EXCEPTION("xmloff.draw", "")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "xmloff.draw")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break;
 case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "" << " " <<
 exceptionToString(tools_warn_exception)) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "980" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "980" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "" << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "980" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "980" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
  }

  // if something goes wrong, its always a good idea to clear the attribute list
  mxExport->ClearAttrList();
985}

987void AnimationsExporterImpl::exportContainer( const Reference< XTimeContainer >& xContainer, sal_Int16 nContainerNodeType )
988{
  try
  {
      const sal_Int32 nNodeType = xContainer->getType();

      if( nNodeType == AnimationNodeType::ITERATE )
      {
          OUStringBuffer sTmp;
          Reference< XIterateContainer > xIter( xContainer, UNO_QUERY_THROW );

          Any aTemp( xIter->getTarget() );
          if( aTemp.hasValue() )
          {
              convertTarget( sTmp, aTemp );
              mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_TARGETELEMENT, sTmp.makeStringAndClear() );
          }

          sal_Int16 nTemp = xIter->getSubItem();
          if( nTemp )
          {
              SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_SubItem );
              mxExport->AddAttribute( XML_NAMESPACE_ANIMATION, XML_SUB_ITEM, sTmp.makeStringAndClear() );
          }

          nTemp = xIter->getIterateType();
          if( nTemp )
          {
              SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_IterateType );
              mxExport->AddAttribute( XML_NAMESPACE_ANIMATION, XML_ITERATE_TYPE, sTmp.makeStringAndClear() );
          }

          double fTemp = xIter->getIterateInterval();
          if( fTemp )
          {
              OUStringBuffer buf;
              ::sax::Converter::convertDuration(buf, fTemp / (24*60*60));
              mxExport->AddAttribute( XML_NAMESPACE_ANIMATION,
                      XML_ITERATE_INTERVAL, buf.makeStringAndClear());
          }
      }

      XMLTokenEnum eElementToken;
      switch( nNodeType )
      {
      case AnimationNodeType::PAR:    eElementToken = XML_PAR; break;
      case AnimationNodeType::SEQ:    eElementToken = XML_SEQ; break;
      case AnimationNodeType::ITERATE:eElementToken = XML_ITERATE; break;
      default:
          OSL_FAIL( "xmloff::AnimationsExporterImpl::exportContainer(), invalid TimeContainerType!" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1036" ": "), "%s", "xmloff::AnimationsExporterImpl::exportContainer(), invalid TimeContainerType!"
); } } while (false);
          return;
      }
      SvXMLElementExport aElement( *mxExport, XML_NAMESPACE_ANIMATION, eElementToken, true, true );

      if( nContainerNodeType == EffectNodeType::TIMING_ROOT )
          exportTransitionNode();

      Reference< XEnumerationAccess > xEnumerationAccess( xContainer, UNO_QUERY_THROW );
      Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), css::uno::UNO_SET_THROW );
      while( xEnumeration->hasMoreElements() )
      {
          Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
          exportNode( xChildNode );
      }
  }
  catch (const RuntimeException&)
  {
      TOOLS_WARN_EXCEPTION("xmloff.draw", "")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "xmloff.draw")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break;
 case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "" << " " <<
 exceptionToString(tools_warn_exception)) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1054" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1054" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "" << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1054" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1054" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
  }
1056}

1058void AnimationsExporterImpl::exportAnimate( const Reference< XAnimate >& xAnimate )
1059{
  try
  {
      const sal_Int16 nNodeType = xAnimate->getType();

      OUStringBuffer sTmp;
      sal_Int16 nTemp;
      bool bTemp;

      Any aTemp( xAnimate->getTarget() );
      if( aTemp.hasValue() )
      {
          convertTarget( sTmp, aTemp );
          mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_TARGETELEMENT, sTmp.makeStringAndClear() );
      }

      nTemp = xAnimate->getSubItem();
      if( nTemp )
      {
          SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_SubItem );
          mxExport->AddAttribute( XML_NAMESPACE_ANIMATION, XML_SUB_ITEM, sTmp.makeStringAndClear() );
      }

      XMLTokenEnum eAttributeName = XML_TOKEN_INVALID;

      if( nNodeType == AnimationNodeType::TRANSITIONFILTER )
      {
          eAttributeName = XML_TRANSITIONFILTER;
      }
      else if( nNodeType == AnimationNodeType::ANIMATETRANSFORM )
      {
          eAttributeName = XML_ANIMATETRANSFORM;
      }
      else if( nNodeType == AnimationNodeType::ANIMATEMOTION )
      {
          eAttributeName = XML_ANIMATEMOTION;
      }
      else if( nNodeType == AnimationNodeType::ANIMATEPHYSICS )
      {
          eAttributeName = XML_ANIMATEPHYSICS;
      }
      else
      {
          OUString sTemp( xAnimate->getAttributeName() );
          if( !sTemp.isEmpty() )
          {
              const struct ImplAttributeNameConversion* p = getAnimationAttributeNamesConversionList();
              while( p->mpAPIName )
              {
                  if( sTemp.equalsAscii( p->mpAPIName ) )
                  {
                      sTemp = GetXMLToken( p->meXMLToken );
                      eAttributeName = p->meXMLToken;
                      break;
                  }

                  p++;
              }

              mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_ATTRIBUTENAME, sTemp );
          }
          else
          {
              mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_ATTRIBUTENAME, "invalid" );
          }
      }

      Sequence< Any > aValues( xAnimate->getValues() );
      if( aValues.hasElements() )
      {
          aTemp <<= aValues;
          convertValue( eAttributeName, sTmp, aTemp );
          mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_VALUES, sTmp.makeStringAndClear() );
      }
      else
      {
          aTemp = xAnimate->getFrom();
          if( aTemp.hasValue() )
          {
              convertValue( eAttributeName, sTmp, aTemp );
              mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_FROM, sTmp.makeStringAndClear() );
          }

          aTemp = xAnimate->getBy();
          if( aTemp.hasValue() )
          {
              convertValue( eAttributeName, sTmp, aTemp );
              mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_BY, sTmp.makeStringAndClear() );
          }

          aTemp = xAnimate->getTo();
          if( aTemp.hasValue() )
          {
              convertValue( eAttributeName, sTmp, aTemp );
              mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_TO, sTmp.makeStringAndClear() );
          }
      }

      if(nNodeType != AnimationNodeType::SET)
      {
          const Sequence< double > aKeyTimes( xAnimate->getKeyTimes() );
          if( aKeyTimes.hasElements() )
          {
              for( const auto& rKeyTime : aKeyTimes )
              {
                  if( !sTmp.isEmpty() )
                      sTmp.append( ';' );

                  sTmp.append( rKeyTime );
              }
              mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_KEYTIMES, sTmp.makeStringAndClear() );
          }

          OUString sTemp( xAnimate->getFormula() );
          if( !sTemp.isEmpty() )
              mxExport->AddAttribute( XML_NAMESPACE_ANIMATION, XML_FORMULA, sTemp );

          if( (nNodeType != AnimationNodeType::TRANSITIONFILTER) &&
              (nNodeType != AnimationNodeType::AUDIO ) )
          {
              // calcMode  = "discrete | linear | paced | spline"
              nTemp = xAnimate->getCalcMode();
              if( ((nNodeType == AnimationNodeType::ANIMATEMOTION ) && (nTemp != AnimationCalcMode::PACED)) ||
                  ((nNodeType != AnimationNodeType::ANIMATEMOTION ) && (nTemp != AnimationCalcMode::LINEAR)) )
              {
                  SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_CalcMode );
                  mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_CALCMODE, sTmp.makeStringAndClear() );
              }

              bTemp = xAnimate->getAccumulate();
              if( bTemp )
                  mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_ACCUMULATE, XML_SUM );

              nTemp = xAnimate->getAdditive();
              if( nTemp != AnimationAdditiveMode::REPLACE )
              {
                  SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_AdditiveMode );
                  mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_ADDITIVE, sTmp.makeStringAndClear() );
              }
          }

          const Sequence< TimeFilterPair > aTimeFilter( xAnimate->getTimeFilter() );
          if( aTimeFilter.hasElements() )
          {
              for( const auto& rPair : aTimeFilter )
              {
                  if( !sTmp.isEmpty() )
                      sTmp.append( ';' );

                  sTmp.append( OUString::number(rPair.Time) ).append( "," ).append( OUString::number(rPair.Progress) );
              }

              mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_KEYSPLINES, sTmp.makeStringAndClear() );
          }
      }

      XMLTokenEnum eElementToken = XML_ANIMATE;

      switch( nNodeType )
      {
      case AnimationNodeType::ANIMATE:
          eElementToken = XML_ANIMATE;
          break;

      case AnimationNodeType::SET:
          eElementToken = XML_SET;
          break;

      case AnimationNodeType::ANIMATEMOTION:
      {
          eElementToken = XML_ANIMATEMOTION;

          Reference< XAnimateMotion > xAnimateMotion( xAnimate, UNO_QUERY_THROW );

          aTemp = xAnimateMotion->getPath();
          if( aTemp.hasValue() )
          {
              convertPath( sTmp, aTemp );
              mxExport->AddAttribute( XML_NAMESPACE_SVG, XML_PATH, sTmp.makeStringAndClear() );
          }

          // TODO: origin = ( parent | layout )
          aTemp = xAnimateMotion->getOrigin();
      }
      break;

      case AnimationNodeType::ANIMATEPHYSICS:
      {
          eElementToken = XML_ANIMATEPHYSICS;
          double fTemp = 0;

          Reference< XAnimatePhysics > xAnimatePhysics( xAnimate, UNO_QUERY_THROW );
          aTemp = xAnimatePhysics->getStartVelocityX();
          if( aTemp.hasValue() )
          {
              aTemp >>= fTemp;
              ::sax::Converter::convertDouble( sTmp, fTemp );
              mxExport->AddAttribute( XML_NAMESPACE_LO_EXT, XML_PHYSICS_ANIMATION_START_VELOCITY_X, sTmp.makeStringAndClear() );
          }

          aTemp = xAnimatePhysics->getStartVelocityY();
          if( aTemp.hasValue() )
          {
              aTemp >>= fTemp;
              ::sax::Converter::convertDouble( sTmp, fTemp );
              mxExport->AddAttribute( XML_NAMESPACE_LO_EXT, XML_PHYSICS_ANIMATION_START_VELOCITY_Y, sTmp.makeStringAndClear() );
          }

          aTemp = xAnimatePhysics->getDensity();
          if( aTemp.hasValue() )
          {
              aTemp >>= fTemp;
              ::sax::Converter::convertDouble( sTmp, fTemp );
              mxExport->AddAttribute( XML_NAMESPACE_LO_EXT, XML_PHYSICS_ANIMATION_DENSITY, sTmp.makeStringAndClear() );
          }

          aTemp = xAnimatePhysics->getBounciness();
          if( aTemp.hasValue() )
          {
              aTemp >>= fTemp;
              ::sax::Converter::convertDouble( sTmp, fTemp );
              mxExport->AddAttribute( XML_NAMESPACE_LO_EXT, XML_PHYSICS_ANIMATION_BOUNCINESS, sTmp.makeStringAndClear() );
          }
      }
      break;

      case AnimationNodeType::ANIMATECOLOR:
      {
          eElementToken = XML_ANIMATECOLOR;

          Reference< XAnimateColor > xAnimateColor( xAnimate, UNO_QUERY_THROW );

          nTemp = xAnimateColor->getColorInterpolation();
          mxExport->AddAttribute( XML_NAMESPACE_ANIMATION, XML_COLOR_INTERPOLATION, (nTemp == AnimationColorSpace::RGB) ? XML_RGB : XML_HSL );

          bTemp = xAnimateColor->getDirection();
          mxExport->AddAttribute( XML_NAMESPACE_ANIMATION, XML_COLOR_INTERPOLATION_DIRECTION, bTemp ? XML_CLOCKWISE : XML_COUNTER_CLOCKWISE );
      }
      break;

      case AnimationNodeType::ANIMATETRANSFORM:
      {
          eElementToken = XML_ANIMATETRANSFORM;

          mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_ATTRIBUTENAME, XML_TRANSFORM );

          Reference< XAnimateTransform > xTransform( xAnimate, UNO_QUERY_THROW );
          nTemp = xTransform->getTransformType();
          SvXMLUnitConverter::convertEnum( sTmp, nTemp, aAnimations_EnumMap_TransformType );
          mxExport->AddAttribute( XML_NAMESPACE_SVG, XML_TYPE, sTmp.makeStringAndClear() );
      }
      break;

      case AnimationNodeType::TRANSITIONFILTER:
      {
          Reference< XTransitionFilter > xTransitionFilter( xAnimate, UNO_QUERY );
          eElementToken = XML_TRANSITIONFILTER;

          sal_Int16 nTransition = xTransitionFilter->getTransition();
          SvXMLUnitConverter::convertEnum( sTmp, nTransition, aAnimations_EnumMap_TransitionType );
          mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_TYPE, sTmp.makeStringAndClear() );

          sal_Int16 nSubtype = xTransitionFilter->getSubtype();
          if( nSubtype != TransitionSubType::DEFAULT )
          {
              SvXMLUnitConverter::convertEnum( sTmp, nSubtype, aAnimations_EnumMap_TransitionSubType );
              mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_SUBTYPE, sTmp.makeStringAndClear() );
          }

          bTemp = xTransitionFilter->getMode();
          if( !bTemp )
              mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_MODE, XML_OUT );

          bTemp = xTransitionFilter->getDirection();
          if( !bTemp )
              mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_DIRECTION, XML_REVERSE );

          if( (nTransition == TransitionType::FADE) && ((nSubtype == TransitionSubType::FADETOCOLOR) || (nSubtype == TransitionSubType::FADEFROMCOLOR) ))
          {
              nTemp = xTransitionFilter->getFadeColor();
              ::sax::Converter::convertColor( sTmp, nTemp );
              mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_FADECOLOR, sTmp.makeStringAndClear() );
          }
      }
      break;
      }

      if( eElementToken == XML_ANIMATEPHYSICS ) // not a standard should use the extension namespace
      {
          SvXMLElementExport aElement( *mxExport, XML_NAMESPACE_LO_EXT, eElementToken, true, true );
      }
      else
      {
          SvXMLElementExport aElement( *mxExport, XML_NAMESPACE_ANIMATION, eElementToken, true, true );
      }

  }
  catch (const Exception&)
  {
      TOOLS_WARN_EXCEPTION("xmloff.draw", "")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "xmloff.draw")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break;
 case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "" << " " <<
 exceptionToString(tools_warn_exception)) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1358" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1358" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "" << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1358" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1358" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
  }
1360}

1362void AnimationsExporterImpl::exportAudio( const Reference< XAudio >& xAudio )
1363{
  if( !xAudio.is() )
      return;

  try
  {
      OUString aSourceURL;
      xAudio->getSource() >>= aSourceURL;
      if( !aSourceURL.isEmpty() )
          mxExport->AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, mxExport->GetRelativeReference( aSourceURL ) );

      const double fVolume = xAudio->getVolume();
      if( fVolume != 1.0 )
      {
          OUStringBuffer sTmp;
          ::sax::Converter::convertDouble( sTmp, fVolume );
          mxExport->AddAttribute( XML_NAMESPACE_ANIMATION, XML_AUDIO_LEVEL, sTmp.makeStringAndClear() );
      }

  /* todo?
     sal_Int32 nEndAfterSlide = 0;
      xAudio->getEndAfterSlide() >>= nEndAfterSlide;
      if( nEndAfterSlide != 0 )
          mxExport->AddAttribute( );
  */
      SvXMLElementExport aElement( *mxExport, XML_NAMESPACE_ANIMATION, XML_AUDIO, true, true );

  }
  catch (const Exception&)
  {
      TOOLS_WARN_EXCEPTION("xmloff.draw", "")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "xmloff.draw")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break;
 case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "" << " " <<
 exceptionToString(tools_warn_exception)) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1393" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1393" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "" << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1393" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1393" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
  }
1395}

1397void AnimationsExporterImpl::exportCommand( const Reference< XCommand >& xCommand )
1398{
  if( !xCommand.is() )
      return;

  try
  {
      OUStringBuffer sTmp;
      Any aTemp( xCommand->getTarget() );
      if( aTemp.hasValue() )
      {
          convertTarget( sTmp, aTemp );
          mxExport->AddAttribute( XML_NAMESPACE_SMIL, XML_TARGETELEMENT, sTmp.makeStringAndClear() );
      }

      sal_Int16 nCommand = xCommand->getCommand();
      SvXMLUnitConverter::convertEnum( sTmp, nCommand, aAnimations_EnumMap_Command );
      mxExport->AddAttribute( XML_NAMESPACE_ANIMATION, XML_COMMAND, sTmp.makeStringAndClear() );

  // todo virtual css::uno::Any SAL_CALL getParameter() throw (css::uno::RuntimeException) = 0;

      SvXMLElementExport aElement( *mxExport, XML_NAMESPACE_ANIMATION, XML_COMMAND, true, true );

  }
  catch (const Exception&)
  {
      TOOLS_WARN_EXCEPTION("xmloff.draw", "")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "xmloff.draw")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break;
 case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "" << " " <<
 exceptionToString(tools_warn_exception)) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1423" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1423" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "" << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1423" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1423" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
  }
1425}

1427Reference< XInterface > AnimationsExporterImpl::getParagraphTarget( const ParagraphTarget& pTarget )
1428{
  try
  {
      Reference< XEnumerationAccess > xParaEnumAccess( pTarget.Shape, UNO_QUERY_THROW );

      Reference< XEnumeration > xEnumeration( xParaEnumAccess->createEnumeration(), css::uno::UNO_SET_THROW );
      sal_Int32 nParagraph = pTarget.Paragraph;

      while( xEnumeration->hasMoreElements() )
      {
          Reference< XInterface > xRef( xEnumeration->nextElement(), UNO_QUERY );
          if( nParagraph-- == 0 )
              return xRef;
      }
  }
  catch (const RuntimeException&)
  {
      TOOLS_WARN_EXCEPTION("xmloff.draw", "")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "xmloff.draw")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break;
 case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "" << " " <<
 exceptionToString(tools_warn_exception)) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1445" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1445" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "" << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1445" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1445" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
  }

  Reference< XInterface > xRef;
  return xRef;
1450}

1452void AnimationsExporterImpl::convertPath( OUStringBuffer& sTmp, const Any& rPath )
1453{
  OUString aStr;
  rPath >>= aStr;

  sTmp = aStr;
1458}

1460void AnimationsExporterImpl::convertValue( XMLTokenEnum eAttributeName, OUStringBuffer& sTmp, const Any& rValue ) const
1461{
  if( !rValue.hasValue() )
      return;

  if( auto pValuePair = o3tl::tryAccess<ValuePair>(rValue) )
  {
      OUStringBuffer sTmp2;
      convertValue( eAttributeName, sTmp, pValuePair->First );
      sTmp.append( ',' );
      convertValue( eAttributeName, sTmp2, pValuePair->Second );
      sTmp.append( sTmp2.makeStringAndClear() );
  }
  else if( auto pSequence = o3tl::tryAccess<Sequence<Any>>(rValue) )
  {
      const sal_Int32 nLength = pSequence->getLength();
      sal_Int32 nElement;
      const Any* pAny = pSequence->getConstArray();

      OUStringBuffer sTmp2;

      for( nElement = 0; nElement < nLength; nElement++, pAny++ )
      {
          if( !sTmp.isEmpty() )
              sTmp.append( ';' );
          convertValue( eAttributeName, sTmp2, *pAny );
          sTmp.append( sTmp2.makeStringAndClear() );
      }
  }
  else
  {
      sal_Int32 nType;

      switch( eAttributeName )
      {
      case XML_X:
      case XML_Y:
      case XML_WIDTH:
      case XML_HEIGHT:
      case XML_ANIMATETRANSFORM:
      case XML_ANIMATEMOTION:
      case XML_ANIMATEPHYSICS:
      {
          if( auto aString = o3tl::tryAccess<OUString>(rValue) )
          {
              sTmp.append( *aString );
          }
          else if( auto x = o3tl::tryAccess<double>(rValue) )
          {
              sTmp.append( *x );
          }
          else
          {
              OSL_FAIL( "xmloff::AnimationsExporterImpl::convertValue(), invalid value type!" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1513" ": "), "%s", "xmloff::AnimationsExporterImpl::convertValue(), invalid value type!"
); } } while (false);
          }
          return;
      }

      case XML_SKEWX:
      case XML_ROTATE:            nType = XML_TYPE_DOUBLE0x0000200e;                    break;
      case XML_TEXT_ROTATION_ANGLE: nType = XML_TYPE_NUMBER160x0000200c;                break;
      case XML_FILL_COLOR:
      case XML_STROKE_COLOR:
      case XML_DIM:
      case XML_COLOR:             nType = XML_TYPE_COLOR0x00002009;                     break;
      case XML_FILL:              nType = XML_SD_TYPE_FILLSTYLE((0x2 << 10) + 9 );              break;
      case XML_STROKE:            nType = XML_SD_TYPE_STROKE((0x2 << 10) + 0);                 break;
      case XML_FONT_WEIGHT:       nType = XML_TYPE_TEXT_WEIGHT((0x3 << 10) + 10);               break;
      case XML_FONT_STYLE:        nType = XML_TYPE_TEXT_POSTURE((0x3 << 10) + 7);              break;
      case XML_TEXT_UNDERLINE:    nType = XML_TYPE_TEXT_UNDERLINE_STYLE((0x3 << 10) + 9);      break;
      case XML_FONT_SIZE:         nType = XML_TYPE_DOUBLE_PERCENT0x00002024;            break;
      case XML_VISIBILITY:        nType = XML_SD_TYPE_PRESPAGE_VISIBILITY((0x2 << 10) + 5);    break;
      case XML_OPACITY:
      case XML_TRANSITIONFILTER:  nType = XML_TYPE_DOUBLE0x0000200e;                    break;
      default:
          OSL_FAIL( "xmloff::AnimationsExporterImpl::convertValue(), invalid AttributeName!" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1535" ": "), "%s", "xmloff::AnimationsExporterImpl::convertValue(), invalid AttributeName!"
); } } while (false);
          nType = XML_TYPE_STRING0x00002008;
      }

      //const XMLPropertyHandler* pHandler = static_cast<SdXMLExport*>(&mrExport)->GetSdPropHdlFactory()->GetPropertyHandler( nType );
      const XMLPropertyHandler* pHandler = mxSdPropHdlFactory->GetPropertyHandler( nType );
      if( pHandler )
      {
          OUString aString;
          pHandler->exportXML( aString, rValue, mxExport->GetMM100UnitConverter() );
          sTmp.append( aString );
      }
  }
1548}

1550void AnimationsExporterImpl::convertTiming( OUStringBuffer& sTmp, const Any& rValue ) const
1551{
  if( !rValue.hasValue() )
5
←
Taking false branch→
      return;

  if( auto pSequence = o3tl::tryAccess<Sequence<Any>>(rValue) )
6
←
Assuming 'pSequence' is null→
7
←
Taking false branch→
  {
      const sal_Int32 nLength = pSequence->getLength();
      sal_Int32 nElement;
      const Any* pAny = pSequence->getConstArray();

      OUStringBuffer sTmp2;

      for( nElement = 0; nElement < nLength; nElement++, pAny++ )
      {
          if( !sTmp.isEmpty() )
              sTmp.append( ';' );
          convertTiming( sTmp2, *pAny );
          sTmp.append( sTmp2.makeStringAndClear() );
      }
  }
  else if( auto x = o3tl::tryAccess<double>(rValue) )
8
←
Calling 'tryAccess<double>'→
  {
      sTmp.append( *x );
      sTmp.append( 's');
  }
  else if( auto pTiming = o3tl::tryAccess<Timing>(rValue) )
  {
      sTmp.append( GetXMLToken( (*pTiming == Timing_MEDIA) ? XML_MEDIA : XML_INDEFINITE ) );
  }
  else if( auto pEvent = o3tl::tryAccess<Event>(rValue) )
  {
      OUStringBuffer sTmp2;

      if( pEvent->Trigger != EventTrigger::NONE )
      {
          if( pEvent->Source.hasValue() )
          {
              convertTarget( sTmp, pEvent->Source );
              sTmp.append( '.' );
          }

          SvXMLUnitConverter::convertEnum( sTmp2, pEvent->Trigger, aAnimations_EnumMap_EventTrigger );

          sTmp.append( sTmp2.makeStringAndClear() );
      }

      if( pEvent->Offset.hasValue() )
      {
          convertTiming( sTmp2, pEvent->Offset );

          if( !sTmp.isEmpty() )
              sTmp.append( '+' );

          sTmp.append( sTmp2.makeStringAndClear() );
      }
  }
  else
  {
      OSL_FAIL( "xmloff::AnimationsExporterImpl::convertTiming(), invalid value type!" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1609" ": "), "%s", "xmloff::AnimationsExporterImpl::convertTiming(), invalid value type!"
); } } while (false);
  }
1611}

1613void AnimationsExporterImpl::convertTarget( OUStringBuffer& sTmp, const Any& rTarget ) const
1614{
  if( !rTarget.hasValue() )
      return;

  Reference< XInterface > xRef;

  if( !(rTarget >>= xRef) )
  {
      if( auto pt = o3tl::tryAccess<ParagraphTarget>(rTarget) )
      {
          xRef = getParagraphTarget( *pt );
      }
  }

  SAL_WARN_IF( !xRef.is(), "xmloff", "xmloff::AnimationsExporterImpl::convertTarget(), invalid target type!" )do { if (true && (!xRef.is())) { switch (sal_detail_log_report
(::SAL_DETAIL_LOG_LEVEL_WARN, "xmloff")) { case SAL_DETAIL_LOG_ACTION_IGNORE
: break; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail
::getResult( ::sal::detail::StreamStart() << "xmloff::AnimationsExporterImpl::convertTarget(), invalid target type!"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("xmloff"
), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1628" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "xmloff::AnimationsExporterImpl::convertTarget(), invalid target type!"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "xmloff::AnimationsExporterImpl::convertTarget(), invalid target type!"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("xmloff"
), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1628" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "xmloff::AnimationsExporterImpl::convertTarget(), invalid target type!"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("xmloff"
), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1628" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "xmloff::AnimationsExporterImpl::convertTarget(), invalid target type!"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "xmloff::AnimationsExporterImpl::convertTarget(), invalid target type!"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("xmloff"
), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1628" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  if( xRef.is() )
  {
      const OUString& rIdentifier = mxExport->getInterfaceToIdentifierMapper().getIdentifier(xRef);
      if( !rIdentifier.isEmpty() )
          sTmp.append( rIdentifier );
  }
1635}

1637void AnimationsExporterImpl::prepareValue( const Any& rValue )
1638{
  if( !rValue.hasValue() )
      return;

  if( auto pValuePair = o3tl::tryAccess<ValuePair>(rValue) )
  {
      prepareValue( pValuePair->First );
      prepareValue( pValuePair->Second );
  }
  else if( auto pSequence = o3tl::tryAccess<Sequence<Any>>(rValue) )
  {
      const sal_Int32 nLength = pSequence->getLength();
      sal_Int32 nElement;
      const Any* pAny = pSequence->getConstArray();

      for( nElement = 0; nElement < nLength; nElement++, pAny++ )
          prepareValue( *pAny );
  }
  else if( rValue.getValueTypeClass() == css::uno::TypeClass_INTERFACE )
  {
      Reference< XInterface> xRef( rValue, UNO_QUERY );
      if( xRef.is() )
          mxExport->getInterfaceToIdentifierMapper().registerReference( xRef );
  }
  else if( auto pt = o3tl::tryAccess<ParagraphTarget>(rValue) )
  {
      Reference< XInterface> xRef( getParagraphTarget( *pt ) );
      if( xRef.is() )
          mxExport->getInterfaceToIdentifierMapper().registerReference( xRef );
  }
  else if( auto pEvent = o3tl::tryAccess<Event>(rValue) )
  {
      prepareValue( pEvent->Source );
  }
1672}

1674AnimationsExporter::AnimationsExporter( SvXMLExport& rExport, const Reference< XPropertySet >& xPageProps )
  : mpImpl( new AnimationsExporterImpl( rExport, xPageProps ) )
1676{
1677}

1679AnimationsExporter::~AnimationsExporter()
1680{
1681}

1683void AnimationsExporter::prepare( const Reference< XAnimationNode >& xRootNode )
1684{
  try
  {
      if( xRootNode.is() )
      {
          mpImpl->prepareTransitionNode();
          mpImpl->prepareNode( xRootNode );
      }
  }
  catch (const RuntimeException&)
  {
      TOOLS_WARN_EXCEPTION("xmloff.draw", "")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "xmloff.draw")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break;
 case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "" << " " <<
 exceptionToString(tools_warn_exception)) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1695" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1695" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "" << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1695" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1695" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
  }
1697}

1699void AnimationsExporter::exportAnimations( const Reference< XAnimationNode >& xRootNode )
1700{
  try
  {
      if( xRootNode.is() )
      {
          bool bHasEffects = mpImpl->mbHasTransition;

          if( !bHasEffects )
          {
              // first check if there are no animations
              Reference< XEnumerationAccess > xEnumerationAccess( xRootNode, UNO_QUERY_THROW );
              Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), css::uno::UNO_SET_THROW );
              if( xEnumeration->hasMoreElements() )
              {
                  // first child node may be an empty main sequence, check this
                  Reference< XAnimationNode > xMainNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
                  Reference< XEnumerationAccess > xMainEnumerationAccess( xMainNode, UNO_QUERY_THROW );
                  Reference< XEnumeration > xMainEnumeration( xMainEnumerationAccess->createEnumeration(), css::uno::UNO_SET_THROW );

                  // only export if the main sequence is not empty or if there are additional
                  // trigger sequences
                  bHasEffects = xMainEnumeration->hasMoreElements() || xEnumeration->hasMoreElements();
              }
          }

          if( bHasEffects )
              mpImpl->exportNode( xRootNode );
      }
  }
  catch (const RuntimeException&)
  {
      TOOLS_WARN_EXCEPTION("xmloff.draw", "")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "xmloff.draw")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break;
 case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "" << " " <<
 exceptionToString(tools_warn_exception)) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1731" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1731" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "" << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1731" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("xmloff.draw"), ("/home/maarten/src/libreoffice/core/xmloff/source/draw/animationexport.cxx"
 ":" "1731" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
  }
1733}

1735}

1737/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/include/o3tl/any.hxx

→

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#ifndef INCLUDED_O3TL_ANY_HXX
11#define INCLUDED_O3TL_ANY_HXX
12 
13#include <sal/config.h>
14 
15#include <cassert>
16#include <type_traits>
17#include <utility>
18 
19#include <optional>
20 
21#include <com/sun/star/uno/Any.hxx>
22#include <com/sun/star/uno/RuntimeException.hpp>
23#include <com/sun/star/uno/Reference.hxx>
24#include <com/sun/star/uno/XInterface.hpp>
25#include <cppu/unotype.hxx>
26#include <rtl/ustring.hxx>
27#include <sal/types.h>
28 
29// Some functionality related to css::uno::Any that would ideally be part of
30// <com/sun/star/uno/Any.hxx>, but (for now) cannot be for some reason.
31 
32namespace o3tl {
33 
34namespace detail {
35 
36struct Void {};
37 
38template<typename T> struct Optional { using type = T const *; };
39template<> struct Optional<void> { using type = std::optional<Void const>; };
40template<> struct Optional<bool> { using type = std::optional<bool const>; };
41template<> struct Optional<sal_Int8> {
42    using type = std::optional<sal_Int8 const>;
43};
44template<> struct Optional<sal_Int16> {
45    using type = std::optional<sal_Int16 const>;
46};
47template<> struct Optional<sal_uInt16> {
48    using type = std::optional<sal_uInt16 const>;
49};
50template<> struct Optional<sal_Int32> {
51    using type = std::optional<sal_Int32 const>;
52};
53template<> struct Optional<sal_uInt32> {
54    using type = std::optional<sal_uInt32 const>;
55};
56template<> struct Optional<sal_Int64> {
57    using type = std::optional<sal_Int64 const>;
58};
59template<> struct Optional<sal_uInt64> {
60    using type = std::optional<sal_uInt64 const>;
61};
62template<> struct Optional<float> {
63    using type = std::optional<float const>;
64};
65template<> struct Optional<double> {
66    using type = std::optional<double const>;
67};
68template<typename T> struct Optional<css::uno::Reference<T>> {
69    using type = std::optional<css::uno::Reference<T> const>;
70};
71template<> struct Optional<css::uno::Reference<css::uno::XInterface>> {
72    using type = css::uno::Reference<css::uno::XInterface> const *;
73};
74 
75template<typename> struct IsDerivedReference: std::false_type {};
76template<typename T> struct IsDerivedReference<css::uno::Reference<T>>:
77    std::true_type
78{};
79template<> struct IsDerivedReference<css::uno::Reference<css::uno::XInterface>>:
80    std::false_type
81{};
82 
83template<typename> struct IsUnoSequenceType: std::false_type {};
84template<typename T> struct IsUnoSequenceType<cppu::UnoSequenceType<T>>:
85    std::true_type
86{};
87 
88template<typename T> inline std::optional<T const> tryGetConverted(
89    css::uno::Any const & any)
90{
91    T v;
92    return (any >>= v)
10
←
Calling 'operator>>=<double>'→
93        ? std::optional<T const>(std::move(v)) : std::optional<T const>();
94}
95 
96}
97 
98/** Try to access the value of a specific type stored in an Any.
99 
100    In trying to obtain a value, the same set of conversions as supported by
101    ">>=" are considered.
102 
103    The returned object is a proxy.  Proxies can be either positive or negative.
104    Each proxy can be contextually converted to bool, yielding true iff the
105    proxy is positive.  For a positive proxy P representing a value of requested
106    type T, for any T other than void, the expression *P yields that value of
107    type T.  (Technically, the proxy is either a plain pointer or a
108    std::optional, depending on whether a plain pointer into the given Any can
109    be returned for the specified type.)
110 
111    @attention A proxy returned from this function must not outlive the
112    corresponding Any passed into this function (as it may constitute a pointer
113    into the Any's internals).  That is the reason why this function is
114    restricted to lvalue arguments (i.e., to non-temporary Any objects), to
115    avoid misuses like
116    @code
117      css::uno::Any f();
118 
119      if (auto p = o3tl::tryAccess<css::beans::NamedValue>(f())) {
120        return p->Name;
121      }
122    @endcode
123 
124    @note Ideally this would be a public member function of css::uno::Any (at
125    least conditional on LIBO_INTERNAL_ONLY, as it requires C++11).  However, as
126    std::optional (which would be needed to implement the proxies) is only
127    available since C++14, we need to use std::optional for now.  But To not
128    make every entity that includes <com/sun/star/uno/Any.hxx> depend on
129    boost_headers, keep this here for now.
130 
131    @tparam T  the C++ representation of a UNO type that can be contained in a
132    UNO ANY (i.e., any UNO type other than ANY itself).  The legacy C++
133    representations sal_Bool, cppu::UnoVoidType, cppu::UnoUnsignedShortType,
134    cppu::UnoCharType, and cppu::UnoSequenceType are not supported.  Must be a
135    complete type or void.
136 
137    @param any  an Any value.
138 
139    @return a positive proxy for the value of the specified type obtained from
140    the given Any, or a negative proxy if no such value can be obtained.
141*/
142template<typename T> inline
143typename std::enable_if<
144    !(detail::IsDerivedReference<T>::value
145      || detail::IsUnoSequenceType<T>::value
146      || std::is_base_of<css::uno::XInterface, T>::value),
147    typename detail::Optional<T>::type>::type
148tryAccess(css::uno::Any const & any) {
149    // CHAR, STRING, TYPE, sequence types, enum types, struct types, exception
150    // types, and com.sun.star.uno.XInterface interface type:
151    return cppu::UnoType<T>::get().isAssignableFrom(any.getValueType())
152        ? static_cast<T const *>(any.getValue()) : nullptr;
153}
154 
155template<> inline detail::Optional<void>::type tryAccess<void>(
156    css::uno::Any const & any)
157{
158    return any.hasValue()
159        ? std::optional<detail::Void const>()
160        : std::optional<detail::Void const>(detail::Void());
161}
162 
163template<> inline detail::Optional<bool>::type tryAccess<bool>(
164    css::uno::Any const & any)
165{
166    return detail::tryGetConverted<bool>(any);
167}
168 
169template<> inline detail::Optional<sal_Int8>::type tryAccess<sal_Int8>(
170    css::uno::Any const & any)
171{
172    return detail::tryGetConverted<sal_Int8>(any);
173}
174 
175template<> inline detail::Optional<sal_Int16>::type tryAccess<sal_Int16>(
176    css::uno::Any const & any)
177{
178    return detail::tryGetConverted<sal_Int16>(any);
179}
180 
181template<> inline detail::Optional<sal_uInt16>::type tryAccess<sal_uInt16>(
182    css::uno::Any const & any)
183{
184    return detail::tryGetConverted<sal_uInt16>(any);
185}
186 
187template<> inline detail::Optional<sal_Int32>::type tryAccess<sal_Int32>(
188    css::uno::Any const & any)
189{
190    return detail::tryGetConverted<sal_Int32>(any);
191}
192 
193template<> inline detail::Optional<sal_uInt32>::type tryAccess<sal_uInt32>(
194    css::uno::Any const & any)
195{
196    return detail::tryGetConverted<sal_uInt32>(any);
197}
198 
199template<> inline detail::Optional<sal_Int64>::type tryAccess<sal_Int64>(
200    css::uno::Any const & any)
201{
202    return detail::tryGetConverted<sal_Int64>(any);
203}
204 
205template<> inline detail::Optional<sal_uInt64>::type tryAccess<sal_uInt64>(
206    css::uno::Any const & any)
207{
208    return detail::tryGetConverted<sal_uInt64>(any);
209}
210 
211template<> inline detail::Optional<float>::type tryAccess<float>(
212    css::uno::Any const & any)
213{
214    return detail::tryGetConverted<float>(any);
215}
216 
217template<> inline detail::Optional<double>::type tryAccess<double>(
218    css::uno::Any const & any)
219{
220    return detail::tryGetConverted<double>(any);
9
←
Calling 'tryGetConverted<double>'→
221}
222 
223template<> detail::Optional<css::uno::Any>::type tryAccess<css::uno::Any>(
224    css::uno::Any const &) = delete;
225 
226template<> detail::Optional<sal_Bool>::type tryAccess<sal_Bool>(
227    css::uno::Any const &) = delete;
228 
229/*
230 
231// Already prevented by std::is_base_of<css::uno::XInterface, T> requiring T to
232// be complete:
233 
234template<> detail::Optional<cppu::UnoVoidType>::type
235tryAccess<cppu::UnoVoidType>(css::uno::Any const &) = delete;
236 
237template<> detail::Optional<cppu::UnoUnsignedShortType>::type
238tryAccess<cppu::UnoUnsignedShortType>(css::uno::Any const &) = delete;
239 
240template<> detail::Optional<cppu::UnoCharType>::type
241tryAccess<cppu::UnoCharType>(css::uno::Any const &) = delete;
242 
243*/
244 
245template<typename T> inline
246typename std::enable_if<
247    detail::IsDerivedReference<T>::value,
248    typename detail::Optional<T>::type>::type
249tryAccess(css::uno::Any const & any) {
250    return detail::tryGetConverted<T>(any);
251}
252 
253template<typename T> typename detail::Optional<T>::type tryAccess(
254    css::uno::Any const volatile &&) = delete;
255 
256/** Access the value of a specific type stored in an Any, throwing an exception
257    on failure.
258 
259    @attention A proxy returned from this function must not outlive the
260    corresponding Any passed into this function (as it may constitute a pointer
261    into the Any's internals).  However, unlike with tryAccess, the benefit of
262    allowing this function to operate on temporaries appears to outweigh its
263    dangers.
264 
265    @note Ideally this would be a public member function of css::uno::Any.  See
266    tryAccess for details.
267 
268    @tparam T  the C++ representation of a UNO type that can be contained in a
269    UNO ANY.  See tryAccess for details.
270 
271    @param any  an Any value.
272 
273    @return a positive proxy for the value of the specified type obtained from
274    the given Any.  See tryAccess for details.
275 
276    @throws css::uno::RuntimeException  when a value of the requested type
277    cannot be obtained.
278*/
279template<typename T> inline typename detail::Optional<T>::type doAccess(
280    css::uno::Any const & any)
281{
282    auto opt = tryAccess<T>(any);
283    if (!opt) {
284        throw css::uno::RuntimeException(
285            OUString(
286                cppu_Any_extraction_failure_msg(
287                    &any, cppu::UnoType<T>::get().getTypeLibType()),
288                SAL_NO_ACQUIRE));
289    }
290    return opt;
291}
292 
293/** Access the value of a specific type stored in an Any, knowing the Any
294    contains a value of a matching type.
295 
296    @attention A proxy returned from this function must not outlive the
297    corresponding Any passed into this function (as it may constitute a pointer
298    into the Any's internals).  However, unlike with tryAccess, the benefit of
299    allowing this function to operate on temporaries appears to outweigh its
300    dangers.
301 
302    @note Ideally this would be a public member function of css::uno::Any.  See
303    tryAccess for details.
304 
305    @tparam T  the C++ representation of a UNO type that can be contained in a
306    UNO ANY.  See tryAccess for details.
307 
308    @param any  an Any value.
309 
310    @return a positive proxy for the value of the specified type obtained from
311    the given Any.  See tryAccess for details.
312*/
313template<typename T> inline typename detail::Optional<T>::type forceAccess(
314    css::uno::Any const & any)
315{
316    auto opt = tryAccess<T>(any);
317    assert(opt)(static_cast <bool> (opt) ? void (0) : __assert_fail ("opt"
, "/home/maarten/src/libreoffice/core/include/o3tl/any.hxx", 317
, __extension__ __PRETTY_FUNCTION__));
318    return opt;
319}
320 
321}
322 
323#endif
324 
325/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */

←

/home/maarten/src/libreoffice/core/include/com/sun/star/uno/Any.hxx

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#ifndef INCLUDED_COM_SUN_STAR_UNO_ANY_HXX
20#define INCLUDED_COM_SUN_STAR_UNO_ANY_HXX
21 
22#include "sal/config.h"
23 
24#include <algorithm>
25#include <cassert>
26#include <cstddef>
27#include <iomanip>
28#include <ostream>
29#include <utility>
30 
31#include "com/sun/star/uno/Any.h"
32#include "uno/data.h"
33#include "uno/sequence2.h"
34#include "com/sun/star/uno/Type.hxx"
35#include "com/sun/star/uno/Reference.h"
36#include "com/sun/star/uno/genfunc.hxx"
37#include "com/sun/star/uno/RuntimeException.hpp"
38#include "cppu/cppudllapi.h"
39#include "cppu/unotype.hxx"
40 
41extern "C" CPPU_DLLPUBLIC__attribute__ ((visibility("default"))) rtl_uString * SAL_CALL cppu_Any_extraction_failure_msg(
42    uno_Any const * pAny, typelib_TypeDescriptionReference * pType )
43    SAL_THROW_EXTERN_C()throw ();
44 
45namespace com
46{
47namespace sun
48{
49namespace star
50{
51namespace uno
52{
53 
54 
55inline Any::Any()
56{
57    ::uno_any_construct( this, NULL__null, NULL__null, cpp_acquire );
58}
59 
60 
61template <typename T>
62inline Any::Any( T const & value )
63{
64    ::uno_type_any_construct(
65        this, const_cast<T *>(&value),
66        ::cppu::getTypeFavourUnsigned(&value).getTypeLibType(),
67        cpp_acquire );
68}
69 
70inline Any::Any( bool value )
71{
72    sal_Bool b = value;
73    ::uno_type_any_construct(
74        this, &b, cppu::UnoType<bool>::get().getTypeLibType(),
75        cpp_acquire );
76}
77 
78#if defined LIBO_INTERNAL_ONLY1
79template<typename T1, typename T2>
80Any::Any(rtl::OUStringConcat<T1, T2> && value):
81    Any(rtl::OUString(std::move(value)))
82{}
83#endif
84 
85inline Any::Any( const Any & rAny )
86{
87    ::uno_type_any_construct( this, rAny.pData, rAny.pType, cpp_acquire );
88}
89 
90inline Any::Any( const void * pData_, const Type & rType )
91{
92    ::uno_type_any_construct(
93        this, const_cast< void * >( pData_ ), rType.getTypeLibType(),
94        cpp_acquire );
95}
96 
97inline Any::Any( const void * pData_, typelib_TypeDescription * pTypeDescr )
98{
99    ::uno_any_construct(
100        this, const_cast< void * >( pData_ ), pTypeDescr, cpp_acquire );
101}
102 
103inline Any::Any( const void * pData_, typelib_TypeDescriptionReference * pType_ )
104{
105    ::uno_type_any_construct(
106        this, const_cast< void * >( pData_ ), pType_, cpp_acquire );
107}
108 
109inline Any::~Any()
110{
111    ::uno_any_destruct(
112        this, cpp_release );
113}
114 
115inline Any & Any::operator = ( const Any & rAny )
116{
117    if (this != &rAny)
118    {
119        ::uno_type_any_assign(
120            this, rAny.pData, rAny.pType,
121            cpp_acquire, cpp_release );
122    }
123    return *this;
124}
125 
126#if defined LIBO_INTERNAL_ONLY1
127 
128namespace detail {
129 
130inline void moveAnyInternals(Any & from, Any & to) noexcept {
131    uno_any_construct(&to, nullptr, nullptr, &cpp_acquire);
132    std::swap(from.pType, to.pType);
133    std::swap(from.pData, to.pData);
134    std::swap(from.pReserved, to.pReserved);
135    if (to.pData == &from.pReserved) {
136        to.pData = &to.pReserved;
137    }
138    // This leaves from.pData (where "from" is now VOID) dangling to somewhere (cf.
139    // CONSTRUCT_EMPTY_ANY, cppu/source/uno/prim.hxx), but what's relevant is
140    // only that it isn't a nullptr (as e.g. >>= -> uno_type_assignData ->
141    // _assignData takes a null pSource to mean "construct a default value").
142}
143 
144}
145 
146Any::Any(Any && other) noexcept {
147    detail::moveAnyInternals(other, *this);
148}
149 
150Any & Any::operator =(Any && other) noexcept {
151    uno_any_destruct(this, &cpp_release);
152    detail::moveAnyInternals(other, *this);
153    return *this;
154}
155 
156#endif
157 
158inline ::rtl::OUString Any::getValueTypeName() const
159{
160    return ::rtl::OUString( pType->pTypeName );
161}
162 
163inline void Any::setValue( const void * pData_, const Type & rType )
164{
165    ::uno_type_any_assign(
166        this, const_cast< void * >( pData_ ), rType.getTypeLibType(),
167        cpp_acquire, cpp_release );
168}
169 
170inline void Any::setValue( const void * pData_, typelib_TypeDescriptionReference * pType_ )
171{
172    ::uno_type_any_assign(
173        this, const_cast< void * >( pData_ ), pType_,
174        cpp_acquire, cpp_release );
175}
176 
177inline void Any::setValue( const void * pData_, typelib_TypeDescription * pTypeDescr )
178{
179    ::uno_any_assign(
180        this, const_cast< void * >( pData_ ), pTypeDescr,
181        cpp_acquire, cpp_release );
182}
183 
184inline void Any::clear()
185{
186    ::uno_any_clear(
187        this, cpp_release );
188}
189 
190inline bool Any::isExtractableTo( const Type & rType ) const
191{
192    return ::uno_type_isAssignableFromData(
193        rType.getTypeLibType(), pData, pType,
194        cpp_queryInterface, cpp_release );
195}
196 
197 
198template <typename T>
199inline bool Any::has() const
200{
201    Type const & rType = ::cppu::getTypeFavourUnsigned(static_cast< T * >(0));
202    return ::uno_type_isAssignableFromData(
203        rType.getTypeLibType(), pData, pType,
204        cpp_queryInterface,
205        cpp_release );
206}
207 
208#if defined LIBO_INTERNAL_ONLY1
209template<> bool Any::has<Any>() const = delete;
210#endif
211 
212inline bool Any::operator == ( const Any & rAny ) const
213{
214    return ::uno_type_equalData(
215        pData, pType, rAny.pData, rAny.pType,
216        cpp_queryInterface, cpp_release );
217}
218 
219inline bool Any::operator != ( const Any & rAny ) const
220{
221    return (! ::uno_type_equalData(
222        pData, pType, rAny.pData, rAny.pType,
223        cpp_queryInterface, cpp_release ));
224}
225 
226 
227template< class C >
228inline Any SAL_CALL makeAny( const C & value )
229{
230    return Any(value);
231}
232 
233#if !defined LIBO_INTERNAL_ONLY1
234template<> Any makeAny(sal_uInt16 const & value)
235{ return Any(&value, cppu::UnoType<cppu::UnoUnsignedShortType>::get()); }
236#endif
237 
238template<typename T> Any toAny(T const & value) { return makeAny(value); }
239 
240template<> Any toAny(Any const & value) { return value; }
241 
242#if defined LIBO_INTERNAL_ONLY1
243 
244template<typename T1, typename T2>
245Any makeAny(rtl::OUStringConcat<T1, T2> && value)
246{ return Any(std::move(value)); }
247 
248template<typename T1, typename T2>
249Any toAny(rtl::OUStringConcat<T1, T2> && value)
250{ return makeAny(std::move(value)); }
251 
252template<typename T>
253Any makeAny(rtl::OUStringNumber<T> && value)
254{ return Any(OUString(std::move(value))); }
255 
256template<typename T>
257Any toAny(rtl::OUStringNumber<T> && value)
258{ return makeAny(std::move(value)); }
259 
260template<typename T> bool fromAny(Any const & any, T * value) {
261    assert(value != nullptr)(static_cast <bool> (value != nullptr) ? void (0) : __assert_fail
 ("value != nullptr", "/home/maarten/src/libreoffice/core/include/com/sun/star/uno/Any.hxx"
, 261, __extension__ __PRETTY_FUNCTION__));
262    return any >>= *value;
263}
264 
265template<> bool fromAny(Any const & any, Any * value) {
266    assert(value != nullptr)(static_cast <bool> (value != nullptr) ? void (0) : __assert_fail
 ("value != nullptr", "/home/maarten/src/libreoffice/core/include/com/sun/star/uno/Any.hxx"
, 266, __extension__ __PRETTY_FUNCTION__));
267    *value = any;
268    return true;
269}
270 
271#endif
272 
273template< class C >
274inline void SAL_CALL operator <<= ( Any & rAny, const C & value )
275{
276    const Type & rType = ::cppu::getTypeFavourUnsigned(&value);
277    ::uno_type_any_assign(
278        &rAny, const_cast< C * >( &value ), rType.getTypeLibType(),
279        cpp_acquire, cpp_release );
280}
281 
282// additionally for C++ bool:
283 
284template<>
285inline void SAL_CALL operator <<= ( Any & rAny, bool const & value )
286{
287    sal_Bool b = value;
288    ::uno_type_any_assign(
289        &rAny, &b, cppu::UnoType<bool>::get().getTypeLibType(),
290        cpp_acquire, cpp_release );
291}
292 
293 
294#ifdef LIBO_INTERNAL_ONLY1 // "RTL_FAST_STRING"
295template< class C1, class C2 >
296inline void SAL_CALL operator <<= ( Any & rAny, rtl::OUStringConcat< C1, C2 >&& value )
297{
298    const rtl::OUString str( std::move(value) );
299    const Type & rType = ::cppu::getTypeFavourUnsigned(&str);
300    ::uno_type_any_assign(
301        &rAny, const_cast< rtl::OUString * >( &str ), rType.getTypeLibType(),
302        cpp_acquire, cpp_release );
303}
304template<typename T1, typename T2>
305void operator <<=(Any &, rtl::OUStringConcat<T1, T2> const &) = delete;
306template< class C >
307inline void SAL_CALL operator <<= ( Any & rAny, rtl::OUStringNumber< C >&& value )
308{
309    const rtl::OUString str( std::move(value) );
310    const Type & rType = ::cppu::getTypeFavourUnsigned(&str);
311    ::uno_type_any_assign(
312        &rAny, const_cast< rtl::OUString * >( &str ), rType.getTypeLibType(),
313        cpp_acquire, cpp_release );
314}
315template<typename T>
316void operator <<=(Any &, rtl::OUStringNumber<T> const &) = delete;
317#endif
318 
319#if defined LIBO_INTERNAL_ONLY1
320template<> void SAL_CALL operator <<=(Any &, Any const &) = delete;
321#endif
322 
323template< class C >
324inline bool SAL_CALL operator >>= ( const Any & rAny, C & value )
325{
326    const Type & rType = ::cppu::getTypeFavourUnsigned(&value);
327    return ::uno_type_assignData(
328        &value, rType.getTypeLibType(),
329        rAny.pData, rAny.pType,
330        cpp_queryInterface,
331        cpp_acquire, cpp_release );
332}
333 
334// bool
335 
336template<>
337inline bool SAL_CALL operator >>= ( const ::com::sun::star::uno::Any & rAny, sal_Bool & value )
338{
339    if (typelib_TypeClass_BOOLEAN == rAny.pType->eTypeClass)
340    {
341        value = bool(* static_cast< const sal_Bool * >( rAny.pData ));
342        return true;
343    }
344    return false;
345}
346 
347template<>
348inline bool SAL_CALL operator == ( const Any & rAny, const sal_Bool & value )
349{
350    return (typelib_TypeClass_BOOLEAN == rAny.pType->eTypeClass &&
351            bool(value) == bool(* static_cast< const sal_Bool * >( rAny.pData )));
352}
353 
354 
355template<>
356inline bool SAL_CALL operator >>= ( Any const & rAny, bool & value )
357{
358    if (rAny.pType->eTypeClass == typelib_TypeClass_BOOLEAN)
359    {
360        value = *static_cast< sal_Bool const * >( rAny.pData );
361        return true;
362    }
363    return false;
364}
365 
366 
367template<>
368inline bool SAL_CALL operator == ( Any const & rAny, bool const & value )
369{
370    return (rAny.pType->eTypeClass == typelib_TypeClass_BOOLEAN &&
371            (value ==
372             bool(*static_cast< sal_Bool const * >( rAny.pData ))));
373}
374 
375// byte
376 
377template<>
378inline bool SAL_CALL operator >>= ( const ::com::sun::star::uno::Any & rAny, sal_Int8 & value )
379{
380    if (typelib_TypeClass_BYTE == rAny.pType->eTypeClass)
381    {
382        value = * static_cast< const sal_Int8 * >( rAny.pData );
383        return true;
384    }
385    return false;
386}
387// short
388 
389template<>
390inline bool SAL_CALL operator >>= ( const Any & rAny, sal_Int16 & value )
391{
392    switch (rAny.pType->eTypeClass)
393    {
394    case typelib_TypeClass_BYTE:
395        value = * static_cast< const sal_Int8 * >( rAny.pData );
396        return true;
397    case typelib_TypeClass_SHORT:
398    case typelib_TypeClass_UNSIGNED_SHORT:
399        value = * static_cast< const sal_Int16 * >( rAny.pData );
400        return true;
401    default:
402        return false;
403    }
404}
405 
406template<>
407inline bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt16 & value )
408{
409    switch (rAny.pType->eTypeClass)
410    {
411    case typelib_TypeClass_BYTE:
412        value = static_cast<sal_uInt16>( * static_cast< const sal_Int8 * >( rAny.pData ) );
413        return true;
414    case typelib_TypeClass_SHORT:
415    case typelib_TypeClass_UNSIGNED_SHORT:
416        value = * static_cast< const sal_uInt16 * >( rAny.pData );
417        return true;
418    default:
419        return false;
420    }
421}
422// long
423 
424template<>
425inline bool SAL_CALL operator >>= ( const Any & rAny, sal_Int32 & value )
426{
427    switch (rAny.pType->eTypeClass)
428    {
429    case typelib_TypeClass_BYTE:
430        value = * static_cast< const sal_Int8 * >( rAny.pData );
431        return true;
432    case typelib_TypeClass_SHORT:
433        value = * static_cast< const sal_Int16 * >( rAny.pData );
434        return true;
435    case typelib_TypeClass_UNSIGNED_SHORT:
436        value = * static_cast< const sal_uInt16 * >( rAny.pData );
437        return true;
438    case typelib_TypeClass_LONG:
439    case typelib_TypeClass_UNSIGNED_LONG:
440        value = * static_cast< const sal_Int32 * >( rAny.pData );
441        return true;
442    default:
443        return false;
444    }
445}
446 
447template<>
448inline bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt32 & value )
449{
450    switch (rAny.pType->eTypeClass)
451    {
452    case typelib_TypeClass_BYTE:
453        value = static_cast<sal_uInt32>( * static_cast< const sal_Int8 * >( rAny.pData ) );
454        return true;
455    case typelib_TypeClass_SHORT:
456        value = static_cast<sal_uInt32>( * static_cast< const sal_Int16 * >( rAny.pData ) );
457        return true;
458    case typelib_TypeClass_UNSIGNED_SHORT:
459        value = * static_cast< const sal_uInt16 * >( rAny.pData );
460        return true;
461    case typelib_TypeClass_LONG:
462    case typelib_TypeClass_UNSIGNED_LONG:
463        value = * static_cast< const sal_uInt32 * >( rAny.pData );
464        return true;
465    default:
466        return false;
467    }
468}
469// hyper
470 
471template<>
472inline bool SAL_CALL operator >>= ( const Any & rAny, sal_Int64 & value )
473{
474    switch (rAny.pType->eTypeClass)
475    {
476    case typelib_TypeClass_BYTE:
477        value = * static_cast< const sal_Int8 * >( rAny.pData );
478        return true;
479    case typelib_TypeClass_SHORT:
480        value = * static_cast< const sal_Int16 * >( rAny.pData );
481        return true;
482    case typelib_TypeClass_UNSIGNED_SHORT:
483        value = * static_cast< const sal_uInt16 * >( rAny.pData );
484        return true;
485    case typelib_TypeClass_LONG:
486        value = * static_cast< const sal_Int32 * >( rAny.pData );
487        return true;
488    case typelib_TypeClass_UNSIGNED_LONG:
489        value = * static_cast< const sal_uInt32 * >( rAny.pData );
490        return true;
491    case typelib_TypeClass_HYPER:
492    case typelib_TypeClass_UNSIGNED_HYPER:
493        value = * static_cast< const sal_Int64 * >( rAny.pData );
494        return true;
495    default:
496        return false;
497    }
498}
499 
500template<>
501inline bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt64 & value )
502{
503    switch (rAny.pType->eTypeClass)
504    {
505    case typelib_TypeClass_BYTE:
506        value = static_cast<sal_uInt64>( * static_cast< const sal_Int8 * >( rAny.pData ) );
507        return true;
508    case typelib_TypeClass_SHORT:
509        value = static_cast<sal_uInt64>( * static_cast< const sal_Int16 * >( rAny.pData ) );
510        return true;
511    case typelib_TypeClass_UNSIGNED_SHORT:
512        value = * static_cast< const sal_uInt16 * >( rAny.pData );
513        return true;
514    case typelib_TypeClass_LONG:
515        value = static_cast<sal_uInt64>( * static_cast< const sal_Int32 * >( rAny.pData ) );
516        return true;
517    case typelib_TypeClass_UNSIGNED_LONG:
518        value = * static_cast< const sal_uInt32 * >( rAny.pData );
519        return true;
520    case typelib_TypeClass_HYPER:
521    case typelib_TypeClass_UNSIGNED_HYPER:
522        value = * static_cast< const sal_uInt64 * >( rAny.pData );
523        return true;
524    default:
525        return false;
526    }
527}
528// float
529 
530template<>
531inline bool SAL_CALL operator >>= ( const Any & rAny, float & value )
532{
533    switch (rAny.pType->eTypeClass)
534    {
535    case typelib_TypeClass_BYTE:
536        value = * static_cast< const sal_Int8 * >( rAny.pData );
537        return true;
538    case typelib_TypeClass_SHORT:
539        value = * static_cast< const sal_Int16 * >( rAny.pData );
540        return true;
541    case typelib_TypeClass_UNSIGNED_SHORT:
542        value = * static_cast< const sal_uInt16 * >( rAny.pData );
543        return true;
544    case typelib_TypeClass_FLOAT:
545        value = * static_cast< const float * >( rAny.pData );
546        return true;
547    default:
548        return false;
549    }
550}
551// double
552 
553template<>
554inline bool SAL_CALL operator >>= ( const Any & rAny, double & value )
555{
556    switch (rAny.pType->eTypeClass)
11
←
Control jumps to 'case typelib_TypeClass_DOUBLE:'  at line 576→
557    {
558    case typelib_TypeClass_BYTE:
559        value = * static_cast< const sal_Int8 * >( rAny.pData );
560        return true;
561    case typelib_TypeClass_SHORT:
562        value = * static_cast< const sal_Int16 * >( rAny.pData );
563        return true;
564    case typelib_TypeClass_UNSIGNED_SHORT:
565        value = * static_cast< const sal_uInt16 * >( rAny.pData );
566        return true;
567    case typelib_TypeClass_LONG:
568        value = * static_cast< const sal_Int32 * >( rAny.pData );
569        return true;
570    case typelib_TypeClass_UNSIGNED_LONG:
571        value = * static_cast< const sal_uInt32 * >( rAny.pData );
572        return true;
573    case typelib_TypeClass_FLOAT:
574        value = * static_cast< const float * >( rAny.pData );
575        return true;
576    case typelib_TypeClass_DOUBLE:
577        value = * static_cast< const double * >( rAny.pData );
12
←
Dereference of null pointer
578        return true;
579    default:
580        return false;
581    }
582}
583// string
584 
585template<>
586inline bool SAL_CALL operator >>= ( const Any & rAny, ::rtl::OUString & value )
587{
588    if (typelib_TypeClass_STRING == rAny.pType->eTypeClass)
589    {
590        value = * static_cast< const ::rtl::OUString * >( rAny.pData );
591        return true;
592    }
593    return false;
594}
595 
596template<>
597inline bool SAL_CALL operator == ( const Any & rAny, const ::rtl::OUString & value )
598{
599    return (typelib_TypeClass_STRING == rAny.pType->eTypeClass &&
600            value == * static_cast< const ::rtl::OUString * >( rAny.pData ) );
601}
602// type
603 
604template<>
605inline bool SAL_CALL operator >>= ( const Any & rAny, Type & value )
606{
607    if (typelib_TypeClass_TYPE == rAny.pType->eTypeClass)
608    {
609        value = * static_cast< const Type * >( rAny.pData );
610        return true;
611    }
612    return false;
613}
614 
615template<>
616inline bool SAL_CALL operator == ( const Any & rAny, const Type & value )
617{
618    return (typelib_TypeClass_TYPE == rAny.pType->eTypeClass &&
619            value.equals( * static_cast< const Type * >( rAny.pData ) ));
620}
621// any
622 
623#if defined LIBO_INTERNAL_ONLY1
624template<> bool SAL_CALL operator >>=(Any const &, Any &) = delete;
625#else
626template<>
627inline bool SAL_CALL operator >>= ( const Any & rAny, Any & value )
628{
629    if (&rAny != &value)
630    {
631        ::uno_type_any_assign(
632            &value, rAny.pData, rAny.pType,
633            cpp_acquire, cpp_release );
634    }
635    return true;
636}
637#endif
638// interface
639 
640template<>
641inline bool SAL_CALL operator == ( const Any & rAny, const BaseReference & value )
642{
643    if (typelib_TypeClass_INTERFACE == rAny.pType->eTypeClass)
644    {
645        return static_cast< const BaseReference * >( rAny.pData )->operator == ( value );
646    }
647    return false;
648}
649 
650// operator to compare to an any.
651 
652template< class C >
653inline bool SAL_CALL operator == ( const Any & rAny, const C & value )
654{
655    const Type & rType = ::cppu::getTypeFavourUnsigned(&value);
656    return ::uno_type_equalData(
657        rAny.pData, rAny.pType,
658        const_cast< C * >( &value ), rType.getTypeLibType(),
659        cpp_queryInterface, cpp_release );
660}
661// operator to compare to an any.  may use specialized operators ==.
662 
663template< class C >
664inline bool SAL_CALL operator != ( const Any & rAny, const C & value )
665{
666    return (! operator == ( rAny, value ));
667}
668 
669template <typename T>
670T Any::get() const
671{
672    T value = T();
673    if (! (*this >>= value)) {
674        throw RuntimeException(
675            ::rtl::OUString(
676                cppu_Any_extraction_failure_msg(
677                    this,
678                    ::cppu::getTypeFavourUnsigned(&value).getTypeLibType() ),
679                SAL_NO_ACQUIRE ) );
680    }
681    return value;
682}
683 
684#if defined LIBO_INTERNAL_ONLY1
685template<> Any Any::get() const = delete;
686#endif
687 
688/**
689   Support for Any in std::ostream (and thus in CPPUNIT_ASSERT or SAL_INFO
690   macros, for example).
691 
692   @since LibreOffice 4.2
693*/
694template<typename charT, typename traits>
695inline std::basic_ostream<charT, traits> &operator<<(std::basic_ostream<charT, traits> &o, Any const &any) {
696    o << "<Any: (" << any.getValueTypeName() << ')';
697    switch(any.pType->eTypeClass) {
698        case typelib_TypeClass_VOID:
699            break;
700        case typelib_TypeClass_BOOLEAN:
701            o << ' ' << any.get<bool>();
702            break;
703        case typelib_TypeClass_BYTE:
704        case typelib_TypeClass_SHORT:
705        case typelib_TypeClass_LONG:
706        case typelib_TypeClass_HYPER:
707            o << ' ' << any.get<sal_Int64>();
708            break;
709        case typelib_TypeClass_UNSIGNED_SHORT:
710        case typelib_TypeClass_UNSIGNED_LONG:
711        case typelib_TypeClass_UNSIGNED_HYPER:
712            o << ' ' << any.get<sal_uInt64>();
713            break;
714        case typelib_TypeClass_FLOAT:
715        case typelib_TypeClass_DOUBLE:
716            o << ' ' << any.get<double>();
717            break;
718        case typelib_TypeClass_CHAR: {
719            std::ios_base::fmtflags flgs = o.setf(
720                std::ios_base::hex, std::ios_base::basefield);
721            charT fill = o.fill('0');
722            o << " U+" << std::setw(4)
723              << unsigned(*static_cast<sal_Unicode const *>(any.getValue()));
724            o.setf(flgs);
725            o.fill(fill);
726            break;
727        }
728        case typelib_TypeClass_STRING:
729            o << ' ' << any.get<rtl::OUString>();
730            break;
731        case typelib_TypeClass_TYPE:
732            o << ' ' << any.get<css::uno::Type>().getTypeName();
733            break;
734        case typelib_TypeClass_SEQUENCE:
735            o << " len "
736              << ((*static_cast<uno_Sequence * const *>(any.getValue()))->
737                  nElements);
738            break;
739        case typelib_TypeClass_ENUM:
740            o << ' ' << *static_cast<sal_Int32 const *>(any.getValue());
741            break;
742        case typelib_TypeClass_STRUCT:
743        case typelib_TypeClass_EXCEPTION:
744            o << ' ' << any.getValue();
745            break;
746        case typelib_TypeClass_INTERFACE:
747            o << ' ' << *static_cast<void * const *>(any.getValue());
748            break;
749        default:
750            assert(false)(static_cast <bool> (false) ? void (0) : __assert_fail (
"false", "/home/maarten/src/libreoffice/core/include/com/sun/star/uno/Any.hxx"
, 750, __extension__ __PRETTY_FUNCTION__)); // this cannot happen
751            break;
752    }
753    o << '>';
754    return o;
755}
756 
757}
758}
759}
760}
761 
762#endif
763 
764/* vim:set shiftwidth=4 softtabstop=4 expandtab: */