/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx

Bug Summary

File:	home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx
Warning:	line 1669, column 24 Assigned value is garbage or undefined

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 xechart.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 BOOST_ALL_NO_LIB -D BOOST_ALL_NO_LIB -D BOOST_ALL_NO_LIB -D SYSTEM_ZLIB -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/liborcus/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/liborcus/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/mdds/include -I /home/maarten/src/libreoffice/core/external/clew/source/include -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/sc/source/core/inc -I /home/maarten/src/libreoffice/core/sc/source/filter/inc -I /home/maarten/src/libreoffice/core/sc/source/ui/inc -I /home/maarten/src/libreoffice/core/sc/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/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/oovbaapi/normal -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/oox/generated -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/officecfg/registry -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/sc/source/filter/excel/xechart.cxx

/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.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 .
*/

20#include <xechart.hxx>

22#include <com/sun/star/i18n/XBreakIterator.hpp>
23#include <com/sun/star/i18n/ScriptType.hpp>
24#include <com/sun/star/drawing/FillStyle.hpp>
25#include <com/sun/star/drawing/XShapes.hpp>
26#include <com/sun/star/chart/XChartDocument.hpp>
27#include <com/sun/star/chart/ChartAxisLabelPosition.hpp>
28#include <com/sun/star/chart/ChartAxisPosition.hpp>
29#include <com/sun/star/chart/ChartLegendExpansion.hpp>
30#include <com/sun/star/chart/DataLabelPlacement.hpp>
31#include <com/sun/star/chart/ErrorBarStyle.hpp>
32#include <com/sun/star/chart/MissingValueTreatment.hpp>
33#include <com/sun/star/chart/TimeInterval.hpp>
34#include <com/sun/star/chart/TimeUnit.hpp>
35#include <com/sun/star/chart/XAxisSupplier.hpp>
36#include <com/sun/star/chart/XDiagramPositioning.hpp>
37#include <com/sun/star/chart2/XChartDocument.hpp>
38#include <com/sun/star/chart2/XDiagram.hpp>
39#include <com/sun/star/chart2/XCoordinateSystemContainer.hpp>
40#include <com/sun/star/chart2/XChartTypeContainer.hpp>
41#include <com/sun/star/chart2/XDataSeriesContainer.hpp>
42#include <com/sun/star/chart2/XRegressionCurveContainer.hpp>
43#include <com/sun/star/chart2/XTitled.hpp>
44#include <com/sun/star/chart2/XColorScheme.hpp>
45#include <com/sun/star/chart2/data/XDataSource.hpp>
46#include <com/sun/star/chart2/AxisType.hpp>
47#include <com/sun/star/chart2/CurveStyle.hpp>
48#include <com/sun/star/chart2/DataPointGeometry3D.hpp>
49#include <com/sun/star/chart2/DataPointLabel.hpp>
50#include <com/sun/star/chart2/LegendPosition.hpp>
51#include <com/sun/star/chart2/RelativePosition.hpp>
52#include <com/sun/star/chart2/RelativeSize.hpp>
53#include <com/sun/star/chart2/StackingDirection.hpp>
54#include <com/sun/star/chart2/TickmarkStyle.hpp>

56#include <tools/gen.hxx>
57#include <vcl/outdev.hxx>
58#include <filter/msfilter/escherex.hxx>

60#include <document.hxx>
61#include <compiler.hxx>
62#include <tokenarray.hxx>
63#include <xeescher.hxx>
64#include <xeformula.hxx>
65#include <xehelper.hxx>
66#include <xepage.hxx>
67#include <xestyle.hxx>
68#include <xltools.hxx>

70#include <memory>

72using ::com::sun::star::uno::Any;
73using ::com::sun::star::uno::Reference;
74using ::com::sun::star::uno::Sequence;
75using ::com::sun::star::uno::UNO_QUERY;
76using ::com::sun::star::uno::UNO_QUERY_THROW;
77using ::com::sun::star::uno::UNO_SET_THROW;
78using ::com::sun::star::uno::Exception;
79using ::com::sun::star::beans::XPropertySet;
80using ::com::sun::star::i18n::XBreakIterator;
81using ::com::sun::star::frame::XModel;
82using ::com::sun::star::drawing::XShape;
83using ::com::sun::star::drawing::XShapes;

85using ::com::sun::star::chart2::IncrementData;
86using ::com::sun::star::chart2::RelativePosition;
87using ::com::sun::star::chart2::RelativeSize;
88using ::com::sun::star::chart2::ScaleData;
89using ::com::sun::star::chart2::SubIncrement;
90using ::com::sun::star::chart2::XAxis;
91using ::com::sun::star::chart2::XChartDocument;
92using ::com::sun::star::chart2::XChartTypeContainer;
93using ::com::sun::star::chart2::XColorScheme;
94using ::com::sun::star::chart2::XCoordinateSystem;
95using ::com::sun::star::chart2::XCoordinateSystemContainer;
96using ::com::sun::star::chart2::XChartType;
97using ::com::sun::star::chart2::XDataSeries;
98using ::com::sun::star::chart2::XDataSeriesContainer;
99using ::com::sun::star::chart2::XDiagram;
100using ::com::sun::star::chart2::XFormattedString;
101using ::com::sun::star::chart2::XLegend;
102using ::com::sun::star::chart2::XRegressionCurve;
103using ::com::sun::star::chart2::XRegressionCurveContainer;
104using ::com::sun::star::chart2::XTitle;
105using ::com::sun::star::chart2::XTitled;

107using ::com::sun::star::chart2::data::XDataSequence;
108using ::com::sun::star::chart2::data::XDataSource;
109using ::com::sun::star::chart2::data::XLabeledDataSequence;

111using ::formula::FormulaToken;
112using ::formula::FormulaTokenArrayPlainIterator;

114namespace cssc = ::com::sun::star::chart;
115namespace cssc2 = ::com::sun::star::chart2;

117// Helpers ====================================================================

119namespace {

121XclExpStream& operator<<( XclExpStream& rStrm, const XclChRectangle& rRect )
122{
  return rStrm << rRect.mnX << rRect.mnY << rRect.mnWidth << rRect.mnHeight;
124}

126void lclSaveRecord( XclExpStream& rStrm, XclExpRecordRef const & xRec )
127{
  if( xRec )
      xRec->Save( rStrm );
130}

132/** Saves the passed record (group) together with a leading value record. */
133template< typename Type >
134void lclSaveRecord( XclExpStream& rStrm, XclExpRecordRef const & xRec, sal_uInt16 nRecId, Type nValue )
135{
  if( xRec )
  {
      XclExpValueRecord< Type >( nRecId, nValue ).Save( rStrm );
      xRec->Save( rStrm );
  }
141}

143template<typename ValueType, typename KeyType>
144void lclSaveRecord(XclExpStream& rStrm, ValueType* pRec, sal_uInt16 nRecId, KeyType nValue)
145{
  if (pRec)
  {
      XclExpValueRecord<KeyType>(nRecId, nValue).Save(rStrm);
      pRec->Save(rStrm);
  }
151}

153void lclWriteChFrBlockRecord( XclExpStream& rStrm, const XclChFrBlock& rFrBlock, bool bBegin )
154{
  sal_uInt16 nRecId = bBegin ? EXC_ID_CHFRBLOCKBEGIN : EXC_ID_CHFRBLOCKEND;
  rStrm.StartRecord( nRecId, 12 );
  rStrm << nRecId << EXC_FUTUREREC_EMPTYFLAGS << rFrBlock.mnType << rFrBlock.mnContext << rFrBlock.mnValue1 << rFrBlock.mnValue2;
  rStrm.EndRecord();
159}

161template< typename Type >
162bool lclIsAutoAnyOrGetValue( Type& rValue, const Any& rAny )
163{
  return !rAny.hasValue() || !(rAny >>= rValue);
165}

167bool lclIsAutoAnyOrGetScaledValue( double& rfValue, const Any& rAny, bool bLogScale )
168{
  bool bIsAuto = lclIsAutoAnyOrGetValue( rfValue, rAny );
  if( !bIsAuto && bLogScale )
      rfValue = log( rfValue ) / log( 10.0 );
  return bIsAuto;
173}

175sal_uInt16 lclGetTimeValue( const XclExpRoot& rRoot, double fSerialDate, sal_uInt16 nTimeUnit )
176{
  DateTime aDateTime = rRoot.GetDateTimeFromDouble( fSerialDate );
  switch( nTimeUnit )
  {
      case EXC_CHDATERANGE_DAYS:
          return ::limit_cast< sal_uInt16, double >( fSerialDate, 0, SAL_MAX_UINT16((sal_uInt16) 0xFFFF) );
      case EXC_CHDATERANGE_MONTHS:
          return ::limit_cast< sal_uInt16, sal_uInt16 >( 12 * (aDateTime.GetYear() - rRoot.GetBaseYear()) + aDateTime.GetMonth() - 1, 0, SAL_MAX_INT16((sal_Int16) 0x7FFF) );
      case EXC_CHDATERANGE_YEARS:
          return ::limit_cast< sal_uInt16, sal_uInt16 >( aDateTime.GetYear() - rRoot.GetBaseYear(), 0, SAL_MAX_INT16((sal_Int16) 0x7FFF) );
      default:
          OSL_ENSURE( false, "lclGetTimeValue - unexpected time unit" )do { if (true && (!(false))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx"
 ":" "187" ": "), "%s", "lclGetTimeValue - unexpected time unit"
); } } while (false);
  }
  return ::limit_cast< sal_uInt16, double >( fSerialDate, 0, SAL_MAX_UINT16((sal_uInt16) 0xFFFF) );
190}

192bool lclConvertTimeValue( const XclExpRoot& rRoot, sal_uInt16& rnValue, const Any& rAny, sal_uInt16 nTimeUnit )
193{
  double fSerialDate = 0;
  bool bAuto = lclIsAutoAnyOrGetValue( fSerialDate, rAny );
  if( !bAuto )
      rnValue = lclGetTimeValue( rRoot, fSerialDate, nTimeUnit );
  return bAuto;
199}

201sal_uInt16 lclGetTimeUnit( sal_Int32 nApiTimeUnit )
202{
  switch( nApiTimeUnit )
  {
      case cssc::TimeUnit::DAY:   return EXC_CHDATERANGE_DAYS;
      case cssc::TimeUnit::MONTH: return EXC_CHDATERANGE_MONTHS;
      case cssc::TimeUnit::YEAR:  return EXC_CHDATERANGE_YEARS;
      default:                    OSL_ENSURE( false, "lclGetTimeUnit - unexpected time unit" )do { if (true && (!(false))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx"
 ":" "208" ": "), "%s", "lclGetTimeUnit - unexpected time unit"
); } } while (false);
  }
  return EXC_CHDATERANGE_DAYS;
211}

213bool lclConvertTimeInterval( sal_uInt16& rnValue, sal_uInt16& rnTimeUnit, const Any& rAny )
214{
  cssc::TimeInterval aInterval;
  bool bAuto = lclIsAutoAnyOrGetValue( aInterval, rAny );
  if( !bAuto )
  {
      rnValue = ::limit_cast< sal_uInt16, sal_Int32 >( aInterval.Number, 1, SAL_MAX_UINT16((sal_uInt16) 0xFFFF) );
      rnTimeUnit = lclGetTimeUnit( aInterval.TimeUnit );
  }
  return bAuto;
223}

225} // namespace

227// Common =====================================================================

229/** Stores global data needed in various classes of the Chart export filter. */
230struct XclExpChRootData : public XclChRootData
231{
  typedef ::std::vector< XclChFrBlock > XclChFrBlockVector;

  XclExpChChart&      mrChartData;            /// The chart data object.
  XclChFrBlockVector  maWrittenFrBlocks;      /// Stack of future record levels already written out.
  XclChFrBlockVector  maUnwrittenFrBlocks;    /// Stack of future record levels not yet written out.

  explicit     XclExpChRootData( XclExpChChart& rChartData ) : mrChartData( rChartData ) {}

  /** Registers a new future record level. */
  void                RegisterFutureRecBlock( const XclChFrBlock& rFrBlock );
  /** Initializes the current future record level (writes all unwritten CHFRBLOCKBEGIN records). */
  void                InitializeFutureRecBlock( XclExpStream& rStrm );
  /** Finalizes the current future record level (writes CHFRBLOCKEND record if needed). */
  void                FinalizeFutureRecBlock( XclExpStream& rStrm );
246};

248void XclExpChRootData::RegisterFutureRecBlock( const XclChFrBlock& rFrBlock )
249{
  maUnwrittenFrBlocks.push_back( rFrBlock );
251}

253void XclExpChRootData::InitializeFutureRecBlock( XclExpStream& rStrm )
254{
  // first call from a future record writes all missing CHFRBLOCKBEGIN records
  if( maUnwrittenFrBlocks.empty() )
      return;

  // write the leading CHFRINFO record
  if( maWrittenFrBlocks.empty() )
  {
      rStrm.StartRecord( EXC_ID_CHFRINFO, 20 );
      rStrm << EXC_ID_CHFRINFO << EXC_FUTUREREC_EMPTYFLAGS << EXC_CHFRINFO_EXCELXP2003 << EXC_CHFRINFO_EXCELXP2003 << sal_uInt16( 3 );
      rStrm << sal_uInt16( 0x0850 ) << sal_uInt16( 0x085A ) << sal_uInt16( 0x0861 ) << sal_uInt16( 0x0861 ) << sal_uInt16( 0x086A ) << sal_uInt16( 0x086B );
      rStrm.EndRecord();
  }
  // write all unwritten CHFRBLOCKBEGIN records
  for( const auto& rUnwrittenFrBlock : maUnwrittenFrBlocks )
  {
      OSL_ENSURE( rUnwrittenFrBlock.mnType != EXC_CHFRBLOCK_TYPE_UNKNOWN, "XclExpChRootData::InitializeFutureRecBlock - unknown future record block type" )do { if (true && (!(rUnwrittenFrBlock.mnType != EXC_CHFRBLOCK_TYPE_UNKNOWN
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx"
 ":" "270" ": "), "%s", "XclExpChRootData::InitializeFutureRecBlock - unknown future record block type"
); } } while (false);
      lclWriteChFrBlockRecord( rStrm, rUnwrittenFrBlock, true );
  }
  // move all record infos to vector of written blocks
  maWrittenFrBlocks.insert( maWrittenFrBlocks.end(), maUnwrittenFrBlocks.begin(), maUnwrittenFrBlocks.end() );
  maUnwrittenFrBlocks.clear();
276}

278void XclExpChRootData::FinalizeFutureRecBlock( XclExpStream& rStrm )
279{
  OSL_ENSURE( !maUnwrittenFrBlocks.empty() || !maWrittenFrBlocks.empty(), "XclExpChRootData::FinalizeFutureRecBlock - no future record level found" )do { if (true && (!(!maUnwrittenFrBlocks.empty() || !
maWrittenFrBlocks.empty()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx"
 ":" "280" ": "), "%s", "XclExpChRootData::FinalizeFutureRecBlock - no future record level found"
); } } while (false);
  if( !maUnwrittenFrBlocks.empty() )
  {
      // no future record has been written, just forget the topmost level
      maUnwrittenFrBlocks.pop_back();
  }
  else if( !maWrittenFrBlocks.empty() )
  {
      // write the CHFRBLOCKEND record for the topmost block and delete it
      lclWriteChFrBlockRecord( rStrm, maWrittenFrBlocks.back(), false );
      maWrittenFrBlocks.pop_back();
  }
292}

294XclExpChRoot::XclExpChRoot( const XclExpRoot& rRoot, XclExpChChart& rChartData ) :
  XclExpRoot( rRoot ),
  mxChData( std::make_shared<XclExpChRootData>( rChartData ) )
297{
298}

300XclExpChRoot::~XclExpChRoot()
301{
302}

304Reference< XChartDocument > const & XclExpChRoot::GetChartDocument() const
305{
  return mxChData->mxChartDoc;
307}

309XclExpChChart& XclExpChRoot::GetChartData() const
310{
  return mxChData->mrChartData;
312}

314const XclChTypeInfo& XclExpChRoot::GetChartTypeInfo( XclChTypeId eType ) const
315{
  return mxChData->mxTypeInfoProv->GetTypeInfo( eType );
317}

319const XclChTypeInfo& XclExpChRoot::GetChartTypeInfo( const OUString& rServiceName ) const
320{
  return mxChData->mxTypeInfoProv->GetTypeInfoFromService( rServiceName );
322}

324const XclChFormatInfo& XclExpChRoot::GetFormatInfo( XclChObjectType eObjType ) const
325{
  return mxChData->mxFmtInfoProv->GetFormatInfo( eObjType );
327}

329void XclExpChRoot::InitConversion( css::uno::Reference< css::chart2::XChartDocument > const & xChartDoc, const tools::Rectangle& rChartRect ) const
330{
  mxChData->InitConversion( GetRoot(), xChartDoc, rChartRect );
332}

334void XclExpChRoot::FinishConversion() const
335{
  mxChData->FinishConversion();
337}

339bool XclExpChRoot::IsSystemColor( const Color& rColor, sal_uInt16 nSysColorIdx ) const
340{
  XclExpPalette& rPal = GetPalette();
  return rPal.IsSystemColor( nSysColorIdx ) && (rColor == rPal.GetDefColor( nSysColorIdx ));
343}

345void XclExpChRoot::SetSystemColor( Color& rColor, sal_uInt32& rnColorId, sal_uInt16 nSysColorIdx ) const
346{
  OSL_ENSURE( GetPalette().IsSystemColor( nSysColorIdx ), "XclExpChRoot::SetSystemColor - invalid color index" )do { if (true && (!(GetPalette().IsSystemColor( nSysColorIdx
 )))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx"
 ":" "347" ": "), "%s", "XclExpChRoot::SetSystemColor - invalid color index"
); } } while (false);
  rColor = GetPalette().GetDefColor( nSysColorIdx );
  rnColorId = XclExpPalette::GetColorIdFromIndex( nSysColorIdx );
350}

352sal_Int32 XclExpChRoot::CalcChartXFromHmm( sal_Int32 nPosX ) const
353{
  return ::limit_cast< sal_Int32, double >( (nPosX - mxChData->mnBorderGapX) / mxChData->mfUnitSizeX, 0, EXC_CHART_TOTALUNITS );
355}

357sal_Int32 XclExpChRoot::CalcChartYFromHmm( sal_Int32 nPosY ) const
358{
  return ::limit_cast< sal_Int32, double >( (nPosY - mxChData->mnBorderGapY) / mxChData->mfUnitSizeY, 0, EXC_CHART_TOTALUNITS );
360}

362XclChRectangle XclExpChRoot::CalcChartRectFromHmm( const css::awt::Rectangle& rRect ) const
363{
  XclChRectangle aRect;
  aRect.mnX = CalcChartXFromHmm( rRect.X );
  aRect.mnY = CalcChartYFromHmm( rRect.Y );
  aRect.mnWidth = CalcChartXFromHmm( rRect.Width );
  aRect.mnHeight = CalcChartYFromHmm( rRect.Height );
  return aRect;
370}

372void XclExpChRoot::ConvertLineFormat( XclChLineFormat& rLineFmt,
      const ScfPropertySet& rPropSet, XclChPropertyMode ePropMode ) const
374{
  GetChartPropSetHelper().ReadLineProperties(
      rLineFmt, *mxChData->mxLineDashTable, rPropSet, ePropMode );
377}

379bool XclExpChRoot::ConvertAreaFormat( XclChAreaFormat& rAreaFmt,
      const ScfPropertySet& rPropSet, XclChPropertyMode ePropMode ) const
381{
  return GetChartPropSetHelper().ReadAreaProperties( rAreaFmt, rPropSet, ePropMode );
383}

385void XclExpChRoot::ConvertEscherFormat(
      XclChEscherFormat& rEscherFmt, XclChPicFormat& rPicFmt,
      const ScfPropertySet& rPropSet, XclChPropertyMode ePropMode ) const
388{
  GetChartPropSetHelper().ReadEscherProperties( rEscherFmt, rPicFmt,
      *mxChData->mxGradientTable, *mxChData->mxHatchTable, *mxChData->mxBitmapTable, rPropSet, ePropMode );
391}

393sal_uInt16 XclExpChRoot::ConvertFont( const ScfPropertySet& rPropSet, sal_Int16 nScript ) const
394{
  XclFontData aFontData;
  GetFontPropSetHelper().ReadFontProperties( aFontData, rPropSet, EXC_FONTPROPSET_CHART, nScript );
  return GetFontBuffer().Insert( aFontData, EXC_COLOR_CHARTTEXT );
398}

400sal_uInt16 XclExpChRoot::ConvertPieRotation( const ScfPropertySet& rPropSet )
401{
  sal_Int32 nApiRot = 0;
  rPropSet.GetProperty( nApiRot, EXC_CHPROP_STARTINGANGLE"StartingAngle" );
  return static_cast< sal_uInt16 >( (450 - (nApiRot % 360)) % 360 );
405}

407void XclExpChRoot::RegisterFutureRecBlock( const XclChFrBlock& rFrBlock )
408{
  mxChData->RegisterFutureRecBlock( rFrBlock );
410}

412void XclExpChRoot::InitializeFutureRecBlock( XclExpStream& rStrm )
413{
  mxChData->InitializeFutureRecBlock( rStrm );
415}

417void XclExpChRoot::FinalizeFutureRecBlock( XclExpStream& rStrm )
418{
  mxChData->FinalizeFutureRecBlock( rStrm );
420}

422XclExpChGroupBase::XclExpChGroupBase( const XclExpChRoot& rRoot,
      sal_uInt16 nFrType, sal_uInt16 nRecId, std::size_t nRecSize ) :
  XclExpRecord( nRecId, nRecSize ),
  XclExpChRoot( rRoot ),
  maFrBlock( nFrType )
427{
428}

430XclExpChGroupBase::~XclExpChGroupBase()
431{
432}

434void XclExpChGroupBase::Save( XclExpStream& rStrm )
435{
  // header record
  XclExpRecord::Save( rStrm );
  // group records
  if( !HasSubRecords() )
      return;

  // register the future record context corresponding to this record group
  RegisterFutureRecBlock( maFrBlock );
  // CHBEGIN record
  XclExpEmptyRecord( EXC_ID_CHBEGIN ).Save( rStrm );
  // embedded records
  WriteSubRecords( rStrm );
  // finalize the future records, must be done before the closing CHEND
  FinalizeFutureRecBlock( rStrm );
  // CHEND record
  XclExpEmptyRecord( EXC_ID_CHEND ).Save( rStrm );
452}

454bool XclExpChGroupBase::HasSubRecords() const
455{
  return true;
457}

459void XclExpChGroupBase::SetFutureRecordContext( sal_uInt16 nFrContext, sal_uInt16 nFrValue1, sal_uInt16 nFrValue2 )
460{
  maFrBlock.mnContext = nFrContext;
  maFrBlock.mnValue1  = nFrValue1;
  maFrBlock.mnValue2  = nFrValue2;
464}

466XclExpChFutureRecordBase::XclExpChFutureRecordBase( const XclExpChRoot& rRoot,
      XclFutureRecType eRecType, sal_uInt16 nRecId, std::size_t nRecSize ) :
  XclExpFutureRecord( eRecType, nRecId, nRecSize ),
  XclExpChRoot( rRoot )
470{
471}

473void XclExpChFutureRecordBase::Save( XclExpStream& rStrm )
474{
  InitializeFutureRecBlock( rStrm );
  XclExpFutureRecord::Save( rStrm );
477}

479// Frame formatting ===========================================================

481XclExpChFramePos::XclExpChFramePos( sal_uInt16 nTLMode ) :
  XclExpRecord( EXC_ID_CHFRAMEPOS, 20 )
483{
  maData.mnTLMode = nTLMode;
  maData.mnBRMode = EXC_CHFRAMEPOS_PARENT;
486}

488void XclExpChFramePos::WriteBody( XclExpStream& rStrm )
489{
  rStrm << maData.mnTLMode << maData.mnBRMode << maData.maRect;
491}

493XclExpChLineFormat::XclExpChLineFormat( const XclExpChRoot& rRoot ) :
  XclExpRecord( EXC_ID_CHLINEFORMAT, (rRoot.GetBiff() == EXC_BIFF8) ? 12 : 10 ),
  mnColorId( XclExpPalette::GetColorIdFromIndex( EXC_COLOR_CHWINDOWTEXT ) )
496{
497}

499void XclExpChLineFormat::SetDefault( XclChFrameType eDefFrameType )
500{
  switch( eDefFrameType )
  {
      case EXC_CHFRAMETYPE_AUTO:
          SetAuto( true );
      break;
      case EXC_CHFRAMETYPE_INVISIBLE:
          SetAuto( false );
          maData.mnPattern = EXC_CHLINEFORMAT_NONE;
      break;
      default:
          OSL_FAIL( "XclExpChLineFormat::SetDefault - unknown frame type" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx"
 ":" "511" ": "), "%s", "XclExpChLineFormat::SetDefault - unknown frame type"
); } } while (false);
  }
513}

515void XclExpChLineFormat::Convert( const XclExpChRoot& rRoot,
      const ScfPropertySet& rPropSet, XclChObjectType eObjType )
517{
  const XclChFormatInfo& rFmtInfo = rRoot.GetFormatInfo( eObjType );
  rRoot.ConvertLineFormat( maData, rPropSet, rFmtInfo.mePropMode );
  if( HasLine() )
  {
      // detect system color, set color identifier (TODO: detect automatic series line)
      if( (eObjType != EXC_CHOBJTYPE_LINEARSERIES) && rRoot.IsSystemColor( maData.maColor, rFmtInfo.mnAutoLineColorIdx ) )
      {
          // store color index from automatic format data
          mnColorId = XclExpPalette::GetColorIdFromIndex( rFmtInfo.mnAutoLineColorIdx );
          // try to set automatic mode
          bool bAuto = (maData.mnPattern == EXC_CHLINEFORMAT_SOLID) && (maData.mnWeight == rFmtInfo.mnAutoLineWeight);
          ::set_flag( maData.mnFlags, EXC_CHLINEFORMAT_AUTO, bAuto );
      }
      else
      {
          // user defined color - register in palette
          mnColorId = rRoot.GetPalette().InsertColor( maData.maColor, EXC_COLOR_CHARTLINE );
      }
  }
  else
  {
      // no line - set default system color
      rRoot.SetSystemColor( maData.maColor, mnColorId, EXC_COLOR_CHWINDOWTEXT );
  }
542}

544bool XclExpChLineFormat::IsDefault( XclChFrameType eDefFrameType ) const
545{
  return
      ((eDefFrameType == EXC_CHFRAMETYPE_INVISIBLE) && !HasLine()) ||
      ((eDefFrameType == EXC_CHFRAMETYPE_AUTO) && IsAuto());
549}

551void XclExpChLineFormat::WriteBody( XclExpStream& rStrm )
552{
  rStrm << maData.maColor << maData.mnPattern << maData.mnWeight << maData.mnFlags;
  if( rStrm.GetRoot().GetBiff() == EXC_BIFF8 )
      rStrm << rStrm.GetRoot().GetPalette().GetColorIndex( mnColorId );
556}

558namespace {

560/** Creates a CHLINEFORMAT record from the passed property set. */
561XclExpChLineFormatRef lclCreateLineFormat( const XclExpChRoot& rRoot,
      const ScfPropertySet& rPropSet, XclChObjectType eObjType )
563{
  XclExpChLineFormatRef xLineFmt = new XclExpChLineFormat( rRoot );
  xLineFmt->Convert( rRoot, rPropSet, eObjType );
  const XclChFormatInfo& rFmtInfo = rRoot.GetFormatInfo( eObjType );
  if( rFmtInfo.mbDeleteDefFrame && xLineFmt->IsDefault( rFmtInfo.meDefFrameType ) )
      xLineFmt.clear();
  return xLineFmt;
570}

572} // namespace

574XclExpChAreaFormat::XclExpChAreaFormat( const XclExpChRoot& rRoot ) :
  XclExpRecord( EXC_ID_CHAREAFORMAT, (rRoot.GetBiff() == EXC_BIFF8) ? 16 : 12 ),
  mnPattColorId( XclExpPalette::GetColorIdFromIndex( EXC_COLOR_CHWINDOWBACK ) ),
  mnBackColorId( XclExpPalette::GetColorIdFromIndex( EXC_COLOR_CHWINDOWTEXT ) )
578{
579}

581bool XclExpChAreaFormat::Convert( const XclExpChRoot& rRoot,
      const ScfPropertySet& rPropSet, XclChObjectType eObjType )
583{
  const XclChFormatInfo& rFmtInfo = rRoot.GetFormatInfo( eObjType );
  bool bComplexFill = rRoot.ConvertAreaFormat( maData, rPropSet, rFmtInfo.mePropMode );
  if( HasArea() )
  {
      bool bSolid = maData.mnPattern == EXC_PATT_SOLID;
      // detect system color, set color identifier (TODO: detect automatic series area)
      if( (eObjType != EXC_CHOBJTYPE_FILLEDSERIES) && rRoot.IsSystemColor( maData.maPattColor, rFmtInfo.mnAutoPattColorIdx ) )
      {
          // store color index from automatic format data
          mnPattColorId = XclExpPalette::GetColorIdFromIndex( rFmtInfo.mnAutoPattColorIdx );
          // set automatic mode
          ::set_flag( maData.mnFlags, EXC_CHAREAFORMAT_AUTO, bSolid );
      }
      else
      {
          // user defined color - register color in palette
          mnPattColorId = rRoot.GetPalette().InsertColor( maData.maPattColor, EXC_COLOR_CHARTAREA );
      }
      // background color (default system color for solid fills)
      if( bSolid )
          rRoot.SetSystemColor( maData.maBackColor, mnBackColorId, EXC_COLOR_CHWINDOWTEXT );
      else
          mnBackColorId = rRoot.GetPalette().InsertColor( maData.maBackColor, EXC_COLOR_CHARTAREA );
  }
  else
  {
      // no area - set default system colors
      rRoot.SetSystemColor( maData.maPattColor, mnPattColorId, EXC_COLOR_CHWINDOWBACK );
      rRoot.SetSystemColor( maData.maBackColor, mnBackColorId, EXC_COLOR_CHWINDOWTEXT );
  }
  return bComplexFill;
615}

617void XclExpChAreaFormat::SetDefault( XclChFrameType eDefFrameType )
618{
  switch( eDefFrameType )
  {
      case EXC_CHFRAMETYPE_AUTO:
          SetAuto( true );
      break;
      case EXC_CHFRAMETYPE_INVISIBLE:
          SetAuto( false );
          maData.mnPattern = EXC_PATT_NONE;
      break;
      default:
          OSL_FAIL( "XclExpChAreaFormat::SetDefault - unknown frame type" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx"
 ":" "629" ": "), "%s", "XclExpChAreaFormat::SetDefault - unknown frame type"
); } } while (false);
  }
631}

633bool XclExpChAreaFormat::IsDefault( XclChFrameType eDefFrameType ) const
634{
  return
      ((eDefFrameType == EXC_CHFRAMETYPE_INVISIBLE) && !HasArea()) ||
      ((eDefFrameType == EXC_CHFRAMETYPE_AUTO) && IsAuto());
638}

640void XclExpChAreaFormat::WriteBody( XclExpStream& rStrm )
641{
  rStrm << maData.maPattColor << maData.maBackColor << maData.mnPattern << maData.mnFlags;
  if( rStrm.GetRoot().GetBiff() == EXC_BIFF8 )
  {
      const XclExpPalette& rPal = rStrm.GetRoot().GetPalette();
      rStrm << rPal.GetColorIndex( mnPattColorId ) << rPal.GetColorIndex( mnBackColorId );
  }
648}

650XclExpChEscherFormat::XclExpChEscherFormat( const XclExpChRoot& rRoot ) :
  XclExpChGroupBase( rRoot, EXC_CHFRBLOCK_TYPE_UNKNOWN, EXC_ID_CHESCHERFORMAT ),
  mnColor1Id( XclExpPalette::GetColorIdFromIndex( EXC_COLOR_CHWINDOWBACK ) ),
  mnColor2Id( XclExpPalette::GetColorIdFromIndex( EXC_COLOR_CHWINDOWBACK ) )
654{
  OSL_ENSURE_BIFF( GetBiff() == EXC_BIFF8 )do { if (true && (!(GetBiff() == EXC_BIFF8))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx"
 ":" "655" ": "), "%s", "Unknown BIFF type!"); } } while (false
);
656}

658void XclExpChEscherFormat::Convert( const ScfPropertySet& rPropSet, XclChObjectType eObjType )
659{
  const XclChFormatInfo& rFmtInfo = GetFormatInfo( eObjType );
  ConvertEscherFormat( maData, maPicFmt, rPropSet, rFmtInfo.mePropMode );
  // register colors in palette
  mnColor1Id = RegisterColor( ESCHER_Prop_fillColor385 );
  mnColor2Id = RegisterColor( ESCHER_Prop_fillBackColor387 );
665}

667bool XclExpChEscherFormat::IsValid() const
668{
  return static_cast< bool >(maData.mxEscherSet);
670}

672void XclExpChEscherFormat::Save( XclExpStream& rStrm )
673{
  if( maData.mxEscherSet )
  {
      // replace RGB colors with palette indexes in the Escher container
      const XclExpPalette& rPal = GetPalette();
      maData.mxEscherSet->AddOpt( ESCHER_Prop_fillColor385, 0x08000000 | rPal.GetColorIndex( mnColor1Id ) );
      maData.mxEscherSet->AddOpt( ESCHER_Prop_fillBackColor387, 0x08000000 | rPal.GetColorIndex( mnColor2Id ) );

      // save the record group
      XclExpChGroupBase::Save( rStrm );
  }
684}

686bool XclExpChEscherFormat::HasSubRecords() const
687{
  // no subrecords for gradients
  return maPicFmt.mnBmpMode != EXC_CHPICFORMAT_NONE;
690}

692void XclExpChEscherFormat::WriteSubRecords( XclExpStream& rStrm )
693{
  rStrm.StartRecord( EXC_ID_CHPICFORMAT, 14 );
  rStrm << maPicFmt.mnBmpMode << sal_uInt16( 0 ) << maPicFmt.mnFlags << maPicFmt.mfScale;
  rStrm.EndRecord();
697}

699sal_uInt32 XclExpChEscherFormat::RegisterColor( sal_uInt16 nPropId )
700{
  sal_uInt32 nBGRValue;
  if( maData.mxEscherSet && maData.mxEscherSet->GetOpt( nPropId, nBGRValue ) )
  {
      // swap red and blue
      Color aColor( nBGRValue & 0xff, (nBGRValue >> 8) & 0xff, (nBGRValue >> 16) & 0xff );
      return GetPalette().InsertColor( aColor, EXC_COLOR_CHARTAREA );
  }
  return XclExpPalette::GetColorIdFromIndex( EXC_COLOR_CHWINDOWBACK );
709}

711void XclExpChEscherFormat::WriteBody( XclExpStream& rStrm )
712{
  OSL_ENSURE( maData.mxEscherSet, "XclExpChEscherFormat::WriteBody - missing property container" )do { if (true && (!(maData.mxEscherSet))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx"
 ":" "713" ": "), "%s", "XclExpChEscherFormat::WriteBody - missing property container"
); } } while (false);
  // write Escher property container via temporary memory stream
  SvMemoryStream aMemStrm;
  maData.mxEscherSet->Commit( aMemStrm );
  aMemStrm.Flush();
  aMemStrm.Seek( STREAM_SEEK_TO_BEGIN0L );
  rStrm.CopyFromStream( aMemStrm );
720}

722XclExpChFrameBase::XclExpChFrameBase()
723{
724}

726XclExpChFrameBase::~XclExpChFrameBase()
727{
728}

730void XclExpChFrameBase::ConvertFrameBase( const XclExpChRoot& rRoot,
      const ScfPropertySet& rPropSet, XclChObjectType eObjType )
732{
  // line format
  mxLineFmt = new XclExpChLineFormat( rRoot );
  mxLineFmt->Convert( rRoot, rPropSet, eObjType );
  // area format (only for frame objects)
  if( !rRoot.GetFormatInfo( eObjType ).mbIsFrame )
      return;

  mxAreaFmt = new XclExpChAreaFormat( rRoot );
  bool bComplexFill = mxAreaFmt->Convert( rRoot, rPropSet, eObjType );
  if( (rRoot.GetBiff() == EXC_BIFF8) && bComplexFill )
  {
      mxEscherFmt = new XclExpChEscherFormat( rRoot );
      mxEscherFmt->Convert( rPropSet, eObjType );
      if( mxEscherFmt->IsValid() )
          mxAreaFmt->SetAuto( false );
      else
          mxEscherFmt.clear();
  }
751}

753void XclExpChFrameBase::SetDefaultFrameBase( const XclExpChRoot& rRoot,
      XclChFrameType eDefFrameType, bool bIsFrame )
755{
  // line format
  mxLineFmt = new XclExpChLineFormat( rRoot );
  mxLineFmt->SetDefault( eDefFrameType );
  // area format (only for frame objects)
  if( bIsFrame )
  {
      mxAreaFmt = new XclExpChAreaFormat( rRoot );
      mxAreaFmt->SetDefault( eDefFrameType );
      mxEscherFmt.clear();
  }
766}

768bool XclExpChFrameBase::IsDefaultFrameBase( XclChFrameType eDefFrameType ) const
769{
  return
      (!mxLineFmt || mxLineFmt->IsDefault( eDefFrameType )) &&
      (!mxAreaFmt || mxAreaFmt->IsDefault( eDefFrameType ));
773}

775void XclExpChFrameBase::WriteFrameRecords( XclExpStream& rStrm )
776{
  lclSaveRecord( rStrm, mxLineFmt );
  lclSaveRecord( rStrm, mxAreaFmt );
  lclSaveRecord( rStrm, mxEscherFmt );
780}

782XclExpChFrame::XclExpChFrame( const XclExpChRoot& rRoot, XclChObjectType eObjType ) :
  XclExpChGroupBase( rRoot, EXC_CHFRBLOCK_TYPE_FRAME, EXC_ID_CHFRAME, 4 ),
  meObjType( eObjType )
785{
786}

788void XclExpChFrame::Convert( const ScfPropertySet& rPropSet )
789{
  ConvertFrameBase( GetChRoot(), rPropSet, meObjType );
791}

793void XclExpChFrame::SetAutoFlags( bool bAutoPos, bool bAutoSize )
794{
  ::set_flag( maData.mnFlags, EXC_CHFRAME_AUTOPOS, bAutoPos );
  ::set_flag( maData.mnFlags, EXC_CHFRAME_AUTOSIZE, bAutoSize );
797}

799bool XclExpChFrame::IsDefault() const
800{
  return IsDefaultFrameBase( GetFormatInfo( meObjType ).meDefFrameType );
802}

804bool XclExpChFrame::IsDeleteable() const
805{
  return IsDefault() && GetFormatInfo( meObjType ).mbDeleteDefFrame;
807}

809void XclExpChFrame::Save( XclExpStream& rStrm )
810{
  switch( meObjType )
  {
      // wall/floor frame without CHFRAME header record
      case EXC_CHOBJTYPE_WALL3D:
      case EXC_CHOBJTYPE_FLOOR3D:
          WriteFrameRecords( rStrm );
      break;
      default:
          XclExpChGroupBase::Save( rStrm );
  }
821}

823void XclExpChFrame::WriteSubRecords( XclExpStream& rStrm )
824{
  WriteFrameRecords( rStrm );
826}

828void XclExpChFrame::WriteBody( XclExpStream& rStrm )
829{
  rStrm << maData.mnFormat << maData.mnFlags;
831}

833namespace {

835/** Creates a CHFRAME record from the passed property set. */
836XclExpChFrameRef lclCreateFrame( const XclExpChRoot& rRoot,
      const ScfPropertySet& rPropSet, XclChObjectType eObjType )
838{
  XclExpChFrameRef xFrame = new XclExpChFrame( rRoot, eObjType );
  xFrame->Convert( rPropSet );
  if( xFrame->IsDeleteable() )
      xFrame.clear();
  return xFrame;
844}

846} // namespace

848// Source links ===============================================================

850namespace {

852void lclAddDoubleRefData(
      ScTokenArray& orArray, const FormulaToken& rToken,
      SCTAB nScTab1, SCCOL nScCol1, SCROW nScRow1,
      SCTAB nScTab2, SCCOL nScCol2, SCROW nScRow2 )
856{
  ScComplexRefData aComplexRef;
  aComplexRef.InitRange(ScRange(nScCol1,nScRow1,nScTab1,nScCol2,nScRow2,nScTab2));
  aComplexRef.Ref1.SetFlag3D( true );

  if( orArray.GetLen() > 0 )
      orArray.AddOpCode( ocUnion );

  OSL_ENSURE( (rToken.GetType() == ::formula::svDoubleRef) || (rToken.GetType() == ::formula::svExternalDoubleRef),do { if (true && (!((rToken.GetType() == ::formula::svDoubleRef
) || (rToken.GetType() == ::formula::svExternalDoubleRef)))) {
 sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx"
 ":" "865" ": "), "%s", "lclAddDoubleRefData - double reference token expected"
); } } while (false)
      "lclAddDoubleRefData - double reference token expected")do { if (true && (!((rToken.GetType() == ::formula::svDoubleRef
) || (rToken.GetType() == ::formula::svExternalDoubleRef)))) {
 sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx"
 ":" "865" ": "), "%s", "lclAddDoubleRefData - double reference token expected"
); } } while (false);
  if( rToken.GetType() == ::formula::svExternalDoubleRef )
      orArray.AddExternalDoubleReference(
          rToken.GetIndex(), rToken.GetString(), aComplexRef);
  else
      orArray.AddDoubleReference( aComplexRef );
871}

873} // namespace

875XclExpChSourceLink::XclExpChSourceLink( const XclExpChRoot& rRoot, sal_uInt8 nDestType ) :
  XclExpRecord( EXC_ID_CHSOURCELINK ),
  XclExpChRoot( rRoot )
878{
  maData.mnDestType = nDestType;
  maData.mnLinkType = EXC_CHSRCLINK_DIRECTLY;
881}

883sal_uInt16 XclExpChSourceLink::ConvertDataSequence( Reference< XDataSequence > const & xDataSeq, bool bSplitToColumns, sal_uInt16 nDefCount )
884{
  mxLinkFmla.reset();
  maData.mnLinkType = EXC_CHSRCLINK_DEFAULT;

  if( !xDataSeq.is() )
      return nDefCount;

  // Compile the range representation string into token array.  Note that the
  // source range text depends on the current grammar.
  OUString aRangeRepr = xDataSeq->getSourceRangeRepresentation();
  ScCompiler aComp( GetDoc(), ScAddress(), GetDoc().GetGrammar() );
  std::unique_ptr<ScTokenArray> pArray(aComp.CompileString(aRangeRepr));
  if( !pArray )
      return nDefCount;

  ScTokenArray aArray(GetRoot().GetDoc());
  sal_uInt32 nValueCount = 0;
  FormulaTokenArrayPlainIterator aIter(*pArray);
  for( const FormulaToken* pToken = aIter.First(); pToken; pToken = aIter.Next() )
  {
      switch( pToken->GetType() )
      {
          case ::formula::svSingleRef:
          case ::formula::svExternalSingleRef:
              // for a single ref token, just add it to the new token array as is
              if( aArray.GetLen() > 0 )
                  aArray.AddOpCode( ocUnion );
              aArray.AddToken( *pToken );
              ++nValueCount;
          break;

          case ::formula::svDoubleRef:
          case ::formula::svExternalDoubleRef:
          {
              // split 3-dimensional ranges into single sheets
              const ScComplexRefData& rComplexRef = *pToken->GetDoubleRef();
              ScAddress aAbs1 = rComplexRef.Ref1.toAbs(GetRoot().GetDoc(), ScAddress());
              ScAddress aAbs2 = rComplexRef.Ref2.toAbs(GetRoot().GetDoc(), ScAddress());
              for (SCTAB nScTab = aAbs1.Tab(); nScTab <= aAbs2.Tab(); ++nScTab)
              {
                  // split 2-dimensional ranges into single columns
                  if (bSplitToColumns && (aAbs1.Col() < aAbs2.Col()) && (aAbs1.Row() < aAbs2.Row()))
                      for (SCCOL nScCol = aAbs1.Col(); nScCol <= aAbs2.Col(); ++nScCol)
                          lclAddDoubleRefData(aArray, *pToken, nScTab, nScCol, aAbs1.Row(), nScTab, nScCol, aAbs2.Row());
                  else
                      lclAddDoubleRefData(aArray, *pToken, nScTab, aAbs1.Col(), aAbs1.Row(), nScTab, aAbs2.Col(), aAbs2.Row());
              }
              sal_uInt32 nTabs = static_cast<sal_uInt32>(aAbs2.Tab() - aAbs1.Tab() + 1);
              sal_uInt32 nCols = static_cast<sal_uInt32>(aAbs2.Col() - aAbs1.Col() + 1);
              sal_uInt32 nRows = static_cast<sal_uInt32>(aAbs2.Row() - aAbs1.Row() + 1);
              nValueCount += nCols * nRows * nTabs;
          }
          break;

          default:;
      }
  }

  const ScAddress aBaseCell;
  mxLinkFmla = GetFormulaCompiler().CreateFormula( EXC_FMLATYPE_CHART, aArray, &aBaseCell );
  maData.mnLinkType = EXC_CHSRCLINK_WORKSHEET;
  return ulimit_cast< sal_uInt16 >( nValueCount, EXC_CHDATAFORMAT_MAXPOINTCOUNT );
946}

948void XclExpChSourceLink::ConvertString( const OUString& aString )
949{
  mxString = XclExpStringHelper::CreateString( GetRoot(), aString, XclStrFlags::ForceUnicode | XclStrFlags::EightBitLength | XclStrFlags::SeparateFormats );
951}

953sal_uInt16 XclExpChSourceLink::ConvertStringSequence( const Sequence< Reference< XFormattedString > >& rStringSeq )
954{
  mxString.reset();
  sal_uInt16 nFontIdx = EXC_FONT_APP;
  if( rStringSeq.hasElements() )
  {
      mxString = XclExpStringHelper::CreateString( GetRoot(), OUString(), XclStrFlags::ForceUnicode | XclStrFlags::EightBitLength | XclStrFlags::SeparateFormats );
      Reference< XBreakIterator > xBreakIt = GetDoc().GetBreakIterator();
      namespace ApiScriptType = ::com::sun::star::i18n::ScriptType;

      // convert all formatted string entries from the sequence
      for( const Reference< XFormattedString >& rString : rStringSeq )
      {
          if( rString.is() )
          {
              sal_uInt16 nWstrnFontIdx = EXC_FONT_NOTFOUND;
              sal_uInt16 nAsianFontIdx = EXC_FONT_NOTFOUND;
              sal_uInt16 nCmplxFontIdx = EXC_FONT_NOTFOUND;
              OUString aText = rString->getString();
              ScfPropertySet aStrProp( rString );

              // #i63255# get script type for leading weak characters
              sal_Int16 nLastScript = XclExpStringHelper::GetLeadingScriptType( GetRoot(), aText );

              // process all script portions
              sal_Int32 nPortionPos = 0;
              sal_Int32 nTextLen = aText.getLength();
              while( nPortionPos < nTextLen )
              {
                  // get script type and end position of next script portion
                  sal_Int16 nScript = xBreakIt->getScriptType( aText, nPortionPos );
                  sal_Int32 nPortionEnd = xBreakIt->endOfScript( aText, nPortionPos, nScript );

                  // reuse previous script for following weak portions
                  if( nScript == ApiScriptType::WEAK )
                      nScript = nLastScript;

                  // Excel start position of this portion
                  sal_uInt16 nXclPortionStart = mxString->Len();
                  // add portion text to Excel string
                  XclExpStringHelper::AppendString( *mxString, GetRoot(), aText.copy( nPortionPos, nPortionEnd - nPortionPos ) );
                  if( nXclPortionStart < mxString->Len() )
                  {
                      // find font index variable dependent on script type
                      sal_uInt16& rnFontIdx = (nScript == ApiScriptType::COMPLEX) ? nCmplxFontIdx :
                          ((nScript == ApiScriptType::ASIAN) ? nAsianFontIdx : nWstrnFontIdx);

                      // insert font into buffer (if not yet done)
                      if( rnFontIdx == EXC_FONT_NOTFOUND )
                          rnFontIdx = ConvertFont( aStrProp, nScript );

                      // insert font index into format run vector
                      mxString->AppendFormat( nXclPortionStart, rnFontIdx );
                  }

                  // go to next script portion
                  nLastScript = nScript;
                  nPortionPos = nPortionEnd;
              }
          }
      }
      if( !mxString->IsEmpty() )
      {
          // get leading font index
          const XclFormatRunVec& rFormats = mxString->GetFormats();
          OSL_ENSURE( !rFormats.empty() && (rFormats.front().mnChar == 0),do { if (true && (!(!rFormats.empty() && (rFormats
.front().mnChar == 0)))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx"
 ":" "1019" ": "), "%s", "XclExpChSourceLink::ConvertStringSequenc - missing leading format"
); } } while (false)
              "XclExpChSourceLink::ConvertStringSequenc - missing leading format" )do { if (true && (!(!rFormats.empty() && (rFormats
.front().mnChar == 0)))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx"
 ":" "1019" ": "), "%s", "XclExpChSourceLink::ConvertStringSequenc - missing leading format"
); } } while (false);
          // remove leading format run, if entire string is equally formatted
          if( rFormats.size() == 1 )
              nFontIdx = mxString->RemoveLeadingFont();
          else if( !rFormats.empty() )
              nFontIdx = rFormats.front().mnFontIdx;
          // add trailing format run, if string is rich-formatted
          if( mxString->IsRich() )
              mxString->AppendTrailingFormat( EXC_FONT_APP );
      }
  }
  return nFontIdx;
1031}

1033void XclExpChSourceLink::ConvertNumFmt( const ScfPropertySet& rPropSet, bool bPercent )
1034{
  sal_Int32 nApiNumFmt = 0;
  if( bPercent ? rPropSet.GetProperty( nApiNumFmt, EXC_CHPROP_PERCENTAGENUMFMT"PercentageNumberFormat" ) : rPropSet.GetProperty( nApiNumFmt, EXC_CHPROP_NUMBERFORMAT"NumberFormat" ) )
  {
      ::set_flag( maData.mnFlags, EXC_CHSRCLINK_NUMFMT );
      maData.mnNumFmtIdx = GetNumFmtBuffer().Insert( static_cast< sal_uInt32 >( nApiNumFmt ) );
  }
1041}

1043void XclExpChSourceLink::AppendString( const OUString& rStr )
1044{
  if (!mxString)
      return;
  XclExpStringHelper::AppendString( *mxString, GetRoot(), rStr );
1048}

1050void XclExpChSourceLink::Save( XclExpStream& rStrm )
1051{
  // CHFORMATRUNS record
  if( mxString && mxString->IsRich() )
  {
      std::size_t nRecSize = (1 + mxString->GetFormatsCount()) * ((GetBiff() == EXC_BIFF8) ? 2 : 1);
      rStrm.StartRecord( EXC_ID_CHFORMATRUNS, nRecSize );
      mxString->WriteFormats( rStrm, true );
      rStrm.EndRecord();
  }
  // CHSOURCELINK record
  XclExpRecord::Save( rStrm );
  // CHSTRING record
  if( mxString && !mxString->IsEmpty() )
  {
      rStrm.StartRecord( EXC_ID_CHSTRING, 2 + mxString->GetSize() );
      rStrm << sal_uInt16( 0 ) << *mxString;
      rStrm.EndRecord();
  }
1069}

1071void XclExpChSourceLink::WriteBody( XclExpStream& rStrm )
1072{
  rStrm   << maData.mnDestType
          << maData.mnLinkType
          << maData.mnFlags
          << maData.mnNumFmtIdx
          << mxLinkFmla;
1078}

1080// Text =======================================================================

1082XclExpChFont::XclExpChFont( sal_uInt16 nFontIdx ) :
  XclExpUInt16Record( EXC_ID_CHFONT, nFontIdx )
1084{
1085}

1087XclExpChObjectLink::XclExpChObjectLink( sal_uInt16 nLinkTarget, const XclChDataPointPos& rPointPos ) :
  XclExpRecord( EXC_ID_CHOBJECTLINK, 6 )
1089{
  maData.mnTarget = nLinkTarget;
  maData.maPointPos = rPointPos;
1092}

1094void XclExpChObjectLink::WriteBody( XclExpStream& rStrm )
1095{
  rStrm << maData.mnTarget << maData.maPointPos.mnSeriesIdx << maData.maPointPos.mnPointIdx;
1097}

1099XclExpChFrLabelProps::XclExpChFrLabelProps( const XclExpChRoot& rRoot ) :
  XclExpChFutureRecordBase( rRoot, EXC_FUTUREREC_UNUSEDREF, EXC_ID_CHFRLABELPROPS, 4 )
1101{
1102}

1104void XclExpChFrLabelProps::Convert( const ScfPropertySet& rPropSet,
      bool bShowCateg, bool bShowValue, bool bShowPercent, bool bShowBubble )
1106{
  // label value flags
  ::set_flag( maData.mnFlags, EXC_CHFRLABELPROPS_SHOWSERIES,  false );
  ::set_flag( maData.mnFlags, EXC_CHFRLABELPROPS_SHOWCATEG,   bShowCateg );
  ::set_flag( maData.mnFlags, EXC_CHFRLABELPROPS_SHOWVALUE,   bShowValue );
  ::set_flag( maData.mnFlags, EXC_CHFRLABELPROPS_SHOWPERCENT, bShowPercent );
  ::set_flag( maData.mnFlags, EXC_CHFRLABELPROPS_SHOWBUBBLE,  bShowBubble );

  // label value separator
  maData.maSeparator = rPropSet.GetStringProperty( EXC_CHPROP_LABELSEPARATOR"LabelSeparator" );
  if( maData.maSeparator.isEmpty() )
      maData.maSeparator = " ";
1118}

1120void XclExpChFrLabelProps::WriteBody( XclExpStream& rStrm )
1121{
  XclExpString aXclSep( maData.maSeparator, XclStrFlags::ForceUnicode | XclStrFlags::SmartFlags );
  rStrm << maData.mnFlags << aXclSep;
1124}

1126XclExpChFontBase::~XclExpChFontBase()
1127{
1128}

1130void XclExpChFontBase::ConvertFontBase( const XclExpChRoot& rRoot, sal_uInt16 nFontIdx )
1131{
  if( const XclExpFont* pFont = rRoot.GetFontBuffer().GetFont( nFontIdx ) )
  {
      XclExpChFontRef xFont = new XclExpChFont( nFontIdx );
      SetFont( xFont, pFont->GetFontData().maColor, pFont->GetFontColorId() );
  }
1137}

1139void XclExpChFontBase::ConvertFontBase( const XclExpChRoot& rRoot, const ScfPropertySet& rPropSet )
1140{
  ConvertFontBase( rRoot, rRoot.ConvertFont( rPropSet, rRoot.GetDefApiScript() ) );
1142}

1144void XclExpChFontBase::ConvertRotationBase(const ScfPropertySet& rPropSet, bool bSupportsStacked )
1145{
  sal_uInt16 nRotation = XclChPropSetHelper::ReadRotationProperties( rPropSet, bSupportsStacked );
  SetRotation( nRotation );
1148}

1150XclExpChText::XclExpChText( const XclExpChRoot& rRoot ) :
  XclExpChGroupBase( rRoot, EXC_CHFRBLOCK_TYPE_TEXT, EXC_ID_CHTEXT, (rRoot.GetBiff() == EXC_BIFF8) ? 32 : 26 ),
  mnTextColorId( XclExpPalette::GetColorIdFromIndex( EXC_COLOR_CHWINDOWTEXT ) )
1153{
1154}

1156void XclExpChText::SetFont( XclExpChFontRef xFont, const Color& rColor, sal_uInt32 nColorId )
1157{
  mxFont = xFont;
  maData.maTextColor = rColor;
  ::set_flag( maData.mnFlags, EXC_CHTEXT_AUTOCOLOR, rColor == COL_AUTO );
  mnTextColorId = nColorId;
1162}

1164void XclExpChText::SetRotation( sal_uInt16 nRotation )
1165{
  maData.mnRotation = nRotation;
  ::insert_value( maData.mnFlags, XclTools::GetXclOrientFromRot( nRotation ), 8, 3 );
1168}

1170void XclExpChText::ConvertTitle( Reference< XTitle > const & xTitle, sal_uInt16 nTarget, const OUString* pSubTitle )
1171{
  switch( nTarget )
  {
      case EXC_CHOBJLINK_TITLE:   SetFutureRecordContext( EXC_CHFRBLOCK_TEXT_TITLE );         break;
      case EXC_CHOBJLINK_YAXIS:   SetFutureRecordContext( EXC_CHFRBLOCK_TEXT_AXISTITLE, 1 );  break;
      case EXC_CHOBJLINK_XAXIS:   SetFutureRecordContext( EXC_CHFRBLOCK_TEXT_AXISTITLE );  break;
      case EXC_CHOBJLINK_ZAXIS:   SetFutureRecordContext( EXC_CHFRBLOCK_TEXT_AXISTITLE, 2 );  break;
  }

  mxSrcLink.clear();
  mxObjLink = new XclExpChObjectLink( nTarget, XclChDataPointPos( 0, 0 ) );

  if( xTitle.is() )
  {
      // title frame formatting
      ScfPropertySet aTitleProp( xTitle );
      mxFrame = lclCreateFrame( GetChRoot(), aTitleProp, EXC_CHOBJTYPE_TEXT );

      // string sequence
      mxSrcLink = new XclExpChSourceLink( GetChRoot(), EXC_CHSRCLINK_TITLE );
      sal_uInt16 nFontIdx = mxSrcLink->ConvertStringSequence( xTitle->getText() );
      if (pSubTitle)
      {
          // append subtitle as the 2nd line of the title.
          OUString aSubTitle = "\n" + *pSubTitle;
          mxSrcLink->AppendString(aSubTitle);
      }

      ConvertFontBase( GetChRoot(), nFontIdx );

      // rotation
      ConvertRotationBase( aTitleProp, true );

      // manual text position - only for main title
      mxFramePos = new XclExpChFramePos( EXC_CHFRAMEPOS_PARENT );
      if( nTarget == EXC_CHOBJLINK_TITLE )
      {
          Any aRelPos;
          if( aTitleProp.GetAnyProperty( aRelPos, EXC_CHPROP_RELATIVEPOSITION"RelativePosition" ) && aRelPos.has< RelativePosition >() ) try
          {
              // calculate absolute position for CHTEXT record
              Reference< cssc::XChartDocument > xChart1Doc( GetChartDocument(), UNO_QUERY_THROW );
              Reference< XShape > xTitleShape( xChart1Doc->getTitle(), UNO_SET_THROW );
              css::awt::Point aPos = xTitleShape->getPosition();
              css::awt::Size aSize = xTitleShape->getSize();
              css::awt::Rectangle aRect( aPos.X, aPos.Y, aSize.Width, aSize.Height );
              maData.maRect = CalcChartRectFromHmm( aRect );
              ::insert_value( maData.mnFlags2, EXC_CHTEXT_POS_MOVED, 0, 4 );
              // manual title position implies manual plot area
              GetChartData().SetManualPlotArea();
              // calculate the default title position in chart units
              sal_Int32 nDefPosX = ::std::max< sal_Int32 >( (EXC_CHART_TOTALUNITS - maData.maRect.mnWidth) / 2, 0 );
              sal_Int32 nDefPosY = 85;
              // set the position relative to the standard position
              XclChRectangle& rFrameRect = mxFramePos->GetFramePosData().maRect;
              rFrameRect.mnX = maData.maRect.mnX - nDefPosX;
              rFrameRect.mnY = maData.maRect.mnY - nDefPosY;
          }
          catch( Exception& )
          {
          }
      }
  }
  else
  {
      ::set_flag( maData.mnFlags, EXC_CHTEXT_DELETED );
  }
1238}

1240void XclExpChText::ConvertLegend( const ScfPropertySet& rPropSet )
1241{
  ::set_flag( maData.mnFlags, EXC_CHTEXT_AUTOTEXT );
  ::set_flag( maData.mnFlags, EXC_CHTEXT_AUTOGEN );
  ConvertFontBase( GetChRoot(), rPropSet );
1245}

1247bool XclExpChText::ConvertDataLabel( const ScfPropertySet& rPropSet,
      const XclChTypeInfo& rTypeInfo, const XclChDataPointPos& rPointPos )
1249{
  SetFutureRecordContext( EXC_CHFRBLOCK_TEXT_DATALABEL, rPointPos.mnPointIdx, rPointPos.mnSeriesIdx );

  cssc2::DataPointLabel aPointLabel;
  if( !rPropSet.GetProperty( aPointLabel, EXC_CHPROP_LABEL"Label" ) )
      return false;

  // percentage only allowed in pie and donut charts
  bool bIsPie = rTypeInfo.meTypeCateg == EXC_CHTYPECATEG_PIE;
  // bubble sizes only allowed in bubble charts
  bool bIsBubble = rTypeInfo.meTypeId == EXC_CHTYPEID_BUBBLES;
  OSL_ENSURE( (GetBiff() == EXC_BIFF8) || !bIsBubble, "XclExpChText::ConvertDataLabel - bubble charts only in BIFF8" )do { if (true && (!((GetBiff() == EXC_BIFF8) || !bIsBubble
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx"
 ":" "1260" ": "), "%s", "XclExpChText::ConvertDataLabel - bubble charts only in BIFF8"
); } } while (false);

  // raw show flags
  bool bShowValue   = !bIsBubble && aPointLabel.ShowNumber;       // Chart2 uses 'ShowNumber' for bubble size
  bool bShowPercent = bIsPie && aPointLabel.ShowNumberInPercent;  // percentage only in pie/donut charts
  bool bShowCateg   = aPointLabel.ShowCategoryName;
  bool bShowBubble  = bIsBubble && aPointLabel.ShowNumber;        // Chart2 uses 'ShowNumber' for bubble size
  bool bShowAny     = bShowValue || bShowPercent || bShowCateg || bShowBubble;

  // create the CHFRLABELPROPS record for extended settings in BIFF8
  if( bShowAny && (GetBiff() == EXC_BIFF8) )
  {
      mxLabelProps = new XclExpChFrLabelProps( GetChRoot() );
      mxLabelProps->Convert( rPropSet, bShowCateg, bShowValue, bShowPercent, bShowBubble );
  }

  // restrict to combinations allowed in CHTEXT
  if( bShowPercent ) bShowValue = false;              // percent wins over value
  if( bShowValue ) bShowCateg = false;                // value wins over category
  if( bShowValue || bShowCateg ) bShowBubble = false; // value or category wins over bubble size

  // set all flags
  ::set_flag( maData.mnFlags, EXC_CHTEXT_AUTOTEXT );
  ::set_flag( maData.mnFlags, EXC_CHTEXT_SHOWVALUE, bShowValue );
  ::set_flag( maData.mnFlags, EXC_CHTEXT_SHOWPERCENT, bShowPercent );
  ::set_flag( maData.mnFlags, EXC_CHTEXT_SHOWCATEG, bShowCateg );
  ::set_flag( maData.mnFlags, EXC_CHTEXT_SHOWCATEGPERC, bShowPercent && bShowCateg );
  ::set_flag( maData.mnFlags, EXC_CHTEXT_SHOWBUBBLE, bShowBubble );
  ::set_flag( maData.mnFlags, EXC_CHTEXT_SHOWSYMBOL, bShowAny && aPointLabel.ShowLegendSymbol );
  ::set_flag( maData.mnFlags, EXC_CHTEXT_DELETED, !bShowAny );

  if( bShowAny )
  {
      // font settings
      ConvertFontBase( GetChRoot(), rPropSet );
      ConvertRotationBase( rPropSet, false );
      // label placement
      sal_Int32 nPlacement = 0;
      sal_uInt16 nLabelPos = EXC_CHTEXT_POS_AUTO;
      if( rPropSet.GetProperty( nPlacement, EXC_CHPROP_LABELPLACEMENT"LabelPlacement" ) )
      {
          using namespace cssc::DataLabelPlacement;
          if( nPlacement == rTypeInfo.mnDefaultLabelPos )
          {
              nLabelPos = EXC_CHTEXT_POS_DEFAULT;
          }
          else switch( nPlacement )
          {
              case AVOID_OVERLAP:     nLabelPos = EXC_CHTEXT_POS_AUTO;    break;
              case CENTER:            nLabelPos = EXC_CHTEXT_POS_CENTER;  break;
              case TOP:               nLabelPos = EXC_CHTEXT_POS_ABOVE;   break;
              case TOP_LEFT:          nLabelPos = EXC_CHTEXT_POS_LEFT;    break;
              case LEFT:              nLabelPos = EXC_CHTEXT_POS_LEFT;    break;
              case BOTTOM_LEFT:       nLabelPos = EXC_CHTEXT_POS_LEFT;    break;
              case BOTTOM:            nLabelPos = EXC_CHTEXT_POS_BELOW;   break;
              case BOTTOM_RIGHT:      nLabelPos = EXC_CHTEXT_POS_RIGHT;   break;
              case RIGHT:             nLabelPos = EXC_CHTEXT_POS_RIGHT;   break;
              case TOP_RIGHT:         nLabelPos = EXC_CHTEXT_POS_RIGHT;   break;
              case INSIDE:            nLabelPos = EXC_CHTEXT_POS_INSIDE;  break;
              case OUTSIDE:           nLabelPos = EXC_CHTEXT_POS_OUTSIDE; break;
              case NEAR_ORIGIN:       nLabelPos = EXC_CHTEXT_POS_AXIS;    break;
              default:                OSL_FAIL( "XclExpChText::ConvertDataLabel - unknown label placement type" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx"
 ":" "1321" ": "), "%s", "XclExpChText::ConvertDataLabel - unknown label placement type"
); } } while (false);
          }
      }
      ::insert_value( maData.mnFlags2, nLabelPos, 0, 4 );
      // source link (contains number format)
      mxSrcLink = new XclExpChSourceLink( GetChRoot(), EXC_CHSRCLINK_TITLE );
      if( bShowValue || bShowPercent )
          // percentage format wins over value format
          mxSrcLink->ConvertNumFmt( rPropSet, bShowPercent );
      // object link
      mxObjLink = new XclExpChObjectLink( EXC_CHOBJLINK_DATA, rPointPos );
  }

  /*  Return true to indicate valid label settings:
      - for existing labels at entire series
      - for any settings at single data point (to be able to delete a point label) */
  return bShowAny || (rPointPos.mnPointIdx != EXC_CHDATAFORMAT_ALLPOINTS);
1338}

1340void XclExpChText::ConvertTrendLineEquation( const ScfPropertySet& rPropSet, const XclChDataPointPos& rPointPos )
1341{
  // required flags
  ::set_flag( maData.mnFlags, EXC_CHTEXT_AUTOTEXT );
  if( GetBiff() == EXC_BIFF8 )
      ::set_flag( maData.mnFlags, EXC_CHTEXT_SHOWCATEG ); // must set this to make equation visible in Excel
  // frame formatting
  mxFrame = lclCreateFrame( GetChRoot(), rPropSet, EXC_CHOBJTYPE_TEXT );
  // font settings
  maData.mnHAlign = EXC_CHTEXT_ALIGN_TOPLEFT;
  maData.mnVAlign = EXC_CHTEXT_ALIGN_TOPLEFT;
  ConvertFontBase( GetChRoot(), rPropSet );
  // source link (contains number format)
  mxSrcLink = new XclExpChSourceLink( GetChRoot(), EXC_CHSRCLINK_TITLE );
  mxSrcLink->ConvertNumFmt( rPropSet, false );
  // object link
  mxObjLink = new XclExpChObjectLink( EXC_CHOBJLINK_DATA, rPointPos );
1357}

1359sal_uInt16 XclExpChText::GetAttLabelFlags() const
1360{
  sal_uInt16 nFlags = 0;
  ::set_flag( nFlags, EXC_CHATTLABEL_SHOWVALUE,     ::get_flag( maData.mnFlags, EXC_CHTEXT_SHOWVALUE ) );
  ::set_flag( nFlags, EXC_CHATTLABEL_SHOWPERCENT,   ::get_flag( maData.mnFlags, EXC_CHTEXT_SHOWPERCENT ) );
  ::set_flag( nFlags, EXC_CHATTLABEL_SHOWCATEGPERC, ::get_flag( maData.mnFlags, EXC_CHTEXT_SHOWCATEGPERC ) );
  ::set_flag( nFlags, EXC_CHATTLABEL_SHOWCATEG,     ::get_flag( maData.mnFlags, EXC_CHTEXT_SHOWCATEG ) );
  return nFlags;
1367}

1369void XclExpChText::WriteSubRecords( XclExpStream& rStrm )
1370{
  // CHFRAMEPOS record
  lclSaveRecord( rStrm, mxFramePos );
  // CHFONT record
  lclSaveRecord( rStrm, mxFont );
  // CHSOURCELINK group
  lclSaveRecord( rStrm, mxSrcLink );
  // CHFRAME group
  lclSaveRecord( rStrm, mxFrame );
  // CHOBJECTLINK record
  lclSaveRecord( rStrm, mxObjLink );
  // CHFRLABELPROPS record
  lclSaveRecord( rStrm, mxLabelProps );
1383}

1385void XclExpChText::WriteBody( XclExpStream& rStrm )
1386{
  rStrm   << maData.mnHAlign
          << maData.mnVAlign
          << maData.mnBackMode
          << maData.maTextColor
          << maData.maRect
          << maData.mnFlags;

  if( GetBiff() == EXC_BIFF8 )
  {
      rStrm   << GetPalette().GetColorIndex( mnTextColorId )
              << maData.mnFlags2
              << maData.mnRotation;
  }
1400}

1402namespace {

1404/** Creates and returns an Excel text object from the passed title. */
1405XclExpChTextRef lclCreateTitle( const XclExpChRoot& rRoot, Reference< XTitled > const & xTitled, sal_uInt16 nTarget,
                              const OUString* pSubTitle = nullptr )
1407{
  Reference< XTitle > xTitle;
  if( xTitled.is() )
      xTitle = xTitled->getTitleObject();

  XclExpChTextRef xText = new XclExpChText( rRoot );
  xText->ConvertTitle( xTitle, nTarget, pSubTitle );
  /*  Do not delete the CHTEXT group for the main title. A missing CHTEXT
      will be interpreted as auto-generated title showing the series title in
      charts that contain exactly one data series. */
  if( (nTarget != EXC_CHOBJLINK_TITLE) && !xText->HasString() )
      xText.clear();

  return xText;
1421}

1423}

1425// Data series ================================================================

1427XclExpChMarkerFormat::XclExpChMarkerFormat( const XclExpChRoot& rRoot ) :
  XclExpRecord( EXC_ID_CHMARKERFORMAT, (rRoot.GetBiff() == EXC_BIFF8) ? 20 : 12 ),
  mnLineColorId( XclExpPalette::GetColorIdFromIndex( EXC_COLOR_CHWINDOWTEXT ) ),
  mnFillColorId( XclExpPalette::GetColorIdFromIndex( EXC_COLOR_CHWINDOWBACK ) )
1431{
1432}

1434void XclExpChMarkerFormat::Convert( const XclExpChRoot& rRoot,
      const ScfPropertySet& rPropSet, sal_uInt16 nFormatIdx )
1436{
  XclChPropSetHelper::ReadMarkerProperties( maData, rPropSet, nFormatIdx );
  /*  Set marker line/fill color to series line color.
      TODO: remove this if OOChart supports own colors in markers. */
  Color aLineColor;
  if( rPropSet.GetColorProperty( aLineColor, EXC_CHPROP_COLOR"Color" ) )
      maData.maLineColor = maData.maFillColor = aLineColor;
  // register colors in palette
  RegisterColors( rRoot );
1445}

1447void XclExpChMarkerFormat::ConvertStockSymbol( const XclExpChRoot& rRoot,
      const ScfPropertySet& rPropSet, bool bCloseSymbol )
1449{
  // clear the automatic flag
  ::set_flag( maData.mnFlags, EXC_CHMARKERFORMAT_AUTO, false );
  // symbol type and color
  if( bCloseSymbol )
  {
      // set symbol type for the 'close' data series
      maData.mnMarkerType = EXC_CHMARKERFORMAT_DOWJ;
      maData.mnMarkerSize = EXC_CHMARKERFORMAT_DOUBLESIZE;
      // set symbol line/fill color to series line color
      Color aLineColor;
      if( rPropSet.GetColorProperty( aLineColor, EXC_CHPROP_COLOR"Color" ) )
      {
          maData.maLineColor = maData.maFillColor = aLineColor;
          RegisterColors( rRoot );
      }
  }
  else
  {
      // set invisible symbol
      maData.mnMarkerType = EXC_CHMARKERFORMAT_NOSYMBOL;
  }
1471}

1473void XclExpChMarkerFormat::RegisterColors( const XclExpChRoot& rRoot )
1474{
  if( HasMarker() )
  {
      if( HasLineColor() )
          mnLineColorId = rRoot.GetPalette().InsertColor( maData.maLineColor, EXC_COLOR_CHARTLINE );
      if( HasFillColor() )
          mnFillColorId = rRoot.GetPalette().InsertColor( maData.maFillColor, EXC_COLOR_CHARTAREA );
  }
1482}

1484void XclExpChMarkerFormat::WriteBody( XclExpStream& rStrm )
1485{
  rStrm << maData.maLineColor << maData.maFillColor << maData.mnMarkerType << maData.mnFlags;
  if( rStrm.GetRoot().GetBiff() == EXC_BIFF8 )
  {
      const XclExpPalette& rPal = rStrm.GetRoot().GetPalette();
      rStrm << rPal.GetColorIndex( mnLineColorId ) << rPal.GetColorIndex( mnFillColorId ) << maData.mnMarkerSize;
  }
1492}

1494XclExpChPieFormat::XclExpChPieFormat() :
  XclExpUInt16Record( EXC_ID_CHPIEFORMAT, 0 )
1496{
1497}

1499void XclExpChPieFormat::Convert( const ScfPropertySet& rPropSet )
1500{
  double fApiDist(0.0);
  if( rPropSet.GetProperty( fApiDist, EXC_CHPROP_OFFSET"Offset" ) )
      SetValue( limit_cast< sal_uInt16 >( fApiDist * 100.0, 0, 100 ) );
1504}

1506XclExpCh3dDataFormat::XclExpCh3dDataFormat() :
  XclExpRecord( EXC_ID_CH3DDATAFORMAT, 2 )
1508{
1509}

1511void XclExpCh3dDataFormat::Convert( const ScfPropertySet& rPropSet )
1512{
  sal_Int32 nApiType(0);
  if( !rPropSet.GetProperty( nApiType, EXC_CHPROP_GEOMETRY3D"Geometry3D" ) )
      return;

  using namespace cssc2::DataPointGeometry3D;
  switch( nApiType )
  {
      case CUBOID:
          maData.mnBase = EXC_CH3DDATAFORMAT_RECT;
          maData.mnTop = EXC_CH3DDATAFORMAT_STRAIGHT;
      break;
      case PYRAMID:
          maData.mnBase = EXC_CH3DDATAFORMAT_RECT;
          maData.mnTop = EXC_CH3DDATAFORMAT_SHARP;
      break;
      case CYLINDER:
          maData.mnBase = EXC_CH3DDATAFORMAT_CIRC;
          maData.mnTop = EXC_CH3DDATAFORMAT_STRAIGHT;
      break;
      case CONE:
          maData.mnBase = EXC_CH3DDATAFORMAT_CIRC;
          maData.mnTop = EXC_CH3DDATAFORMAT_SHARP;
      break;
      default:
          OSL_FAIL( "XclExpCh3dDataFormat::Convert - unknown 3D bar format" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx"
 ":" "1537" ": "), "%s", "XclExpCh3dDataFormat::Convert - unknown 3D bar format"
); } } while (false);
  }
1539}

1541void XclExpCh3dDataFormat::WriteBody( XclExpStream& rStrm )
1542{
  rStrm << maData.mnBase << maData.mnTop;
1544}

1546XclExpChAttachedLabel::XclExpChAttachedLabel( sal_uInt16 nFlags ) :
  XclExpUInt16Record( EXC_ID_CHATTACHEDLABEL, nFlags )
1548{
1549}

1551XclExpChDataFormat::XclExpChDataFormat( const XclExpChRoot& rRoot,
      const XclChDataPointPos& rPointPos, sal_uInt16 nFormatIdx ) :
  XclExpChGroupBase( rRoot, EXC_CHFRBLOCK_TYPE_DATAFORMAT, EXC_ID_CHDATAFORMAT, 8 )
1554{
  maData.maPointPos = rPointPos;
  maData.mnFormatIdx = nFormatIdx;
1557}

1559void XclExpChDataFormat::ConvertDataSeries( const ScfPropertySet& rPropSet, const XclChExtTypeInfo& rTypeInfo )
1560{
  // line and area formatting
  ConvertFrameBase( GetChRoot(), rPropSet, rTypeInfo.GetSeriesObjectType() );

  // data point symbols
  bool bIsFrame = rTypeInfo.IsSeriesFrameFormat();
  if( !bIsFrame )
  {
      mxMarkerFmt = new XclExpChMarkerFormat( GetChRoot() );
      mxMarkerFmt->Convert( GetChRoot(), rPropSet, maData.mnFormatIdx );
  }

  // pie segments
  if( rTypeInfo.meTypeCateg == EXC_CHTYPECATEG_PIE )
  {
      mxPieFmt = new XclExpChPieFormat();
      mxPieFmt->Convert( rPropSet );
  }

  // 3D bars (only allowed for entire series in BIFF8)
  if( IsSeriesFormat() && (GetBiff() == EXC_BIFF8) && rTypeInfo.mb3dChart && (rTypeInfo.meTypeCateg == EXC_CHTYPECATEG_BAR) )
  {
      mx3dDataFmt = new XclExpCh3dDataFormat();
      mx3dDataFmt->Convert( rPropSet );
  }

  // spline
  if( IsSeriesFormat() && rTypeInfo.mbSpline && !bIsFrame )
      mxSeriesFmt = new XclExpUInt16Record( EXC_ID_CHSERIESFORMAT, EXC_CHSERIESFORMAT_SMOOTHED );

  // data point labels
  XclExpChTextRef xLabel = new XclExpChText( GetChRoot() );
  if( xLabel->ConvertDataLabel( rPropSet, rTypeInfo, maData.maPointPos ) )
  {
      // CHTEXT groups for data labels are stored in global CHCHART group
      GetChartData().SetDataLabel( xLabel );
      mxAttLabel = new XclExpChAttachedLabel( xLabel->GetAttLabelFlags() );
  }
1598}

1600void XclExpChDataFormat::ConvertStockSeries( const ScfPropertySet& rPropSet, bool bCloseSymbol )
1601{
  // set line format to invisible
  SetDefaultFrameBase( GetChRoot(), EXC_CHFRAMETYPE_INVISIBLE, false );
  // set symbols to invisible or to 'close' series symbol
  mxMarkerFmt = new XclExpChMarkerFormat( GetChRoot() );
  mxMarkerFmt->ConvertStockSymbol( GetChRoot(), rPropSet, bCloseSymbol );
1607}

1609void XclExpChDataFormat::ConvertLine( const ScfPropertySet& rPropSet, XclChObjectType eObjType )
1610{
  ConvertFrameBase( GetChRoot(), rPropSet, eObjType );
1612}

1614void XclExpChDataFormat::WriteSubRecords( XclExpStream& rStrm )
1615{
  lclSaveRecord( rStrm, mx3dDataFmt );
  WriteFrameRecords( rStrm );
  lclSaveRecord( rStrm, mxPieFmt );
  lclSaveRecord( rStrm, mxMarkerFmt );
  lclSaveRecord( rStrm, mxSeriesFmt );
  lclSaveRecord( rStrm, mxAttLabel );
1622}

1624void XclExpChDataFormat::WriteBody( XclExpStream& rStrm )
1625{
  rStrm   << maData.maPointPos.mnPointIdx
          << maData.maPointPos.mnSeriesIdx
          << maData.mnFormatIdx
          << maData.mnFlags;
1630}

1632XclExpChSerTrendLine::XclExpChSerTrendLine( const XclExpChRoot& rRoot ) :
  XclExpRecord( EXC_ID_CHSERTRENDLINE, 28 ),
  XclExpChRoot( rRoot )
1635{
1636}

1638bool XclExpChSerTrendLine::Convert( Reference< XRegressionCurve > const & xRegCurve, sal_uInt16 nSeriesIdx )
1639{
  if( !xRegCurve.is() )
5
←
Calling 'BaseReference::is'→
8
←
Returning from 'BaseReference::is'→
9
←
Taking false branch→
      return false;

  // trend line type
  ScfPropertySet aCurveProp( xRegCurve );

  OUString aService = aCurveProp.GetServiceName();
  if( aService == "com.sun.star.chart2.LinearRegressionCurve" )
10
←
Calling 'operator==<char const[42]>'→
19
←
Returning from 'operator==<char const[42]>'→
20
←
Taking false branch→
  {
      maData.mnLineType = EXC_CHSERTREND_POLYNOMIAL;
      maData.mnOrder = 1;
  }
  else if( aService == "com.sun.star.chart2.ExponentialRegressionCurve" )
21
←
Calling 'operator==<char const[47]>'→
30
←
Returning from 'operator==<char const[47]>'→
31
←
Taking false branch→
  {
      maData.mnLineType = EXC_CHSERTREND_EXPONENTIAL;
  }
  else if( aService == "com.sun.star.chart2.LogarithmicRegressionCurve" )
32
←
Calling 'operator==<char const[47]>'→
40
←
Returning from 'operator==<char const[47]>'→
41
←
Taking false branch→
  {
      maData.mnLineType = EXC_CHSERTREND_LOGARITHMIC;
  }
  else if( aService == "com.sun.star.chart2.PotentialRegressionCurve" )
42
←
Calling 'operator==<char const[45]>'→
51
←
Returning from 'operator==<char const[45]>'→
52
←
Taking false branch→
  {
      maData.mnLineType = EXC_CHSERTREND_POWER;
  }
  else if( aService == "com.sun.star.chart2.PolynomialRegressionCurve" )
53
←
Calling 'operator==<char const[46]>'→
62
←
Returning from 'operator==<char const[46]>'→
63
←
Assuming the condition is true→
64
←
Taking true branch→
  {
      maData.mnLineType = EXC_CHSERTREND_POLYNOMIAL;
      sal_Int32 aDegree;
65
←
'aDegree' declared without an initial value→
      aCurveProp.GetProperty(aDegree, EXC_CHPROP_POLYNOMIAL_DEGREE"PolynomialDegree");
66
←
Calling 'ScfPropertySet::GetProperty'→
69
←
Returning from 'ScfPropertySet::GetProperty'→
      maData.mnOrder = static_cast<sal_uInt8> (aDegree);
70
←
Assigned value is garbage or undefined
  }
  else if( aService == "com.sun.star.chart2.MovingAverageRegressionCurve" )
  {
      maData.mnLineType = EXC_CHSERTREND_MOVING_AVG;
      sal_Int32 aPeriod;
      aCurveProp.GetProperty(aPeriod, EXC_CHPROP_MOVING_AVERAGE_PERIOD"MovingAveragePeriod");
      maData.mnOrder = static_cast<sal_uInt8> (aPeriod);
  }
  else
  {
      return false;
  }

  aCurveProp.GetProperty(maData.mfForecastFor,  EXC_CHPROP_EXTRAPOLATE_FORWARD"ExtrapolateForward");
  aCurveProp.GetProperty(maData.mfForecastBack, EXC_CHPROP_EXTRAPOLATE_BACKWARD"ExtrapolateBackward");
  bool bIsForceIntercept = false;
  aCurveProp.GetProperty(bIsForceIntercept,  EXC_CHPROP_FORCE_INTERCEPT"ForceIntercept");
  if (bIsForceIntercept)
      aCurveProp.GetProperty(maData.mfIntercept, EXC_CHPROP_INTERCEPT_VALUE"InterceptValue");

  // line formatting
  XclChDataPointPos aPointPos( nSeriesIdx );
  mxDataFmt = new XclExpChDataFormat( GetChRoot(), aPointPos, 0 );
  mxDataFmt->ConvertLine( aCurveProp, EXC_CHOBJTYPE_TRENDLINE );

  // #i83100# show equation and correlation coefficient
  ScfPropertySet aEquationProp( xRegCurve->getEquationProperties() );
  maData.mnShowEquation = aEquationProp.GetBoolProperty( EXC_CHPROP_SHOWEQUATION"ShowEquation" ) ? 1 : 0;
  maData.mnShowRSquared = aEquationProp.GetBoolProperty( EXC_CHPROP_SHOWCORRELATION"ShowCorrelationCoefficient" ) ? 1 : 0;

  // #i83100# formatting of the equation text box
  if( (maData.mnShowEquation != 0) || (maData.mnShowRSquared != 0) )
  {
      mxLabel = new XclExpChText( GetChRoot() );
      mxLabel->ConvertTrendLineEquation( aEquationProp, aPointPos );
  }

  // missing features
  // #i5085# manual trend line size
  // #i34093# manual crossing point
  return true;
1711}

1713void XclExpChSerTrendLine::WriteBody( XclExpStream& rStrm )
1714{
  rStrm   << maData.mnLineType
          << maData.mnOrder
          << maData.mfIntercept
          << maData.mnShowEquation
          << maData.mnShowRSquared
          << maData.mfForecastFor
          << maData.mfForecastBack;
1722}

1724XclExpChSerErrorBar::XclExpChSerErrorBar( const XclExpChRoot& rRoot, sal_uInt8 nBarType ) :
  XclExpRecord( EXC_ID_CHSERERRORBAR, 14 ),
  XclExpChRoot( rRoot )
1727{
  maData.mnBarType = nBarType;
1729}

1731bool XclExpChSerErrorBar::Convert( XclExpChSourceLink& rValueLink, sal_uInt16& rnValueCount, const ScfPropertySet& rPropSet )
1732{
  sal_Int32 nBarStyle = 0;
  bool bOk = rPropSet.GetProperty( nBarStyle, EXC_CHPROP_ERRORBARSTYLE"ErrorBarStyle" );
  if( bOk )
  {
      switch( nBarStyle )
      {
          case cssc::ErrorBarStyle::ABSOLUTE:
              maData.mnSourceType = EXC_CHSERERR_FIXED;
              rPropSet.GetProperty( maData.mfValue, EXC_CHPROP_POSITIVEERROR"PositiveError" );
          break;
          case cssc::ErrorBarStyle::RELATIVE:
              maData.mnSourceType = EXC_CHSERERR_PERCENT;
              rPropSet.GetProperty( maData.mfValue, EXC_CHPROP_POSITIVEERROR"PositiveError" );
          break;
          case cssc::ErrorBarStyle::STANDARD_DEVIATION:
              maData.mnSourceType = EXC_CHSERERR_STDDEV;
              rPropSet.GetProperty( maData.mfValue, EXC_CHPROP_WEIGHT"Weight" );
          break;
          case cssc::ErrorBarStyle::STANDARD_ERROR:
              maData.mnSourceType = EXC_CHSERERR_STDERR;
          break;
          case cssc::ErrorBarStyle::FROM_DATA:
          {
              bOk = false;
              maData.mnSourceType = EXC_CHSERERR_CUSTOM;
              Reference< XDataSource > xDataSource( rPropSet.GetApiPropertySet(), UNO_QUERY );
              if( xDataSource.is() )
              {
                  // find first sequence with current role
                  OUString aRole = XclChartHelper::GetErrorBarValuesRole( maData.mnBarType );
                  Reference< XDataSequence > xValueSeq;

                  const Sequence< Reference< XLabeledDataSequence > > aLabeledSeqVec = xDataSource->getDataSequences();
                  for( const Reference< XLabeledDataSequence >& rLabeledSeq : aLabeledSeqVec )
                  {
                      Reference< XDataSequence > xTmpValueSeq = rLabeledSeq->getValues();
                      ScfPropertySet aValueProp( xTmpValueSeq );
                      OUString aCurrRole;
                      if( aValueProp.GetProperty( aCurrRole, EXC_CHPROP_ROLE"Role" ) && (aCurrRole == aRole) )
                      {
                          xValueSeq = xTmpValueSeq;
                          break;
                      }
                  }
                  if( xValueSeq.is() )
                  {
                      // #i86465# pass value count back to series
                      rnValueCount = maData.mnValueCount = rValueLink.ConvertDataSequence( xValueSeq, true );
                      bOk = maData.mnValueCount > 0;
                  }
              }
          }
          break;
          default:
              bOk = false;
      }
  }
  return bOk;
1791}

1793void XclExpChSerErrorBar::WriteBody( XclExpStream& rStrm )
1794{
  rStrm   << maData.mnBarType
          << maData.mnSourceType
          << maData.mnLineEnd
          << sal_uInt8( 1 )       // must be 1 to make line visible
          << maData.mfValue
          << maData.mnValueCount;
1801}

1803namespace {

1805/** Returns the property set of the specified data point. */
1806ScfPropertySet lclGetPointPropSet( Reference< XDataSeries > const & xDataSeries, sal_Int32 nPointIdx )
1807{
  ScfPropertySet aPropSet;
  try
  {
      aPropSet.Set( xDataSeries->getDataPointByIndex( nPointIdx ) );
  }
  catch( Exception& )
  {
      OSL_FAIL( "lclGetPointPropSet - no data point property set" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx"
 ":" "1815" ": "), "%s", "lclGetPointPropSet - no data point property set"
); } } while (false);
  }
  return aPropSet;
1818}

1820} // namespace

1822XclExpChSeries::XclExpChSeries( const XclExpChRoot& rRoot, sal_uInt16 nSeriesIdx ) :
  XclExpChGroupBase( rRoot, EXC_CHFRBLOCK_TYPE_SERIES, EXC_ID_CHSERIES, (rRoot.GetBiff() == EXC_BIFF8) ? 12 : 8 ),
  mnGroupIdx( EXC_CHSERGROUP_NONE ),
  mnSeriesIdx( nSeriesIdx ),
  mnParentIdx( EXC_CHSERIES_INVALID )
1827{
  // CHSOURCELINK records are always required, even if unused
  mxTitleLink = new XclExpChSourceLink( GetChRoot(), EXC_CHSRCLINK_TITLE );
  mxValueLink = new XclExpChSourceLink( GetChRoot(), EXC_CHSRCLINK_VALUES );
  mxCategLink = new XclExpChSourceLink( GetChRoot(), EXC_CHSRCLINK_CATEGORY );
  if( GetBiff() == EXC_BIFF8 )
      mxBubbleLink = new XclExpChSourceLink( GetChRoot(), EXC_CHSRCLINK_BUBBLES );
1834}

1836bool XclExpChSeries::ConvertDataSeries(
      Reference< XDiagram > const & xDiagram, Reference< XDataSeries > const & xDataSeries,
      const XclChExtTypeInfo& rTypeInfo, sal_uInt16 nGroupIdx, sal_uInt16 nFormatIdx )
1839{
  bool bOk = false;
  Reference< XDataSource > xDataSource( xDataSeries, UNO_QUERY );
  if( xDataSource.is() )
  {
      Reference< XDataSequence > xYValueSeq, xTitleSeq, xXValueSeq, xBubbleSeq;

      // find first sequence with role 'values-y'
      const Sequence< Reference< XLabeledDataSequence > > aLabeledSeqVec = xDataSource->getDataSequences();
      for( const Reference< XLabeledDataSequence >& rLabeledSeq : aLabeledSeqVec )
      {
          Reference< XDataSequence > xTmpValueSeq = rLabeledSeq->getValues();
          ScfPropertySet aValueProp( xTmpValueSeq );
          OUString aRole;
          if( aValueProp.GetProperty( aRole, EXC_CHPROP_ROLE"Role" ) )
          {
              if( !xYValueSeq.is() && (aRole == EXC_CHPROP_ROLE_YVALUES"values-y") )
              {
                  xYValueSeq = xTmpValueSeq;
                  if( !xTitleSeq.is() )
                      xTitleSeq = rLabeledSeq->getLabel(); // ignore role of label sequence
              }
              else if( !xXValueSeq.is() && !rTypeInfo.mbCategoryAxis && (aRole == EXC_CHPROP_ROLE_XVALUES"values-x") )
              {
                  xXValueSeq = xTmpValueSeq;
              }
              else if( !xBubbleSeq.is() && (rTypeInfo.meTypeId == EXC_CHTYPEID_BUBBLES) && (aRole == EXC_CHPROP_ROLE_SIZEVALUES"values-size") )
              {
                  xBubbleSeq = xTmpValueSeq;
                  xTitleSeq = rLabeledSeq->getLabel();     // ignore role of label sequence
              }
          }
      }

      bOk = xYValueSeq.is();
      if( bOk )
      {
          // chart type group index
          mnGroupIdx = nGroupIdx;

          // convert source links
          maData.mnValueCount = mxValueLink->ConvertDataSequence( xYValueSeq, true );
          mxTitleLink->ConvertDataSequence( xTitleSeq, true );

          // X values of XY charts
          maData.mnCategCount = mxCategLink->ConvertDataSequence( xXValueSeq, false, maData.mnValueCount );

          // size values of bubble charts
          if( mxBubbleLink )
              mxBubbleLink->ConvertDataSequence( xBubbleSeq, false, maData.mnValueCount );

          // series formatting
          XclChDataPointPos aPointPos( mnSeriesIdx );
          ScfPropertySet aSeriesProp( xDataSeries );
          mxSeriesFmt = new XclExpChDataFormat( GetChRoot(), aPointPos, nFormatIdx );
          mxSeriesFmt->ConvertDataSeries( aSeriesProp, rTypeInfo );

          // trend lines
          CreateTrendLines( xDataSeries );

          // error bars
          CreateErrorBars( aSeriesProp, EXC_CHPROP_ERRORBARX"ErrorBarX", EXC_CHSERERR_XPLUS, EXC_CHSERERR_XMINUS );
          CreateErrorBars( aSeriesProp, EXC_CHPROP_ERRORBARY"ErrorBarY", EXC_CHSERERR_YPLUS, EXC_CHSERERR_YMINUS );

          if( maData.mnValueCount > 0 )
          {
              const sal_Int32 nMaxPointCount = maData.mnValueCount;

              /*  #i91063# Create missing fill properties in pie/doughnut charts.
                  If freshly created (never saved to ODF), these charts show
                  varying point colors but do not return these points via API. */
              if( xDiagram.is() && (rTypeInfo.meTypeCateg == EXC_CHTYPECATEG_PIE) )
              {
                  Reference< XColorScheme > xColorScheme = xDiagram->getDefaultColorScheme();
                  if( xColorScheme.is() )
                  {
                      const OUString aFillStyleName = "FillStyle";
                      const OUString aColorName = "Color";
                      namespace cssd = ::com::sun::star::drawing;
                      for( sal_Int32 nPointIdx = 0; nPointIdx < nMaxPointCount; ++nPointIdx )
                      {
                          aPointPos.mnPointIdx = static_cast< sal_uInt16 >( nPointIdx );
                          ScfPropertySet aPointProp = lclGetPointPropSet( xDataSeries, nPointIdx );
                          // test that the point fill style is solid, but no color is set
                          cssd::FillStyle eFillStyle = cssd::FillStyle_NONE;
                          if( aPointProp.GetProperty( eFillStyle, aFillStyleName ) &&
                              (eFillStyle == cssd::FillStyle_SOLID) &&
                              !aPointProp.HasProperty( aColorName ) )
                          {
                              aPointProp.SetProperty( aColorName, xColorScheme->getColorByIndex( nPointIdx ) );
                          }
                      }
                  }
              }

              // data point formatting
              Sequence< sal_Int32 > aPointIndexes;
              if( aSeriesProp.GetProperty( aPointIndexes, EXC_CHPROP_ATTRIBDATAPOINTS"AttributedDataPoints" ) && aPointIndexes.hasElements() )
              {
                  for( const sal_Int32 nPointIndex : aPointIndexes )
                  {
                      if (nPointIndex >= nMaxPointCount)
                          break;
                      aPointPos.mnPointIdx = static_cast< sal_uInt16 >( nPointIndex );
                      ScfPropertySet aPointProp = lclGetPointPropSet( xDataSeries, nPointIndex );
                      XclExpChDataFormatRef xPointFmt = new XclExpChDataFormat( GetChRoot(), aPointPos, nFormatIdx );
                      xPointFmt->ConvertDataSeries( aPointProp, rTypeInfo );
                      maPointFmts.AppendRecord( xPointFmt );
                  }
              }
          }
      }
  }
  return bOk;
1953}

1955bool XclExpChSeries::ConvertStockSeries( css::uno::Reference< css::chart2::XDataSeries > const & xDataSeries,
      const OUString& rValueRole, sal_uInt16 nGroupIdx, sal_uInt16 nFormatIdx, bool bCloseSymbol )
1957{
  bool bOk = false;
  Reference< XDataSource > xDataSource( xDataSeries, UNO_QUERY );
  if( xDataSource.is() )
  {
      Reference< XDataSequence > xYValueSeq, xTitleSeq;

      // find first sequence with passed role
      const Sequence< Reference< XLabeledDataSequence > > aLabeledSeqVec = xDataSource->getDataSequences();
      for( const Reference< XLabeledDataSequence >& rLabeledSeq : aLabeledSeqVec )
      {
          Reference< XDataSequence > xTmpValueSeq = rLabeledSeq->getValues();
          ScfPropertySet aValueProp( xTmpValueSeq );
          OUString aRole;
          if( aValueProp.GetProperty( aRole, EXC_CHPROP_ROLE"Role" ) && (aRole == rValueRole) )
          {
              xYValueSeq = xTmpValueSeq;
              xTitleSeq = rLabeledSeq->getLabel();     // ignore role of label sequence
              break;
          }
      }

      bOk = xYValueSeq.is();
      if( bOk )
      {
          // chart type group index
          mnGroupIdx = nGroupIdx;
          // convert source links
          maData.mnValueCount = mxValueLink->ConvertDataSequence( xYValueSeq, true );
          mxTitleLink->ConvertDataSequence( xTitleSeq, true );
          // series formatting
          ScfPropertySet aSeriesProp( xDataSeries );
          mxSeriesFmt = new XclExpChDataFormat( GetChRoot(), XclChDataPointPos( mnSeriesIdx ), nFormatIdx );
          mxSeriesFmt->ConvertStockSeries( aSeriesProp, bCloseSymbol );
      }
  }
  return bOk;
1994}

1996bool XclExpChSeries::ConvertTrendLine( const XclExpChSeries& rParent, Reference< XRegressionCurve > const & xRegCurve )
1997{
  InitFromParent( rParent );

  mxTrendLine = new XclExpChSerTrendLine( GetChRoot() );
  bool bOk = mxTrendLine->Convert( xRegCurve, mnSeriesIdx );
4
←
Calling 'XclExpChSerTrendLine::Convert'→
  if( bOk )
  {
      OUString aName;
      ScfPropertySet aProperties( xRegCurve );
      aProperties.GetProperty(aName, EXC_CHPROP_CURVENAME"CurveName");
      mxTitleLink->ConvertString(aName);

      mxSeriesFmt = mxTrendLine->GetDataFormat();
      GetChartData().SetDataLabel( mxTrendLine->GetDataLabel() );
  }
  return bOk;
2013}

2015bool XclExpChSeries::ConvertErrorBar( const XclExpChSeries& rParent, const ScfPropertySet& rPropSet, sal_uInt8 nBarId )
2016{
  InitFromParent( rParent );
  // error bar settings
  mxErrorBar = new XclExpChSerErrorBar( GetChRoot(), nBarId );
  bool bOk = mxErrorBar->Convert( *mxValueLink, maData.mnValueCount, rPropSet );
  if( bOk )
  {
      // error bar formatting
      mxSeriesFmt = new XclExpChDataFormat( GetChRoot(), XclChDataPointPos( mnSeriesIdx ), 0 );
      mxSeriesFmt->ConvertLine( rPropSet, EXC_CHOBJTYPE_ERRORBAR );
  }
  return bOk;
2028}

2030void XclExpChSeries::ConvertCategSequence( Reference< XLabeledDataSequence > const & xCategSeq )
2031{
  if( xCategSeq.is() )
      maData.mnCategCount = mxCategLink->ConvertDataSequence( xCategSeq->getValues(), false );
2034}

2036void XclExpChSeries::WriteSubRecords( XclExpStream& rStrm )
2037{
  lclSaveRecord( rStrm, mxTitleLink );
  lclSaveRecord( rStrm, mxValueLink );
  lclSaveRecord( rStrm, mxCategLink );
  lclSaveRecord( rStrm, mxBubbleLink );
  lclSaveRecord( rStrm, mxSeriesFmt );
  maPointFmts.Save( rStrm );
  if( mnGroupIdx != EXC_CHSERGROUP_NONE )
      XclExpUInt16Record( EXC_ID_CHSERGROUP, mnGroupIdx ).Save( rStrm );
  if( mnParentIdx != EXC_CHSERIES_INVALID )
      XclExpUInt16Record( EXC_ID_CHSERPARENT, mnParentIdx ).Save( rStrm );
  lclSaveRecord( rStrm, mxTrendLine );
  lclSaveRecord( rStrm, mxErrorBar );
2050}

2052void XclExpChSeries::InitFromParent( const XclExpChSeries& rParent )
2053{
  // index to parent series is stored 1-based
  mnParentIdx = rParent.mnSeriesIdx + 1;
  /*  #i86465# MSO2007 SP1 expects correct point counts in child series
      (there was no problem in Excel2003 or Excel2007 without SP1...) */
  maData.mnCategCount = rParent.maData.mnCategCount;
  maData.mnValueCount = rParent.maData.mnValueCount;
2060}

2062void XclExpChSeries::CreateTrendLines( css::uno::Reference< css::chart2::XDataSeries > const & xDataSeries )
2063{
  Reference< XRegressionCurveContainer > xRegCurveCont( xDataSeries, UNO_QUERY );
  if( xRegCurveCont.is() )
1
Taking true branch→
  {
      const Sequence< Reference< XRegressionCurve > > aRegCurveSeq = xRegCurveCont->getRegressionCurves();
      for( const Reference< XRegressionCurve >& rRegCurve : aRegCurveSeq )
2
←
Assuming '__begin2' is not equal to '__end2'→
      {
          XclExpChSeriesRef xSeries = GetChartData().CreateSeries();
          if( xSeries && !xSeries->ConvertTrendLine( *this, rRegCurve ) )
3
←
Calling 'XclExpChSeries::ConvertTrendLine'→
              GetChartData().RemoveLastSeries();
      }
  }
2075}

2077void XclExpChSeries::CreateErrorBars( const ScfPropertySet& rPropSet,
      const OUString& rBarPropName, sal_uInt8 nPosBarId, sal_uInt8 nNegBarId )
2079{
  Reference< XPropertySet > xErrorBar;
  if( rPropSet.GetProperty( xErrorBar, rBarPropName ) && xErrorBar.is() )
  {
      ScfPropertySet aErrorProp( xErrorBar );
      CreateErrorBar( aErrorProp, EXC_CHPROP_SHOWPOSITIVEERROR"ShowPositiveError", nPosBarId );
      CreateErrorBar( aErrorProp, EXC_CHPROP_SHOWNEGATIVEERROR"ShowNegativeError", nNegBarId );
  }
2087}

2089void XclExpChSeries::CreateErrorBar( const ScfPropertySet& rPropSet,
      const OUString& rShowPropName, sal_uInt8 nBarId )
2091{
  if( rPropSet.GetBoolProperty( rShowPropName ) )
  {
      XclExpChSeriesRef xSeries = GetChartData().CreateSeries();
      if( xSeries && !xSeries->ConvertErrorBar( *this, rPropSet, nBarId ) )
          GetChartData().RemoveLastSeries();
  }
2098}

2100void XclExpChSeries::WriteBody( XclExpStream& rStrm )
2101{
  rStrm << maData.mnCategType << maData.mnValueType << maData.mnCategCount << maData.mnValueCount;
  if( GetBiff() == EXC_BIFF8 )
      rStrm << maData.mnBubbleType << maData.mnBubbleCount;
2105}

2107// Chart type groups ==========================================================

2109XclExpChType::XclExpChType( const XclExpChRoot& rRoot ) :
  XclExpRecord( EXC_ID_CHUNKNOWN ),
  XclExpChRoot( rRoot ),
  maTypeInfo( rRoot.GetChartTypeInfo( EXC_CHTYPEID_UNKNOWN ) )
2113{
2114}

2116void XclExpChType::Convert( Reference< XDiagram > const & xDiagram, Reference< XChartType > const & xChartType,
      sal_Int32 nApiAxesSetIdx, bool bSwappedAxesSet, bool bHasXLabels )
2118{
  if( !xChartType.is() )
      return;

  maTypeInfo = GetChartTypeInfo( xChartType->getChartType() );
  // special handling for some chart types
  switch( maTypeInfo.meTypeCateg )
  {
      case EXC_CHTYPECATEG_BAR:
      {
          maTypeInfo = GetChartTypeInfo( bSwappedAxesSet ? EXC_CHTYPEID_HORBAR : EXC_CHTYPEID_BAR );
          ::set_flag( maData.mnFlags, EXC_CHBAR_HORIZONTAL, bSwappedAxesSet );
          ScfPropertySet aTypeProp( xChartType );
          Sequence< sal_Int32 > aInt32Seq;
          maData.mnOverlap = 0;
          if( aTypeProp.GetProperty( aInt32Seq, EXC_CHPROP_OVERLAPSEQ"OverlapSequence" ) && (nApiAxesSetIdx < aInt32Seq.getLength()) )
              maData.mnOverlap = limit_cast< sal_Int16 >( -aInt32Seq[ nApiAxesSetIdx ], -100, 100 );
          maData.mnGap = 150;
          if( aTypeProp.GetProperty( aInt32Seq, EXC_CHPROP_GAPWIDTHSEQ"GapwidthSequence" ) && (nApiAxesSetIdx < aInt32Seq.getLength()) )
              maData.mnGap = limit_cast< sal_uInt16 >( aInt32Seq[ nApiAxesSetIdx ], 0, 500 );
      }
      break;
      case EXC_CHTYPECATEG_RADAR:
          ::set_flag( maData.mnFlags, EXC_CHRADAR_AXISLABELS, bHasXLabels );
      break;
      case EXC_CHTYPECATEG_PIE:
      {
          ScfPropertySet aTypeProp( xChartType );
          bool bDonut = aTypeProp.GetBoolProperty( EXC_CHPROP_USERINGS"UseRings" );
          maTypeInfo = GetChartTypeInfo( bDonut ? EXC_CHTYPEID_DONUT : EXC_CHTYPEID_PIE );
          maData.mnPieHole = bDonut ? 50 : 0;
          // #i85166# starting angle of first pie slice
          ScfPropertySet aDiaProp( xDiagram );
          maData.mnRotation = XclExpChRoot::ConvertPieRotation( aDiaProp );
      }
      break;
      case EXC_CHTYPECATEG_SCATTER:
          if( GetBiff() == EXC_BIFF8 )
              ::set_flag( maData.mnFlags, EXC_CHSCATTER_BUBBLES, maTypeInfo.meTypeId == EXC_CHTYPEID_BUBBLES );
      break;
      default:;
  }
  SetRecId( maTypeInfo.mnRecId );
2161}

2163void XclExpChType::SetStacked( bool bPercent )
2164{
  switch( maTypeInfo.meTypeCateg )
  {
      case EXC_CHTYPECATEG_LINE:
          ::set_flag( maData.mnFlags, EXC_CHLINE_STACKED );
          ::set_flag( maData.mnFlags, EXC_CHLINE_PERCENT, bPercent );
      break;
      case EXC_CHTYPECATEG_BAR:
          ::set_flag( maData.mnFlags, EXC_CHBAR_STACKED );
          ::set_flag( maData.mnFlags, EXC_CHBAR_PERCENT, bPercent );
          maData.mnOverlap = -100;
      break;
      default:;
  }
2178}

2180void XclExpChType::WriteBody( XclExpStream& rStrm )
2181{
  switch( GetRecId() )
  {
      case EXC_ID_CHBAR:
          rStrm << maData.mnOverlap << maData.mnGap << maData.mnFlags;
      break;

      case EXC_ID_CHLINE:
      case EXC_ID_CHAREA:
      case EXC_ID_CHRADARLINE:
      case EXC_ID_CHRADARAREA:
          rStrm << maData.mnFlags;
      break;

      case EXC_ID_CHPIE:
          rStrm << maData.mnRotation << maData.mnPieHole;
          if( GetBiff() == EXC_BIFF8 )
              rStrm << maData.mnFlags;
      break;

      case EXC_ID_CHSCATTER:
          if( GetBiff() == EXC_BIFF8 )
              rStrm << maData.mnBubbleSize << maData.mnBubbleType << maData.mnFlags;
      break;

      default:
          OSL_FAIL( "XclExpChType::WriteBody - unknown chart type" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx"
 ":" "2207" ": "), "%s", "XclExpChType::WriteBody - unknown chart type"
); } } while (false);
  }
2209}

2211XclExpChChart3d::XclExpChChart3d() :
  XclExpRecord( EXC_ID_CHCHART3D, 14 )
2213{
2214}

2216void XclExpChChart3d::Convert( const ScfPropertySet& rPropSet, bool b3dWallChart )
2217{
  sal_Int32 nRotationY = 0;
  rPropSet.GetProperty( nRotationY, EXC_CHPROP_ROTATIONVERTICAL"RotationVertical" );
  sal_Int32 nRotationX = 0;
  rPropSet.GetProperty( nRotationX, EXC_CHPROP_ROTATIONHORIZONTAL"RotationHorizontal" );
  sal_Int32 nPerspective = 15;
  rPropSet.GetProperty( nPerspective, EXC_CHPROP_PERSPECTIVE"Perspective" );

  if( b3dWallChart )
  {
      // Y rotation (Excel [0..359], Chart2 [-179,180])
      if( nRotationY < 0 ) nRotationY += 360;
      maData.mnRotation = static_cast< sal_uInt16 >( nRotationY );
      // X rotation a.k.a. elevation (Excel [-90..90], Chart2 [-179,180])
      maData.mnElevation = limit_cast< sal_Int16 >( nRotationX, -90, 90 );
      // perspective (Excel and Chart2 [0,100])
      maData.mnEyeDist = limit_cast< sal_uInt16 >( nPerspective, 0, 100 );
      // flags
      maData.mnFlags = 0;
      ::set_flag( maData.mnFlags, EXC_CHCHART3D_REAL3D, !rPropSet.GetBoolProperty( EXC_CHPROP_RIGHTANGLEDAXES"RightAngledAxes" ) );
      ::set_flag( maData.mnFlags, EXC_CHCHART3D_AUTOHEIGHT );
      ::set_flag( maData.mnFlags, EXC_CHCHART3D_HASWALLS );
  }
  else
  {
      // Y rotation not used in pie charts, but 'first pie slice angle'
      maData.mnRotation = XclExpChRoot::ConvertPieRotation( rPropSet );
      // X rotation a.k.a. elevation (map Chart2 [-80,-10] to Excel [10..80])
      maData.mnElevation = limit_cast< sal_Int16 >( (nRotationX + 270) % 180, 10, 80 );
      // perspective (Excel and Chart2 [0,100])
      maData.mnEyeDist = limit_cast< sal_uInt16 >( nPerspective, 0, 100 );
      // flags
      maData.mnFlags = 0;
  }
2251}

2253void XclExpChChart3d::WriteBody( XclExpStream& rStrm )
2254{
  rStrm   << maData.mnRotation
          << maData.mnElevation
          << maData.mnEyeDist
          << maData.mnRelHeight
          << maData.mnRelDepth
          << maData.mnDepthGap
          << maData.mnFlags;
2262}

2264XclExpChLegend::XclExpChLegend( const XclExpChRoot& rRoot ) :
  XclExpChGroupBase( rRoot, EXC_CHFRBLOCK_TYPE_LEGEND, EXC_ID_CHLEGEND, 20 )
2266{
2267}

2269void XclExpChLegend::Convert( const ScfPropertySet& rPropSet )
2270{
  // frame properties
  mxFrame = lclCreateFrame( GetChRoot(), rPropSet, EXC_CHOBJTYPE_LEGEND );
  // text properties
  mxText = new XclExpChText( GetChRoot() );
  mxText->ConvertLegend( rPropSet );

  // legend position and size
  Any aRelPosAny, aRelSizeAny;
  rPropSet.GetAnyProperty( aRelPosAny, EXC_CHPROP_RELATIVEPOSITION"RelativePosition" );
  rPropSet.GetAnyProperty( aRelSizeAny, EXC_CHPROP_RELATIVESIZE"RelativeSize" );
  cssc::ChartLegendExpansion eApiExpand = cssc::ChartLegendExpansion_CUSTOM;
  rPropSet.GetProperty( eApiExpand, EXC_CHPROP_EXPANSION"Expansion" );
  if( aRelPosAny.has< RelativePosition >() || ((eApiExpand == cssc::ChartLegendExpansion_CUSTOM) && aRelSizeAny.has< RelativeSize >()) )
  {
      try
      {
          /*  The 'RelativePosition' or 'RelativeSize' properties are used as
              indicator of manually changed legend position/size, but due to
              the different anchor modes used by this property (in the
              RelativePosition.Anchor member) it cannot be used to calculate
              the position easily. For this, the Chart1 API will be used
              instead. */
          Reference< cssc::XChartDocument > xChart1Doc( GetChartDocument(), UNO_QUERY_THROW );
          Reference< XShape > xChart1Legend( xChart1Doc->getLegend(), UNO_SET_THROW );
          // coordinates in CHLEGEND record written but not used by Excel
          mxFramePos = new XclExpChFramePos( EXC_CHFRAMEPOS_CHARTSIZE );
          XclChFramePos& rFramePos = mxFramePos->GetFramePosData();
          rFramePos.mnTLMode = EXC_CHFRAMEPOS_CHARTSIZE;
          css::awt::Point aLegendPos = xChart1Legend->getPosition();
          rFramePos.maRect.mnX = maData.maRect.mnX = CalcChartXFromHmm( aLegendPos.X );
          rFramePos.maRect.mnY = maData.maRect.mnY = CalcChartYFromHmm( aLegendPos.Y );
          // legend size, Excel expects points in CHFRAMEPOS record
          rFramePos.mnBRMode = EXC_CHFRAMEPOS_ABSSIZE_POINTS;
          css::awt::Size aLegendSize = xChart1Legend->getSize();
          rFramePos.maRect.mnWidth = static_cast< sal_uInt16 >( aLegendSize.Width * EXC_POINTS_PER_HMM + 0.5 );
          rFramePos.maRect.mnHeight = static_cast< sal_uInt16 >( aLegendSize.Height * EXC_POINTS_PER_HMM + 0.5 );
          maData.maRect.mnWidth = CalcChartXFromHmm( aLegendSize.Width );
          maData.maRect.mnHeight = CalcChartYFromHmm( aLegendSize.Height );
          eApiExpand = cssc::ChartLegendExpansion_CUSTOM;
          // manual legend position implies manual plot area
          GetChartData().SetManualPlotArea();
          maData.mnDockMode = EXC_CHLEGEND_NOTDOCKED;
          // a CHFRAME record with cleared auto flags is needed
          if( !mxFrame )
              mxFrame = new XclExpChFrame( GetChRoot(), EXC_CHOBJTYPE_LEGEND );
          mxFrame->SetAutoFlags( false, false );
      }
      catch( Exception& )
      {
          OSL_FAIL( "XclExpChLegend::Convert - cannot get legend shape" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx"
 ":" "2320" ": "), "%s", "XclExpChLegend::Convert - cannot get legend shape"
); } } while (false);
          maData.mnDockMode = EXC_CHLEGEND_RIGHT;
          eApiExpand = cssc::ChartLegendExpansion_HIGH;
      }
  }
  else
  {
      cssc2::LegendPosition eApiPos = cssc2::LegendPosition_LINE_END;
      rPropSet.GetProperty( eApiPos, EXC_CHPROP_ANCHORPOSITION"AnchorPosition" );
      switch( eApiPos )
      {
          case cssc2::LegendPosition_LINE_START:   maData.mnDockMode = EXC_CHLEGEND_LEFT;      break;
          case cssc2::LegendPosition_LINE_END:     maData.mnDockMode = EXC_CHLEGEND_RIGHT;     break;
          case cssc2::LegendPosition_PAGE_START:   maData.mnDockMode = EXC_CHLEGEND_TOP;       break;
          case cssc2::LegendPosition_PAGE_END:     maData.mnDockMode = EXC_CHLEGEND_BOTTOM;    break;
          default:
              OSL_FAIL( "XclExpChLegend::Convert - unrecognized legend position" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx"
 ":" "2336" ": "), "%s", "XclExpChLegend::Convert - unrecognized legend position"
); } } while (false);
              maData.mnDockMode = EXC_CHLEGEND_RIGHT;
              eApiExpand = cssc::ChartLegendExpansion_HIGH;
      }
  }
  ::set_flag( maData.mnFlags, EXC_CHLEGEND_STACKED, eApiExpand == cssc::ChartLegendExpansion_HIGH );

  // other flags
  ::set_flag( maData.mnFlags, EXC_CHLEGEND_AUTOSERIES );
  const sal_uInt16 nAutoFlags = EXC_CHLEGEND_DOCKED | EXC_CHLEGEND_AUTOPOSX | EXC_CHLEGEND_AUTOPOSY;
  ::set_flag( maData.mnFlags, nAutoFlags, maData.mnDockMode != EXC_CHLEGEND_NOTDOCKED );
2347}

2349void XclExpChLegend::WriteSubRecords( XclExpStream& rStrm )
2350{
  lclSaveRecord( rStrm, mxFramePos );
  lclSaveRecord( rStrm, mxText );
  lclSaveRecord( rStrm, mxFrame );
2354}

2356void XclExpChLegend::WriteBody( XclExpStream& rStrm )
2357{
  rStrm << maData.maRect << maData.mnDockMode << maData.mnSpacing << maData.mnFlags;
2359}

2361XclExpChDropBar::XclExpChDropBar( const XclExpChRoot& rRoot, XclChObjectType eObjType ) :
  XclExpChGroupBase( rRoot, EXC_CHFRBLOCK_TYPE_DROPBAR, EXC_ID_CHDROPBAR, 2 ),
  meObjType( eObjType )
2364{
2365}

2367void XclExpChDropBar::Convert( const ScfPropertySet& rPropSet )
2368{
  if( rPropSet.Is() )
      ConvertFrameBase( GetChRoot(), rPropSet, meObjType );
  else
      SetDefaultFrameBase( GetChRoot(), EXC_CHFRAMETYPE_INVISIBLE, true );
2373}

2375void XclExpChDropBar::WriteSubRecords( XclExpStream& rStrm )
2376{
  WriteFrameRecords( rStrm );
2378}

2380void XclExpChDropBar::WriteBody( XclExpStream& rStrm )
2381{
  rStrm << sal_uInt16(100); // Distance between bars (CHDROPBAR record).
2383}

2385XclExpChTypeGroup::XclExpChTypeGroup( const XclExpChRoot& rRoot, sal_uInt16 nGroupIdx ) :
  XclExpChGroupBase( rRoot, EXC_CHFRBLOCK_TYPE_TYPEGROUP, EXC_ID_CHTYPEGROUP, 20 ),
  maType( rRoot ),
  maTypeInfo( maType.GetTypeInfo() )
2389{
  maData.mnGroupIdx = nGroupIdx;
2391}

2393void XclExpChTypeGroup::ConvertType(
      Reference< XDiagram > const & xDiagram, Reference< XChartType > const & xChartType,
      sal_Int32 nApiAxesSetIdx, bool b3dChart, bool bSwappedAxesSet, bool bHasXLabels )
2396{
  // chart type settings
  maType.Convert( xDiagram, xChartType, nApiAxesSetIdx, bSwappedAxesSet, bHasXLabels );

  // spline - TODO: get from single series (#i66858#)
  ScfPropertySet aTypeProp( xChartType );
  cssc2::CurveStyle eCurveStyle;
  bool bSpline = aTypeProp.GetProperty( eCurveStyle, EXC_CHPROP_CURVESTYLE"CurveStyle" ) &&
      (eCurveStyle != cssc2::CurveStyle_LINES);

  // extended type info
  maTypeInfo.Set( maType.GetTypeInfo(), b3dChart, bSpline );

  // 3d chart settings
  if( maTypeInfo.mb3dChart )  // only true, if Excel chart supports 3d mode
  {
      mxChart3d = new XclExpChChart3d();
      ScfPropertySet aDiaProp( xDiagram );
      mxChart3d->Convert( aDiaProp, Is3dWallChart() );
  }
2416}

2418void XclExpChTypeGroup::ConvertSeries(
      Reference< XDiagram > const & xDiagram, Reference< XChartType > const & xChartType,
      sal_Int32 nGroupAxesSetIdx, bool bPercent, bool bConnectBars )
2421{
  Reference< XDataSeriesContainer > xSeriesCont( xChartType, UNO_QUERY );
  if( !xSeriesCont.is() )
      return;

  std::vector< Reference< XDataSeries > > aSeriesVec;

  // copy data series attached to the current axes set to the vector
  const Sequence< Reference< XDataSeries > > aSeriesSeq = xSeriesCont->getDataSeries();
  for( const Reference< XDataSeries >& rSeries : aSeriesSeq )
  {
      ScfPropertySet aSeriesProp( rSeries );
      sal_Int32 nSeriesAxesSetIdx(0);
      if( aSeriesProp.GetProperty( nSeriesAxesSetIdx, EXC_CHPROP_ATTAXISINDEX"AttachedAxisIndex" ) && (nSeriesAxesSetIdx == nGroupAxesSetIdx) )
          aSeriesVec.push_back( rSeries );
  }

  // Are there any series in the current axes set?
  if( aSeriesVec.empty() )
      return;

  // stacking direction (stacked/percent/deep 3d) from first series
  ScfPropertySet aSeriesProp( aSeriesVec.front() );
  cssc2::StackingDirection eStacking;
  if( !aSeriesProp.GetProperty( eStacking, EXC_CHPROP_STACKINGDIR"StackingDirection" ) )
      eStacking = cssc2::StackingDirection_NO_STACKING;

  // stacked or percent chart
  if( maTypeInfo.mbSupportsStacking && (eStacking == cssc2::StackingDirection_Y_STACKING) )
  {
      // percent overrides simple stacking
      maType.SetStacked( bPercent );

      // connected data points (only in stacked bar charts)
      if (bConnectBars && (maTypeInfo.meTypeCateg == EXC_CHTYPECATEG_BAR))
      {
          sal_uInt16 nKey = EXC_CHCHARTLINE_CONNECT;
          m_ChartLines.insert(std::make_pair(nKey, std::make_unique<XclExpChLineFormat>(GetChRoot())));
      }
  }
  else
  {
      // reverse series order for some unstacked 2D chart types
      if( maTypeInfo.mbReverseSeries && !Is3dChart() )
          ::std::reverse( aSeriesVec.begin(), aSeriesVec.end() );
  }

  // deep 3d chart or clustered 3d chart (stacked is not clustered)
  if( (eStacking == cssc2::StackingDirection_NO_STACKING) && Is3dWallChart() )
      mxChart3d->SetClustered();

  // varied point colors
  ::set_flag( maData.mnFlags, EXC_CHTYPEGROUP_VARIEDCOLORS, aSeriesProp.GetBoolProperty( EXC_CHPROP_VARYCOLORSBY"VaryColorsByPoint" ) );

  // process all series
  for( const auto& rxSeries : aSeriesVec )
  {
      // create Excel series object, stock charts need special processing
      if( maTypeInfo.meTypeId == EXC_CHTYPEID_STOCK )
          CreateAllStockSeries( xChartType, rxSeries );
      else
          CreateDataSeries( xDiagram, rxSeries );
  }
2484}

2486void XclExpChTypeGroup::ConvertCategSequence( Reference< XLabeledDataSequence > const & xCategSeq )
2487{
  for( size_t nIdx = 0, nSize = maSeries.GetSize(); nIdx < nSize; ++nIdx )
      maSeries.GetRecord( nIdx )->ConvertCategSequence( xCategSeq );
2490}

2492void XclExpChTypeGroup::ConvertLegend( const ScfPropertySet& rPropSet )
2493{
  if( rPropSet.GetBoolProperty( EXC_CHPROP_SHOW"Show" ) )
  {
      mxLegend = new XclExpChLegend( GetChRoot() );
      mxLegend->Convert( rPropSet );
  }
2499}

2501void XclExpChTypeGroup::WriteSubRecords( XclExpStream& rStrm )
2502{
  maType.Save( rStrm );
  lclSaveRecord( rStrm, mxChart3d );
  lclSaveRecord( rStrm, mxLegend );
  lclSaveRecord( rStrm, mxUpBar );
  lclSaveRecord( rStrm, mxDownBar );
  for (auto const& it : m_ChartLines)
  {
      lclSaveRecord( rStrm, it.second.get(), EXC_ID_CHCHARTLINE, it.first );
  }
2512}

2514sal_uInt16 XclExpChTypeGroup::GetFreeFormatIdx() const
2515{
  return static_cast< sal_uInt16 >( maSeries.GetSize() );
2517}

2519void XclExpChTypeGroup::CreateDataSeries(
      Reference< XDiagram > const & xDiagram, Reference< XDataSeries > const & xDataSeries )
2521{
  // let chart create series object with correct series index
  XclExpChSeriesRef xSeries = GetChartData().CreateSeries();
  if( xSeries )
  {
      if( xSeries->ConvertDataSeries( xDiagram, xDataSeries, maTypeInfo, GetGroupIdx(), GetFreeFormatIdx() ) )
          maSeries.AppendRecord( xSeries );
      else
          GetChartData().RemoveLastSeries();
  }
2531}

2533void XclExpChTypeGroup::CreateAllStockSeries(
      Reference< XChartType > const & xChartType, Reference< XDataSeries > const & xDataSeries )
2535{
  // create existing series objects
  bool bHasOpen = CreateStockSeries( xDataSeries, EXC_CHPROP_ROLE_OPENVALUES"values-first", false );
  bool bHasHigh = CreateStockSeries( xDataSeries, EXC_CHPROP_ROLE_HIGHVALUES"values-max", false );
  bool bHasLow = CreateStockSeries( xDataSeries, EXC_CHPROP_ROLE_LOWVALUES"values-min", false );
  bool bHasClose = CreateStockSeries( xDataSeries, EXC_CHPROP_ROLE_CLOSEVALUES"values-last", !bHasOpen );

  // formatting of special stock chart elements
  ScfPropertySet aTypeProp( xChartType );
  // hi-lo lines
  if( bHasHigh && bHasLow && aTypeProp.GetBoolProperty( EXC_CHPROP_SHOWHIGHLOW"ShowHighLow" ) )
  {
      ScfPropertySet aSeriesProp( xDataSeries );
      XclExpChLineFormatRef xLineFmt = new XclExpChLineFormat( GetChRoot() );
      xLineFmt->Convert( GetChRoot(), aSeriesProp, EXC_CHOBJTYPE_HILOLINE );
      sal_uInt16 nKey = EXC_CHCHARTLINE_HILO;
      m_ChartLines.insert(std::make_pair(nKey, std::make_unique<XclExpChLineFormat>(GetChRoot())));
  }
  // dropbars
  if( !(bHasOpen && bHasClose) )
      return;

  // dropbar type is dependent on position in the file - always create both
  Reference< XPropertySet > xWhitePropSet, xBlackPropSet;
  // white dropbar format
  aTypeProp.GetProperty( xWhitePropSet, EXC_CHPROP_WHITEDAY"WhiteDay" );
  ScfPropertySet aWhiteProp( xWhitePropSet );
  mxUpBar = new XclExpChDropBar( GetChRoot(), EXC_CHOBJTYPE_WHITEDROPBAR );
  mxUpBar->Convert( aWhiteProp );
  // black dropbar format
  aTypeProp.GetProperty( xBlackPropSet, EXC_CHPROP_BLACKDAY"BlackDay" );
  ScfPropertySet aBlackProp( xBlackPropSet );
  mxDownBar = new XclExpChDropBar( GetChRoot(), EXC_CHOBJTYPE_BLACKDROPBAR );
  mxDownBar->Convert( aBlackProp );
2569}

2571bool XclExpChTypeGroup::CreateStockSeries( Reference< XDataSeries > const & xDataSeries,
      const OUString& rValueRole, bool bCloseSymbol )
2573{
  bool bOk = false;
  // let chart create series object with correct series index
  XclExpChSeriesRef xSeries = GetChartData().CreateSeries();
  if( xSeries )
  {
      bOk = xSeries->ConvertStockSeries( xDataSeries,
          rValueRole, GetGroupIdx(), GetFreeFormatIdx(), bCloseSymbol );
      if( bOk )
          maSeries.AppendRecord( xSeries );
      else
          GetChartData().RemoveLastSeries();
  }
  return bOk;
2587}

2589void XclExpChTypeGroup::WriteBody( XclExpStream& rStrm )
2590{
  rStrm.WriteZeroBytes( 16 );
  rStrm << maData.mnFlags << maData.mnGroupIdx;
2593}

2595// Axes =======================================================================

2597XclExpChLabelRange::XclExpChLabelRange( const XclExpChRoot& rRoot ) :
  XclExpRecord( EXC_ID_CHLABELRANGE, 8 ),
  XclExpChRoot( rRoot )
2600{
2601}

2603void XclExpChLabelRange::Convert( const ScaleData& rScaleData, const ScfPropertySet& rChart1Axis, bool bMirrorOrient )
2604{
  /*  Base time unit (using the property 'ExplicitTimeIncrement' from the old
      chart API allows to detect axis type (date axis, if property exists),
      and to receive the base time unit currently used in case the base time
      unit is set to 'automatic'. */
  cssc::TimeIncrement aTimeIncrement;
  if( rChart1Axis.GetProperty( aTimeIncrement, EXC_CHPROP_EXPTIMEINCREMENT"ExplicitTimeIncrement" ) )
  {
      // property exists -> this is a date axis currently
      ::set_flag( maDateData.mnFlags, EXC_CHDATERANGE_DATEAXIS );

      // automatic base time unit, if the UNO Any 'rScaleData.TimeIncrement.TimeResolution' does not contain a valid value...
      bool bAutoBase = !rScaleData.TimeIncrement.TimeResolution.has< cssc::TimeIncrement >();
      ::set_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOBASE, bAutoBase );

      // ...but get the current base time unit from the property of the old chart API
      sal_Int32 nApiTimeUnit = 0;
      bool bValidBaseUnit = aTimeIncrement.TimeResolution >>= nApiTimeUnit;
      OSL_ENSURE( bValidBaseUnit, "XclExpChLabelRange::Convert - cannot get base time unit" )do { if (true && (!(bValidBaseUnit))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/filter/excel/xechart.cxx"
 ":" "2622" ": "), "%s", "XclExpChLabelRange::Convert - cannot get base time unit"
); } } while (false);
      maDateData.mnBaseUnit = bValidBaseUnit ? lclGetTimeUnit( nApiTimeUnit ) : EXC_CHDATERANGE_DAYS;

      /*  Min/max values depend on base time unit, they specify the number of
          days, months, or years starting from null date. */
      bool bAutoMin = lclConvertTimeValue( GetRoot(), maDateData.mnMinDate, rScaleData.Minimum, maDateData.mnBaseUnit );
      ::set_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOMIN, bAutoMin );
      bool bAutoMax = lclConvertTimeValue( GetRoot(), maDateData.mnMaxDate, rScaleData.Maximum, maDateData.mnBaseUnit );
      ::set_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOMAX, bAutoMax );
  }

  // automatic axis type detection
  ::set_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTODATE, rScaleData.AutoDateAxis );

  // increment
  bool bAutoMajor = lclConvertTimeInterval( maDateData.mnMajorStep, maDateData.mnMajorUnit, rScaleData.TimeIncrement.MajorTimeInterval );
  ::set_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOMAJOR, bAutoMajor );
  bool bAutoMinor = lclConvertTimeInterval( maDateData.mnMinorStep, maDateData.mnMinorUnit, rScaleData.TimeIncrement.MinorTimeInterval );
  ::set_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOMINOR, bAutoMinor );

  // origin
  double fOrigin = 0.0;
  if( !lclIsAutoAnyOrGetValue( fOrigin, rScaleData.Origin ) )
      maLabelData.mnCross = limit_cast< sal_uInt16 >( fOrigin, 1, 31999 );

  // reverse order
  if( (rScaleData.Orientation == cssc2::AxisOrientation_REVERSE) != bMirrorOrient )
      ::set_flag( maLabelData.mnFlags, EXC_CHLABELRANGE_REVERSE );
2650}

2652void XclExpChLabelRange::ConvertAxisPosition( const ScfPropertySet& rPropSet )
2653{
  cssc::ChartAxisPosition eAxisPos = cssc::ChartAxisPosition_VALUE;
  rPropSet.GetProperty( eAxisPos, EXC_CHPROP_CROSSOVERPOSITION"CrossoverPosition" );
  double fCrossingPos = 1.0;
  rPropSet.GetProperty( fCrossingPos, EXC_CHPROP_CROSSOVERVALUE"CrossoverValue" );

  bool bDateAxis = ::get_flag( maDateData.mnFlags, EXC_CHDATERANGE_DATEAXIS );
  switch( eAxisPos )
  {
      case cssc::ChartAxisPosition_ZERO:
      case cssc::ChartAxisPosition_START:
          maLabelData.mnCross = 1;
          ::set_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOCROSS );
      break;
      case cssc::ChartAxisPosition_END:
          ::set_flag( maLabelData.mnFlags, EXC_CHLABELRANGE_MAXCROSS );
      break;
      case cssc::ChartAxisPosition_VALUE:
          maLabelData.mnCross = limit_cast< sal_uInt16 >( fCrossingPos, 1, 31999 );
          ::set_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOCROSS, false );
          if( bDateAxis )
              maDateData.mnCross = lclGetTimeValue( GetRoot(), fCrossingPos, maDateData.mnBaseUnit );
      break;
      default:
          maLabelData.mnCross = 1;
          ::set_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOCROSS );
  }
2680}

2682void XclExpChLabelRange::Save( XclExpStream& rStrm )
2683{
  // the CHLABELRANGE record
  XclExpRecord::Save( rStrm );

  // the CHDATERANGE record with date axis settings (BIFF8 only)
  if( GetBiff() != EXC_BIFF8 )
      return;

  rStrm.StartRecord( EXC_ID_CHDATERANGE, 18 );
  rStrm   << maDateData.mnMinDate
          << maDateData.mnMaxDate
          << maDateData.mnMajorStep
          << maDateData.mnMajorUnit
          << maDateData.mnMinorStep
          << maDateData.mnMinorUnit
          << maDateData.mnBaseUnit
          << maDateData.mnCross
          << maDateData.mnFlags;
  rStrm.EndRecord();
2702}

2704void XclExpChLabelRange::WriteBody( XclExpStream& rStrm )
2705{
  rStrm << maLabelData.mnCross << maLabelData.mnLabelFreq << maLabelData.mnTickFreq << maLabelData.mnFlags;
2707}

2709XclExpChValueRange::XclExpChValueRange( const XclExpChRoot& rRoot ) :
  XclExpRecord( EXC_ID_CHVALUERANGE, 42 ),
  XclExpChRoot( rRoot )
2712{
2713}

2715void XclExpChValueRange::Convert( const ScaleData& rScaleData )
2716{
  // scaling algorithm
  bool bLogScale = ScfApiHelper::GetServiceName( rScaleData.Scaling ) == "com.sun.star.chart2.LogarithmicScaling";
  ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_LOGSCALE, bLogScale );

  // min/max
  bool bAutoMin = lclIsAutoAnyOrGetScaledValue( maData.mfMin, rScaleData.Minimum, bLogScale );
  ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_AUTOMIN, bAutoMin );
  bool bAutoMax = lclIsAutoAnyOrGetScaledValue( maData.mfMax, rScaleData.Maximum, bLogScale );
  ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_AUTOMAX, bAutoMax );

  // origin
  bool bAutoCross = lclIsAutoAnyOrGetScaledValue( maData.mfCross, rScaleData.Origin, bLogScale );
  ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_AUTOCROSS, bAutoCross );

  // major increment
  const IncrementData& rIncrementData = rScaleData.IncrementData;
  const bool bAutoMajor = lclIsAutoAnyOrGetValue( maData.mfMajorStep, rIncrementData.Distance ) || (maData.mfMajorStep <= 0.0);
  ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_AUTOMAJOR, bAutoMajor );
  // minor increment
  const Sequence< SubIncrement >& rSubIncrementSeq = rIncrementData.SubIncrements;
  sal_Int32 nCount = 0;

  // tdf#114168 If IntervalCount is 5, then enable automatic minor calculation.
  // During import, if minorUnit is set and majorUnit not, then it is impossible
  // to calculate IntervalCount.
  const bool bAutoMinor = bLogScale || bAutoMajor || !rSubIncrementSeq.hasElements() ||
      lclIsAutoAnyOrGetValue( nCount, rSubIncrementSeq[ 0 ].IntervalCount ) || (nCount < 1) || (nCount == 5);

  if( maData.mfMajorStep && !bAutoMinor )
      maData.mfMinorStep = maData.mfMajorStep / nCount;
  ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_AUTOMINOR, bAutoMinor );

  // reverse order
  ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_REVERSE, rScaleData.Orientation == cssc2::AxisOrientation_REVERSE );
2751}

2753void XclExpChValueRange::ConvertAxisPosition( const ScfPropertySet& rPropSet )
2754{
  cssc::ChartAxisPosition eAxisPos = cssc::ChartAxisPosition_VALUE;
  double fCrossingPos = 0.0;
  if( !(rPropSet.GetProperty( eAxisPos, EXC_CHPROP_CROSSOVERPOSITION"CrossoverPosition" ) && rPropSet.GetProperty( fCrossingPos, EXC_CHPROP_CROSSOVERVALUE"CrossoverValue" )) )
      return;

  switch( eAxisPos )
  {
      case cssc::ChartAxisPosition_ZERO:
      case cssc::ChartAxisPosition_START:
          ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_AUTOCROSS );
      break;
      case cssc::ChartAxisPosition_END:
          ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_MAXCROSS );
      break;
      case cssc::ChartAxisPosition_VALUE:
          ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_AUTOCROSS, false );
          maData.mfCross = ::get_flagvalue< double >( maData.mnFlags, EXC_CHVALUERANGE_LOGSCALE, log( fCrossingPos ) / log( 10.0 ), fCrossingPos );
      break;
      default:
          ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_AUTOCROSS );
  }
2776}

2778void XclExpChValueRange::WriteBody( XclExpStream& rStrm )
2779{
  rStrm   << maData.mfMin
          << maData.mfMax
          << maData.mfMajorStep
          << maData.mfMinorStep
          << maData.mfCross
          << maData.mnFlags;
2786}

2788namespace {

2790sal_uInt8 lclGetXclTickPos( sal_Int32 nApiTickmarks )
2791{
  using namespace cssc2::TickmarkStyle;
  sal_uInt8 nXclTickPos = 0;
  ::set_flag( nXclTickPos, EXC_CHTICK_INSIDE,  ::get_flag( nApiTickmarks, INNER ) );
  ::set_flag( nXclTickPos, EXC_CHTICK_OUTSIDE, ::get_flag( nApiTickmarks, OUTER ) );
  return nXclTickPos;
2797}

2799} // namespace

2801XclExpChTick::XclExpChTick( const XclExpChRoot& rRoot ) :
  XclExpRecord( EXC_ID_CHTICK, (rRoot.GetBiff() == EXC_BIFF8) ? 30 : 26 ),
  XclExpChRoot( rRoot ),
  mnTextColorId( XclExpPalette::GetColorIdFromIndex( EXC_COLOR_CHWINDOWTEXT ) )
2805{
2806}

2808void XclExpChTick::Convert( const ScfPropertySet& rPropSet, const XclChExtTypeInfo& rTypeInfo, sal_uInt16 nAxisType )
2809{
  // tick mark style
  sal_Int32 nApiTickmarks = 0;
  if( rPropSet.GetProperty( nApiTickmarks, EXC_CHPROP_MAJORTICKS"MajorTickmarks" ) )
      maData.mnMajor = lclGetXclTickPos( nApiTickmarks );
  if( rPropSet.GetProperty( nApiTickmarks, EXC_CHPROP_MINORTICKS"MinorTickmarks" ) )
      maData.mnMinor = lclGetXclTickPos( nApiTickmarks );

  // axis labels
  if( (rTypeInfo.meTypeCateg == EXC_CHTYPECATEG_RADAR) && (nAxisType == EXC_CHAXIS_X) )
  {
      /*  Radar charts disable their category labels via chart type, not via
          axis, and axis labels are always 'near axis'. */
      maData.mnLabelPos = EXC_CHTICK_NEXT;
  }
  else if( !rPropSet.GetBoolProperty( EXC_CHPROP_DISPLAYLABELS"DisplayLabels" ) )
  {
      // no labels
      maData.mnLabelPos = EXC_CHTICK_NOLABEL;
  }
  else if( rTypeInfo.mb3dChart && (nAxisType == EXC_CHAXIS_Y) )
  {
      // Excel expects 'near axis' at Y axes in 3D charts
      maData.mnLabelPos = EXC_CHTICK_NEXT;
  }
  else
  {
      cssc::ChartAxisLabelPosition eApiLabelPos = cssc::ChartAxisLabelPosition_NEAR_AXIS;
      rPropSet.GetProperty( eApiLabelPos, EXC_CHPROP_LABELPOSITION"LabelPosition" );
      switch( eApiLabelPos )
      {
          case cssc::ChartAxisLabelPosition_NEAR_AXIS:
          case cssc::ChartAxisLabelPosition_NEAR_AXIS_OTHER_SIDE: maData.mnLabelPos = EXC_CHTICK_NEXT;    break;
          case cssc::ChartAxisLabelPosition_OUTSIDE_START:        maData.mnLabelPos = EXC_CHTICK_LOW;     break;
          case cssc::ChartAxisLabelPosition_OUTSIDE_END:          maData.mnLabelPos = EXC_CHTICK_HIGH;    break;
          default:                                                maData.mnLabelPos = EXC_CHTICK_NEXT;
      }
  }
2847}

2849void XclExpChTick::SetFontColor( const Color& rColor, sal_uInt32 nColorId )
2850{
  maData.maTextColor = rColor;
  ::set_flag( maData.mnFlags, EXC_CHTICK_AUTOCOLOR, rColor == COL_AUTO );
  mnTextColorId = nColorId;
2854}

2856void XclExpChTick::SetRotation( sal_uInt16 nRotation )
2857{
  maData.mnRotation = nRotation;
  ::set_flag( maData.mnFlags, EXC_CHTICK_AUTOROT, false );
  ::insert_value( maData.mnFlags, XclTools::GetXclOrientFromRot( nRotation ), 2, 3 );
2861}

2863void XclExpChTick::WriteBody( XclExpStream& rStrm )
2864{
  rStrm   << maData.mnMajor
          << maData.mnMinor
          << maData.mnLabelPos
          << maData.mnBackMode;
  rStrm.WriteZeroBytes( 16 );
  rStrm   << maData.maTextColor
          << maData.mnFlags;
  if( GetBiff() == EXC_BIFF8 )
      rStrm << GetPalette().GetColorIndex( mnTextColorId ) << maData.mnRotation;
2874}

2876namespace {

2878/** Returns an API axis object from the passed coordinate system. */
2879Reference< XAxis > lclGetApiAxis( Reference< XCoordinateSystem > const & xCoordSystem,
      sal_Int32 nApiAxisDim, sal_Int32 nApiAxesSetIdx )
2881{
  Reference< XAxis > xAxis;
  if( (nApiAxisDim >= 0) && xCoordSystem.is() ) try
  {
      xAxis = xCoordSystem->getAxisByDimension( nApiAxisDim, nApiAxesSetIdx );
  }
  catch( Exception& )
  {
  }
  return xAxis;
2891}

2893Reference< cssc::XAxis > lclGetApiChart1Axis( Reference< XChartDocument > const & xChartDoc,
      sal_Int32 nApiAxisDim, sal_Int32 nApiAxesSetIdx )
2895{
  Reference< cssc::XAxis > xChart1Axis;
  try
  {
      Reference< cssc::XChartDocument > xChart1Doc( xChartDoc, UNO_QUERY_THROW );
      Reference< cssc::XAxisSupplier > xChart1AxisSupp( xChart1Doc->getDiagram(), UNO_QUERY_THROW );
      switch( nApiAxesSetIdx )
      {
          case EXC_CHART_AXESSET_PRIMARY:
              xChart1Axis = xChart1AxisSupp->getAxis( nApiAxisDim );
          break;
          case EXC_CHART_AXESSET_SECONDARY:
              xChart1Axis = xChart1AxisSupp->getSecondaryAxis( nApiAxisDim );
          break;
      }
  }
  catch( Exception& )
  {
  }
  return xChart1Axis;
2915}

2917} // namespace

2919XclExpChAxis::XclExpChAxis( const XclExpChRoot& rRoot, sal_uInt16 nAxisType ) :
  XclExpChGroupBase( rRoot, EXC_CHFRBLOCK_TYPE_AXIS, EXC_ID_CHAXIS, 18 ),
  mnNumFmtIdx( EXC_FORMAT_NOTFOUND )
2922{
  maData.mnType = nAxisType;
2924}

2926void XclExpChAxis::SetFont( XclExpChFontRef xFont, const Color& rColor, sal_uInt32 nColorId )
2927{
  mxFont = xFont;
  if( mxTick )
      mxTick->SetFontColor( rColor, nColorId );
2931}

2933void XclExpChAxis::SetRotation( sal_uInt16 nRotation )
2934{
  if( mxTick )
      mxTick->SetRotation( nRotation );
2937}

2939void XclExpChAxis::Convert( Reference< XAxis > const & xAxis, Reference< XAxis > const & xCrossingAxis,
      Reference< cssc::XAxis > const & xChart1Axis, const XclChExtTypeInfo& rTypeInfo )
2941{
  ScfPropertySet aAxisProp( xAxis );
  bool bCategoryAxis = ((GetAxisType() == EXC_CHAXIS_X) && rTypeInfo.mbCategoryAxis) || (GetAxisType() == EXC_CHAXIS_Z);

  // axis line format -------------------------------------------------------

  mxAxisLine = new XclExpChLineFormat( GetChRoot() );
  mxAxisLine->Convert( GetChRoot(), aAxisProp, EXC_CHOBJTYPE_AXISLINE );
  // #i58688# axis enabled
  mxAxisLine->SetShowAxis( aAxisProp.GetBoolProperty( EXC_CHPROP_SHOW"Show" ) );

  // axis scaling and increment ---------------------------------------------

  ScfPropertySet aCrossingProp( xCrossingAxis );
  if( bCategoryAxis )
  {
      mxLabelRange = new XclExpChLabelRange( GetChRoot() );
      mxLabelRange->SetTicksBetweenCateg( rTypeInfo.mbTicksBetweenCateg );
      if( xAxis.is() )
      {
          ScfPropertySet aChart1AxisProp( xChart1Axis );
          // #i71684# radar charts have reversed rotation direction
          mxLabelRange->Convert( xAxis->getScaleData(), aChart1AxisProp, (GetAxisType() == EXC_CHAXIS_X) && (rTypeInfo.meTypeCateg == EXC_CHTYPECATEG_RADAR) );
      }
      // get position of crossing axis on this axis from passed axis object
      if( aCrossingProp.Is() )
          mxLabelRange->ConvertAxisPosition( aCrossingProp );
  }
  else
  {
      mxValueRange = new XclExpChValueRange( GetChRoot() );
      if( xAxis.is() )
          mxValueRange->Convert( xAxis->getScaleData() );
      // get position of crossing axis on this axis from passed axis object
      if( aCrossingProp.Is() )
          mxValueRange->ConvertAxisPosition( aCrossingProp );
  }

  // axis caption text ------------------------------------------------------

  // axis ticks properties
  mxTick = new XclExpChTick( GetChRoot() );
  mxTick->Convert( aAxisProp, rTypeInfo, GetAxisType() );

  // axis label formatting and rotation
  ConvertFontBase( GetChRoot(), aAxisProp );
  ConvertRotationBase( aAxisProp, true );

  // axis number format
  sal_Int32 nApiNumFmt = 0;
  if( !bCategoryAxis && aAxisProp.GetProperty( nApiNumFmt, EXC_CHPROP_NUMBERFORMAT"NumberFormat" ) )
  {
      bool bLinkNumberFmtToSource = false;
      if ( !aAxisProp.GetProperty( bLinkNumberFmtToSource, EXC_CHPROP_NUMBERFORMAT_LINKSRC"LinkNumberFormatToSource" ) || !bLinkNumberFmtToSource )
          mnNumFmtIdx = GetNumFmtBuffer().Insert( static_cast< sal_uInt32 >( nApiNumFmt ) );
  }

  // grid -------------------------------------------------------------------

  if( !xAxis.is() )
      return;

  // main grid
  ScfPropertySet aGridProp( xAxis->getGridProperties() );
  if( aGridProp.GetBoolProperty( EXC_CHPROP_SHOW"Show" ) )
      mxMajorGrid = lclCreateLineFormat( GetChRoot(), aGridProp, EXC_CHOBJTYPE_GRIDLINE );
  // sub grid
  Sequence< Reference< XPropertySet > > aSubGridPropSeq = xAxis->getSubGridProperties();
  if( aSubGridPropSeq.hasElements() )
  {
      ScfPropertySet aSubGridProp( aSubGridPropSeq[ 0 ] );
      if( aSubGridProp.GetBoolProperty( EXC_CHPROP_SHOW"Show" ) )
          mxMinorGrid = lclCreateLineFormat( GetChRoot(), aSubGridProp, EXC_CHOBJTYPE_GRIDLINE );
  }
3015}

3017void XclExpChAxis::ConvertWall( css::uno::Reference< css::chart2::XDiagram > const & xDiagram )
3018{
  if( !xDiagram.is() )
      return;

  switch( GetAxisType() )
  {
  case EXC_CHAXIS_X:
  {
      ScfPropertySet aWallProp( xDiagram->getWall() );
      mxWallFrame = lclCreateFrame( GetChRoot(), aWallProp, EXC_CHOBJTYPE_WALL3D );
  }
  break;
  case EXC_CHAXIS_Y:
  {
      ScfPropertySet aFloorProp( xDiagram->getFloor() );
      mxWallFrame = lclCreateFrame( GetChRoot(), aFloorProp, EXC_CHOBJTYPE_FLOOR3D );
  }
  break;
  default:
      mxWallFrame.clear();
  }
3039}

3041void XclExpChAxis::WriteSubRecords( XclExpStream& rStrm )
3042{
  lclSaveRecord( rStrm, mxLabelRange );
  lclSaveRecord( rStrm, mxValueRange );
  if( mnNumFmtIdx != EXC_FORMAT_NOTFOUND )
      XclExpUInt16Record( EXC_ID_CHFORMAT, mnNumFmtIdx ).Save( rStrm );
  lclSaveRecord( rStrm, mxTick );
  lclSaveRecord( rStrm, mxFont );
  lclSaveRecord( rStrm, mxAxisLine, EXC_ID_CHAXISLINE, EXC_CHAXISLINE_AXISLINE );
  lclSaveRecord( rStrm, mxMajorGrid, EXC_ID_CHAXISLINE, EXC_CHAXISLINE_MAJORGRID );
  lclSaveRecord( rStrm, mxMinorGrid, EXC_ID_CHAXISLINE, EXC_CHAXISLINE_MINORGRID );
  lclSaveRecord( rStrm, mxWallFrame, EXC_ID_CHAXISLINE, EXC_CHAXISLINE_WALLS );
3053}

3055void XclExpChAxis::WriteBody( XclExpStream& rStrm )
3056{
  rStrm << maData.mnType;
  rStrm.WriteZeroBytes( 16 );
3059}

3061XclExpChAxesSet::XclExpChAxesSet( const XclExpChRoot& rRoot, sal_uInt16 nAxesSetId ) :
  XclExpChGroupBase( rRoot, EXC_CHFRBLOCK_TYPE_AXESSET, EXC_ID_CHAXESSET, 18 )
3063{
  maData.mnAxesSetId = nAxesSetId;
  SetFutureRecordContext( 0, nAxesSetId );

  /*  Need to set a reasonable size for the plot area, otherwise Excel will
      move away embedded shapes while auto-sizing the plot area. This is just
      a wild guess, but will be fixed with implementing manual positioning of
      chart elements. */
  maData.maRect.mnX = 262;
  maData.maRect.mnY = 626;
  maData.maRect.mnWidth = 3187;
  maData.maRect.mnHeight = 2633;
3075}

3077sal_uInt16 XclExpChAxesSet::Convert( Reference< XDiagram > const & xDiagram, sal_uInt16 nFirstGroupIdx )
3078{
  /*  First unused chart type group index is passed to be able to continue
      counting of chart type groups for secondary axes set. */
  sal_uInt16 nGroupIdx = nFirstGroupIdx;
  Reference< XCoordinateSystemContainer > xCoordSysCont( xDiagram, UNO_QUERY );
  if( xCoordSysCont.is() )
  {
      Sequence< Reference< XCoordinateSystem > > aCoordSysSeq = xCoordSysCont->getCoordinateSystems();
      if( aCoordSysSeq.hasElements() )
      {
          /*  Process first coordinate system only. Import filter puts all
              chart types into one coordinate system. */
          Reference< XCoordinateSystem > xCoordSystem = aCoordSysSeq[ 0 ];
          sal_Int32 nApiAxesSetIdx = GetApiAxesSetIndex();

          // 3d mode
          bool b3dChart = xCoordSystem.is() && (xCoordSystem->getDimension() == 3);

          // percent charts
          namespace ApiAxisType = cssc2::AxisType;
          Reference< XAxis > xApiYAxis = lclGetApiAxis( xCoordSystem, EXC_CHART_AXIS_Y, nApiAxesSetIdx );
          bool bPercent = xApiYAxis.is() && (xApiYAxis->getScaleData().AxisType == ApiAxisType::PERCENT);

          // connector lines in bar charts
          ScfPropertySet aDiaProp( xDiagram );
          bool bConnectBars = aDiaProp.GetBoolProperty( EXC_CHPROP_CONNECTBARS"ConnectBars" );

          // swapped axes sets
          ScfPropertySet aCoordSysProp( xCoordSystem );
          bool bSwappedAxesSet = aCoordSysProp.GetBoolProperty( EXC_CHPROP_SWAPXANDYAXIS"SwapXAndYAxis" );

          // X axis for later use
          Reference< XAxis > xApiXAxis = lclGetApiAxis( xCoordSystem, EXC_CHART_AXIS_X, nApiAxesSetIdx );
          // X axis labels
          ScfPropertySet aXAxisProp( xApiXAxis );
          bool bHasXLabels = aXAxisProp.GetBoolProperty( EXC_CHPROP_DISPLAYLABELS"DisplayLabels" );

          // process chart types
          Reference< XChartTypeContainer > xChartTypeCont( xCoordSystem, UNO_QUERY );
          if( xChartTypeCont.is() )
          {
              const Sequence< Reference< XChartType > > aChartTypeSeq = xChartTypeCont->getChartTypes();
              for( const Reference< XChartType >& rChartType : aChartTypeSeq )
              {
                  XclExpChTypeGroupRef xTypeGroup = new XclExpChTypeGroup( GetChRoot(), nGroupIdx );
                  xTypeGroup->ConvertType( xDiagram, rChartType, nApiAxesSetIdx, b3dChart, bSwappedAxesSet, bHasXLabels );
                  /*  If new chart type group cannot be inserted into a combination
                      chart with existing type groups, insert all series into last
                      contained chart type group instead of creating a new group. */
                  XclExpChTypeGroupRef xLastGroup = GetLastTypeGroup();
                  if( xLastGroup && !(xTypeGroup->IsCombinable2d() && xLastGroup->IsCombinable2d()) )
                  {
                      xLastGroup->ConvertSeries( xDiagram, rChartType, nApiAxesSetIdx, bPercent, bConnectBars );
                  }
                  else
                  {
                      xTypeGroup->ConvertSeries( xDiagram, rChartType, nApiAxesSetIdx, bPercent, bConnectBars );
                      if( xTypeGroup->IsValidGroup() )
                      {
                          maTypeGroups.AppendRecord( xTypeGroup );
                          ++nGroupIdx;
                      }
                  }
              }
          }

          if( XclExpChTypeGroup* pGroup = GetFirstTypeGroup().get() )
          {
              const XclChExtTypeInfo& rTypeInfo = pGroup->GetTypeInfo();

              // create axes according to chart type (no axes for pie and donut charts)
              if( rTypeInfo.meTypeCateg != EXC_CHTYPECATEG_PIE )
              {
                  ConvertAxis( mxXAxis, EXC_CHAXIS_X, mxXAxisTitle, EXC_CHOBJLINK_XAXIS, xCoordSystem, rTypeInfo, EXC_CHART_AXIS_Y );
                  ConvertAxis( mxYAxis, EXC_CHAXIS_Y, mxYAxisTitle, EXC_CHOBJLINK_YAXIS, xCoordSystem, rTypeInfo, EXC_CHART_AXIS_X );
                  if( pGroup->Is3dDeepChart() )
                      ConvertAxis( mxZAxis, EXC_CHAXIS_Z, mxZAxisTitle, EXC_CHOBJLINK_ZAXIS, xCoordSystem, rTypeInfo, EXC_CHART_AXIS_NONE );
              }

              // X axis category ranges
              if( rTypeInfo.mbCategoryAxis && xApiXAxis.is() )
              {
                  const ScaleData aScaleData = xApiXAxis->getScaleData();
                  for( size_t nIdx = 0, nSize = maTypeGroups.GetSize(); nIdx < nSize; ++nIdx )
                      maTypeGroups.GetRecord( nIdx )->ConvertCategSequence( aScaleData.Categories );
              }

              // legend
              if( xDiagram.is() && (GetAxesSetId() == EXC_CHAXESSET_PRIMARY) )
              {
                  Reference< XLegend > xLegend = xDiagram->getLegend();
                  if( xLegend.is() )
                  {
                      ScfPropertySet aLegendProp( xLegend );
                      pGroup->ConvertLegend( aLegendProp );
                  }
              }
          }
      }
  }

  // wall/floor/diagram frame formatting
  if( xDiagram.is() && (GetAxesSetId() == EXC_CHAXESSET_PRIMARY) )
  {
      XclExpChTypeGroupRef xTypeGroup = GetFirstTypeGroup();
      if( xTypeGroup && xTypeGroup->Is3dWallChart() )
      {
          // wall/floor formatting (3D charts)
          if( mxXAxis )
              mxXAxis->ConvertWall( xDiagram );
          if( mxYAxis )
              mxYAxis->ConvertWall( xDiagram );
      }
      else
      {
          // diagram background formatting
          ScfPropertySet aWallProp( xDiagram->getWall() );
          mxPlotFrame = lclCreateFrame( GetChRoot(), aWallProp, EXC_CHOBJTYPE_PLOTFRAME );
      }
  }

  // inner and outer plot area position and size
  try
  {
      Reference< cssc::XChartDocument > xChart1Doc( GetChartDocument(), UNO_QUERY_THROW );
      Reference< cssc::XDiagramPositioning > xPositioning( xChart1Doc->getDiagram(), UNO_QUERY_THROW );
      // set manual flag in chart data
      if( !xPositioning->isAutomaticDiagramPositioning() )
          GetChartData().SetManualPlotArea();
      // the CHAXESSET record contains the inner plot area
      maData.maRect = CalcChartRectFromHmm( xPositioning->calculateDiagramPositionExcludingAxes() );
      // the embedded CHFRAMEPOS record contains the outer plot area
      mxFramePos = new XclExpChFramePos( EXC_CHFRAMEPOS_PARENT );
      // for pie charts, always use inner plot area size to exclude the data labels as Excel does
      const XclExpChTypeGroup* pFirstTypeGroup = GetFirstTypeGroup().get();
      bool bPieChart = pFirstTypeGroup && (pFirstTypeGroup->GetTypeInfo().meTypeCateg == EXC_CHTYPECATEG_PIE);
      mxFramePos->GetFramePosData().maRect = bPieChart ? maData.maRect :
          CalcChartRectFromHmm( xPositioning->calculateDiagramPositionIncludingAxes() );
  }
  catch( Exception& )
  {
  }

  // return first unused chart type group index for next axes set
  return nGroupIdx;
3223}

3225bool XclExpChAxesSet::Is3dChart() const
3226{
  XclExpChTypeGroupRef xTypeGroup = GetFirstTypeGroup();
  return xTypeGroup && xTypeGroup->Is3dChart();
3229}

3231void XclExpChAxesSet::WriteSubRecords( XclExpStream& rStrm )
3232{
  lclSaveRecord( rStrm, mxFramePos );
  lclSaveRecord( rStrm, mxXAxis );
  lclSaveRecord( rStrm, mxYAxis );
  lclSaveRecord( rStrm, mxZAxis );
  lclSaveRecord( rStrm, mxXAxisTitle );
  lclSaveRecord( rStrm, mxYAxisTitle );
  lclSaveRecord( rStrm, mxZAxisTitle );
  if( mxPlotFrame )
  {
      XclExpEmptyRecord( EXC_ID_CHPLOTFRAME ).Save( rStrm );
      mxPlotFrame->Save( rStrm );
  }
  maTypeGroups.Save( rStrm );
3246}

3248XclExpChTypeGroupRef XclExpChAxesSet::GetFirstTypeGroup() const
3249{
  return maTypeGroups.GetFirstRecord();
3251}

3253XclExpChTypeGroupRef XclExpChAxesSet::GetLastTypeGroup() const
3254{
  return maTypeGroups.GetLastRecord();
3256}

3258void XclExpChAxesSet::ConvertAxis(
      XclExpChAxisRef& rxChAxis, sal_uInt16 nAxisType,
      XclExpChTextRef& rxChAxisTitle, sal_uInt16 nTitleTarget,
      Reference< XCoordinateSystem > const & xCoordSystem, const XclChExtTypeInfo& rTypeInfo,
      sal_Int32 nCrossingAxisDim )
3263{
  // create and convert axis object
  rxChAxis = new XclExpChAxis( GetChRoot(), nAxisType );
  sal_Int32 nApiAxisDim = rxChAxis->GetApiAxisDimension();
  sal_Int32 nApiAxesSetIdx = GetApiAxesSetIndex();
  Reference< XAxis > xAxis = lclGetApiAxis( xCoordSystem, nApiAxisDim, nApiAxesSetIdx );
  Reference< XAxis > xCrossingAxis = lclGetApiAxis( xCoordSystem, nCrossingAxisDim, nApiAxesSetIdx );
  Reference< cssc::XAxis > xChart1Axis = lclGetApiChart1Axis( GetChartDocument(), nApiAxisDim, nApiAxesSetIdx );
  rxChAxis->Convert( xAxis, xCrossingAxis, xChart1Axis, rTypeInfo );

  // create and convert axis title
  Reference< XTitled > xTitled( xAxis, UNO_QUERY );
  rxChAxisTitle = lclCreateTitle( GetChRoot(), xTitled, nTitleTarget );
3276}

3278void XclExpChAxesSet::WriteBody( XclExpStream& rStrm )
3279{
  rStrm << maData.mnAxesSetId << maData.maRect;
3281}

3283// The chart object ===========================================================

3285static void lcl_getChartSubTitle(const Reference<XChartDocument>& xChartDoc,
                               OUString& rSubTitle)
3287{
  Reference< css::chart::XChartDocument > xChartDoc1(xChartDoc, UNO_QUERY);
  if (!xChartDoc1.is())
      return;

  Reference< XPropertySet > xProp(xChartDoc1->getSubTitle(), UNO_QUERY);
  if (!xProp.is())
      return;

  OUString aTitle;
  Any any = xProp->getPropertyValue("String");
  if (any >>= aTitle)
      rSubTitle = aTitle;
3300}

3302XclExpChChart::XclExpChChart( const XclExpRoot& rRoot,
      Reference< XChartDocument > const & xChartDoc, const tools::Rectangle& rChartRect ) :
  XclExpChGroupBase( XclExpChRoot( rRoot, *this ), EXC_CHFRBLOCK_TYPE_CHART, EXC_ID_CHCHART, 16 )
3305{
  Size aPtSize = OutputDevice::LogicToLogic( rChartRect.GetSize(), MapMode( MapUnit::Map100thMM ), MapMode( MapUnit::MapPoint ) );
  // rectangle is stored in 16.16 fixed-point format
  maRect.mnX = maRect.mnY = 0;
  maRect.mnWidth = static_cast< sal_Int32 >( aPtSize.Width() << 16 );
  maRect.mnHeight = static_cast< sal_Int32 >( aPtSize.Height() << 16 );

  // global chart properties (default values)
  ::set_flag( maProps.mnFlags, EXC_CHPROPS_SHOWVISIBLEONLY, false );
  ::set_flag( maProps.mnFlags, EXC_CHPROPS_MANPLOTAREA );
  maProps.mnEmptyMode = EXC_CHPROPS_EMPTY_SKIP;

  // always create both axes set objects
  mxPrimAxesSet = std::make_shared<XclExpChAxesSet>( GetChRoot(), EXC_CHAXESSET_PRIMARY );
  mxSecnAxesSet = std::make_shared<XclExpChAxesSet>( GetChRoot(), EXC_CHAXESSET_SECONDARY );

  if( !xChartDoc.is() )
      return;

  Reference< XDiagram > xDiagram = xChartDoc->getFirstDiagram();

  // global chart properties (only 'include hidden cells' attribute for now)
  ScfPropertySet aDiagramProp( xDiagram );
  bool bIncludeHidden = aDiagramProp.GetBoolProperty( EXC_CHPROP_INCLUDEHIDDENCELLS"IncludeHiddenCells" );
  ::set_flag( maProps.mnFlags,  EXC_CHPROPS_SHOWVISIBLEONLY, !bIncludeHidden );

  // initialize API conversion (remembers xChartDoc and rChartRect internally)
  InitConversion( xChartDoc, rChartRect );

  // chart frame
  ScfPropertySet aFrameProp( xChartDoc->getPageBackground() );
  mxFrame = lclCreateFrame( GetChRoot(), aFrameProp, EXC_CHOBJTYPE_BACKGROUND );

  // chart title
  Reference< XTitled > xTitled( xChartDoc, UNO_QUERY );
  OUString aSubTitle;
  lcl_getChartSubTitle(xChartDoc, aSubTitle);
  mxTitle = lclCreateTitle( GetChRoot(), xTitled, EXC_CHOBJLINK_TITLE,
                            !aSubTitle.isEmpty() ? &aSubTitle : nullptr );

  // diagrams (axes sets)
  sal_uInt16 nFreeGroupIdx = mxPrimAxesSet->Convert( xDiagram, 0 );
  if( !mxPrimAxesSet->Is3dChart() )
      mxSecnAxesSet->Convert( xDiagram, nFreeGroupIdx );

  // treatment of missing values
  ScfPropertySet aDiaProp( xDiagram );
  sal_Int32 nMissingValues = 0;
  if( aDiaProp.GetProperty( nMissingValues, EXC_CHPROP_MISSINGVALUETREATMENT"MissingValueTreatment" ) )
  {
      using namespace cssc::MissingValueTreatment;
      switch( nMissingValues )
      {
          case LEAVE_GAP: maProps.mnEmptyMode = EXC_CHPROPS_EMPTY_SKIP;           break;
          case USE_ZERO:  maProps.mnEmptyMode = EXC_CHPROPS_EMPTY_ZERO;           break;
          case CONTINUE:  maProps.mnEmptyMode = EXC_CHPROPS_EMPTY_INTERPOLATE;    break;
      }
  }

  // finish API conversion
  FinishConversion();
3366}

3368XclExpChSeriesRef XclExpChChart::CreateSeries()
3369{
  XclExpChSeriesRef xSeries;
  sal_uInt16 nSeriesIdx = static_cast< sal_uInt16 >( maSeries.GetSize() );
  if( nSeriesIdx <= EXC_CHSERIES_MAXSERIES )
  {
      xSeries = new XclExpChSeries( GetChRoot(), nSeriesIdx );
      maSeries.AppendRecord( xSeries );
  }
  return xSeries;
3378}

3380void XclExpChChart::RemoveLastSeries()
3381{
  if( !maSeries.IsEmpty() )
      maSeries.RemoveRecord( maSeries.GetSize() - 1 );
3384}

3386void XclExpChChart::SetDataLabel( XclExpChTextRef const & xText )
3387{
  if( xText )
      maLabels.AppendRecord( xText );
3390}

3392void XclExpChChart::SetManualPlotArea()
3393{
  // this flag does not exist in BIFF5
  if( GetBiff() == EXC_BIFF8 )
      ::set_flag( maProps.mnFlags, EXC_CHPROPS_USEMANPLOTAREA );
3397}

3399void XclExpChChart::WriteSubRecords( XclExpStream& rStrm )
3400{
  // background format
  lclSaveRecord( rStrm, mxFrame );

  // data series
  maSeries.Save( rStrm );

  // CHPROPERTIES record
  rStrm.StartRecord( EXC_ID_CHPROPERTIES, 4 );
  rStrm << maProps.mnFlags << maProps.mnEmptyMode << sal_uInt8( 0 );
  rStrm.EndRecord();

  // axes sets (always save primary axes set)
  sal_uInt16 nUsedAxesSets = mxSecnAxesSet->IsValidAxesSet() ? 2 : 1;
  XclExpUInt16Record( EXC_ID_CHUSEDAXESSETS, nUsedAxesSets ).Save( rStrm );
  mxPrimAxesSet->Save( rStrm );
  if( mxSecnAxesSet->IsValidAxesSet() )
      mxSecnAxesSet->Save( rStrm );

  // chart title and data labels
  lclSaveRecord( rStrm, mxTitle );
  maLabels.Save( rStrm );
3422}

3424void XclExpChChart::WriteBody( XclExpStream& rStrm )
3425{
   rStrm << maRect;
3427}

3429XclExpChartDrawing::XclExpChartDrawing( const XclExpRoot& rRoot,
      const Reference< XModel >& rxModel, const Size& rChartSize ) :
  XclExpRoot( rRoot )
3432{
  if( rChartSize.IsEmpty() )
      return;

  ScfPropertySet aPropSet( rxModel );
  Reference< XShapes > xShapes;
  if( !(aPropSet.GetProperty( xShapes, EXC_CHPROP_ADDITIONALSHAPES"AdditionalShapes" ) && xShapes.is() && (xShapes->getCount() > 0)) )
      return;

  /*  Create a new independent object manager with own DFF stream for the
      DGCONTAINER, pass global manager as parent for shared usage of
      global DFF data (picture container etc.). */
  mxObjMgr = std::make_shared<XclExpEmbeddedObjectManager>( GetObjectManager(), rChartSize, EXC_CHART_TOTALUNITS, EXC_CHART_TOTALUNITS );
  // initialize the drawing object list
  mxObjMgr->StartSheet();
  // process the draw page (convert all shapes)
  mxObjRecs = mxObjMgr->ProcessDrawing( xShapes );
  // finalize the DFF stream
  mxObjMgr->EndDocument();
3451}

3453XclExpChartDrawing::~XclExpChartDrawing()
3454{
3455}

3457void XclExpChartDrawing::Save( XclExpStream& rStrm )
3458{
  if( mxObjRecs )
      mxObjRecs->Save( rStrm );
3461}

3463XclExpChart::XclExpChart( const XclExpRoot& rRoot, Reference< XModel > const & xModel, const tools::Rectangle& rChartRect ) :
  XclExpSubStream( EXC_BOF_CHART ),
  XclExpRoot( rRoot )
3466{
  AppendNewRecord( new XclExpChartPageSettings( rRoot ) );
  AppendNewRecord( new XclExpBoolRecord( EXC_ID_PROTECT, false ) );
  AppendNewRecord( new XclExpChartDrawing( rRoot, xModel, rChartRect.GetSize() ) );
  AppendNewRecord( new XclExpUInt16Record( EXC_ID_CHUNITS, EXC_CHUNITS_TWIPS ) );

  Reference< XChartDocument > xChartDoc( xModel, UNO_QUERY );
  AppendNewRecord( new XclExpChChart( rRoot, xChartDoc, rChartRect ) );
3474}

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

←

/home/maarten/src/libreoffice/core/include/com/sun/star/uno/Reference.h

→

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 .
*/
19#ifndef INCLUDED_COM_SUN_STAR_UNO_REFERENCE_H
20#define INCLUDED_COM_SUN_STAR_UNO_REFERENCE_H

22#include "sal/config.h"

24#include <cassert>
25#include <cstddef>

27#if defined LIBO_INTERNAL_ONLY1
28#include <type_traits>
29#endif

31#include "rtl/alloc.h"

33namespace com
34{
35namespace sun
36{
37namespace star
38{
39namespace uno
40{

42class RuntimeException;
43class XInterface;
44class Type;
45class Any;

47/** Enum defining UNO_REF_NO_ACQUIRE for setting reference without acquiring a given interface.
  Deprecated, please use SAL_NO_ACQUIRE.
  @deprecated
50*/
51enum UnoReference_NoAcquire
52{
  /** This enum value can be used for creating a reference granting a given interface,
      i.e. transferring ownership to it.
  */
  UNO_REF_NO_ACQUIRE
57};

59/** This base class serves as a base class for all template reference classes and
  has been introduced due to compiler problems with templated operators ==, =!.
61*/
62class BaseReference
63{
64protected:
  /** the interface pointer
  */
  XInterface * _pInterface;

  /** Queries given interface for type rType.

      @param pInterface interface pointer
      @param rType interface type
      @return interface of demanded type (may be null)
  */
  inline static XInterface * SAL_CALL iquery( XInterface * pInterface, const Type & rType );
  /** Queries given interface for type rType.
      Throws a RuntimeException if the demanded interface cannot be queried.

      @param pInterface interface pointer
      @param rType interface type
      @return interface of demanded type
  */
  inline static XInterface * SAL_CALL iquery_throw( XInterface * pInterface, const Type & rType );

85public:
  /** Gets interface pointer. This call does not acquire the interface.

      @return UNacquired interface pointer
  */
  XInterface * SAL_CALL get() const
      { return _pInterface; }

  /** Checks if reference is null.

      @return true if reference acquires an interface, i.e. true if it is not null
  */
  bool SAL_CALL is() const
      { return (NULL__null != _pInterface); }
6
←
Assuming NULL is not equal to field '_pInterface'→
7
←
Returning the value 1, which participates in a condition later→

100#if defined LIBO_INTERNAL_ONLY1
  /** Checks if reference is null.

      @return true if reference acquires an interface, i.e. true if it is not null
  */
  explicit operator bool() const
      { return is(); }
107#endif

  /** Equality operator: compares two interfaces
      Checks if both references are null or refer to the same object.

      @param pInterface another interface
      @return true if both references are null or refer to the same object, false otherwise
  */
  inline bool SAL_CALL operator == ( XInterface * pInterface ) const;
  /** Inequality operator: compares two interfaces
      Checks if both references are null or refer to the same object.

      @param pInterface another interface
      @return false if both references are null or refer to the same object, true otherwise
  */
  inline bool SAL_CALL operator != ( XInterface * pInterface ) const;

  /** Equality operator: compares two interfaces
      Checks if both references are null or refer to the same object.

      @param rRef another reference
      @return true if both references are null or refer to the same object, false otherwise
  */
  inline bool SAL_CALL operator == ( const BaseReference & rRef ) const;
  /** Inequality operator: compares two interfaces
      Checks if both references are null or refer to the same object.

      @param rRef another reference
      @return false if both references are null or refer to the same object, true otherwise
  */
  inline bool SAL_CALL operator != ( const BaseReference & rRef ) const;

  /** Needed by some STL containers.

      @param rRef another reference
      @return true, if this reference is less than rRef
  */
  inline bool SAL_CALL operator < ( const BaseReference & rRef ) const;
145};

147/** Enum defining UNO_QUERY for implicit interface query.
148*/
149enum UnoReference_Query
150{
  /** This enum value can be used for implicit interface query.
  */
  UNO_QUERY
154};
155/** Enum defining UNO_QUERY_THROW for implicit interface query.
  If the demanded interface is unavailable, then a RuntimeException is thrown.
157*/
158enum UnoReference_QueryThrow
159{
  /** This enum value can be used for implicit interface query.
  */
  UNO_QUERY_THROW
163};
164/** Enum defining UNO_SET_THROW for throwing if attempts are made to assign a null
  interface

  @since UDK 3.2.8
168*/
169enum UnoReference_SetThrow
170{
  UNO_SET_THROW
172};

174/** Template reference class for interface type derived from BaseReference.
  A special constructor given the UNO_QUERY identifier queries interfaces
  for reference type.
177*/
178template< class interface_type >
179class SAL_DLLPUBLIC_RTTI__attribute__ ((type_visibility("default"))) Reference : public BaseReference
180{
  /** Queries given interface for type interface_type.

      @param pInterface interface pointer
      @return interface of demanded type (may be null)
  */
  inline static XInterface * SAL_CALL iquery( XInterface * pInterface );
  /** Queries given interface for type interface_type.
      Throws a RuntimeException if the demanded interface cannot be queried.

      @param pInterface interface pointer
      @return interface of demanded type
  */
  inline static XInterface * SAL_CALL iquery_throw( XInterface * pInterface );
  /** Returns the given interface if it is not <NULL/>, throws a RuntimeException otherwise.

      @param pInterface interface pointer
      @return pInterface
  */
  inline static interface_type * SAL_CALL iset_throw( interface_type * pInterface );

  /** Cast from an "interface pointer" (e.g., BaseReference::_pInterface) to a
      pointer to this interface_type.

      To work around ambiguities in the case of multiple-inheritance interface
      types (which inherit XInterface more than once), use reinterpret_cast
      (resp. a sequence of two static_casts, to avoid warnings about
      reinterpret_cast used between related classes) to switch from a pointer
      to XInterface to a pointer to this derived interface_type.  In
      principle, this is not guaranteed to work.  In practice, it seems to
      work on all supported platforms.
  */
  static interface_type * castFromXInterface(XInterface * p) {
      return static_cast< interface_type * >(static_cast< void * >(p));
  }

  /** Cast from a pointer to this interface_type to an "interface pointer"
      (e.g., BaseReference::_pInterface).

      To work around ambiguities in the case of multiple-inheritance interface
      types (which inherit XInterface more than once), use reinterpret_cast
      (resp. a sequence of two static_casts, to avoid warnings about
      reinterpret_cast used between related classes) to switch from a pointer
      to this derived interface_type to a pointer to XInterface.  In
      principle, this is not guaranteed to work.  In practice, it seems to
      work on all supported platforms.
  */
  static XInterface * castToXInterface(interface_type * p) {
      return static_cast< XInterface * >(static_cast< void * >(p));
  }

231public:
  /// @cond INTERNAL
  // these are here to force memory de/allocation to sal lib.
  static void * SAL_CALL operator new ( ::size_t nSize )
      { return ::rtl_allocateMemory( nSize ); }
  static void SAL_CALL operator delete ( void * pMem )
      { ::rtl_freeMemory( pMem ); }
  static void * SAL_CALL operator new ( ::size_t, void * pMem )
      { return pMem; }
  static void SAL_CALL operator delete ( void *, void * )
      {}
  /// @endcond

  /** Destructor: Releases interface if set.
  */
  inline ~Reference() COVERITY_NOEXCEPT_FALSE;

  /** Default Constructor: Sets null reference.
  */
  inline Reference();

  /** Copy constructor: Copies interface reference.

      @param rRef another reference
  */
  inline Reference( const Reference< interface_type > & rRef );

258#if defined LIBO_INTERNAL_ONLY1
  /** Move constructor

      @param rRef another reference
  */
  inline Reference( Reference< interface_type > && rRef ) noexcept;

  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.  For the special case of
      up-casting to Reference< XInterface >, see the corresponding conversion
      operator.

      @param rRef another reference
  */
  template< class derived_type >
  inline Reference(
      const Reference< derived_type > & rRef,
      std::enable_if_t<
          std::is_base_of_v<interface_type, derived_type>
          && !std::is_same_v<interface_type, XInterface>, void *> = nullptr);
279#endif

  /** Constructor: Sets given interface pointer.

      @param pInterface an interface pointer
  */
  inline Reference( interface_type * pInterface );

  /** Constructor: Sets given interface pointer without acquiring it.

      @param pInterface another reference
      @param dummy SAL_NO_ACQUIRE to force obvious distinction to other constructors
  */
  inline Reference( interface_type * pInterface, __sal_NoAcquire dummy);
  /** Constructor: Sets given interface pointer without acquiring it.
      Deprecated, please use SAL_NO_ACQUIRE version.

      @deprecated
      @param pInterface another reference
      @param dummy UNO_REF_NO_ACQUIRE to force obvious distinction to other constructors
  */
  inline SAL_DEPRECATED("use SAL_NO_ACQUIRE version")__attribute__((deprecated("use SAL_NO_ACQUIRE version"))) Reference( interface_type * pInterface, UnoReference_NoAcquire dummy );

  /** Constructor: Queries given interface for reference interface type (interface_type).

      @param rRef another reference
      @param dummy UNO_QUERY to force obvious distinction to other constructors
  */
  inline Reference( const BaseReference & rRef, UnoReference_Query dummy );
  /** Constructor: Queries given interface for reference interface type (interface_type).

      @param pInterface an interface pointer
      @param dummy UNO_QUERY to force obvious distinction to other constructors
  */
  inline Reference( XInterface * pInterface, UnoReference_Query dummy);
  /** Constructor: Queries given any for reference interface type (interface_type).

      @param rAny an any
      @param dummy UNO_QUERY to force obvious distinction to other constructors
  */
  inline Reference( const Any & rAny, UnoReference_Query dummy);
  /** Constructor: Queries given interface for reference interface type (interface_type).
      Throws a RuntimeException if the demanded interface cannot be queried.

      @param rRef another reference
      @param dummy UNO_QUERY_THROW to force obvious distinction
                   to other constructors
  */
  inline Reference( const BaseReference & rRef, UnoReference_QueryThrow dummy );
328#ifdef LIBO_INTERNAL_ONLY1
  /**
      Prevent code from calling the QUERY_THROW constructor, when they meant to use the SET_THROW constructor.
  */
  Reference( const Reference< interface_type > & rRef, UnoReference_QueryThrow dummy ) = delete;
333#endif
  /** Constructor: Queries given interface for reference interface type (interface_type).
      Throws a RuntimeException if the demanded interface cannot be queried.

      @param pInterface an interface pointer
      @param dummy UNO_QUERY_THROW to force obvious distinction
                   to other constructors
  */
  inline Reference( XInterface * pInterface, UnoReference_QueryThrow dummy );
  /** Constructor: Queries given any for reference interface type (interface_type).
      Throws a RuntimeException if the demanded interface cannot be queried.

      @param rAny an any
      @param dummy UNO_QUERY_THROW to force obvious distinction
                   to other constructors
  */
  inline Reference( const Any & rAny, UnoReference_QueryThrow dummy );
  /** Constructor: assigns from the given interface of the same type. Throws a RuntimeException
      if the source interface is NULL.

      @param rRef another interface reference of the same type
      @param dummy UNO_SET_THROW to distinguish from default copy constructor

      @since UDK 3.2.8
  */
  inline Reference( const Reference< interface_type > & rRef, UnoReference_SetThrow dummy );
  /** Constructor: assigns from the given interface of the same type. Throws a RuntimeException
      if the source interface is NULL.

      @param pInterface an interface pointer
      @param dummy UNO_SET_THROW to distinguish from default assignment constructor

      @since UDK 3.2.8
  */
  inline Reference( interface_type * pInterface, UnoReference_SetThrow dummy );

  /** Cast operator to Reference< XInterface >: Reference objects are binary compatible and
      any interface must be derived from com.sun.star.uno.XInterface.
      This a useful direct cast possibility.
  */
  SAL_CALL operator const Reference< XInterface > & () const
      { return * reinterpret_cast< const Reference< XInterface > * >( this ); }

  /** Dereference operator: Used to call interface methods.

      @return UNacquired interface pointer
  */
  interface_type * SAL_CALL operator -> () const {
      assert(_pInterface != NULL)(static_cast <bool> (_pInterface != __null) ? void (0) :
 __assert_fail ("_pInterface != NULL", "/home/maarten/src/libreoffice/core/include/com/sun/star/uno/Reference.h"
, 381, __extension__ __PRETTY_FUNCTION__));
      return castFromXInterface(_pInterface);
  }

  /** Indirection operator.

      @since LibreOffice 6.3
      @return UNacquired interface reference
  */
  interface_type & SAL_CALL operator * () const {
      assert(_pInterface != NULL)(static_cast <bool> (_pInterface != __null) ? void (0) :
 __assert_fail ("_pInterface != NULL", "/home/maarten/src/libreoffice/core/include/com/sun/star/uno/Reference.h"
, 391, __extension__ __PRETTY_FUNCTION__));
      return *castFromXInterface(_pInterface);
  }

  /** Gets interface pointer. This call does not acquire the interface.

      @return UNacquired interface pointer
  */
  interface_type * SAL_CALL get() const
      { return castFromXInterface(_pInterface); }

  /** Clears reference, i.e. releases interface. Reference is null after clear() call.
  */
  inline void SAL_CALL clear();

  /** Sets the given interface. An interface already set will be released.

      @param rRef another reference
      @return true, if non-null interface was set
  */
  inline bool SAL_CALL set( const Reference< interface_type > & rRef );
  /** Sets the given interface. An interface already set will be released.

      @param pInterface another interface
      @return true, if non-null interface was set
  */
  inline bool SAL_CALL set( interface_type * pInterface );

  /** Sets interface pointer without acquiring it. An interface already set will be released.

      @param pInterface an interface pointer
      @param dummy SAL_NO_ACQUIRE to force obvious distinction to set methods
      @return true, if non-null interface was set
  */
  inline bool SAL_CALL set( interface_type * pInterface, __sal_NoAcquire dummy);
  /** Sets interface pointer without acquiring it. An interface already set will be released.
      Deprecated, please use SAL_NO_ACQUIRE version.

      @deprecated
      @param pInterface an interface pointer
      @param dummy UNO_REF_NO_ACQUIRE to force obvious distinction to set methods
      @return true, if non-null interface was set
  */
  inline SAL_DEPRECATED("use SAL_NO_ACQUIRE version")__attribute__((deprecated("use SAL_NO_ACQUIRE version"))) bool SAL_CALL set( interface_type * pInterface, UnoReference_NoAcquire dummy);

  /** Queries given interface for reference interface type (interface_type) and sets it.
      An interface already set will be released.

      @param pInterface an interface pointer
      @param dummy UNO_QUERY to force obvious distinction to set methods
      @return true, if non-null interface was set
  */
  inline bool SAL_CALL set( XInterface * pInterface, UnoReference_Query dummy );
  /** Queries given interface for reference interface type (interface_type) and sets it.
      An interface already set will be released.

      @param rRef another reference
      @param dummy UNO_QUERY to force obvious distinction to set methods
      @return true, if non-null interface was set
  */
  inline bool SAL_CALL set( const BaseReference & rRef, UnoReference_Query dummy);

  /** Queries given any for reference interface type (interface_type)
      and sets it.  An interface already set will be released.

      @param rAny
             an Any containing an interface
      @param dummy
             UNO_QUERY to force obvious distinction
             to set methods
      @return
              true, if non-null interface was set
  */
  inline bool set( Any const & rAny, UnoReference_Query dummy );

  /** Queries given interface for reference interface type (interface_type) and sets it.
      An interface already set will be released.
      Throws a RuntimeException if the demanded interface cannot be set.

      @param pInterface an interface pointer
      @param dummy UNO_QUERY_THROW to force obvious distinction
                   to set methods
  */
  inline void SAL_CALL set( XInterface * pInterface, UnoReference_QueryThrow dummy );
  /** Queries given interface for reference interface type (interface_type) and sets it.
      An interface already set will be released.
      Throws a RuntimeException if the demanded interface cannot be set.

      @param rRef another reference
      @param dummy UNO_QUERY_THROW to force obvious distinction
             to set methods
  */
  inline void SAL_CALL set( const BaseReference & rRef, UnoReference_QueryThrow dummy );
484#ifdef LIBO_INTERNAL_ONLY1
  /**
      Prevent code from calling the QUERY_THROW version, when they meant to use the SET_THROW version.
  */
  void set( const Reference< interface_type > & rRef, UnoReference_QueryThrow dummy ) = delete;
489#endif

  /** Queries given any for reference interface type (interface_type) and
      sets it.  An interface already set will be released.
      Throws a RuntimeException if the demanded interface cannot be set.

      @param rAny
             an Any containing an interface
      @param dummy
             UNO_QUERY_THROW to force obvious distinction to set methods
  */
  inline void set( Any const & rAny, UnoReference_QueryThrow dummy);
  /** sets the given interface
      An interface already set will be released.
      Throws a RuntimeException if the source interface is @b NULL.

      @param pInterface an interface pointer
      @param dummy UNO_SET_THROW to force obvious distinction to other set methods

      @since UDK 3.2.8
  */
  inline void SAL_CALL set( interface_type * pInterface, UnoReference_SetThrow dummy);
  /** sets the given interface
      An interface already set will be released.
      Throws a RuntimeException if the source interface is @b NULL.

      @param rRef an interface reference
      @param dummy UNO_SET_THROW to force obvious distinction to other set methods

      @since UDK 3.2.8
  */
  inline void SAL_CALL set( const Reference< interface_type > & rRef, UnoReference_SetThrow dummy);


  /** Assignment operator: Acquires given interface pointer and sets reference.
      An interface already set will be released.

      @param pInterface an interface pointer
      @return this reference
  */
  inline Reference< interface_type > & SAL_CALL operator = ( interface_type * pInterface );
  /** Assignment operator: Acquires given interface reference and sets reference.
      An interface already set will be released.

      @param rRef an interface reference
      @return this reference
  */
  inline Reference< interface_type > & SAL_CALL operator = ( const Reference< interface_type > & rRef );
537#if defined LIBO_INTERNAL_ONLY1
  /** Assignment move operator: Acquires given interface reference and sets reference.
      An interface already set will be released.

      @param rRef an interface reference
      @return this reference
  */
  inline Reference< interface_type > & SAL_CALL operator = ( Reference< interface_type > && rRef ) noexcept;
545#endif
  /** Queries given interface reference for type interface_type.

      @param rRef interface reference
      @return interface reference of demanded type (may be null)
  */
  SAL_WARN_UNUSED_RESULT[[nodiscard]] inline static Reference< interface_type > SAL_CALL query( const BaseReference & rRef );
  /** Queries given interface for type interface_type.

      @param pInterface interface pointer
      @return interface reference of demanded type (may be null)
  */
  SAL_WARN_UNUSED_RESULT[[nodiscard]] inline static Reference< interface_type > SAL_CALL query( XInterface * pInterface );
558};

560}
561}
562}
563}

565#endif

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

←

/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx

→

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 .
*/

20#ifndef INCLUDED_RTL_USTRING_HXX
21#define INCLUDED_RTL_USTRING_HXX

23#include "sal/config.h"

25#include <cassert>
26#include <cstddef>
27#include <cstdlib>
28#include <limits>
29#include <new>
30#include <ostream>
31#include <utility>

33#if defined LIBO_INTERNAL_ONLY1
34#include <string_view>
35#include <type_traits>
36#endif

38#include "rtl/ustring.h"
39#include "rtl/string.hxx"
40#include "rtl/stringutils.hxx"
41#include "rtl/textenc.h"

43#ifdef LIBO_INTERNAL_ONLY1 // "RTL_FAST_STRING"
44#include "config_global.h"
45#include "rtl/stringconcat.hxx"
46#endif

48#ifdef RTL_STRING_UNITTEST
49extern bool rtl_string_unittest_invalid_conversion;
50#endif

52// The unittest uses slightly different code to help check that the proper
53// calls are made. The class is put into a different namespace to make
54// sure the compiler generates a different (if generating also non-inline)
55// copy of the function and does not merge them together. The class
56// is "brought" into the proper rtl namespace by a typedef below.
57#ifdef RTL_STRING_UNITTEST
58#define rtl rtlunittest
59#endif

61namespace rtl
62{

64class OUStringBuffer;

66#ifdef RTL_STRING_UNITTEST
67#undef rtl
68#endif

70#if defined LIBO_INTERNAL_ONLY1 // "RTL_FAST_STRING"
71/// @cond INTERNAL

73/**
74A wrapper dressing a string literal as a static-refcount rtl_uString.

76This class is not part of public API and is meant to be used only in LibreOffice code.
77@since LibreOffice 4.0
78*/
79template<std::size_t N> class SAL_WARN_UNUSED__attribute__((warn_unused)) OUStringLiteral {
  static_assert(N != 0);
  static_assert(N - 1 <= std::numeric_limits<sal_Int32>::max(), "literal too long");

83public:
84#if HAVE_CPP_CONSTEVAL0
  consteval
86#else
  constexpr
88#endif
  OUStringLiteral(char16_t const (&literal)[N]) {
      assertLayout();
      assert(literal[N - 1] == '\0')(static_cast <bool> (literal[N - 1] == '\0') ? void (0)
 : __assert_fail ("literal[N - 1] == '\\0'", "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 91, __extension__ __PRETTY_FUNCTION__));
      //TODO: Use C++20 constexpr std::copy_n (P0202R3):
      for (std::size_t i = 0; i != N; ++i) {
          buffer[i] = literal[i];
      }
  }

  constexpr sal_Int32 getLength() const { return length; }

  constexpr sal_Unicode const * getStr() const SAL_RETURNS_NONNULL__attribute__((returns_nonnull)) { return buffer; }

  constexpr operator std::u16string_view() const { return {buffer, sal_uInt32(length)}; }

104private:
  static constexpr void assertLayout() {
      // These static_asserts verifying the layout compatibility with rtl_uString cannot be class
      // member declarations, as offsetof requires a complete type, so defer them to here:
      static_assert(offsetof(OUStringLiteral, refCount)__builtin_offsetof(OUStringLiteral, refCount) == offsetof(rtl_uString, refCount)__builtin_offsetof(rtl_uString, refCount));
      static_assert(std::is_same_v<decltype(refCount), decltype(rtl_uString::refCount)>);
      static_assert(offsetof(OUStringLiteral, length)__builtin_offsetof(OUStringLiteral, length) == offsetof(rtl_uString, length)__builtin_offsetof(rtl_uString, length));
      static_assert(std::is_same_v<decltype(length), decltype(rtl_uString::length)>);
      static_assert(offsetof(OUStringLiteral, buffer)__builtin_offsetof(OUStringLiteral, buffer) == offsetof(rtl_uString, buffer)__builtin_offsetof(rtl_uString, buffer));
      static_assert(
          std::is_same_v<
              std::remove_extent_t<decltype(buffer)>,
              std::remove_extent_t<decltype(rtl_uString::buffer)>>);
  }

  // Same layout as rtl_uString (include/rtl/ustring.h):
  oslInterlockedCount refCount = 0x40000000; // SAL_STRING_STATIC_FLAG (sal/rtl/strimp.hxx)
  sal_Int32 length = N - 1;
  sal_Unicode buffer[N] = {}; //TODO: drop initialization for C++20 (P1331R2)
123};

125#if defined RTL_STRING_UNITTEST
126namespace libreoffice_internal {
127template<std::size_t N> struct ExceptConstCharArrayDetector<OUStringLiteral<N>> {};
128template<std::size_t N> struct ExceptCharArrayDetector<OUStringLiteral<N>> {};
129}
130#endif

132/// @endcond
133#endif

135/* ======================================================================= */

137/**
This String class provides base functionality for C++ like Unicode
character array handling. The advantage of this class is that it
handles all the memory management for you - and it does it
more efficiently. If you assign a string to another string, the
data of both strings are shared (without any copy operation or
memory allocation) as long as you do not change the string. This class
also stores the length of the string, so that many operations are
faster than the C-str-functions.

This class provides only readonly string handling. So you could create
a string and you could only query the content from this string.
It provides also functionality to change the string, but this results
in every case in a new string instance (in the most cases with a
memory allocation). You don't have functionality to change the
content of the string. If you want to change the string content, then
you should use the OStringBuffer class, which provides these
functionalities and avoids too much memory allocation.

The design of this class is similar to the string classes in Java so
less people should have understanding problems when they use this class.
158*/

160class SAL_WARN_UNUSED__attribute__((warn_unused)) SAL_DLLPUBLIC_RTTI__attribute__ ((type_visibility("default"))) OUString
161{
162public:
  /// @cond INTERNAL
  rtl_uString * pData;
  /// @endcond

  /**
    New string containing no characters.
  */
  OUString()
  {
      pData = NULL__null;
      rtl_uString_new( &pData );
  }

  /**
    New string from OUString.

    @param    str         an OUString.
  */
  OUString( const OUString & str )
  {
      pData = str.pData;
      rtl_uString_acquire( pData );
  }

187#if defined LIBO_INTERNAL_ONLY1
  /**
    Move constructor.

    @param    str         an OUString.
    @since LibreOffice 5.2
  */
  OUString( OUString && str ) noexcept
  {
      pData = str.pData;
      str.pData = nullptr;
      rtl_uString_new( &str.pData );
  }
200#endif

  /**
    New string from OUString data.

    @param    str         an OUString data.
  */
  OUString( rtl_uString * str )
  {
      pData = str;
      rtl_uString_acquire( pData );
  }

  /** New OUString from OUString data without acquiring it.  Takeover of ownership.

      The SAL_NO_ACQUIRE dummy parameter is only there to distinguish this
      from other constructors.

      @param str
             OUString data
  */
  OUString( rtl_uString * str, __sal_NoAcquire )
      { pData = str; }

  /**
    New string from a single Unicode character.

    @param    value       a Unicode character.
  */
  explicit OUString( sal_Unicode value )
      : pData (NULL__null)
  {
      rtl_uString_newFromStr_WithLength( &pData, &value, 1 );
  }

235#if defined LIBO_INTERNAL_ONLY1 && !defined RTL_STRING_UNITTEST_CONCAT
  /// @cond INTERNAL
  // Catch inadvertent conversions to the above ctor (but still allow
  // construction from char literals):
  OUString(int) = delete;
  explicit OUString(char c):
      OUString(sal_Unicode(static_cast<unsigned char>(c)))
  {}
  /// @endcond
244#endif

246#if defined LIBO_INTERNAL_ONLY1

  template<typename T> explicit OUString(
      T const & value,
      typename libreoffice_internal::CharPtrDetector<T, libreoffice_internal::Dummy>::TypeUtf16
          = libreoffice_internal::Dummy()):
      pData(nullptr)
  { rtl_uString_newFromStr(&pData, value); }

  template<typename T> explicit OUString(
      T & value,
      typename
      libreoffice_internal::NonConstCharArrayDetector<T, libreoffice_internal::Dummy>::TypeUtf16
          = libreoffice_internal::Dummy()):
      pData(nullptr)
  { rtl_uString_newFromStr(&pData, value); }

263#else

  /**
    New string from a Unicode character buffer array.

    @param    value       a NULL-terminated Unicode character array.
  */
  OUString( const sal_Unicode * value )
  {
      pData = NULL__null;
      rtl_uString_newFromStr( &pData, value );
  }

276#endif

  /**
    New string from a Unicode character buffer array.

    @param    value       a Unicode character array.
    @param    length      the number of character which should be copied.
                          The character array length must be greater than
                          or equal to this value.
  */
  OUString( const sal_Unicode * value, sal_Int32 length )
  {
      pData = NULL__null;
      rtl_uString_newFromStr_WithLength( &pData, value, length );
  }

  /**
    New string from an 8-Bit string literal that is expected to contain only
    characters in the ASCII set (i.e. first 128 characters). This constructor
    allows an efficient and convenient way to create OUString
    instances from ASCII literals. When creating strings from data that
    is not pure ASCII, it needs to be converted to OUString by explicitly
    providing the encoding to use for the conversion.

    If there are any embedded \0's in the string literal, the result is undefined.
    Use the overload that explicitly accepts length.

    @param    literal         the 8-bit ASCII string literal

    @since LibreOffice 3.6
  */
  template< typename T >
  OUString( T& literal, typename libreoffice_internal::ConstCharArrayDetector< T, libreoffice_internal::Dummy >::Type = libreoffice_internal::Dummy() )
  {
      assert((static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 311, __extension__ __PRETTY_FUNCTION__))
          libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 311, __extension__ __PRETTY_FUNCTION__));
      pData = NULL__null;
      if (libreoffice_internal::ConstCharArrayDetector<T>::length == 0) {
          rtl_uString_new(&pData);
      } else {
          rtl_uString_newFromLiteral(
              &pData,
              libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                  literal),
              libreoffice_internal::ConstCharArrayDetector<T>::length, 0);
      }
322#ifdef RTL_STRING_UNITTEST
      rtl_string_unittest_const_literal = true;
324#endif
  }

327#if defined LIBO_INTERNAL_ONLY1
  /** @overload @since LibreOffice 5.3 */
  template<typename T> OUString(
      T & literal,
      typename libreoffice_internal::ConstCharArrayDetector<
          T, libreoffice_internal::Dummy>::TypeUtf16
              = libreoffice_internal::Dummy()):
      pData(nullptr)
  {
      assert((static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 337, __extension__ __PRETTY_FUNCTION__))
          libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 337, __extension__ __PRETTY_FUNCTION__));
      if (libreoffice_internal::ConstCharArrayDetector<T>::length == 0) {
          rtl_uString_new(&pData);
      } else {
          rtl_uString_newFromStr_WithLength(
              &pData,
              libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                  literal),
              libreoffice_internal::ConstCharArrayDetector<T>::length);
      }
  }
348#endif

350#if defined LIBO_INTERNAL_ONLY1 && defined RTL_STRING_UNITTEST
  /// @cond INTERNAL
  /**
   * Only used by unittests to detect incorrect conversions.
   * @internal
   */
  template< typename T >
  OUString( T&, typename libreoffice_internal::ExceptConstCharArrayDetector< T >::Type = libreoffice_internal::Dummy() )
  {
      pData = NULL__null;
      rtl_uString_newFromLiteral( &pData, "!!br0ken!!", 10, 0 ); // set to garbage
      rtl_string_unittest_invalid_conversion = true;
  }
  /**
   * Only used by unittests to detect incorrect conversions.
   * @internal
   */
  template< typename T >
  OUString( const T&, typename libreoffice_internal::ExceptCharArrayDetector< T >::Type = libreoffice_internal::Dummy() )
  {
      pData = NULL__null;
      rtl_uString_newFromLiteral( &pData, "!!br0ken!!", 10, 0 ); // set to garbage
      rtl_string_unittest_invalid_conversion = true;
  }
  /// @endcond
375#endif

377#ifdef LIBO_INTERNAL_ONLY1 // "RTL_FAST_STRING"
  /// @cond INTERNAL
  /**
    New string from a string literal.

    @since LibreOffice 5.0
  */
  template<std::size_t N> OUString(OUStringLiteral<N> const & literal):
      pData(const_cast<rtl_uString *>(reinterpret_cast<rtl_uString const *>(&literal))) {}
  template<std::size_t N> OUString(OUStringLiteral<N> &&) = delete;
  /// @endcond
388#endif

  /**
    New string from an 8-Bit character buffer array.

    @param    value           An 8-Bit character array.
    @param    length          The number of character which should be converted.
                              The 8-Bit character array length must be
                              greater than or equal to this value.
    @param    encoding        The text encoding from which the 8-Bit character
                              sequence should be converted.
    @param    convertFlags    Flags which control the conversion.
                              see RTL_TEXTTOUNICODE_FLAGS_...

    @exception std::bad_alloc is thrown if an out-of-memory condition occurs
  */
  OUString( const char * value, sal_Int32 length,
            rtl_TextEncoding encoding,
            sal_uInt32 convertFlags = OSTRING_TO_OUSTRING_CVTFLAGS(((sal_uInt32)0x0003) | ((sal_uInt32)0x0030) | ((sal_uInt32)0x0300
)) )
  {
      pData = NULL__null;
      rtl_string2UString( &pData, value, length, encoding, convertFlags );
      if (pData == NULL__null) {
          throw std::bad_alloc();
      }
  }

  /** Create a new string from an array of Unicode code points.

      @param codePoints
      an array of at least codePointCount code points, which each must be in
      the range from 0 to 0x10FFFF, inclusive.  May be null if codePointCount
      is zero.

      @param codePointCount
      the non-negative number of code points.

      @exception std::bad_alloc
      is thrown if either an out-of-memory condition occurs or the resulting
      number of UTF-16 code units would have been larger than SAL_MAX_INT32.

      @since UDK 3.2.7
  */
  explicit OUString(
      sal_uInt32 const * codePoints, sal_Int32 codePointCount):
      pData(NULL__null)
  {
      rtl_uString_newFromCodePoints(&pData, codePoints, codePointCount);
      if (pData == NULL__null) {
          throw std::bad_alloc();
      }
  }

441#ifdef LIBO_INTERNAL_ONLY1 // "RTL_FAST_STRING"
  /**
   @overload
   @internal
  */
  template< typename T1, typename T2 >
  OUString( OUStringConcat< T1, T2 >&& c )
  {
      const sal_Int32 l = c.length();
      pData = rtl_uString_alloc( l );
      if (l != 0)
      {
          sal_Unicode* end = c.addData( pData->buffer );
          pData->length = l;
          *end = '\0';
          // TODO realloc in case pData->length is noticeably smaller than l?
      }
  }

  /**
   @overload
   @internal
  */
  template< typename T >
  OUString( OUStringNumber< T >&& n )
      : OUString( n.buf, n.length )
  {}
468#endif

470#if defined LIBO_INTERNAL_ONLY1
  OUString(std::u16string_view sv) {
      if (sv.size() > sal_uInt32(std::numeric_limits<sal_Int32>::max())) {
          throw std::bad_alloc();
      }
      pData = nullptr;
      rtl_uString_newFromStr_WithLength(&pData, sv.data(), sv.size());
  }
478#endif

  /**
    Release the string data.
  */
  ~OUString()
  {
      rtl_uString_release( pData );
  }

  /** Provides an OUString const & passing a storage pointer of an
      rtl_uString * handle.
      It is more convenient to use C++ OUString member functions when dealing
      with rtl_uString * handles.  Using this function avoids unnecessary
      acquire()/release() calls for a temporary OUString object.

      @param ppHandle
             pointer to storage
      @return
             OUString const & based on given storage
  */
  static OUString const & unacquired( rtl_uString * const * ppHandle )
      { return * reinterpret_cast< OUString const * >( ppHandle ); }

  /**
    Assign a new string.

    @param    str         an OUString.
  */
  OUString & operator=( const OUString & str )
  {
      rtl_uString_assign( &pData, str.pData );
      return *this;
  }

513#if defined LIBO_INTERNAL_ONLY1
  /**
    Move assign a new string.

    @param    str         an OUString.
    @since LibreOffice 5.2
  */
  OUString & operator=( OUString && str ) noexcept
  {
      rtl_uString_release( pData );
      pData = str.pData;
      str.pData = nullptr;
      rtl_uString_new( &str.pData );
      return *this;
  }
528#endif

  /**
    Assign a new string from an 8-Bit string literal that is expected to contain only
    characters in the ASCII set (i.e. first 128 characters). This operator
    allows an efficient and convenient way to assign OUString
    instances from ASCII literals. When assigning strings from data that
    is not pure ASCII, it needs to be converted to OUString by explicitly
    providing the encoding to use for the conversion.

    @param    literal         the 8-bit ASCII string literal

    @since LibreOffice 3.6
  */
  template< typename T >
  typename libreoffice_internal::ConstCharArrayDetector< T, OUString& >::Type operator=( T& literal )
  {
      assert((static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 546, __extension__ __PRETTY_FUNCTION__))
          libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 546, __extension__ __PRETTY_FUNCTION__));
      if (libreoffice_internal::ConstCharArrayDetector<T>::length == 0) {
          rtl_uString_new(&pData);
      } else {
          rtl_uString_newFromLiteral(
              &pData,
              libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                  literal),
              libreoffice_internal::ConstCharArrayDetector<T>::length, 0);
      }
      return *this;
  }

559#if defined LIBO_INTERNAL_ONLY1
  /** @overload @since LibreOffice 5.3 */
  template<typename T>
  typename
      libreoffice_internal::ConstCharArrayDetector<T, OUString &>::TypeUtf16
  operator =(T & literal) {
      if (libreoffice_internal::ConstCharArrayDetector<T>::length == 0) {
          rtl_uString_new(&pData);
      } else {
          rtl_uString_newFromStr_WithLength(
              &pData,
              libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                  literal),
              libreoffice_internal::ConstCharArrayDetector<T>::length);
      }
      return *this;
  }

  /** @overload @since LibreOffice 5.4 */
  template<std::size_t N> OUString & operator =(OUStringLiteral<N> const & literal) {
      if (literal.getLength() == 0) {
          rtl_uString_new(&pData);
      } else {
          rtl_uString_newFromStr_WithLength(&pData, literal.getStr(), literal.getLength());
      }
      return *this;
  }

  template<typename T>
  OUString & operator =(OUStringNumber<T> && n) {
      // n.length should never be zero, so no need to add an optimization for that case
      rtl_uString_newFromStr_WithLength(&pData, n.buf, n.length);
      return *this;
  }

  OUString & operator =(std::u16string_view sv) {
      if (sv.empty()) {
          rtl_uString_new(&pData);
      } else {
          rtl_uString_newFromStr_WithLength(&pData, sv.data(), sv.size());
      }
      return *this;
  }
602#endif

604#if defined LIBO_INTERNAL_ONLY1
  /**
    Append the contents of an OUStringBuffer to this string.

    @param    str         an OUStringBuffer.

    @exception std::bad_alloc is thrown if an out-of-memory condition occurs
    @since LibreOffice 6.2
  */
  inline OUString & operator+=( const OUStringBuffer & str ) &;
614#endif

  /**
    Append a string to this string.

    @param    str         an OUString.

    @exception std::bad_alloc is thrown if an out-of-memory condition occurs
  */
  OUString & operator+=( const OUString & str )
624#if defined LIBO_INTERNAL_ONLY1
      &
626#endif
  {
      return internalAppend(str.pData);
  }
630#if defined LIBO_INTERNAL_ONLY1
  void operator+=(OUString const &) && = delete;
632#endif

  /** Append an ASCII string literal to this string.

      @param literal  an 8-bit ASCII-only string literal

      @since LibreOffice 5.1
  */
  template<typename T>
  typename libreoffice_internal::ConstCharArrayDetector<T, OUString &>::Type
  operator +=(T & literal)
643#if defined LIBO_INTERNAL_ONLY1
      &
645#endif
  {
      assert((static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 648, __extension__ __PRETTY_FUNCTION__))
          libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 648, __extension__ __PRETTY_FUNCTION__));
      rtl_uString_newConcatAsciiL(
          &pData, pData,
          libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
          libreoffice_internal::ConstCharArrayDetector<T>::length);
      return *this;
  }
655#if defined LIBO_INTERNAL_ONLY1
  template<typename T>
  typename libreoffice_internal::ConstCharArrayDetector<T, OUString &>::Type
  operator +=(T &) && = delete;
659#endif

661#if defined LIBO_INTERNAL_ONLY1
  /** @overload @since LibreOffice 5.3 */
  template<typename T>
  typename
      libreoffice_internal::ConstCharArrayDetector<T, OUString &>::TypeUtf16
  operator +=(T & literal) & {
      rtl_uString_newConcatUtf16L(
          &pData, pData,
          libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
          libreoffice_internal::ConstCharArrayDetector<T>::length);
      return *this;
  }
  template<typename T>
  typename
      libreoffice_internal::ConstCharArrayDetector<T, OUString &>::TypeUtf16
  operator +=(T &) && = delete;

  /** @overload @since LibreOffice 5.4 */
  template<std::size_t N> OUString & operator +=(OUStringLiteral<N> const & literal) & {
      rtl_uString_newConcatUtf16L(&pData, pData, literal.getStr(), literal.getLength());
      return *this;
  }
  template<std::size_t N> void operator +=(OUStringLiteral<N> const &) && = delete;

  OUString & operator +=(std::u16string_view sv) & {
      if (sv.size() > sal_uInt32(std::numeric_limits<sal_Int32>::max())) {
          throw std::bad_alloc();
      }
      rtl_uString_newConcatUtf16L(&pData, pData, sv.data(), sv.size());
      return *this;
  }
  void operator +=(std::u16string_view) && = delete;
693#endif

695#ifdef LIBO_INTERNAL_ONLY1 // "RTL_FAST_STRING"
  /**
   @overload
   @internal
  */
  template< typename T1, typename T2 >
  OUString& operator+=( OUStringConcat< T1, T2 >&& c ) & {
      sal_Int32 l = c.length();
      if( l == 0 )
          return *this;
      l += pData->length;
      rtl_uString_ensureCapacity( &pData, l );
      sal_Unicode* end = c.addData( pData->buffer + pData->length );
      *end = '\0';
      pData->length = l;
      return *this;
  }
  template<typename T1, typename T2> void operator +=(
      OUStringConcat<T1, T2> &&) && = delete;

  /**
   @overload
   @internal
  */
  template< typename T >
  OUString& operator+=( OUStringNumber< T >&& n ) & {
      sal_Int32 l = n.length;
      if( l == 0 )
          return *this;
      l += pData->length;
      rtl_uString_ensureCapacity( &pData, l );
      sal_Unicode* end = addDataHelper( pData->buffer + pData->length, n.buf, n.length );
      *end = '\0';
      pData->length = l;
      return *this;
  }
  template<typename T> void operator +=(
      OUStringNumber<T> &&) && = delete;
733#endif

  /**
    Clears the string, i.e, makes a zero-character string
    @since LibreOffice 4.4
  */
  void clear()
  {
      rtl_uString_new( &pData );
  }

  /**
    Returns the length of this string.

    The length is equal to the number of Unicode characters in this string.

    @return   the length of the sequence of characters represented by this
              object.
  */
  sal_Int32 getLength() const { return pData->length; }

  /**
    Checks if a string is empty.

    @return   true if the string is empty;
              false, otherwise.

    @since LibreOffice 3.4
  */
  bool isEmpty() const
  {
      return pData->length == 0;
  }

  /**
    Returns a pointer to the Unicode character buffer for this string.

    It isn't necessarily NULL terminated.

    @return   a pointer to the Unicode characters buffer for this object.
  */
  const sal_Unicode * getStr() const SAL_RETURNS_NONNULL__attribute__((returns_nonnull)) { return pData->buffer; }

  /**
    Access to individual characters.

    @param index must be non-negative and less than length.

    @return the character at the given index.

    @since LibreOffice 3.5
  */
  sal_Unicode operator [](sal_Int32 index) const {
      // silence spurious -Werror=strict-overflow warnings from GCC 4.8.2
      assert(index >= 0 && static_cast<sal_uInt32>(index) < static_cast<sal_uInt32>(getLength()))(static_cast <bool> (index >= 0 && static_cast
<sal_uInt32>(index) < static_cast<sal_uInt32>(
getLength())) ? void (0) : __assert_fail ("index >= 0 && static_cast<sal_uInt32>(index) < static_cast<sal_uInt32>(getLength())"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 787, __extension__ __PRETTY_FUNCTION__));
      return getStr()[index];
  }

  /**
    Compares two strings.

    The comparison is based on the numeric value of each character in
    the strings and return a value indicating their relationship.
    This function can't be used for language specific sorting.

    @param    str         the object to be compared.
    @return   0 - if both strings are equal
              < 0 - if this string is less than the string argument
              > 0 - if this string is greater than the string argument
  */
  sal_Int32 compareTo( const OUString & str ) const
  {
      return rtl_ustr_compare_WithLength( pData->buffer, pData->length,
                                          str.pData->buffer, str.pData->length );
  }

  /**
    Compares two strings with a maximum count of characters.

    The comparison is based on the numeric value of each character in
    the strings and return a value indicating their relationship.
    This function can't be used for language specific sorting.

    @param    str         the object to be compared.
    @param    maxLength   the maximum count of characters to be compared.
    @return   0 - if both strings are equal
              < 0 - if this string is less than the string argument
              > 0 - if this string is greater than the string argument

    @since UDK 3.2.7
  */
  sal_Int32 compareTo( const OUString & str, sal_Int32 maxLength ) const
  {
      return rtl_ustr_shortenedCompare_WithLength( pData->buffer, pData->length,
                                                   str.pData->buffer, str.pData->length, maxLength );
  }

  /**
    Compares two strings in reverse order.

    The comparison is based on the numeric value of each character in
    the strings and return a value indicating their relationship.
    This function can't be used for language specific sorting.

    @param    str         the object to be compared.
    @return   0 - if both strings are equal
              < 0 - if this string is less than the string argument
              > 0 - if this string is greater than the string argument
  */
842#if defined LIBO_INTERNAL_ONLY1
  sal_Int32 reverseCompareTo(std::u16string_view sv) const {
      return rtl_ustr_reverseCompare_WithLength(
          pData->buffer, pData->length, sv.data(), sv.size());
  }
847#else
  sal_Int32 reverseCompareTo( const OUString & str ) const
  {
      return rtl_ustr_reverseCompare_WithLength( pData->buffer, pData->length,
                                                 str.pData->buffer, str.pData->length );
  }
853#endif

  /**
   @overload
   This function accepts an ASCII string literal as its argument.
   @since LibreOffice 4.1
  */
  template< typename T >
  typename libreoffice_internal::ConstCharArrayDetector< T, sal_Int32 >::Type reverseCompareTo( T& literal ) const
  {
      assert((static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 864, __extension__ __PRETTY_FUNCTION__))
          libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 864, __extension__ __PRETTY_FUNCTION__));
      return rtl_ustr_asciil_reverseCompare_WithLength(
          pData->buffer, pData->length,
          libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
          libreoffice_internal::ConstCharArrayDetector<T>::length);
  }

  /**
    Perform a comparison of two strings.

    The result is true if and only if second string
    represents the same sequence of characters as the first string.
    This function can't be used for language specific comparison.

    @param    str         the object to be compared.
    @return   true if the strings are equal;
              false, otherwise.
  */
  bool equals( const OUString & str ) const
  {
      if ( pData->length != str.pData->length )
          return false;
      if ( pData == str.pData )
          return true;
      return rtl_ustr_reverseCompare_WithLength( pData->buffer, pData->length,
                                                 str.pData->buffer, str.pData->length ) == 0;
  }

  /**
    Perform an ASCII lowercase comparison of two strings.

    The result is true if and only if second string
    represents the same sequence of characters as the first string,
    ignoring the case.
    Character values between 65 and 90 (ASCII A-Z) are interpreted as
    values between 97 and 122 (ASCII a-z).
    This function can't be used for language specific comparison.

    @param    str         the object to be compared.
    @return   true if the strings are equal;
              false, otherwise.
  */
906#if defined LIBO_INTERNAL_ONLY1
  bool equalsIgnoreAsciiCase(std::u16string_view sv) const {
      return
          rtl_ustr_compareIgnoreAsciiCase_WithLength(
              pData->buffer, pData->length, sv.data(), sv.size())
          == 0;
  }
913#else
  bool equalsIgnoreAsciiCase( const OUString & str ) const
  {
      if ( pData->length != str.pData->length )
          return false;
      if ( pData == str.pData )
          return true;
      return rtl_ustr_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length,
                                                         str.pData->buffer, str.pData->length ) == 0;
  }
923#endif

  /**
    Perform an ASCII lowercase comparison of two strings.

    Compare the two strings with uppercase ASCII
    character values between 65 and 90 (ASCII A-Z) interpreted as
    values between 97 and 122 (ASCII a-z).
    This function can't be used for language specific comparison.

    @param    str         the object to be compared.
    @return   0 - if both strings are equal
              < 0 - if this string is less than the string argument
              > 0 - if this string is greater than the string argument

    @since LibreOffice 4.0
  */
940#if defined LIBO_INTERNAL_ONLY1
  sal_Int32 compareToIgnoreAsciiCase(std::u16string_view sv) const {
      return rtl_ustr_compareIgnoreAsciiCase_WithLength(
          pData->buffer, pData->length, sv.data(), sv.size());
  }
945#else
  sal_Int32 compareToIgnoreAsciiCase( const OUString & str ) const
  {
      return rtl_ustr_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length,
                                                         str.pData->buffer, str.pData->length );
  }
951#endif

  /**
   @overload
   This function accepts an ASCII string literal as its argument.
   @since LibreOffice 3.6
  */
  template< typename T >
  typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type equalsIgnoreAsciiCase( T& literal ) const
  {
      assert((static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 962, __extension__ __PRETTY_FUNCTION__))
          libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 962, __extension__ __PRETTY_FUNCTION__));
      return
          (pData->length
           == libreoffice_internal::ConstCharArrayDetector<T>::length)
          && (rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength(
                  pData->buffer, pData->length,
                  libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                      literal))
              == 0);
  }

 /**
    Match against a substring appearing in this string.

    The result is true if and only if the second string appears as a substring
    of this string, at the given position.
    This function can't be used for language specific comparison.

    @param    str         the object (substring) to be compared.
    @param    fromIndex   the index to start the comparison from.
                          The index must be greater than or equal to 0
                          and less or equal as the string length.
    @return   true if str match with the characters in the string
              at the given position;
              false, otherwise.
  */
988#if defined LIBO_INTERNAL_ONLY1
  bool match(std::u16string_view sv, sal_Int32 fromIndex = 0) const {
      return
          rtl_ustr_shortenedCompare_WithLength(
              pData->buffer + fromIndex, pData->length - fromIndex, sv.data(), sv.size(),
              sv.size())
          == 0;
  }
996#else
  bool match( const OUString & str, sal_Int32 fromIndex = 0 ) const
  {
      return rtl_ustr_shortenedCompare_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
                                                   str.pData->buffer, str.pData->length, str.pData->length ) == 0;
  }
1002#endif

  /**
   @overload
   This function accepts an ASCII string literal as its argument.
   @since LibreOffice 3.6
  */
  template< typename T >
  typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type match( T& literal, sal_Int32 fromIndex = 0 ) const
  {
      assert((static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 1013, __extension__ __PRETTY_FUNCTION__))
          libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 1013, __extension__ __PRETTY_FUNCTION__));
      return
          rtl_ustr_ascii_shortenedCompare_WithLength(
              pData->buffer+fromIndex, pData->length-fromIndex,
              libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                  literal),
              libreoffice_internal::ConstCharArrayDetector<T>::length)
          == 0;
  }

  /**
    Match against a substring appearing in this string, ignoring the case of
    ASCII letters.

    The result is true if and only if the second string appears as a substring
    of this string, at the given position.
    Character values between 65 and 90 (ASCII A-Z) are interpreted as
    values between 97 and 122 (ASCII a-z).
    This function can't be used for language specific comparison.

    @param    str         the object (substring) to be compared.
    @param    fromIndex   the index to start the comparison from.
                          The index must be greater than or equal to 0
                          and less than or equal to the string length.
    @return   true if str match with the characters in the string
              at the given position;
              false, otherwise.
  */
1041#if defined LIBO_INTERNAL_ONLY1
  bool matchIgnoreAsciiCase(std::u16string_view sv, sal_Int32 fromIndex = 0) const {
      return
          rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength(
              pData->buffer + fromIndex, pData->length - fromIndex, sv.data(), sv.size(),
              sv.size())
          == 0;
  }
1049#else
  bool matchIgnoreAsciiCase( const OUString & str, sal_Int32 fromIndex = 0 ) const
  {
      return rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
                                                                  str.pData->buffer, str.pData->length,
                                                                  str.pData->length ) == 0;
  }
1056#endif

  /**
   @overload
   This function accepts an ASCII string literal as its argument.
   @since LibreOffice 3.6
  */
  template< typename T >
  typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type matchIgnoreAsciiCase( T& literal, sal_Int32 fromIndex = 0 ) const
  {
      assert((static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 1067, __extension__ __PRETTY_FUNCTION__))
          libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 1067, __extension__ __PRETTY_FUNCTION__));
      return
          rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength(
              pData->buffer+fromIndex, pData->length-fromIndex,
              libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                  literal),
              libreoffice_internal::ConstCharArrayDetector<T>::length)
          == 0;
  }

  /**
    Compares two strings.

    The comparison is based on the numeric value of each character in
    the strings and return a value indicating their relationship.
    Since this method is optimized for performance, the ASCII character
    values are not converted in any way. The caller has to make sure that
    all ASCII characters are in the allowed range between 0 and 127.
    The ASCII string must be NULL-terminated.
    This function can't be used for language specific sorting.

    @param  asciiStr      the 8-Bit ASCII character string to be compared.
    @return   0 - if both strings are equal
              < 0 - if this string is less than the string argument
              > 0 - if this string is greater than the string argument
  */
  sal_Int32 compareToAscii( const char* asciiStr ) const
  {
      return rtl_ustr_ascii_compare_WithLength( pData->buffer, pData->length, asciiStr );
  }

  /**
    Compares two strings with a maximum count of characters.

    The comparison is based on the numeric value of each character in
    the strings and return a value indicating their relationship.
    Since this method is optimized for performance, the ASCII character
    values are not converted in any way. The caller has to make sure that
    all ASCII characters are in the allowed range between 0 and 127.
    The ASCII string must be NULL-terminated.
    This function can't be used for language specific sorting.

    @deprecated  This is a confusing overload with unexpectedly different
    semantics from the one-parameter form, so it is marked as deprecated.
    Practically all uses compare the return value against zero and can thus
    be replaced with uses of startsWith.

    @param  asciiStr          the 8-Bit ASCII character string to be compared.
    @param  maxLength         the maximum count of characters to be compared.
    @return   0 - if both strings are equal
              < 0 - if this string is less than the string argument
              > 0 - if this string is greater than the string argument
  */
  SAL_DEPRECATED(__attribute__((deprecated("replace s1.compareToAscii(s2, strlen(s2)) == 0 with s1.startsWith(s2)"
)))
      "replace s1.compareToAscii(s2, strlen(s2)) == 0 with s1.startsWith(s2)")__attribute__((deprecated("replace s1.compareToAscii(s2, strlen(s2)) == 0 with s1.startsWith(s2)"
)))
  sal_Int32 compareToAscii( const char * asciiStr, sal_Int32 maxLength ) const
  {
      return rtl_ustr_ascii_shortenedCompare_WithLength( pData->buffer, pData->length,
                                                         asciiStr, maxLength );
  }

  /**
    Compares two strings in reverse order.

    This could be useful, if normally both strings start with the same
    content. The comparison is based on the numeric value of each character
    in the strings and return a value indicating their relationship.
    Since this method is optimized for performance, the ASCII character
    values are not converted in any way. The caller has to make sure that
    all ASCII characters are in the allowed range between 0 and 127.
    The ASCII string must be NULL-terminated and must be greater than
    or equal to asciiStrLength.
    This function can't be used for language specific sorting.

    @param    asciiStr        the 8-Bit ASCII character string to be compared.
    @param    asciiStrLength  the length of the ascii string
    @return   0 - if both strings are equal
              < 0 - if this string is less than the string argument
              > 0 - if this string is greater than the string argument
  */
  sal_Int32 reverseCompareToAsciiL( const char * asciiStr, sal_Int32 asciiStrLength ) const
  {
      return rtl_ustr_asciil_reverseCompare_WithLength( pData->buffer, pData->length,
                                                        asciiStr, asciiStrLength );
  }

  /**
    Perform a comparison of two strings.

    The result is true if and only if second string
    represents the same sequence of characters as the first string.
    Since this method is optimized for performance, the ASCII character
    values are not converted in any way. The caller has to make sure that
    all ASCII characters are in the allowed range between 0 and 127.
    The ASCII string must be NULL-terminated.
    This function can't be used for language specific comparison.

    @param    asciiStr        the 8-Bit ASCII character string to be compared.
    @return   true if the strings are equal;
              false, otherwise.
  */
  bool equalsAscii( const char* asciiStr ) const
  {
      return rtl_ustr_ascii_compare_WithLength( pData->buffer, pData->length,
                                                asciiStr ) == 0;
  }

  /**
    Perform a comparison of two strings.

    The result is true if and only if second string
    represents the same sequence of characters as the first string.
    Since this method is optimized for performance, the ASCII character
    values are not converted in any way. The caller has to make sure that
    all ASCII characters are in the allowed range between 0 and 127.
    The ASCII string must be NULL-terminated and must be greater than
    or equal to asciiStrLength.
    This function can't be used for language specific comparison.

    @param    asciiStr         the 8-Bit ASCII character string to be compared.
    @param    asciiStrLength   the length of the ascii string
    @return   true if the strings are equal;
              false, otherwise.
  */
  bool equalsAsciiL( const char* asciiStr, sal_Int32 asciiStrLength ) const
  {
      if ( pData->length != asciiStrLength35.1
'asciiStrLength' is not equal to field 'length'
1
'asciiStrLength' is not equal to field 'length'
1
'asciiStrLength' is not equal to field 'length'
1
'asciiStrLength' is not equal to field 'length'
 )
14
←
Assuming 'asciiStrLength' is not equal to field 'length'→
15
←
Taking true branch→
25
←
Assuming 'asciiStrLength' is not equal to field 'length'→
26
←
Taking true branch→
36
←
Taking true branch→
46
←
Assuming 'asciiStrLength' is not equal to field 'length'→
47
←
Taking true branch→
57
←
Assuming 'asciiStrLength' is equal to field 'length'→
58
←
Taking false branch→
          return false;
16
←
Returning zero, which participates in a condition later→
27
←
Returning zero, which participates in a condition later→
37
←
Returning zero, which participates in a condition later→
48
←
Returning zero, which participates in a condition later→

      return rtl_ustr_asciil_reverseEquals_WithLength(
59
←
Returning value, which participates in a condition later→
                  pData->buffer, asciiStr, asciiStrLength );
  }

  /**
    Perform an ASCII lowercase comparison of two strings.

    The result is true if and only if second string
    represents the same sequence of characters as the first string,
    ignoring the case.
    Character values between 65 and 90 (ASCII A-Z) are interpreted as
    values between 97 and 122 (ASCII a-z).
    Since this method is optimized for performance, the ASCII character
    values are not converted in any way. The caller has to make sure that
    all ASCII characters are in the allowed range between 0 and 127.
    The ASCII string must be NULL-terminated.
    This function can't be used for language specific comparison.

    @param    asciiStr        the 8-Bit ASCII character string to be compared.
    @return   true if the strings are equal;
              false, otherwise.
  */
  bool equalsIgnoreAsciiCaseAscii( const char * asciiStr ) const
  {
      return rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length, asciiStr ) == 0;
  }

  /**
    Compares two ASCII strings ignoring case

    The comparison is based on the numeric value of each character in
    the strings and return a value indicating their relationship.
    Since this method is optimized for performance, the ASCII character
    values are not converted in any way. The caller has to make sure that
    all ASCII characters are in the allowed range between 0 and 127.
    The ASCII string must be NULL-terminated.
    This function can't be used for language specific sorting.

    @param  asciiStr      the 8-Bit ASCII character string to be compared.
    @return   0 - if both strings are equal
              < 0 - if this string is less than the string argument
              > 0 - if this string is greater than the string argument

    @since LibreOffice 3.5
  */
  sal_Int32 compareToIgnoreAsciiCaseAscii( const char * asciiStr ) const
  {
      return rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length, asciiStr );
  }

  /**
    Perform an ASCII lowercase comparison of two strings.

    The result is true if and only if second string
    represents the same sequence of characters as the first string,
    ignoring the case.
    Character values between 65 and 90 (ASCII A-Z) are interpreted as
    values between 97 and 122 (ASCII a-z).
    Since this method is optimized for performance, the ASCII character
    values are not converted in any way. The caller has to make sure that
    all ASCII characters are in the allowed range between 0 and 127.
    The ASCII string must be NULL-terminated and must be greater than
    or equal to asciiStrLength.
    This function can't be used for language specific comparison.

    @param    asciiStr        the 8-Bit ASCII character string to be compared.
    @param    asciiStrLength  the length of the ascii string
    @return   true if the strings are equal;
              false, otherwise.
  */
  bool equalsIgnoreAsciiCaseAsciiL( const char * asciiStr, sal_Int32 asciiStrLength ) const
  {
      if ( pData->length != asciiStrLength )
          return false;

      return rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length, asciiStr ) == 0;
  }

  /**
    Match against a substring appearing in this string.

    The result is true if and only if the second string appears as a substring
    of this string, at the given position.
    Since this method is optimized for performance, the ASCII character
    values are not converted in any way. The caller has to make sure that
    all ASCII characters are in the allowed range between 0 and 127.
    The ASCII string must be NULL-terminated and must be greater than or
    equal to asciiStrLength.
    This function can't be used for language specific comparison.

    @param    asciiStr    the object (substring) to be compared.
    @param    asciiStrLength the length of asciiStr.
    @param    fromIndex   the index to start the comparison from.
                          The index must be greater than or equal to 0
                          and less than or equal to the string length.
    @return   true if str match with the characters in the string
              at the given position;
              false, otherwise.
  */
  bool matchAsciiL( const char* asciiStr, sal_Int32 asciiStrLength, sal_Int32 fromIndex = 0 ) const
  {
      return rtl_ustr_ascii_shortenedCompare_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
                                                         asciiStr, asciiStrLength ) == 0;
  }

  // This overload is left undefined, to detect calls of matchAsciiL that
  // erroneously use RTL_CONSTASCII_USTRINGPARAM instead of
  // RTL_CONSTASCII_STRINGPARAM (but would lead to ambiguities on 32 bit
  // platforms):
1305#if SAL_TYPES_SIZEOFLONG8 == 8
  void matchAsciiL(char const *, sal_Int32, rtl_TextEncoding) const;
1307#endif

  /**
    Match against a substring appearing in this string, ignoring the case of
    ASCII letters.

    The result is true if and only if the second string appears as a substring
    of this string, at the given position.
    Character values between 65 and 90 (ASCII A-Z) are interpreted as
    values between 97 and 122 (ASCII a-z).
    Since this method is optimized for performance, the ASCII character
    values are not converted in any way. The caller has to make sure that
    all ASCII characters are in the allowed range between 0 and 127.
    The ASCII string must be NULL-terminated and must be greater than or
    equal to asciiStrLength.
    This function can't be used for language specific comparison.

    @param    asciiStr        the 8-Bit ASCII character string to be compared.
    @param    asciiStrLength  the length of the ascii string
    @param    fromIndex       the index to start the comparison from.
                              The index must be greater than or equal to 0
                              and less than or equal to the string length.
    @return   true if str match with the characters in the string
              at the given position;
              false, otherwise.
  */
  bool matchIgnoreAsciiCaseAsciiL( const char* asciiStr, sal_Int32 asciiStrLength, sal_Int32 fromIndex = 0 ) const
  {
      return rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
                                                                        asciiStr, asciiStrLength ) == 0;
  }

  // This overload is left undefined, to detect calls of
  // matchIgnoreAsciiCaseAsciiL that erroneously use
  // RTL_CONSTASCII_USTRINGPARAM instead of RTL_CONSTASCII_STRINGPARAM (but
  // would lead to ambiguities on 32 bit platforms):
1343#if SAL_TYPES_SIZEOFLONG8 == 8
  void matchIgnoreAsciiCaseAsciiL(char const *, sal_Int32, rtl_TextEncoding)
      const;
1346#endif

  /**
    Check whether this string starts with a given substring.

    @param str the substring to be compared

    @param rest if non-null, and this function returns true, then assign a
    copy of the remainder of this string to *rest. Available since
    LibreOffice 4.2

    @return true if and only if the given str appears as a substring at the
    start of this string

    @since LibreOffice 4.0
  */
1362#if defined LIBO_INTERNAL_ONLY1
  bool startsWith(std::u16string_view sv, OUString * rest = nullptr) const {
      auto const b = match(sv);
      if (b && rest != nullptr) {
          *rest = copy(sv.size());
      }
      return b;
  }
1370#else
  bool startsWith(OUString const & str, OUString * rest = NULL__null) const {
      bool b = match(str);
      if (b && rest != NULL__null) {
          *rest = copy(str.getLength());
      }
      return b;
  }
1378#endif

  /**
   @overload
   This function accepts an ASCII string literal as its argument.
   @since LibreOffice 4.0
  */
  template< typename T >
  typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type startsWith(
      T & literal, OUString * rest = NULL__null) const
  {
      assert((static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 1390, __extension__ __PRETTY_FUNCTION__))
          libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 1390, __extension__ __PRETTY_FUNCTION__));
      bool b
          = (libreoffice_internal::ConstCharArrayDetector<T>::length
             <= sal_uInt32(pData->length))
          && rtl_ustr_asciil_reverseEquals_WithLength(
              pData->buffer,
              libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                  literal),
              libreoffice_internal::ConstCharArrayDetector<T>::length);
      if (b && rest != NULL__null) {
          *rest = copy(
              libreoffice_internal::ConstCharArrayDetector<T>::length);
      }
      return b;
  }

  /**
    Check whether this string starts with a given string, ignoring the case of
    ASCII letters.

    Character values between 65 and 90 (ASCII A-Z) are interpreted as
    values between 97 and 122 (ASCII a-z).
    This function can't be used for language specific comparison.

    @param str the substring to be compared

    @param rest if non-null, and this function returns true, then assign a
    copy of the remainder of this string to *rest. Available since
    LibreOffice 4.2

    @return true if and only if the given str appears as a substring at the
    start of this string, ignoring the case of ASCII letters ("A"--"Z" and
    "a"--"z")

    @since LibreOffice 4.0
  */
1426#if defined LIBO_INTERNAL_ONLY1
  bool startsWithIgnoreAsciiCase(std::u16string_view sv, OUString * rest = nullptr) const {
      auto const b = matchIgnoreAsciiCase(sv);
      if (b && rest != nullptr) {
          *rest = copy(sv.size());
      }
      return b;
  }
1434#else
  bool startsWithIgnoreAsciiCase(OUString const & str, OUString * rest = NULL__null)
      const
  {
      bool b = matchIgnoreAsciiCase(str);
      if (b && rest != NULL__null) {
          *rest = copy(str.getLength());
      }
      return b;
  }
1444#endif

  /**
   @overload
   This function accepts an ASCII string literal as its argument.
   @since LibreOffice 4.0
  */
  template< typename T >
  typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type
  startsWithIgnoreAsciiCase(T & literal, OUString * rest = NULL__null) const
  {
      assert((static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 1456, __extension__ __PRETTY_FUNCTION__))
          libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 1456, __extension__ __PRETTY_FUNCTION__));
      bool b
          = (rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths(
                 pData->buffer,
                 libreoffice_internal::ConstCharArrayDetector<T>::length,
                 libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                     literal),
                 libreoffice_internal::ConstCharArrayDetector<T>::length)
             == 0);
      if (b && rest != NULL__null) {
          *rest = copy(
              libreoffice_internal::ConstCharArrayDetector<T>::length);
      }
      return b;
  }

  /**
    Check whether this string ends with a given substring.

    @param str the substring to be compared

    @param rest if non-null, and this function returns true, then assign a
    copy of the remainder of this string to *rest. Available since
    LibreOffice 4.2

    @return true if and only if the given str appears as a substring at the
    end of this string

    @since LibreOffice 3.6
  */
1486#if defined LIBO_INTERNAL_ONLY1
  bool endsWith(std::u16string_view sv, OUString * rest = nullptr) const {
      auto const b = sv.size() <= sal_uInt32(pData->length)
          && match(sv, pData->length - sv.size());
      if (b && rest != nullptr) {
          *rest = copy(0, (pData->length - sv.size()));
      }
      return b;
  }
1495#else
  bool endsWith(OUString const & str, OUString * rest = NULL__null) const {
      bool b = str.getLength() <= getLength()
          && match(str, getLength() - str.getLength());
      if (b && rest != NULL__null) {
          *rest = copy(0, getLength() - str.getLength());
      }
      return b;
  }
1504#endif

  /**
   @overload
   This function accepts an ASCII string literal as its argument.
   @since LibreOffice 3.6
  */
  template< typename T >
  typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type
  endsWith(T & literal, OUString * rest = NULL__null) const
  {
      assert((static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 1516, __extension__ __PRETTY_FUNCTION__))
          libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 1516, __extension__ __PRETTY_FUNCTION__));
      bool b
          = (libreoffice_internal::ConstCharArrayDetector<T>::length
             <= sal_uInt32(pData->length))
          && rtl_ustr_asciil_reverseEquals_WithLength(
              (pData->buffer + pData->length
               - libreoffice_internal::ConstCharArrayDetector<T>::length),
              libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                  literal),
              libreoffice_internal::ConstCharArrayDetector<T>::length);
      if (b && rest != NULL__null) {
          *rest = copy(
              0,
              (getLength()
               - libreoffice_internal::ConstCharArrayDetector<T>::length));
      }
      return b;
  }

  /**
    Check whether this string ends with a given ASCII string.

    @param asciiStr a sequence of at least asciiStrLength ASCII characters
        (bytes in the range 0x00--0x7F)
    @param asciiStrLength the length of asciiStr; must be non-negative
    @return true if this string ends with asciiStr; otherwise, false is
    returned

    @since UDK 3.2.7
   */
  bool endsWithAsciiL(char const * asciiStr, sal_Int32 asciiStrLength)
      const
  {
      return asciiStrLength <= pData->length
          && rtl_ustr_asciil_reverseEquals_WithLength(
              pData->buffer + pData->length - asciiStrLength, asciiStr,
              asciiStrLength);
  }

  /**
    Check whether this string ends with a given string, ignoring the case of
    ASCII letters.

    Character values between 65 and 90 (ASCII A-Z) are interpreted as
    values between 97 and 122 (ASCII a-z).
    This function can't be used for language specific comparison.

    @param str the substring to be compared

    @param rest if non-null, and this function returns true, then assign a
    copy of the remainder of this string to *rest. Available since
    LibreOffice 4.2

    @return true if and only if the given str appears as a substring at the
    end of this string, ignoring the case of ASCII letters ("A"--"Z" and
    "a"--"z")

    @since LibreOffice 3.6
  */
1575#if defined LIBO_INTERNAL_ONLY1
  bool endsWithIgnoreAsciiCase(std::u16string_view sv, OUString * rest = nullptr) const {
      auto const b = sv.size() <= sal_uInt32(pData->length)
          && matchIgnoreAsciiCase(sv, pData->length - sv.size());
      if (b && rest != nullptr) {
          *rest = copy(0, pData->length - sv.size());
      }
      return b;
  }
1584#else
  bool endsWithIgnoreAsciiCase(OUString const & str, OUString * rest = NULL__null) const
  {
      bool b =  str.getLength() <= getLength()
          && matchIgnoreAsciiCase(str, getLength() - str.getLength());
      if (b && rest != NULL__null) {
          *rest = copy(0, getLength() - str.getLength());
      }
      return b;
  }
1594#endif

  /**
   @overload
   This function accepts an ASCII string literal as its argument.
   @since LibreOffice 3.6
  */
  template< typename T >
  typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type
  endsWithIgnoreAsciiCase(T & literal, OUString * rest = NULL__null) const
  {
      assert((static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 1606, __extension__ __PRETTY_FUNCTION__))
          libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 1606, __extension__ __PRETTY_FUNCTION__));
      bool b
          = (libreoffice_internal::ConstCharArrayDetector<T>::length
             <= sal_uInt32(pData->length))
          && (rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths(
                  (pData->buffer + pData->length
                   - libreoffice_internal::ConstCharArrayDetector<T>::length),
                  libreoffice_internal::ConstCharArrayDetector<T>::length,
                  libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                      literal),
                  libreoffice_internal::ConstCharArrayDetector<T>::length)
              == 0);
      if (b && rest != NULL__null) {
          *rest = copy(
              0,
              (getLength()
               - libreoffice_internal::ConstCharArrayDetector<T>::length));
      }
      return b;
  }

  /**
    Check whether this string ends with a given ASCII string, ignoring the
    case of ASCII letters.

    @param asciiStr a sequence of at least asciiStrLength ASCII characters
        (bytes in the range 0x00--0x7F)
    @param asciiStrLength the length of asciiStr; must be non-negative
    @return true if this string ends with asciiStr, ignoring the case of ASCII
    letters ("A"--"Z" and "a"--"z"); otherwise, false is returned
   */
  bool endsWithIgnoreAsciiCaseAsciiL(
      char const * asciiStr, sal_Int32 asciiStrLength) const
  {
      return asciiStrLength <= pData->length
          && (rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths(
                  pData->buffer + pData->length - asciiStrLength,
                  asciiStrLength, asciiStr, asciiStrLength)
              == 0);
  }

  friend bool     operator == ( const OUString& rStr1,    const OUString& rStr2 )
                      { return rStr1.equals(rStr2); }

  friend bool     operator != ( const OUString& rStr1,        const OUString& rStr2 )
                      { return !(operator == ( rStr1, rStr2 )); }

  friend bool     operator <  ( const OUString& rStr1,    const OUString& rStr2 )
                      { return rStr1.compareTo( rStr2 ) < 0; }
  friend bool     operator >  ( const OUString& rStr1,    const OUString& rStr2 )
                      { return rStr1.compareTo( rStr2 ) > 0; }
  friend bool     operator <= ( const OUString& rStr1,    const OUString& rStr2 )
                      { return rStr1.compareTo( rStr2 ) <= 0; }
  friend bool     operator >= ( const OUString& rStr1,    const OUString& rStr2 )
                      { return rStr1.compareTo( rStr2 ) >= 0; }

1662#if defined LIBO_INTERNAL_ONLY1

  template<typename T> friend typename libreoffice_internal::CharPtrDetector<T, bool>::TypeUtf16
  operator ==(OUString const & s1, T const & s2) {
      return rtl_ustr_compare_WithLength(s1.getStr(), s1.getLength(), s2, rtl_ustr_getLength(s2))
          == 0;
  }

  template<typename T>
  friend typename libreoffice_internal::NonConstCharArrayDetector<T, bool>::TypeUtf16
  operator ==(OUString const & s1, T & s2) {
      return rtl_ustr_compare_WithLength(s1.getStr(), s1.getLength(), s2, rtl_ustr_getLength(s2))
          == 0;
  }

  template<typename T> friend typename libreoffice_internal::CharPtrDetector<T, bool>::TypeUtf16
  operator ==(T const & s1, OUString const & s2) {
      return rtl_ustr_compare_WithLength(s1, rtl_ustr_getLength(s1), s2.getStr(), s2.getLength())
          == 0;
  }

  template<typename T>
  friend typename libreoffice_internal::NonConstCharArrayDetector<T, bool>::TypeUtf16
  operator ==(T & s1, OUString const & s2) {
      return rtl_ustr_compare_WithLength(s1, rtl_ustr_getLength(s1), s2.getStr(), s2.getLength())
          == 0;
  }

  template<typename T> friend typename libreoffice_internal::CharPtrDetector<T, bool>::TypeUtf16
  operator !=(OUString const & s1, T const & s2) { return !(s1 == s2); }

  template<typename T>
  friend typename libreoffice_internal::NonConstCharArrayDetector<T, bool>::TypeUtf16
  operator !=(OUString const & s1, T & s2) { return !(s1 == s2); }

  template<typename T> friend typename libreoffice_internal::CharPtrDetector<T, bool>::TypeUtf16
  operator !=(T const & s1, OUString const & s2) { return !(s1 == s2); }

  template<typename T>
  friend typename libreoffice_internal::NonConstCharArrayDetector<T, bool>::TypeUtf16
  operator !=(T & s1, OUString const & s2) { return !(s1 == s2); }

1704#else

  friend bool     operator == ( const OUString& rStr1,    const sal_Unicode * pStr2 )
                      { return rStr1.compareTo( pStr2 ) == 0; }
  friend bool     operator == ( const sal_Unicode * pStr1,    const OUString& rStr2 )
                      { return OUString( pStr1 ).compareTo( rStr2 ) == 0; }

  friend bool     operator != ( const OUString& rStr1,    const sal_Unicode * pStr2 )
                      { return !(operator == ( rStr1, pStr2 )); }
  friend bool     operator != ( const sal_Unicode * pStr1,    const OUString& rStr2 )
                      { return !(operator == ( pStr1, rStr2 )); }

1716#endif

  /**
   * Compare string to an ASCII string literal.
   *
   * This operator is equal to calling equalsAsciiL().
   *
   * @since LibreOffice 3.6
   */
  template< typename T >
  friend typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type operator==( const OUString& rString, T& literal )
  {
      assert((static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 1729, __extension__ __PRETTY_FUNCTION__))
11
←
Assuming the condition is true→
12
←
'?' condition is true→
22
←
Assuming the condition is true→
23
←
'?' condition is true→
33
←
Assuming the condition is true→
34
←
'?' condition is true→
43
←
Assuming the condition is true→
44
←
'?' condition is true→
54
←
Assuming the condition is true→
55
←
'?' condition is true→
          libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 1729, __extension__ __PRETTY_FUNCTION__));
      return rString.equalsAsciiL(
13
←
Calling 'OUString::equalsAsciiL'→
17
←
Returning from 'OUString::equalsAsciiL'→
18
←
Returning zero, which participates in a condition later→
24
←
Calling 'OUString::equalsAsciiL'→
28
←
Returning from 'OUString::equalsAsciiL'→
29
←
Returning zero, which participates in a condition later→
35
←
Calling 'OUString::equalsAsciiL'→
38
←
Returning from 'OUString::equalsAsciiL'→
39
←
Returning zero, which participates in a condition later→
45
←
Calling 'OUString::equalsAsciiL'→
49
←
Returning from 'OUString::equalsAsciiL'→
50
←
Returning zero, which participates in a condition later→
56
←
Calling 'OUString::equalsAsciiL'→
60
←
Returning from 'OUString::equalsAsciiL'→
61
←
Returning value, which participates in a condition later→
          libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
          libreoffice_internal::ConstCharArrayDetector<T>::length);
  }
  /**
   * Compare string to an ASCII string literal.
   *
   * This operator is equal to calling equalsAsciiL().
   *
   * @since LibreOffice 3.6
   */
  template< typename T >
  friend typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type operator==( T& literal, const OUString& rString )
  {
      assert((static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 1745, __extension__ __PRETTY_FUNCTION__))
          libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 1745, __extension__ __PRETTY_FUNCTION__));
      return rString.equalsAsciiL(
          libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
          libreoffice_internal::ConstCharArrayDetector<T>::length);
  }
  /**
   * Compare string to an ASCII string literal.
   *
   * This operator is equal to calling !equalsAsciiL().
   *
   * @since LibreOffice 3.6
   */
  template< typename T >
  friend typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type operator!=( const OUString& rString, T& literal )
  {
      assert((static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 1761, __extension__ __PRETTY_FUNCTION__))
          libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 1761, __extension__ __PRETTY_FUNCTION__));
      return !rString.equalsAsciiL(
          libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
          libreoffice_internal::ConstCharArrayDetector<T>::length);
  }
  /**
   * Compare string to an ASCII string literal.
   *
   * This operator is equal to calling !equalsAsciiL().
   *
   * @since LibreOffice 3.6
   */
  template< typename T >
  friend typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type operator!=( T& literal, const OUString& rString )
  {
      assert((static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 1777, __extension__ __PRETTY_FUNCTION__))
          libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 1777, __extension__ __PRETTY_FUNCTION__));
      return !rString.equalsAsciiL(
          libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
          libreoffice_internal::ConstCharArrayDetector<T>::length);
  }

1783#if defined LIBO_INTERNAL_ONLY1
  /** @overload @since LibreOffice 5.3 */
  template<typename T> friend typename libreoffice_internal::ConstCharArrayDetector<T, bool>::TypeUtf16
  operator ==(OUString const & string, T & literal) {
      return
          rtl_ustr_reverseCompare_WithLength(
              string.pData->buffer, string.pData->length,
              libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                  literal),
              libreoffice_internal::ConstCharArrayDetector<T>::length)
          == 0;
  }
  /** @overload @since LibreOffice 5.3 */
  template<typename T> friend typename libreoffice_internal::ConstCharArrayDetector<T, bool>::TypeUtf16
  operator ==(T & literal, OUString const & string) {
      return
          rtl_ustr_reverseCompare_WithLength(
              libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                  literal),
              libreoffice_internal::ConstCharArrayDetector<T>::length,
              string.pData->buffer, string.pData->length)
          == 0;
  }
  /** @overload @since LibreOffice 5.3 */
  template<typename T> friend typename libreoffice_internal::ConstCharArrayDetector<T, bool>::TypeUtf16
  operator !=(OUString const & string, T & literal) {
      return
          rtl_ustr_reverseCompare_WithLength(
              string.pData->buffer, string.pData->length,
              libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                  literal),
              libreoffice_internal::ConstCharArrayDetector<T>::length)
          != 0;
  }
  /** @overload @since LibreOffice 5.3 */
  template<typename T> friend typename libreoffice_internal::ConstCharArrayDetector<T, bool>::TypeUtf16
  operator !=(T & literal, OUString const & string) {
      return
          rtl_ustr_reverseCompare_WithLength(
              libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                  literal),
              libreoffice_internal::ConstCharArrayDetector<T>::length,
              string.pData->buffer, string.pData->length)
          != 0;
  }
1828#endif

1830#if defined LIBO_INTERNAL_ONLY1
  /// @cond INTERNAL

  /* Comparison between OUString and OUStringLiteral.

     @since LibreOffice 5.0
  */

  template<std::size_t N>
  friend bool operator ==(OUString const & lhs, OUStringLiteral<N> const & rhs) {
      return
          rtl_ustr_reverseCompare_WithLength(
              lhs.pData->buffer, lhs.pData->length, rhs.getStr(), rhs.getLength())
          == 0;
  }

  template<std::size_t N>
  friend bool operator !=(OUString const & lhs, OUStringLiteral<N> const & rhs) {
      return
          rtl_ustr_reverseCompare_WithLength(
              lhs.pData->buffer, lhs.pData->length, rhs.getStr(), rhs.getLength())
          != 0;
  }

  template<std::size_t N>
  friend bool operator <(OUString const & lhs, OUStringLiteral<N> const & rhs) {
      return
          (rtl_ustr_compare_WithLength(
              lhs.pData->buffer, lhs.pData->length, rhs.getStr(), rhs.getLength()))
          < 0;
  }

  template<std::size_t N>
  friend bool operator <=(OUString const & lhs, OUStringLiteral<N> const & rhs) {
      return
          (rtl_ustr_compare_WithLength(
              lhs.pData->buffer, lhs.pData->length, rhs.getStr(), rhs.getLength()))
          <= 0;
  }

  template<std::size_t N>
  friend bool operator >(OUString const & lhs, OUStringLiteral<N> const & rhs) {
      return
          (rtl_ustr_compare_WithLength(
              lhs.pData->buffer, lhs.pData->length, rhs.getStr(), rhs.getLength()))
          > 0;
  }

  template<std::size_t N>
  friend bool operator >=(OUString const & lhs, OUStringLiteral<N> const & rhs) {
      return
          (rtl_ustr_compare_WithLength(
              lhs.pData->buffer, lhs.pData->length, rhs.getStr(), rhs.getLength()))
          >= 0;
  }

  template<std::size_t N>
  friend bool operator ==(OUStringLiteral<N> const & lhs, OUString const & rhs) {
      return
          rtl_ustr_reverseCompare_WithLength(
              lhs.getStr(), lhs.getLength(), rhs.pData->buffer, rhs.pData->length)
          == 0;
  }

  template<std::size_t N>
  friend bool operator !=(OUStringLiteral<N> const & lhs, OUString const & rhs) {
      return
          rtl_ustr_reverseCompare_WithLength(
              lhs.getStr(), lhs.getLength(), rhs.pData->buffer, rhs.pData->length)
          != 0;
  }

  template<std::size_t N>
  friend bool operator <(OUStringLiteral<N> const & lhs, OUString const & rhs) {
      return
          (rtl_ustr_compare_WithLength(
              lhs.getStr(), lhs.getLength(), rhs.pData->buffer, rhs.pData->length))
          < 0;
  }

  template<std::size_t N>
  friend bool operator <=(OUStringLiteral<N> const & lhs, OUString const & rhs) {
      return
          (rtl_ustr_compare_WithLength(
              lhs.getStr(), lhs.getLength(), rhs.pData->buffer, rhs.pData->length))
          <= 0;
  }

  template<std::size_t N>
  friend bool operator >(OUStringLiteral<N> const & lhs, OUString const & rhs) {
      return
          (rtl_ustr_compare_WithLength(
              lhs.getStr(), lhs.getLength(), rhs.pData->buffer, rhs.pData->length))
          > 0;
  }

  template<std::size_t N>
  friend bool operator >=(OUStringLiteral<N> const & lhs, OUString const & rhs) {
      return
          (rtl_ustr_compare_WithLength(
              lhs.getStr(), lhs.getLength(), rhs.pData->buffer, rhs.pData->length))
          >= 0;
  }

  /// @endcond
1935#endif

1937#if defined LIBO_INTERNAL_ONLY1
  friend bool operator ==(OUString const & lhs, std::u16string_view rhs) {
      return
          rtl_ustr_reverseCompare_WithLength(
              lhs.pData->buffer, lhs.pData->length, rhs.data(), rhs.size())
          == 0;
  }

  friend bool operator !=(OUString const & lhs, std::u16string_view rhs) {
      return
          rtl_ustr_reverseCompare_WithLength(
              lhs.pData->buffer, lhs.pData->length, rhs.data(), rhs.size())
          != 0;
  }

  friend bool operator <(OUString const & lhs, std::u16string_view rhs) {
      return
          (rtl_ustr_compare_WithLength(
              lhs.pData->buffer, lhs.pData->length, rhs.data(), rhs.size()))
          < 0;
  }

  friend bool operator <=(OUString const & lhs, std::u16string_view rhs) {
      return
          (rtl_ustr_compare_WithLength(
              lhs.pData->buffer, lhs.pData->length, rhs.data(), rhs.size()))
          <= 0;
  }

  friend bool operator >(OUString const & lhs, std::u16string_view rhs) {
      return
          (rtl_ustr_compare_WithLength(
              lhs.pData->buffer, lhs.pData->length, rhs.data(), rhs.size()))
          > 0;
  }

  friend bool operator >=(OUString const & lhs, std::u16string_view rhs) {
      return
          (rtl_ustr_compare_WithLength(
              lhs.pData->buffer, lhs.pData->length, rhs.data(), rhs.size()))
          >= 0;
  }

  friend bool operator ==(std::u16string_view lhs, OUString const & rhs) {
      return
          rtl_ustr_reverseCompare_WithLength(
              lhs.data(), lhs.size(), rhs.pData->buffer, rhs.pData->length)
          == 0;
  }

  friend bool operator !=(std::u16string_view lhs, OUString const & rhs) {
      return
          rtl_ustr_reverseCompare_WithLength(
              lhs.data(), lhs.size(), rhs.pData->buffer, rhs.pData->length)
          != 0;
  }

  friend bool operator <(std::u16string_view lhs, OUString const & rhs) {
      return
          (rtl_ustr_compare_WithLength(
              lhs.data(), lhs.size(), rhs.pData->buffer, rhs.pData->length))
          < 0;
  }

  friend bool operator <=(std::u16string_view lhs, OUString const & rhs) {
      return
          (rtl_ustr_compare_WithLength(
              lhs.data(), lhs.size(), rhs.pData->buffer, rhs.pData->length))
          <= 0;
  }

  friend bool operator >(std::u16string_view lhs, OUString const & rhs) {
      return
          (rtl_ustr_compare_WithLength(
              lhs.data(), lhs.size(), rhs.pData->buffer, rhs.pData->length))
          > 0;
  }

  friend bool operator >=(std::u16string_view lhs, OUString const & rhs) {
      return
          (rtl_ustr_compare_WithLength(
              lhs.data(), lhs.size(), rhs.pData->buffer, rhs.pData->length))
          >= 0;
  }
2021#endif

  /**
    Returns a hashcode for this string.

    @return   a hash code value for this object.

    @see rtl::OUStringHash for convenient use of std::unordered_map
  */
  sal_Int32 hashCode() const
  {
      return rtl_ustr_hashCode_WithLength( pData->buffer, pData->length );
  }

  /**
    Returns the index within this string of the first occurrence of the
    specified character, starting the search at the specified index.

    @param    ch          character to be located.
    @param    fromIndex   the index to start the search from.
                          The index must be greater than or equal to 0
                          and less than or equal to the string length.
    @return   the index of the first occurrence of the character in the
              character sequence represented by this string that is
              greater than or equal to fromIndex, or
              -1 if the character does not occur.
  */
  sal_Int32 indexOf( sal_Unicode ch, sal_Int32 fromIndex = 0 ) const
  {
      sal_Int32 ret = rtl_ustr_indexOfChar_WithLength( pData->buffer+fromIndex, pData->length-fromIndex, ch );
      return (ret < 0 ? ret : ret+fromIndex);
  }

  /**
    Returns the index within this string of the last occurrence of the
    specified character, searching backward starting at the end.

    @param    ch          character to be located.
    @return   the index of the last occurrence of the character in the
              character sequence represented by this string, or
              -1 if the character does not occur.
  */
  sal_Int32 lastIndexOf( sal_Unicode ch ) const
  {
      return rtl_ustr_lastIndexOfChar_WithLength( pData->buffer, pData->length, ch );
  }

  /**
    Returns the index within this string of the last occurrence of the
    specified character, searching backward starting before the specified
    index.

    @param    ch          character to be located.
    @param    fromIndex   the index before which to start the search.
    @return   the index of the last occurrence of the character in the
              character sequence represented by this string that
              is less than fromIndex, or -1
              if the character does not occur before that point.
  */
  sal_Int32 lastIndexOf( sal_Unicode ch, sal_Int32 fromIndex ) const
  {
      return rtl_ustr_lastIndexOfChar_WithLength( pData->buffer, fromIndex, ch );
  }

  /**
    Returns the index within this string of the first occurrence of the
    specified substring, starting at the specified index.

    If str doesn't include any character, always -1 is
    returned. This is also the case, if both strings are empty.

    @param    str         the substring to search for.
    @param    fromIndex   the index to start the search from.
    @return   If the string argument occurs one or more times as a substring
              within this string at the starting index, then the index
              of the first character of the first such substring is
              returned. If it does not occur as a substring starting
              at fromIndex or beyond, -1 is returned.
  */
2100#if defined LIBO_INTERNAL_ONLY1
  sal_Int32 indexOf(std::u16string_view sv, sal_Int32 fromIndex = 0) const {
      auto const n = rtl_ustr_indexOfStr_WithLength(
          pData->buffer + fromIndex, pData->length - fromIndex, sv.data(), sv.size());
      return n < 0 ? n : n + fromIndex;
  }
2106#else
  sal_Int32 indexOf( const OUString & str, sal_Int32 fromIndex = 0 ) const
  {
      sal_Int32 ret = rtl_ustr_indexOfStr_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
                                                      str.pData->buffer, str.pData->length );
      return (ret < 0 ? ret : ret+fromIndex);
  }
2113#endif

  /**
   @overload
   This function accepts an ASCII string literal as its argument.
   @since LibreOffice 3.6
  */
  template< typename T >
  typename libreoffice_internal::ConstCharArrayDetector< T, sal_Int32 >::Type indexOf( T& literal, sal_Int32 fromIndex = 0 ) const
  {
      assert((static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 2124, __extension__ __PRETTY_FUNCTION__))
          libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 2124, __extension__ __PRETTY_FUNCTION__));
      sal_Int32 n = rtl_ustr_indexOfAscii_WithLength(
          pData->buffer + fromIndex, pData->length - fromIndex,
          libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
          libreoffice_internal::ConstCharArrayDetector<T>::length);
      return n < 0 ? n : n + fromIndex;
  }

  /**
     Returns the index within this string of the first occurrence of the
     specified ASCII substring, starting at the specified index.

     @param str
     the substring to be searched for.  Need not be null-terminated, but must
     be at least as long as the specified len.  Must only contain characters
     in the ASCII range 0x00--7F.

     @param len
     the length of the substring; must be non-negative.

     @param fromIndex
     the index to start the search from.  Must be in the range from zero to
     the length of this string, inclusive.

     @return
     the index (starting at 0) of the first character of the first occurrence
     of the substring within this string starting at the given fromIndex, or
     -1 if the substring does not occur.  If len is zero, -1 is returned.

     @since UDK 3.2.7
  */
  sal_Int32 indexOfAsciiL(
      char const * str, sal_Int32 len, sal_Int32 fromIndex = 0) const
  {
      sal_Int32 ret = rtl_ustr_indexOfAscii_WithLength(
          pData->buffer + fromIndex, pData->length - fromIndex, str, len);
      return ret < 0 ? ret : ret + fromIndex;
  }

  // This overload is left undefined, to detect calls of indexOfAsciiL that
  // erroneously use RTL_CONSTASCII_USTRINGPARAM instead of
  // RTL_CONSTASCII_STRINGPARAM (but would lead to ambiguities on 32 bit
  // platforms):
2167#if SAL_TYPES_SIZEOFLONG8 == 8
  void indexOfAsciiL(char const *, sal_Int32 len, rtl_TextEncoding) const;
2169#endif

  /**
    Returns the index within this string of the last occurrence of
    the specified substring, searching backward starting at the end.

    The returned index indicates the starting index of the substring
    in this string.
    If str doesn't include any character, always -1 is
    returned. This is also the case, if both strings are empty.

    @param    str         the substring to search for.
    @return   If the string argument occurs one or more times as a substring
              within this string, then the index of the first character of
              the last such substring is returned. If it does not occur as
              a substring, -1 is returned.
  */
2186#if defined LIBO_INTERNAL_ONLY1
  sal_Int32 lastIndexOf(std::u16string_view sv) const {
      return rtl_ustr_lastIndexOfStr_WithLength(
          pData->buffer, pData->length, sv.data(), sv.size());
  }
2191#else
  sal_Int32 lastIndexOf( const OUString & str ) const
  {
      return rtl_ustr_lastIndexOfStr_WithLength( pData->buffer, pData->length,
                                                 str.pData->buffer, str.pData->length );
  }
2197#endif

  /**
    Returns the index within this string of the last occurrence of
    the specified substring, searching backward starting before the specified
    index.

    The returned index indicates the starting index of the substring
    in this string.
    If str doesn't include any character, always -1 is
    returned. This is also the case, if both strings are empty.

    @param    str         the substring to search for.
    @param    fromIndex   the index before which to start the search.
    @return   If the string argument occurs one or more times as a substring
              within this string before the starting index, then the index
              of the first character of the last such substring is
              returned. Otherwise, -1 is returned.
  */
2216#if defined LIBO_INTERNAL_ONLY1
  sal_Int32 lastIndexOf(std::u16string_view sv, sal_Int32 fromIndex) const {
      return rtl_ustr_lastIndexOfStr_WithLength(pData->buffer, fromIndex, sv.data(), sv.size());
  }
2220#else
  sal_Int32 lastIndexOf( const OUString & str, sal_Int32 fromIndex ) const
  {
      return rtl_ustr_lastIndexOfStr_WithLength( pData->buffer, fromIndex,
                                                 str.pData->buffer, str.pData->length );
  }
2226#endif

  /**
   @overload
   This function accepts an ASCII string literal as its argument.
   @since LibreOffice 3.6
  */
  template< typename T >
  typename libreoffice_internal::ConstCharArrayDetector< T, sal_Int32 >::Type lastIndexOf( T& literal ) const
  {
      assert((static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 2237, __extension__ __PRETTY_FUNCTION__))
          libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(literal)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 2237, __extension__ __PRETTY_FUNCTION__));
      return rtl_ustr_lastIndexOfAscii_WithLength(
          pData->buffer, pData->length,
          libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
          libreoffice_internal::ConstCharArrayDetector<T>::length);
  }

  /**
     Returns the index within this string of the last occurrence of the
     specified ASCII substring.

     @param str
     the substring to be searched for.  Need not be null-terminated, but must
     be at least as long as the specified len.  Must only contain characters
     in the ASCII range 0x00--7F.

     @param len
     the length of the substring; must be non-negative.

     @return
     the index (starting at 0) of the first character of the last occurrence
     of the substring within this string, or -1 if the substring does not
     occur.  If len is zero, -1 is returned.

     @since UDK 3.2.7
  */
  sal_Int32 lastIndexOfAsciiL(char const * str, sal_Int32 len) const
  {
      return rtl_ustr_lastIndexOfAscii_WithLength(
          pData->buffer, pData->length, str, len);
  }

  /**
    Returns a new string that is a substring of this string.

    The substring begins at the specified beginIndex. If
    beginIndex is negative or be greater than the length of
    this string, behaviour is undefined.

    @param     beginIndex   the beginning index, inclusive.
    @return    the specified substring.
  */
  SAL_WARN_UNUSED_RESULT[[nodiscard]] OUString copy( sal_Int32 beginIndex ) const
  {
      return copy(beginIndex, getLength() - beginIndex);
  }

  /**
    Returns a new string that is a substring of this string.

    The substring begins at the specified beginIndex and contains count
    characters.  If either beginIndex or count are negative,
    or beginIndex + count are greater than the length of this string
    then behaviour is undefined.

    @param     beginIndex   the beginning index, inclusive.
    @param     count        the number of characters.
    @return    the specified substring.
  */
  SAL_WARN_UNUSED_RESULT[[nodiscard]] OUString copy( sal_Int32 beginIndex, sal_Int32 count ) const
  {
      rtl_uString *pNew = NULL__null;
      rtl_uString_newFromSubString( &pNew, pData, beginIndex, count );
      return OUString( pNew, SAL_NO_ACQUIRE );
  }

  /**
    Concatenates the specified string to the end of this string.

    @param    str   the string that is concatenated to the end
                    of this string.
    @return   a string that represents the concatenation of this string
              followed by the string argument.
  */
  SAL_WARN_UNUSED_RESULT[[nodiscard]] OUString concat( const OUString & str ) const
  {
      rtl_uString* pNew = NULL__null;
      rtl_uString_newConcat( &pNew, pData, str.pData );
      return OUString( pNew, SAL_NO_ACQUIRE );
  }

2318#ifndef LIBO_INTERNAL_ONLY1 // "RTL_FAST_STRING"
  friend OUString operator+( const OUString& rStr1, const OUString& rStr2  )
  {
      return rStr1.concat( rStr2 );
  }
2323#endif

  /**
    Returns a new string resulting from replacing n = count characters
    from position index in this string with newStr.

    @param  index   the replacing index in str.
                    The index must be greater than or equal to 0 and
                    less than or equal to the length of the string.
    @param  count   the count of characters that will be replaced
                    The count must be greater than or equal to 0 and
                    less than or equal to the length of the string minus index.
    @param  newStr  the new substring.
    @return the new string.
  */
  SAL_WARN_UNUSED_RESULT[[nodiscard]] OUString replaceAt( sal_Int32 index, sal_Int32 count, const OUString& newStr ) const
  {
      rtl_uString* pNew = NULL__null;
      rtl_uString_newReplaceStrAt( &pNew, pData, index, count, newStr.pData );
      return OUString( pNew, SAL_NO_ACQUIRE );
  }

  /**
    Returns a new string resulting from replacing all occurrences of
    oldChar in this string with newChar.

    If the character oldChar does not occur in the character sequence
    represented by this object, then the string is assigned with
    str.

    @param    oldChar     the old character.
    @param    newChar     the new character.
    @return   a string derived from this string by replacing every
              occurrence of oldChar with newChar.
  */
  SAL_WARN_UNUSED_RESULT[[nodiscard]] OUString replace( sal_Unicode oldChar, sal_Unicode newChar ) const
  {
      rtl_uString* pNew = NULL__null;
      rtl_uString_newReplace( &pNew, pData, oldChar, newChar );
      return OUString( pNew, SAL_NO_ACQUIRE );
  }

  /**
    Returns a new string resulting from replacing the first occurrence of a
    given substring with another substring.

    @param from  the substring to be replaced

    @param to  the replacing substring

    @param[in,out] index  pointer to a start index; if the pointer is
    non-null: upon entry to the function, its value is the index into this
    string at which to start searching for the \p from substring, the value
    must be non-negative and not greater than this string's length; upon exiting
    the function its value is the index into this string at which the
    replacement took place or -1 if no replacement took place; if the pointer
    is null, searching always starts at index 0

    @since LibreOffice 3.6
  */
2383#if defined LIBO_INTERNAL_ONLY1
  [[nodiscard]] OUString replaceFirst(
      std::u16string_view from, std::u16string_view to, sal_Int32 * index = nullptr) const
  {
      rtl_uString * s = nullptr;
      sal_Int32 i = 0;
      rtl_uString_newReplaceFirstUtf16LUtf16L(
          &s, pData, from.data(), from.size(), to.data(), to.size(),
          index == nullptr ? &i : index);
      return OUString(s, SAL_NO_ACQUIRE);
  }
2394#else
  SAL_WARN_UNUSED_RESULT[[nodiscard]] OUString replaceFirst(
      OUString const & from, OUString const & to, sal_Int32 * index = NULL__null) const
  {
      rtl_uString * s = NULL__null;
      sal_Int32 i = 0;
      rtl_uString_newReplaceFirst(
          &s, pData, from.pData, to.pData, index == NULL__null ? &i : index);
      return OUString(s, SAL_NO_ACQUIRE);
  }
2404#endif

  /**
    Returns a new string resulting from replacing the first occurrence of a
    given substring with another substring.

    @param from  ASCII string literal, the substring to be replaced

    @param to  the replacing substring

    @param[in,out] index  pointer to a start index; if the pointer is
    non-null: upon entry to the function, its value is the index into the this
    string at which to start searching for the \p from substring, the value
    must be non-negative and not greater than this string's length; upon exiting
    the function its value is the index into this string at which the
    replacement took place or -1 if no replacement took place; if the pointer
    is null, searching always starts at index 0

    @since LibreOffice 3.6
  */
2424#if defined LIBO_INTERNAL_ONLY1
  template<typename T> [[nodiscard]]
  typename libreoffice_internal::ConstCharArrayDetector<T, OUString >::Type replaceFirst(
      T & from, std::u16string_view to, sal_Int32 * index = nullptr) const
  {
      assert(libreoffice_internal::ConstCharArrayDetector<T>::isValid(from))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(from)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(from)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 2429, __extension__ __PRETTY_FUNCTION__));
      rtl_uString * s = nullptr;
      sal_Int32 i = 0;
      rtl_uString_newReplaceFirstAsciiLUtf16L(
          &s, pData, libreoffice_internal::ConstCharArrayDetector<T>::toPointer(from),
          libreoffice_internal::ConstCharArrayDetector<T>::length, to.data(), to.size(),
          index == nullptr ? &i : index);
      return OUString(s, SAL_NO_ACQUIRE);
  }
2438#else
  template< typename T >
  SAL_WARN_UNUSED_RESULT[[nodiscard]] typename libreoffice_internal::ConstCharArrayDetector< T, OUString >::Type replaceFirst( T& from, OUString const & to,
                                                                                                      sal_Int32 * index = NULL__null) const
  {
      assert(libreoffice_internal::ConstCharArrayDetector<T>::isValid(from))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(from)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(from)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 2443, __extension__ __PRETTY_FUNCTION__));
      rtl_uString * s = NULL__null;
      sal_Int32 i = 0;
      rtl_uString_newReplaceFirstAsciiL(
          &s, pData,
          libreoffice_internal::ConstCharArrayDetector<T>::toPointer(from),
          libreoffice_internal::ConstCharArrayDetector<T>::length, to.pData,
          index == NULL__null ? &i : index);
      return OUString(s, SAL_NO_ACQUIRE);
  }
2453#endif

  /**
    Returns a new string resulting from replacing the first occurrence of a
    given substring with another substring.

    @param from  the substring to be replaced

    @param to  ASCII string literal, the replacing substring

    @param[in,out] index  pointer to a start index; if the pointer is
    non-null: upon entry to the function, its value is the index into the this
    string at which to start searching for the \p from substring, the value
    must be non-negative and not greater than this string's length; upon exiting
    the function its value is the index into this string at which the
    replacement took place or -1 if no replacement took place; if the pointer
    is null, searching always starts at index 0

    @since LibreOffice 5.1
  */
2473#if defined LIBO_INTERNAL_ONLY1
  template<typename T> [[nodiscard]]
  typename libreoffice_internal::ConstCharArrayDetector<T, OUString >::Type replaceFirst(
      std::u16string_view from, T & to, sal_Int32 * index = nullptr) const
  {
      assert(libreoffice_internal::ConstCharArrayDetector<T>::isValid(to))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(to)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(to)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 2478, __extension__ __PRETTY_FUNCTION__));
      rtl_uString * s = nullptr;
      sal_Int32 i = 0;
      rtl_uString_newReplaceFirstUtf16LAsciiL(
          &s, pData, from.data(), from.size(),
          libreoffice_internal::ConstCharArrayDetector<T>::toPointer(to),
          libreoffice_internal::ConstCharArrayDetector<T>::length, index == nullptr ? &i : index);
      return OUString(s, SAL_NO_ACQUIRE);
  }
2487#else
  template< typename T >
  SAL_WARN_UNUSED_RESULT[[nodiscard]] typename libreoffice_internal::ConstCharArrayDetector< T, OUString >::Type replaceFirst( OUString const & from, T& to,
                                                                                                      sal_Int32 * index = NULL__null) const
  {
      assert(libreoffice_internal::ConstCharArrayDetector<T>::isValid(to))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(to)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(to)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 2492, __extension__ __PRETTY_FUNCTION__));
      rtl_uString * s = NULL__null;
      sal_Int32 i = 0;
      rtl_uString_newReplaceFirstToAsciiL(
          &s, pData, from.pData,
          libreoffice_internal::ConstCharArrayDetector<T>::toPointer(to),
          libreoffice_internal::ConstCharArrayDetector<T>::length,
          index == NULL__null ? &i : index);
      return OUString(s, SAL_NO_ACQUIRE);
  }
2502#endif

  /**
    Returns a new string resulting from replacing the first occurrence of a
    given substring with another substring.

    @param from  ASCII string literal, the substring to be replaced

    @param to  ASCII string literal, the substring to be replaced

    @param[in,out] index  pointer to a start index; if the pointer is
    non-null: upon entry to the function, its value is the index into the this
    string at which to start searching for the \p from substring, the value
    must be non-negative and not greater than this string's length; upon exiting
    the function its value is the index into this string at which the
    replacement took place or -1 if no replacement took place; if the pointer
    is null, searching always starts at index 0

    @since LibreOffice 3.6
  */
  template< typename T1, typename T2 >
      SAL_WARN_UNUSED_RESULT[[nodiscard]] typename libreoffice_internal::ConstCharArrayDetector< T1, typename libreoffice_internal::ConstCharArrayDetector< T2, OUString >::Type >::Type
      replaceFirst( T1& from, T2& to, sal_Int32 * index = NULL__null) const
  {
      assert(libreoffice_internal::ConstCharArrayDetector<T1>::isValid(from))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T1>::isValid(from)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T1>::isValid(from)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 2526, __extension__ __PRETTY_FUNCTION__));
      assert(libreoffice_internal::ConstCharArrayDetector<T2>::isValid(to))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T2>::isValid(to)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T2>::isValid(to)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 2527, __extension__ __PRETTY_FUNCTION__));
      rtl_uString * s = NULL__null;
      sal_Int32 i = 0;
      rtl_uString_newReplaceFirstAsciiLAsciiL(
          &s, pData,
          libreoffice_internal::ConstCharArrayDetector<T1>::toPointer(from),
          libreoffice_internal::ConstCharArrayDetector<T1>::length,
          libreoffice_internal::ConstCharArrayDetector<T2>::toPointer(to),
          libreoffice_internal::ConstCharArrayDetector<T2>::length,
          index == NULL__null ? &i : index);
      return OUString(s, SAL_NO_ACQUIRE);
  }

  /**
    Returns a new string resulting from replacing all occurrences of a given
    substring with another substring.

    Replacing subsequent occurrences picks up only after a given replacement.
    That is, replacing from "xa" to "xx" in "xaa" results in "xxa", not "xxx".

    @param from  the substring to be replaced

    @param to  the replacing substring

    @param fromIndex  the position in the string where we will begin searching

    @since LibreOffice 4.0
  */
2555#if defined LIBO_INTERNAL_ONLY1
  [[nodiscard]] OUString replaceAll(
      std::u16string_view from, std::u16string_view to, sal_Int32 fromIndex = 0) const
  {
      rtl_uString * s = nullptr;
      rtl_uString_newReplaceAllFromIndexUtf16LUtf16L(
          &s, pData, from.data(), from.size(), to.data(), to.size(), fromIndex);
      return OUString(s, SAL_NO_ACQUIRE);
  }
2564#else
  SAL_WARN_UNUSED_RESULT[[nodiscard]] OUString replaceAll(
      OUString const & from, OUString const & to, sal_Int32 fromIndex = 0) const
  {
      rtl_uString * s = NULL__null;
      rtl_uString_newReplaceAllFromIndex(&s, pData, from.pData, to.pData, fromIndex);
      return OUString(s, SAL_NO_ACQUIRE);
  }
2572#endif

  /**
    Returns a new string resulting from replacing all occurrences of a given
    substring with another substring.

    Replacing subsequent occurrences picks up only after a given replacement.
    That is, replacing from "xa" to "xx" in "xaa" results in "xxa", not "xxx".

    @param from ASCII string literal, the substring to be replaced

    @param to  the replacing substring

    @since LibreOffice 3.6
  */
2587#if defined LIBO_INTERNAL_ONLY1
  template<typename T> [[nodiscard]]
  typename libreoffice_internal::ConstCharArrayDetector<T, OUString >::Type replaceAll(
      T & from, std::u16string_view to) const
  {
      assert(libreoffice_internal::ConstCharArrayDetector<T>::isValid(from))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(from)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(from)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 2592, __extension__ __PRETTY_FUNCTION__));
      rtl_uString * s = nullptr;
      rtl_uString_newReplaceAllAsciiLUtf16L(
          &s, pData, libreoffice_internal::ConstCharArrayDetector<T>::toPointer(from),
          libreoffice_internal::ConstCharArrayDetector<T>::length, to.data(), to.size());
      return OUString(s, SAL_NO_ACQUIRE);
  }
2599#else
  template< typename T >
  SAL_WARN_UNUSED_RESULT[[nodiscard]] typename libreoffice_internal::ConstCharArrayDetector< T, OUString >::Type replaceAll( T& from, OUString const & to) const
  {
      assert(libreoffice_internal::ConstCharArrayDetector<T>::isValid(from))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(from)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(from)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 2603, __extension__ __PRETTY_FUNCTION__));
      rtl_uString * s = NULL__null;
      rtl_uString_newReplaceAllAsciiL(
          &s, pData,
          libreoffice_internal::ConstCharArrayDetector<T>::toPointer(from),
          libreoffice_internal::ConstCharArrayDetector<T>::length, to.pData);
      return OUString(s, SAL_NO_ACQUIRE);
  }
2611#endif

  /**
    Returns a new string resulting from replacing all occurrences of a given
    substring with another substring.

    Replacing subsequent occurrences picks up only after a given replacement.
    That is, replacing from "xa" to "xx" in "xaa" results in "xxa", not "xxx".

    @param from  the substring to be replaced

    @param to  ASCII string literal, the replacing substring

    @since LibreOffice 5.1
  */
2626#if defined LIBO_INTERNAL_ONLY1
  template<typename T> [[nodiscard]]
  typename libreoffice_internal::ConstCharArrayDetector<T, OUString >::Type replaceAll(
      std::u16string_view from, T & to) const
  {
      assert(libreoffice_internal::ConstCharArrayDetector<T>::isValid(to))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(to)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(to)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 2631, __extension__ __PRETTY_FUNCTION__));
      rtl_uString * s = nullptr;
      rtl_uString_newReplaceAllUtf16LAsciiL(
          &s, pData, from.data(), from.size(),
          libreoffice_internal::ConstCharArrayDetector<T>::toPointer(to),
          libreoffice_internal::ConstCharArrayDetector<T>::length);
      return OUString(s, SAL_NO_ACQUIRE);
  }
2639#else
  template< typename T >
  SAL_WARN_UNUSED_RESULT[[nodiscard]] typename libreoffice_internal::ConstCharArrayDetector< T, OUString >::Type replaceAll( OUString const & from, T& to) const
  {
      assert(libreoffice_internal::ConstCharArrayDetector<T>::isValid(to))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T>::isValid(to)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T>::isValid(to)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 2643, __extension__ __PRETTY_FUNCTION__));
      rtl_uString * s = NULL__null;
      rtl_uString_newReplaceAllToAsciiL(
          &s, pData, from.pData,
          libreoffice_internal::ConstCharArrayDetector<T>::toPointer(to),
          libreoffice_internal::ConstCharArrayDetector<T>::length);
      return OUString(s, SAL_NO_ACQUIRE);
  }
2651#endif

  /**
    Returns a new string resulting from replacing all occurrences of a given
    substring with another substring.

    Replacing subsequent occurrences picks up only after a given replacement.
    That is, replacing from "xa" to "xx" in "xaa" results in "xxa", not "xxx".

    @param from  ASCII string literal, the substring to be replaced

    @param to  ASCII string literal, the substring to be replaced

    @since LibreOffice 3.6
  */
  template< typename T1, typename T2 >
  SAL_WARN_UNUSED_RESULT[[nodiscard]] typename libreoffice_internal::ConstCharArrayDetector< T1, typename libreoffice_internal::ConstCharArrayDetector< T2, OUString >::Type >::Type
      replaceAll( T1& from, T2& to ) const
  {
      assert(libreoffice_internal::ConstCharArrayDetector<T1>::isValid(from))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T1>::isValid(from)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T1>::isValid(from)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 2670, __extension__ __PRETTY_FUNCTION__));
      assert(libreoffice_internal::ConstCharArrayDetector<T2>::isValid(to))(static_cast <bool> (libreoffice_internal::ConstCharArrayDetector
<T2>::isValid(to)) ? void (0) : __assert_fail ("libreoffice_internal::ConstCharArrayDetector<T2>::isValid(to)"
, "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 2671, __extension__ __PRETTY_FUNCTION__));
      rtl_uString * s = NULL__null;
      rtl_uString_newReplaceAllAsciiLAsciiL(
          &s, pData,
          libreoffice_internal::ConstCharArrayDetector<T1>::toPointer(from),
          libreoffice_internal::ConstCharArrayDetector<T1>::length,
          libreoffice_internal::ConstCharArrayDetector<T2>::toPointer(to),
          libreoffice_internal::ConstCharArrayDetector<T2>::length);
      return OUString(s, SAL_NO_ACQUIRE);
  }

  /**
    Converts from this string all ASCII uppercase characters (65-90)
    to ASCII lowercase characters (97-122).

    This function can't be used for language specific conversion.
    If the string doesn't contain characters which must be converted,
    then the new string is assigned with str.

    @return   the string, converted to ASCII lowercase.
  */
  SAL_WARN_UNUSED_RESULT[[nodiscard]] OUString toAsciiLowerCase() const
  {
      rtl_uString* pNew = NULL__null;
      rtl_uString_newToAsciiLowerCase( &pNew, pData );
      return OUString( pNew, SAL_NO_ACQUIRE );
  }

  /**
    Converts from this string all ASCII lowercase characters (97-122)
    to ASCII uppercase characters (65-90).

    This function can't be used for language specific conversion.
    If the string doesn't contain characters which must be converted,
    then the new string is assigned with str.

    @return   the string, converted to ASCII uppercase.
  */
  SAL_WARN_UNUSED_RESULT[[nodiscard]] OUString toAsciiUpperCase() const
  {
      rtl_uString* pNew = NULL__null;
      rtl_uString_newToAsciiUpperCase( &pNew, pData );
      return OUString( pNew, SAL_NO_ACQUIRE );
  }

  /**
    Returns a new string resulting from removing white space from both ends
    of the string.

    All characters that have codes less than or equal to
    32 (the space character), and Unicode General Punctuation area Space
    and some Control characters are considered to be white space (see
    rtl_ImplIsWhitespace).
    If the string doesn't contain white spaces at both ends,
    then the new string is assigned with str.

    @return   the string, with white space removed from the front and end.
  */
  SAL_WARN_UNUSED_RESULT[[nodiscard]] OUString trim() const
  {
      rtl_uString* pNew = NULL__null;
      rtl_uString_newTrim( &pNew, pData );
      return OUString( pNew, SAL_NO_ACQUIRE );
  }

  /**
    Returns a token in the string.

    Example:
      sal_Int32 nIndex = 0;
      do
      {
          ...
          OUString aToken = aStr.getToken( 0, ';', nIndex );
          ...
      }
      while ( nIndex >= 0 );

    @param    token       the number of the token to return
    @param    cTok        the character which separate the tokens.
    @param    index       the position at which the token is searched in the
                          string.
                          The index must not be greater than the length of the
                          string.
                          This param is set to the position of the
                          next token or to -1, if it is the last token.
    @return   the token; if either token or index is negative, an empty token
              is returned (and index is set to -1)
  */
  OUString getToken( sal_Int32 token, sal_Unicode cTok, sal_Int32& index ) const
  {
      rtl_uString * pNew = NULL__null;
      index = rtl_uString_getToken( &pNew, pData, token, cTok, index );
      return OUString( pNew, SAL_NO_ACQUIRE );
  }

  /**
    Returns a token from the string.

    The same as getToken(sal_Int32, sal_Unicode, sal_Int32 &), but always
    passing in 0 as the start index in the third argument.

    @param count  the number of the token to return, starting with 0
    @param separator  the character which separates the tokens

    @return  the given token, or an empty string

    @since LibreOffice 3.6
   */
  OUString getToken(sal_Int32 count, sal_Unicode separator) const {
      sal_Int32 n = 0;
      return getToken(count, separator, n);
  }

  /**
    Returns the Boolean value from this string.

    This function can't be used for language specific conversion.

    @return   true, if the string is 1 or "True" in any ASCII case.
              false in any other case.
  */
  bool toBoolean() const
  {
      return rtl_ustr_toBoolean( pData->buffer );
  }

  /**
    Returns the first character from this string.

    @return   the first character from this string or 0, if this string
              is empty.
  */
  sal_Unicode toChar() const
  {
      return pData->buffer[0];
  }

  /**
    Returns the int32 value from this string.

    This function can't be used for language specific conversion.

    @param    radix       the radix (between 2 and 36)
    @return   the int32 represented from this string.
              0 if this string represents no number or one of too large
              magnitude.
  */
  sal_Int32 toInt32( sal_Int16 radix = 10 ) const
  {
      return rtl_ustr_toInt32( pData->buffer, radix );
  }

  /**
    Returns the uint32 value from this string.

    This function can't be used for language specific conversion.

    @param    radix       the radix (between 2 and 36)
    @return   the uint32 represented from this string.
              0 if this string represents no number or one of too large
              magnitude.

    @since LibreOffice 4.2
  */
  sal_uInt32 toUInt32( sal_Int16 radix = 10 ) const
  {
      return rtl_ustr_toUInt32( pData->buffer, radix );
  }

  /**
    Returns the int64 value from this string.

    This function can't be used for language specific conversion.

    @param    radix       the radix (between 2 and 36)
    @return   the int64 represented from this string.
              0 if this string represents no number or one of too large
              magnitude.
  */
  sal_Int64 toInt64( sal_Int16 radix = 10 ) const
  {
      return rtl_ustr_toInt64( pData->buffer, radix );
  }

  /**
    Returns the uint64 value from this string.

    This function can't be used for language specific conversion.

    @param    radix       the radix (between 2 and 36)
    @return   the uint64 represented from this string.
              0 if this string represents no number or one of too large
              magnitude.

    @since LibreOffice 4.1
  */
  sal_uInt64 toUInt64( sal_Int16 radix = 10 ) const
  {
      return rtl_ustr_toUInt64( pData->buffer, radix );
  }

  /**
    Returns the float value from this string.

    This function can't be used for language specific conversion.

    @return   the float represented from this string.
              0.0 if this string represents no number.
  */
  float toFloat() const
  {
      return rtl_ustr_toFloat( pData->buffer );
  }

  /**
    Returns the double value from this string.

    This function can't be used for language specific conversion.

    @return   the double represented from this string.
              0.0 if this string represents no number.
  */
  double toDouble() const
  {
      return rtl_ustr_toDouble( pData->buffer );
  }


  /**
     Return a canonical representation for a string.

     A pool of strings, initially empty is maintained privately
     by the string class. On invocation, if present in the pool
     the original string will be returned. Otherwise this string,
     or a copy thereof will be added to the pool and returned.

     @return
     a version of the string from the pool.

     @exception std::bad_alloc is thrown if an out-of-memory condition occurs

     @since UDK 3.2.7
  */
  OUString intern() const
  {
      rtl_uString * pNew = NULL__null;
      rtl_uString_intern( &pNew, pData );
      if (pNew == NULL__null) {
          throw std::bad_alloc();
      }
      return OUString( pNew, SAL_NO_ACQUIRE );
  }

  /**
     Return a canonical representation for a converted string.

     A pool of strings, initially empty is maintained privately
     by the string class. On invocation, if present in the pool
     the original string will be returned. Otherwise this string,
     or a copy thereof will be added to the pool and returned.

     @param    value           a 8-Bit character array.
     @param    length          the number of character which should be converted.
                               The 8-Bit character array length must be
                               greater than or equal to this value.
     @param    encoding        the text encoding from which the 8-Bit character
                               sequence should be converted.
     @param    convertFlags    flags which controls the conversion.
                               see RTL_TEXTTOUNICODE_FLAGS_...
     @param    pInfo           pointer to return conversion status or NULL.

     @return
     a version of the converted string from the pool.

     @exception std::bad_alloc is thrown if an out-of-memory condition occurs

     @since UDK 3.2.7
  */
  static OUString intern( const char * value, sal_Int32 length,
                          rtl_TextEncoding encoding,
                          sal_uInt32 convertFlags = OSTRING_TO_OUSTRING_CVTFLAGS(((sal_uInt32)0x0003) | ((sal_uInt32)0x0030) | ((sal_uInt32)0x0300
)),
                          sal_uInt32 *pInfo = NULL__null )
  {
      rtl_uString * pNew = NULL__null;
      rtl_uString_internConvert( &pNew, value, length, encoding,
                                 convertFlags, pInfo );
      if (pNew == NULL__null) {
          throw std::bad_alloc();
      }
      return OUString( pNew, SAL_NO_ACQUIRE );
  }

  /**
    Converts to an OString, signalling failure.

    @param pTarget
    An out parameter receiving the converted OString.  Must not be null; the
    contents are not modified if conversion fails (convertToOString returns
    false).

    @param nEncoding
    The text encoding to convert into.  Must be an octet encoding (i.e.,
    rtl_isOctetTextEncoding(nEncoding) must return true).

    @param nFlags
    A combination of RTL_UNICODETOTEXT_FLAGS that detail how to do the
    conversion (see rtl_convertUnicodeToText).  RTL_UNICODETOTEXT_FLAGS_FLUSH
    need not be included, it is implicitly assumed.  Typical uses are either
    RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR |
    RTL_UNICODETOTEXT_FLAGS_INVALID_ERROR (fail if a Unicode character cannot
    be converted to the target nEncoding) or OUSTRING_TO_OSTRING_CVTFLAGS
    (make a best efforts conversion).

    @return
    True if the conversion succeeded, false otherwise.
   */
  bool convertToString(OString * pTarget, rtl_TextEncoding nEncoding,
                              sal_uInt32 nFlags) const
  {
      return rtl_convertUStringToString(&pTarget->pData, pData->buffer,
                                          pData->length, nEncoding, nFlags);
  }

  /** Iterate through this string based on code points instead of UTF-16 code
      units.

      See Chapter 3 of The Unicode Standard 5.0 (Addison--Wesley, 2006) for
      definitions of the various terms used in this description.

      This string is interpreted as a sequence of zero or more UTF-16 code
      units.  For each index into this sequence (from zero to one less than
      the length of the sequence, inclusive), a code point represented
      starting at the given index is computed as follows:

      - If the UTF-16 code unit addressed by the index constitutes a
      well-formed UTF-16 code unit sequence, the computed code point is the
      scalar value encoded by that UTF-16 code unit sequence.

      - Otherwise, if the index is at least two UTF-16 code units away from
      the end of the sequence, and the sequence of two UTF-16 code units
      addressed by the index constitutes a well-formed UTF-16 code unit
      sequence, the computed code point is the scalar value encoded by that
      UTF-16 code unit sequence.

      - Otherwise, the computed code point is the UTF-16 code unit addressed
      by the index.  (This last case catches unmatched surrogates as well as
      indices pointing into the middle of surrogate pairs.)

      @param indexUtf16
      pointer to a UTF-16 based index into this string; must not be null.  On
      entry, the index must be in the range from zero to the length of this
      string (in UTF-16 code units), inclusive.  Upon successful return, the
      index will be updated to address the UTF-16 code unit that is the given
      incrementCodePoints away from the initial index.

      @param incrementCodePoints
      the number of code points to move the given *indexUtf16.  If
      non-negative, moving is done after determining the code point at the
      index.  If negative, moving is done before determining the code point
      at the (then updated) index.  The value must be such that the resulting
      UTF-16 based index is in the range from zero to the length of this
      string (in UTF-16 code units), inclusive.

      @return
      the code point (an integer in the range from 0 to 0x10FFFF, inclusive)
      that is represented within this string starting at the index computed as
      follows:  If incrementCodePoints is non-negative, the index is the
      initial value of *indexUtf16; if incrementCodePoints is negative, the
      index is the updated value of *indexUtf16.  In either case, the computed
      index must be in the range from zero to one less than the length of this
      string (in UTF-16 code units), inclusive.

      @since UDK 3.2.7
  */
  sal_uInt32 iterateCodePoints(
      sal_Int32 * indexUtf16, sal_Int32 incrementCodePoints = 1) const
  {
      return rtl_uString_iterateCodePoints(
          pData, indexUtf16, incrementCodePoints);
  }

  /**
   * Convert an OString to an OUString, assuming that the OString is
   * UTF-8-encoded.
   *
   * @param rSource
   * an OString to convert
   *
   * @since LibreOffice 4.4
   */
  static OUString fromUtf8(const OString& rSource)
  {
      OUString aTarget;
      bool bSuccess = rtl_convertStringToUString(&aTarget.pData,
                                                 rSource.getStr(),
                                                 rSource.getLength(),
                                                 RTL_TEXTENCODING_UTF8(((rtl_TextEncoding) 76)),
                                                 RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR((sal_uInt32)0x0001)|RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR((sal_uInt32)0x0010)|RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR((sal_uInt32)0x0100));
      (void) bSuccess;
      assert(bSuccess)(static_cast <bool> (bSuccess) ? void (0) : __assert_fail
 ("bSuccess", "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 3071, __extension__ __PRETTY_FUNCTION__));
      return aTarget;
  }

  /**
   * Convert this string to an OString, assuming that the string can be
   * UTF-8-encoded successfully.
   *
   * In other words, you must not use this method on a random sequence of
   * UTF-16 code units, but only at places where it is assumed that the
   * content is a proper string.
   *
   * @since LibreOffice 4.4
   */
  OString toUtf8() const
  {
      OString aTarget;
      bool bSuccess = rtl_convertUStringToString(&aTarget.pData,
                                                 getStr(),
                                                 getLength(),
                                                 RTL_TEXTENCODING_UTF8(((rtl_TextEncoding) 76)),
                                                 RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR((sal_uInt32)0x0001)|RTL_UNICODETOTEXT_FLAGS_INVALID_ERROR((sal_uInt32)0x0010));
      (void) bSuccess;
      assert(bSuccess)(static_cast <bool> (bSuccess) ? void (0) : __assert_fail
 ("bSuccess", "/home/maarten/src/libreoffice/core/include/rtl/ustring.hxx"
, 3094, __extension__ __PRETTY_FUNCTION__));
      return aTarget;
  }

3098#ifdef LIBO_INTERNAL_ONLY1 // "RTL_FAST_STRING"

  static OUStringNumber< int > number( int i, sal_Int16 radix = 10 )
  {
      return OUStringNumber< int >( i, radix );
  }
  static OUStringNumber< long long > number( long long ll, sal_Int16 radix = 10 )
  {
      return OUStringNumber< long long >( ll, radix );
  }
  static OUStringNumber< unsigned long long > number( unsigned long long ll, sal_Int16 radix = 10 )
  {
      return OUStringNumber< unsigned long long >( ll, radix );
  }
  static OUStringNumber< unsigned long long > number( unsigned int i, sal_Int16 radix = 10 )
  {
      return number( static_cast< unsigned long long >( i ), radix );
  }
  static OUStringNumber< long long > number( long i, sal_Int16 radix = 10)
  {
      return number( static_cast< long long >( i ), radix );
  }
  static OUStringNumber< unsigned long long > number( unsigned long i, sal_Int16 radix = 10 )
  {
      return number( static_cast< unsigned long long >( i ), radix );
  }
  static OUStringNumber< float > number( float f )
  {
      return OUStringNumber< float >( f );
  }
  static OUStringNumber< double > number( double d )
  {
      return OUStringNumber< double >( d );
  }
3132#else
  /**
    Returns the string representation of the integer argument.

    This function can't be used for language specific conversion.

    @param    i           an integer value
    @param    radix       the radix (between 2 and 36)
    @return   a string with the string representation of the argument.
    @since LibreOffice 4.1
  */
  static OUString number( int i, sal_Int16 radix = 10 )
  {
      sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFINT3233];
      return OUString(aBuf, rtl_ustr_valueOfInt32(aBuf, i, radix));
  }
  /// @overload
  /// @since LibreOffice 4.1
  static OUString number( unsigned int i, sal_Int16 radix = 10 )
  {
      return number( static_cast< unsigned long long >( i ), radix );
  }
  /// @overload
  /// @since LibreOffice 4.1
  static OUString number( long i, sal_Int16 radix = 10)
  {
      return number( static_cast< long long >( i ), radix );
  }
  /// @overload
  /// @since LibreOffice 4.1
  static OUString number( unsigned long i, sal_Int16 radix = 10 )
  {
      return number( static_cast< unsigned long long >( i ), radix );
  }
  /// @overload
  /// @since LibreOffice 4.1
  static OUString number( long long ll, sal_Int16 radix = 10 )
  {
      sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFINT6465];
      return OUString(aBuf, rtl_ustr_valueOfInt64(aBuf, ll, radix));
  }
  /// @overload
  /// @since LibreOffice 4.1
  static OUString number( unsigned long long ll, sal_Int16 radix = 10 )
  {
      sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFUINT6465];
      return OUString(aBuf, rtl_ustr_valueOfUInt64(aBuf, ll, radix));
  }

  /**
    Returns the string representation of the float argument.

    This function can't be used for language specific conversion.

    @param    f           a float.
    @return   a string with the decimal representation of the argument.
    @since LibreOffice 4.1
  */
  static OUString number( float f )
  {
      sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFFLOAT15];
      return OUString(aBuf, rtl_ustr_valueOfFloat(aBuf, f));
  }

  /**
    Returns the string representation of the double argument.

    This function can't be used for language specific conversion.

    @param    d           a double.
    @return   a string with the decimal representation of the argument.
    @since LibreOffice 4.1
  */
  static OUString number( double d )
  {
      sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFDOUBLE25];
      return OUString(aBuf, rtl_ustr_valueOfDouble(aBuf, d));
  }
3210#endif

  /**
    Returns the string representation of the sal_Bool argument.

    If the sal_Bool is true, the string "true" is returned.
    If the sal_Bool is false, the string "false" is returned.
    This function can't be used for language specific conversion.

    @param    b   a sal_Bool.
    @return   a string with the string representation of the argument.
    @deprecated use boolean()
  */
  SAL_DEPRECATED("use boolean()")__attribute__((deprecated("use boolean()"))) static OUString valueOf( sal_Bool b )
  {
      return boolean(b);
  }

  /**
    Returns the string representation of the boolean argument.

    If the argument is true, the string "true" is returned.
    If the argument is false, the string "false" is returned.
    This function can't be used for language specific conversion.

    @param    b   a bool.
    @return   a string with the string representation of the argument.
    @since LibreOffice 4.1
  */
  static OUString boolean( bool b )
  {
      sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFBOOLEAN6];
      return OUString(aBuf, rtl_ustr_valueOfBoolean(aBuf, b));
  }

  /**
    Returns the string representation of the char argument.

    @param    c   a character.
    @return   a string with the string representation of the argument.
    @deprecated use operator, function or constructor taking char or sal_Unicode argument
  */
  SAL_DEPRECATED("convert to OUString or use directly")__attribute__((deprecated("convert to OUString or use directly"
))) static OUString valueOf( sal_Unicode c )
  {
      return OUString( &c, 1 );
  }

  /**
    Returns the string representation of the int argument.

    This function can't be used for language specific conversion.

    @param    i           a int32.
    @param    radix       the radix (between 2 and 36)
    @return   a string with the string representation of the argument.
    @deprecated use number()
  */
  SAL_DEPRECATED("use number()")__attribute__((deprecated("use number()"))) static OUString valueOf( sal_Int32 i, sal_Int16 radix = 10 )
  {
      return number( i, radix );
  }

  /**
    Returns the string representation of the long argument.

    This function can't be used for language specific conversion.

    @param    ll          a int64.
    @param    radix       the radix (between 2 and 36)
    @return   a string with the string representation of the argument.
    @deprecated use number()
  */
  SAL_DEPRECATED("use number()")__attribute__((deprecated("use number()"))) static OUString valueOf( sal_Int64 ll, sal_Int16 radix = 10 )
  {
      return number( ll, radix );
  }

  /**
    Returns the string representation of the float argument.

    This function can't be used for language specific conversion.

    @param    f           a float.
    @return   a string with the string representation of the argument.
    @deprecated use number()
  */
  SAL_DEPRECATED("use number()")__attribute__((deprecated("use number()"))) static OUString valueOf( float f )
  {
      return number(f);
  }

  /**
    Returns the string representation of the double argument.

    This function can't be used for language specific conversion.

    @param    d           a double.
    @return   a string with the string representation of the argument.
    @deprecated use number()
  */
  SAL_DEPRECATED("use number()")__attribute__((deprecated("use number()"))) static OUString valueOf( double d )
  {
      return number(d);
  }

  /**
    Returns an OUString copied without conversion from an ASCII
    character string.

    Since this method is optimized for performance, the ASCII character
    values are not converted in any way. The caller has to make sure that
    all ASCII characters are in the allowed range between 0 and 127.
    The ASCII string must be NULL-terminated.

    Note that for string literals it is simpler and more efficient
    to directly use the OUString constructor.

    @param    value       the 8-Bit ASCII character string
    @return   a string with the string representation of the argument.
   */
  static OUString createFromAscii( const char * value )
  {
      rtl_uString* pNew = NULL__null;
      rtl_uString_newFromAscii( &pNew, value );
      return OUString( pNew, SAL_NO_ACQUIRE );
  }

3337#if defined LIBO_INTERNAL_ONLY1
  static OUString createFromAscii(std::string_view value) {
      rtl_uString * p = nullptr;
      rtl_uString_newFromLiteral(&p, value.data(), value.size(), 0); //TODO: check for overflow
      return OUString(p, SAL_NO_ACQUIRE);
  }
#endif

3345#if defined LIBO_INTERNAL_ONLY1
  operator std::u16string_view() const { return {getStr(), sal_uInt32(getLength())}; }
3347#endif

3349#if defined LIBO_INTERNAL_ONLY1
  // A wrapper for the first expression in an
  //
  //   OUString::Concat(e1) + e2 + ...
  //
  // concatenation chain, when neither of the first two e1, e2 is one of our rtl string-related
  // classes (so something like
  //
  //   OUString s = "a" + (b ? std::u16string_view(u"c") : std::u16string_view(u"dd"));
  //
  // would not compile):
  template<typename T> [[nodiscard]] static
  typename std::enable_if_t<
      ToStringHelper<T>::allowOUStringConcat, OUStringConcat<OUStringConcatMarker, T>>
  Concat(T const & value) { return OUStringConcat<OUStringConcatMarker, T>({}, value); }

  // This overload is needed so that an argument of type 'char const[N]' ends up as
  // 'OUStringConcat<rtl::OUStringConcatMarker, char const[N]>' rather than as
  // 'OUStringConcat<rtl::OUStringConcatMarker, char[N]>':
  template<typename T, std::size_t N> [[nodiscard]] static
  typename std::enable_if_t<
      ToStringHelper<T[N]>::allowOUStringConcat, OUStringConcat<OUStringConcatMarker, T[N]>>
  Concat(T (& value)[N]) { return OUStringConcat<OUStringConcatMarker, T[N]>({}, value); }
3372#endif

3374private:
  OUString & internalAppend( rtl_uString* pOtherData )
  {
      rtl_uString* pNewData = NULL__null;
      rtl_uString_newConcat( &pNewData, pData, pOtherData );
      if (pNewData == NULL__null) {
          throw std::bad_alloc();
      }
      rtl_uString_assign(&pData, pNewData);
      rtl_uString_release(pNewData);
      return *this;
  }

3387};

3389#if defined LIBO_INTERNAL_ONLY1
3390// Prevent the operator ==/!= overloads with 'sal_Unicode const *' parameter from
3391// being selected for nonsensical code like
3392//
3393//   if (ouIdAttr == nullptr)
3394//
3395void operator ==(OUString const &, std::nullptr_t) = delete;
3396void operator ==(std::nullptr_t, OUString const &) = delete;
3397void operator !=(OUString const &, std::nullptr_t) = delete;
3398void operator !=(std::nullptr_t, OUString const &) = delete;
3399#endif

3401#if defined LIBO_INTERNAL_ONLY1 // "RTL_FAST_STRING"
3402/// @cond INTERNAL

3404/**
@internal
3406*/
3407template<>
3408struct ToStringHelper< OUString >
  {
  static std::size_t length( const OUString& s ) { return s.getLength(); }
  static sal_Unicode* addData( sal_Unicode* buffer, const OUString& s ) { return addDataHelper( buffer, s.getStr(), s.getLength()); }
  static const bool allowOStringConcat = false;
  static const bool allowOUStringConcat = true;
  };

3416/**
@internal
3418*/
3419template<std::size_t N>
3420struct ToStringHelper< OUStringLiteral<N> >
  {
  static std::size_t length( const OUStringLiteral<N>& str ) { return str.getLength(); }
  static sal_Unicode* addData( sal_Unicode* buffer, const OUStringLiteral<N>& str ) { return addDataHelper( buffer, str.getStr(), str.getLength() ); }
  static const bool allowOStringConcat = false;
  static const bool allowOUStringConcat = true;
  };

3428/**
@internal
3430*/
3431template< typename charT, typename traits, typename T1, typename T2 >
3432inline std::basic_ostream<charT, traits> & operator <<(
  std::basic_ostream<charT, traits> & stream, OUStringConcat< T1, T2 >&& concat)
3434{
  return stream << OUString( std::move(concat) );
3436}

3438/// @endcond
3439#endif

3441/** A helper to use OUStrings with hash maps.

  Instances of this class are unary function objects that can be used as
  hash function arguments to std::unordered_map and similar constructs.
*/
3446struct OUStringHash
3447{
  /** Compute a hash code for a string.

      @param rString
      a string.

      @return
      a hash code for the string.  This hash code should not be stored
      persistently, as its computation may change in later revisions.
   */
  size_t operator()(const OUString& rString) const
      { return static_cast<size_t>(rString.hashCode()); }
3459};

3461/* ======================================================================= */

3463/** Convert an OString to an OUString, using a specific text encoding.

  The lengths of the two strings may differ (e.g., for double-byte
  encodings, UTF-7, UTF-8).

  @param rStr
  an OString to convert.

  @param encoding
  the text encoding to use for conversion.

  @param convertFlags
  flags which control the conversion.  Either use
  OSTRING_TO_OUSTRING_CVTFLAGS, or see
  <http://udk.openoffice.org/cpp/man/spec/textconversion.html> for more
  details.
*/
3480inline OUString OStringToOUString( const OString & rStr,
                                 rtl_TextEncoding encoding,
                                 sal_uInt32 convertFlags = OSTRING_TO_OUSTRING_CVTFLAGS(((sal_uInt32)0x0003) | ((sal_uInt32)0x0030) | ((sal_uInt32)0x0300
)) )
3483{
  return OUString( rStr.getStr(), rStr.getLength(), encoding, convertFlags );
3485}

3487/** Convert an OUString to an OString, using a specific text encoding.

  The lengths of the two strings may differ (e.g., for double-byte
  encodings, UTF-7, UTF-8).

  @param rUnicode
  an OUString to convert.

  @param encoding
  the text encoding to use for conversion.

  @param convertFlags
  flags which control the conversion.  Either use
  OUSTRING_TO_OSTRING_CVTFLAGS, or see
  <http://udk.openoffice.org/cpp/man/spec/textconversion.html> for more
  details.
*/
3504inline OString OUStringToOString( const OUString & rUnicode,
                                rtl_TextEncoding encoding,
                                sal_uInt32 convertFlags = OUSTRING_TO_OSTRING_CVTFLAGS(((sal_uInt32)0x0006) | ((sal_uInt32)0x0060) | ((sal_uInt32)0x0100
) | ((sal_uInt32)0x0400)) )
3507{
  return OString( rUnicode.getStr(), rUnicode.getLength(), encoding, convertFlags );
3509}

3511/* ======================================================================= */

3513/**
  Support for rtl::OUString in std::ostream (and thus in
  CPPUNIT_ASSERT or SAL_INFO macros, for example).

  The rtl::OUString is converted to UTF-8.

  @since LibreOffice 3.5.
3520*/
3521template< typename charT, typename traits >
3522inline std::basic_ostream<charT, traits> & operator <<(
  std::basic_ostream<charT, traits> & stream, OUString const & rString)
3524{
  return stream <<
      OUStringToOString(rString, RTL_TEXTENCODING_UTF8(((rtl_TextEncoding) 76)));
      // best effort; potentially loses data due to conversion failures
      // (stray surrogate halves) and embedded null characters
3529}

3531} // namespace

3533#ifdef RTL_STRING_UNITTEST
3534namespace rtl
3535{
3536typedef rtlunittest::OUString OUString;
3537}
3538#endif

3540// In internal code, allow to use classes like OUString without having to
3541// explicitly refer to the rtl namespace, which is kind of superfluous given
3542// that OUString itself is namespaced by its OU prefix:
3543#if defined LIBO_INTERNAL_ONLY1 && !defined RTL_STRING_UNITTEST
3544using ::rtl::OUString;
3545using ::rtl::OUStringHash;
3546using ::rtl::OStringToOUString;
3547using ::rtl::OUStringToOString;
3548using ::rtl::OUStringLiteral;
3549using ::rtl::OUStringChar;
3550#endif

3552/// @cond INTERNAL
3553/**
Make OUString hashable by default for use in STL containers.

@since LibreOffice 6.0
3557*/
3558#if defined LIBO_INTERNAL_ONLY1
3559namespace std {

3561template<>
3562struct hash<::rtl::OUString>
3563{
  std::size_t operator()(::rtl::OUString const & s) const
  { return std::size_t(s.hashCode()); }
3566};

3568}

3570#endif
3571/// @endcond

3573#endif /* _RTL_USTRING_HXX */

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

←

/home/maarten/src/libreoffice/core/sc/source/filter/inc/fapihelper.hxx

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 .
*/

20#ifndef INCLUDED_SC_SOURCE_FILTER_INC_FAPIHELPER_HXX
21#define INCLUDED_SC_SOURCE_FILTER_INC_FAPIHELPER_HXX

23#include <com/sun/star/uno/Any.hxx>
24#include <com/sun/star/uno/Reference.hxx>
25#include <com/sun/star/uno/Sequence.hxx>
26#include <osl/diagnose.h>
27#include <tools/color.hxx>
28#include "ftools.hxx"

30namespace com::sun::star {
  namespace lang { class XMultiServiceFactory; }
32}

34namespace com::sun::star::beans { struct NamedValue; }
35namespace com::sun::star::beans { class XPropertySet; }
36namespace com::sun::star::beans { class XMultiPropertySet; }

38namespace comphelper { class IDocPasswordVerifier; }

40// Static helper functions ====================================================

42class SfxMedium;
43class SfxObjectShell;

45/** Static API helper functions. */
46class ScfApiHelper
47{
48public:
  /** Converts a non-empty vector into a UNO sequence containing elements of the same type. */
  template< typename Type >
  static css::uno::Sequence< Type >
                          VectorToSequence( const ::std::vector< Type >& rVector );

  /** Returns the service name provided via the XServiceName interface, or an empty string on error. */
  static OUString GetServiceName( const css::uno::Reference< css::uno::XInterface >& xInt );

  /** Returns the multi service factory from a document shell. */
  static css::uno::Reference< css::lang::XMultiServiceFactory > GetServiceFactory( const SfxObjectShell* pShell );

  /** Creates an instance from the passed service name, using the passed service factory. */
  static css::uno::Reference< css::uno::XInterface > CreateInstance(
                          const css::uno::Reference< css::lang::XMultiServiceFactory >& xFactory,
                          const OUString& rServiceName );

  /** Creates an instance from the passed service name, using the service factory of the passed object. */
  static css::uno::Reference< css::uno::XInterface > CreateInstance(
                          const SfxObjectShell* pShell,
                          const OUString& rServiceName );

  /** Creates an instance from the passed service name, using the process service factory. */
  static css::uno::Reference< css::uno::XInterface > CreateInstance( const OUString& rServiceName );

  /** Opens a password dialog and returns the encryption data.
      @return  The encryption data or an empty sequence on 'Cancel' or any error. */
  static css::uno::Sequence< css::beans::NamedValue > QueryEncryptionDataForMedium( SfxMedium& rMedium,
                          ::comphelper::IDocPasswordVerifier& rVerifier,
                          const ::std::vector< OUString >* pDefaultPasswords );
78};

80template< typename Type >
81css::uno::Sequence< Type > ScfApiHelper::VectorToSequence( const ::std::vector< Type >& rVector )
82{
  OSL_ENSURE( !rVector.empty(), "ScfApiHelper::VectorToSequence - vector is empty" )do { if (true && (!(!rVector.empty()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/filter/inc/fapihelper.hxx"
 ":" "83" ": "), "%s", "ScfApiHelper::VectorToSequence - vector is empty"
); } } while (false);
  return css::uno::Sequence<Type>(rVector.data(), static_cast< sal_Int32 >(rVector.size()));
85}

87// Property sets ==============================================================

89/** A wrapper for a UNO property set.

  This class provides functions to silently get and set properties (without
  exceptions, without the need to check validity of the UNO property set).

  An instance is constructed with the reference to a UNO property set or any
  other interface (the constructor will query for the XPropertySet interface
  then). The reference to the property set will be kept as long as the
  instance of this class is alive.

  The functions GetProperties() and SetProperties() try to handle all passed
  values at once, using the XMultiPropertySet interface. If the
  implementation does not support the XMultiPropertySet interface, all
  properties are handled separately in a loop.
*/
104class ScfPropertySet
105{
106public:
  explicit     ScfPropertySet() {}
  /** Constructs a property set wrapper with the passed UNO property set. */
  explicit     ScfPropertySet( const css::uno::Reference< css::beans::XPropertySet > & xPropSet ) { Set( xPropSet ); }
  /** Constructs a property set wrapper after querying the XPropertySet interface. */
  template< typename InterfaceType >
  explicit     ScfPropertySet( const css::uno::Reference< InterfaceType >& xInterface ) { Set( xInterface ); }

                      ~ScfPropertySet();
  //TODO:
  ScfPropertySet(ScfPropertySet const &) = default;
  ScfPropertySet(ScfPropertySet &&) = default;
  ScfPropertySet & operator =(ScfPropertySet const &) = default;
  ScfPropertySet & operator =(ScfPropertySet &&) = default;

  /** Sets the passed UNO property set and releases the old UNO property set. */
  void                Set( css::uno::Reference< css::beans::XPropertySet > const & xPropSet );
  /** Queries the passed interface for an XPropertySet and releases the old UNO property set. */
  template< typename InterfaceType >
  void         Set( css::uno::Reference< InterfaceType > xInterface )
                          { Set( css::uno::Reference< css::beans::XPropertySet >( xInterface, css::uno::UNO_QUERY ) ); }

  /** Returns true, if the contained XPropertySet interface is valid. */
  bool         Is() const { return mxPropSet.is(); }

  /** Returns the contained XPropertySet interface. */
  const css::uno::Reference< css::beans::XPropertySet >& GetApiPropertySet() const { return mxPropSet; }

  /** Returns the service name provided via the XServiceName interface, or an empty string on error. */
  OUString     GetServiceName() const;

  // Get properties ---------------------------------------------------------

  /** Returns true, if the property set contains the specified property. */
  bool                HasProperty( const OUString& rPropName ) const;

  /** Gets the specified property from the property set.
      @return  true, if the Any could be filled with the property value. */
  bool                GetAnyProperty( css::uno::Any& rValue, const OUString& rPropName ) const;

  /** Gets the specified property from the property set.
      @return  true, if the passed variable could be filled with the property value. */
  template< typename Type >
  bool         GetProperty( Type& rValue, const OUString& rPropName ) const
                          { css::uno::Any aAny; return GetAnyProperty( aAny, rPropName ) && (aAny >>= rValue); }
67
←
Assuming the condition is false→
68
←
Returning without writing to 'rValue'→

  /** Gets the specified Boolean property from the property set.
      @return  true = property contains true; false = property contains false or error occurred. */
  bool                GetBoolProperty( const OUString& rPropName ) const;

  /** Gets the specified Boolean property from the property set. */
  OUString       GetStringProperty( const OUString& rPropName ) const;

  /** Gets the specified color property from the property set.
      @return  true, if the passed color variable could be filled with the property value. */
  bool                GetColorProperty( Color& rColor, const OUString& rPropName ) const;

  /** Gets the specified properties from the property set. Tries to use the XMultiPropertySet interface.
      @param rPropNames  The property names. MUST be ordered alphabetically.
      @param rValues  The related property values. */
  void                GetProperties( css::uno::Sequence< css::uno::Any >& rValues, const css::uno::Sequence< OUString >& rPropNames ) const;

  // Set properties ---------------------------------------------------------

  /** Puts the passed Any into the property set. */
  void                SetAnyProperty( const OUString& rPropName, const css::uno::Any& rValue );

  /** Puts the passed value into the property set. */
  template< typename Type >
  void         SetProperty( const OUString& rPropName, const Type& rValue )
                          { SetAnyProperty( rPropName, css::uno::makeAny( rValue ) ); }

  /** Puts the passed Boolean value into the property set. */
  void         SetBoolProperty( const OUString& rPropName, bool bValue )
                          { SetAnyProperty( rPropName, css::uno::Any( bValue ) ); }

  /** Puts the passed string into the property set. */
  void         SetStringProperty( const OUString& rPropName, const OUString& rValue )
                          { SetProperty( rPropName, rValue ); }

  /** Puts the passed color into the property set. */
  void         SetColorProperty( const OUString& rPropName, const Color& rColor )
                          { SetProperty( rPropName, sal_Int32( rColor ) ); }

  /** Puts the passed properties into the property set. Tries to use the XMultiPropertySet interface.
      @param rPropNames  The property names. MUST be ordered alphabetically.
      @param rValues  The related property values. */
  void                SetProperties( const css::uno::Sequence< OUString > & rPropNames, const css::uno::Sequence< css::uno::Any >& rValues );

195private:
  css::uno::Reference< css::beans::XPropertySet >       mxPropSet;          /// The mandatory property set interface.
  css::uno::Reference< css::beans::XMultiPropertySet >  mxMultiPropSet;     /// The optional multi property set interface.
198};

200/** Generic helper class for reading from and writing to property sets.

  Usage:
  1)  Call the constructor with a null-terminated array of ASCII strings.
  2a) Read properties from a property set: Call the ReadFromPropertySet()
      function, then get the properties with the ReadValue() functions or the
      operator>> stream operator. The properties are returned in order of the
      array of property names passed in the constructor.
  2b) Write properties to a property set: Call InitializeWrite() to start a
      new cycle. Set the values with the WriteValue() functions or the
      operator<< stream operator. The order of the properties is equal to the
      array of property names passed in the constructor. Finally, call the
      WriteToPropertySet() function.
*/
214class ScfPropSetHelper
215{
216public:
  /** @param ppPropNames  A null-terminated array of ASCII property names. */
  explicit            ScfPropSetHelper( const char* const* ppcPropNames );

  // read properties --------------------------------------------------------

  /** Reads all values from the passed property set. */
  void                ReadFromPropertySet( const ScfPropertySet& rPropSet );

  /** Reads the next value from the value sequence. */
  template< typename Type >
  void                ReadValue( Type& rValue );
  /** Reads an Any from the value sequence. */
  void                ReadValue( css::uno::Any& rAny );
  /** Reads a color value from the value sequence. */
  void                ReadValue( Color& rColor );
  /** Reads a C++ boolean value from the value sequence. */
  void                ReadValue( bool& rbValue );

  // write properties -------------------------------------------------------

  /** Must be called before reading or storing property values in the helper. */
  void                InitializeWrite();

  /** Writes the next value to the value sequence. */
  template< typename Type >
  void                WriteValue( const Type& rValue );
  /** Writes an Any to the value sequence. */
  void                WriteValue( const css::uno::Any& rAny );
  /** Writes a color value to the value sequence. */
  void         WriteValue( const Color& rColor )
                          { WriteValue( sal_Int32( rColor ) ); }
  /** Writes a C++ boolean value to the value sequence. */
  void                WriteValue( bool rbValue );

  /** Writes all values to the passed property set. */
  void                WriteToPropertySet( ScfPropertySet& rPropSet ) const;

254private:
  /** Returns a pointer to the next Any to be written to. */
  css::uno::Any*             GetNextAny();

258private:
  css::uno::Sequence< OUString >       maNameSeq;          /// Sequence of property names.
  css::uno::Sequence< css::uno::Any >  maValueSeq;         /// Sequence of property values.
  ScfInt32Vec         maNameOrder;        /// Maps initial order to alphabetical order.
  size_t              mnNextIdx;          /// Counter for next Any to be processed.
263};

265template< typename Type >
266void ScfPropSetHelper::ReadValue( Type& rValue )
267{
  css::uno::Any* pAny = GetNextAny();
  if (pAny)
      *pAny >>= rValue;
271}

273template< typename Type >
274void ScfPropSetHelper::WriteValue( const Type& rValue )
275{
  css::uno::Any* pAny = GetNextAny();
  if( pAny )
      *pAny <<= rValue;
279}

281template< typename Type >
282ScfPropSetHelper& operator>>( ScfPropSetHelper& rPropSetHelper, Type& rValue )
283{
  rPropSetHelper.ReadValue( rValue );
  return rPropSetHelper;
286}

288template< typename Type >
289ScfPropSetHelper& operator<<( ScfPropSetHelper& rPropSetHelper, const Type& rValue )
290{
  rPropSetHelper.WriteValue( rValue );
  return rPropSetHelper;
293}

295#endif

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