include/xmloff/xmluconv.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
  20 #ifndef INCLUDED_XMLOFF_XMLUCONV_HXX
  21 #define INCLUDED_XMLOFF_XMLUCONV_HXX
  22
  23 #include <sal/config.h>
  24 #include <xmloff/dllapi.h>
  25 #include <sal/types.h>
  26
  27 #include <memory>
  28
  29 #include <rtl/ustring.hxx>
  30 #include <rtl/ustrbuf.hxx>
  31 #include <xmloff/xmltoken.hxx>
  32
  33 #include <unotools/saveopt.hxx>
  34
  35 #include <tools/fldunit.hxx>
  36
  37 namespace com::sun::star {
  38     namespace text { class XNumberingTypeInfo; }
  39 }
  40
  41 namespace basegfx
  42 {
  43     class B3DVector;
  44 }
  45
  46 namespace com::sun::star::beans { class XPropertySet; }
  47 namespace com::sun::star::beans { struct PropertyValue; }
  48 namespace com::sun::star::drawing { struct Position3D; }
  49 namespace com::sun::star::frame { class XModel; }
  50 namespace com::sun::star::uno { class XComponentContext; }
  51 namespace com::sun::star::uno { template <class E> class Sequence; }
  52 namespace com::sun::star::util { struct Date; }
  53 template <typename EnumT> struct SvXMLEnumMapEntry;
  54 template <typename EnumT> struct SvXMLEnumStringMapEntry;
  55
  56 class XMLOFF_DLLPUBLIC SvXMLTokenEnumerator
  57 {
  58 private:
  59     std::u16string_view     maTokenString;
  60     size_t                  mnNextTokenPos;
  61     sal_Unicode             mcSeparator;
  62
  63 public:
  64     SvXMLTokenEnumerator( std::u16string_view rString, sal_Unicode cSeparator = u' ' );
  65     /** just so no-one accidentally passes a temporary to this, and ends up with this class
  66      * accessing the temporary after the temporary has been deleted. */
  67     SvXMLTokenEnumerator( OUString&& , sal_Unicode cSeparator = u' ' ) = delete;
  68
  69     bool getNextToken( std::u16string_view& rToken );
  70 };
  71
  72 /** the SvXMLTypeConverter converts values of various types from
  73     their internal representation to the textual form used in xml
  74     and back.
  75     Most of the methods are static but the SvXMLTypeConverter can
  76     also store default units for both numerical and textual measures.
  77
  78     @attention:
  79         a lot of the methods here have been moved to <sax/tools/converter.hxx>!
  80 */
  81
  82 class XMLOFF_DLLPUBLIC SvXMLUnitConverter final
  83 {
  84 private:
  85     SvXMLUnitConverter(const SvXMLUnitConverter&) = delete;
  86     SvXMLUnitConverter& operator=(const SvXMLUnitConverter&) = delete;
  87
  88     struct SAL_DLLPRIVATE Impl;
  89     ::std::unique_ptr<Impl> m_pImpl;
  90
  91 public:
  92     /** constructs a SvXMLUnitConverter. The core measure unit is the
  93         default unit for numerical measures, the XML measure unit is
  94         the default unit for textual measures */
  95     SvXMLUnitConverter(
  96         const css::uno::Reference< css::uno::XComponentContext >& xContext,
  97         sal_Int16 eCoreMeasureUnit /*css::util::MeasureUnit*/,
  98         sal_Int16 eXMLMeasureUnit /*css::util::MeasureUnit*/,
  99         SvtSaveOptions::ODFSaneDefaultVersion const nODFVersion);
 100
 101     ~SvXMLUnitConverter();
 102
 103     static sal_Int16 GetMeasureUnit(FieldUnit const nFieldUnit);
 104
 105     /** sets the default unit for numerical measures */
 106     void SetCoreMeasureUnit( sal_Int16 const eCoreMeasureUnit /*css::util::MeasureUnit*/);
 107
 108     /** sets the default unit for textual measures */
 109     void SetXMLMeasureUnit( sal_Int16 const eXMLMeasureUnit /*css::util::MeasureUnit*/);
 110
 111     /** gets the default unit for textual measures */
 112     sal_Int16 GetXMLMeasureUnit() const;
 113
 114     /// ODF version, only when exporting
 115     SvtSaveOptions::ODFSaneDefaultVersion getSaneDefaultVersion() const;
 116     void overrideSaneDefaultVersion(SvtSaveOptions::ODFSaneDefaultVersion const);
 117
 118     /** gets XNumberingTypeInfo */
 119     const css::uno::Reference< css::text::XNumberingTypeInfo >& getNumTypeInfo() const;
 120
 121     /** convert string to measure with meCoreMeasureUnit,
 122         using optional min and max values*/
 123     bool convertMeasureToCore( sal_Int32& rValue,
 124                          std::u16string_view rString,
 125                          sal_Int32 nMin = SAL_MIN_INT32,
 126                          sal_Int32 nMax = SAL_MAX_INT32) const;
 127
 128     /** convert string to measure with meCoreMeasureUnit,
 129         using optional min and max values*/
 130     bool convertMeasureToCore( sal_Int32& rValue,
 131                          std::string_view rString,
 132                          sal_Int32 nMin = SAL_MIN_INT32,
 133                          sal_Int32 nMax = SAL_MAX_INT32) const;
 134
 135     /** convert measure to string: from meCoreMeasureUnit to meXMLMeasureUnit */
 136     void convertMeasureToXML( OUStringBuffer& rBuffer,
 137                          sal_Int32 nMeasure ) const;
 138
 139     /** convert measure to string: from meCoreMeasureUnit to meXMLMeasureUnit */
 140     OUString convertMeasureToXML( sal_Int32 nMeasure ) const;
 141
 142     /** convert string to enum using given enum map, if the enum is
 143         not found in the map, this method will return false */
 144     template<typename EnumT>
 145     static bool convertEnum( EnumT& rEnum,
 146                              std::u16string_view rValue,
 147                              const SvXMLEnumMapEntry<EnumT> *pMap )
 148     {
 149         sal_uInt16 nTmp;
 150         bool bRet = convertEnumImpl(nTmp, rValue,
 151                         reinterpret_cast<const SvXMLEnumMapEntry<sal_uInt16>*>(pMap));
 152         if (bRet)
 153             rEnum = static_cast<EnumT>(nTmp);
 154         return bRet;
 155     }
 156
 157     /** convert string to enum using given enum map, if the enum is
 158         not found in the map, this method will return false */
 159     template<typename EnumT>
 160     static bool convertEnum( EnumT& rEnum,
 161                              std::string_view rValue,
 162                              const SvXMLEnumMapEntry<EnumT> *pMap )
 163     {
 164         sal_uInt16 nTmp;
 165         bool bRet = convertEnumImpl(nTmp, rValue,
 166                         reinterpret_cast<const SvXMLEnumMapEntry<sal_uInt16>*>(pMap));
 167         if (bRet)
 168             rEnum = static_cast<EnumT>(nTmp);
 169         return bRet;
 170     }
 171
 172     /** convert string to enum using given token map, if the enum is
 173         not found in the map, this method will return false */
 174     template<typename EnumT>
 175     static bool convertEnum( EnumT& rEnum,
 176                              std::u16string_view rValue,
 177                              const SvXMLEnumStringMapEntry<EnumT> *pMap )
 178     {
 179         sal_uInt16 nTmp;
 180         bool bRet = convertEnumImpl(nTmp, rValue,
 181                         reinterpret_cast<const SvXMLEnumStringMapEntry<sal_uInt16>*>(pMap));
 182         if (bRet)
 183             rEnum = static_cast<EnumT>(nTmp);
 184         return bRet;
 185     }
 186
 187     /** convert string to enum using given token map, if the enum is
 188         not found in the map, this method will return false */
 189     template<typename EnumT>
 190     static bool convertEnum( EnumT& rEnum,
 191                              std::string_view rValue,
 192                              const SvXMLEnumStringMapEntry<EnumT> *pMap )
 193     {
 194         sal_uInt16 nTmp;
 195         bool bRet = convertEnumImpl(nTmp, rValue,
 196                         reinterpret_cast<const SvXMLEnumStringMapEntry<sal_uInt16>*>(pMap));
 197         if (bRet)
 198             rEnum = static_cast<EnumT>(nTmp);
 199         return bRet;
 200     }
 201
 202     /** convert enum to string using given enum map with an optional
 203         default token. If the enum is not found in the map,
 204         this method will either use the given default or return
 205         false if not default is set */
 206     template<typename EnumT>
 207     static bool convertEnum( OUStringBuffer& rBuffer,
 208                              EnumT nValue,
 209                              const SvXMLEnumMapEntry<EnumT> *pMap,
 210                              enum ::xmloff::token::XMLTokenEnum eDefault =
 211                                          ::xmloff::token::XML_TOKEN_INVALID )
 212     {
 213         return convertEnumImpl(rBuffer, static_cast<sal_uInt16>(nValue),
 214                    reinterpret_cast<const SvXMLEnumMapEntry<sal_uInt16>*>(pMap), eDefault);
 215     }
 216
 217     /** convert double number to string (using ::rtl::math) and DO
 218         convert to export MapUnit using meCoreMeasureUnit/meXMLMeasureUnit */
 219     void convertDouble(OUStringBuffer& rBuffer,
 220         double fNumber) const;
 221
 222     /** convert string to double number (using ::rtl::math) and DO convert. */
 223     bool convertDouble(double& rValue, std::u16string_view rString) const;
 224
 225     /** convert string to double number (using ::rtl::math) and DO convert. */
 226     bool convertDouble(double& rValue, std::string_view rString) const;
 227
 228     /** get the Null Date of the XModel and set it to the UnitConverter */
 229     bool setNullDate (
 230         const css::uno::Reference <css::frame::XModel>& xModel);
 231
 232     /** convert double to ISO Date Time String */
 233     void convertDateTime( OUStringBuffer& rBuffer,
 234                                 const double& fDateTime,
 235                                 bool const bAddTimeIf0AM = false);
 236
 237     /** convert ISO Date Time String to double */
 238     bool convertDateTime(double& fDateTime,
 239                          std::u16string_view rString) const;
 240
 241     /** convert ISO Date Time String to double */
 242     bool convertDateTime(double& fDateTime,
 243                          std::string_view rString) const;
 244
 245     /// these 2 functions use tools Date, so they're not yet moved to sax
 246
 247     /** convert double to ISO Date Time String */
 248     static void convertDateTime( OUStringBuffer& rBuffer,
 249                                 const double& fDateTime,
 250                                 const css::util::Date& aNullDate,
 251                                 bool bAddTimeIf0AM = false);
 252     /** convert ISO Date Time String to double */
 253     static bool convertDateTime( double& fDateTime,
 254                                 std::u16string_view rString,
 255                                 const css::util::Date& aNullDate);
 256     /** convert ISO Date Time String to double */
 257     static bool convertDateTime( double& fDateTime,
 258                                 std::string_view rString,
 259                                 const css::util::Date& aNullDate);
 260
 261     /** convert string to ::basegfx::B3DVector */
 262     static bool convertB3DVector( ::basegfx::B3DVector& rVector,
 263                               std::string_view rValue );
 264
 265     /** convert B3DVector to string */
 266     static void convertB3DVector( OUStringBuffer &rBuffer,
 267         const ::basegfx::B3DVector& rVector );
 268
 269     /** convert string to Position3D */
 270     bool convertPosition3D( css::drawing::Position3D& rPosition,
 271                               std::string_view rValue ) const;
 272
 273     /** convert Position3D to string */
 274     void convertPosition3D( OUStringBuffer &rBuffer,
 275                               const css::drawing::Position3D& rVector );
 276
 277
 278     /** convert num-format and num-letter-sync values to NumberingType */
 279     bool convertNumFormat( sal_Int16& rType,
 280                            const OUString& rNumFormat,
 281                            std::u16string_view rNumLetterSync,
 282                            bool bNumberNone = false ) const;
 283
 284     /** convert NumberingType to num-format and num-letter-sync values */
 285     void convertNumFormat( OUStringBuffer& rBuffer,
 286                            sal_Int16 nType ) const;
 287     static void convertNumLetterSync( OUStringBuffer& rBuffer,
 288                                   sal_Int16 nType );
 289
 290     static void convertPropertySet(css::uno::Sequence<css::beans::PropertyValue>& rProps,
 291                         const css::uno::Reference<css::beans::XPropertySet>& aProperties,
 292                         const std::initializer_list<std::u16string_view>* pOmitFalseValues = nullptr);
 293     static void convertPropertySet(css::uno::Reference<css::beans::XPropertySet> const & rProperties,
 294                         const css::uno::Sequence<css::beans::PropertyValue>& aProps);
 295
 296     OUString encodeStyleName( const OUString& rName,
 297                                      bool *pEncoded=nullptr ) const;
 298     /** convert string (hex) to number (sal_uInt32) */
 299     static bool convertHex( sal_uInt32& nVal,
 300                               std::u16string_view rValue );
 301
 302     /** convert number (sal_uInt32) to string (hex) */
 303     static void convertHex( OUStringBuffer& rBuffer,
 304                                sal_uInt32 nVal );
 305
 306 private:
 307     static bool convertEnumImpl( sal_uInt16& rEnum,
 308                              std::u16string_view rValue,
 309                              const SvXMLEnumMapEntry<sal_uInt16> *pMap );
 310
 311     static bool convertEnumImpl( sal_uInt16& rEnum,
 312                              std::u16string_view rValue,
 313                              const SvXMLEnumStringMapEntry<sal_uInt16> *pMap );
 314
 315     static bool convertEnumImpl( sal_uInt16& rEnum,
 316                              std::string_view rValue,
 317                              const SvXMLEnumMapEntry<sal_uInt16> *pMap );
 318
 319     static bool convertEnumImpl( sal_uInt16& rEnum,
 320                              std::string_view rValue,
 321                              const SvXMLEnumStringMapEntry<sal_uInt16> *pMap );
 322
 323     static bool convertEnumImpl( OUStringBuffer& rBuffer,
 324                              sal_uInt16 nValue,
 325                              const SvXMLEnumMapEntry<sal_uInt16> *pMap,
 326                              enum ::xmloff::token::XMLTokenEnum eDefault );
 327 };
 328
 329 #endif // INCLUDED_XMLOFF_XMLUCONV_HXX
 330
 331 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */