/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx

Bug Summary

File:	home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx
Warning:	line 1524, column 17 Called C++ object pointer is null

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 dbmgr.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 -isystem /usr/include/libxml2 -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 SW_DLLIMPLEMENTATION -D SWUI_DLL_NAME="libswuilo.so" -D SYSTEM_LIBXML -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/i18n -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/common -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/sw/source/core/inc -I /home/maarten/src/libreoffice/core/sw/source/filter/inc -I /home/maarten/src/libreoffice/core/sw/source/uibase/inc -I /home/maarten/src/libreoffice/core/sw/inc -I /home/maarten/src/libreoffice/core/workdir/SdiTarget/sw/sdi -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/officecfg/registry -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/sw/generated -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 -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/sw/source/uibase/dbui/dbmgr.cxx

/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.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 <sal/config.h>

22#include <cassert>

24#include <unotxdoc.hxx>
25#include <sfx2/app.hxx>
26#include <com/sun/star/sdb/CommandType.hpp>
27#include <com/sun/star/sdb/XDocumentDataSource.hpp>
28#include <com/sun/star/lang/DisposedException.hpp>
29#include <com/sun/star/lang/XEventListener.hpp>
30#include <com/sun/star/uri/UriReferenceFactory.hpp>
31#include <com/sun/star/uri/VndSunStarPkgUrlReferenceFactory.hpp>
32#include <com/sun/star/util/NumberFormatter.hpp>
33#include <com/sun/star/sdb/DatabaseContext.hpp>
34#include <com/sun/star/sdb/TextConnectionSettings.hpp>
35#include <com/sun/star/sdb/XCompletedConnection.hpp>
36#include <com/sun/star/sdb/XCompletedExecution.hpp>
37#include <com/sun/star/container/XChild.hpp>
38#include <com/sun/star/text/MailMergeEvent.hpp>
39#include <com/sun/star/frame/XStorable.hpp>
40#include <com/sun/star/task/InteractionHandler.hpp>
41#include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
42#include <com/sun/star/ui/dialogs/XFilePicker3.hpp>
43#include <com/sun/star/beans/XPropertySet.hpp>
44#include <vcl/errinf.hxx>
45#include <vcl/print.hxx>
46#include <vcl/scheduler.hxx>
47#include <sfx2/fcontnr.hxx>
48#include <sfx2/filedlghelper.hxx>
49#include <sfx2/viewfrm.hxx>
50#include <dbconfig.hxx>
51#include <unotools/tempfile.hxx>
52#include <unotools/pathoptions.hxx>
53#include <svl/zforlist.hxx>
54#include <svl/stritem.hxx>
55#include <sfx2/docfile.hxx>
56#include <sfx2/docfilt.hxx>
57#include <sfx2/progress.hxx>
58#include <sfx2/dispatch.hxx>
59#include <cmdid.h>
60#include <swmodule.hxx>
61#include <view.hxx>
62#include <docsh.hxx>
63#include <edtwin.hxx>
64#include <wrtsh.hxx>
65#include <fldbas.hxx>
66#include <dbui.hxx>
67#include <dbmgr.hxx>
68#include <doc.hxx>
69#include <IDocumentLinksAdministration.hxx>
70#include <IDocumentFieldsAccess.hxx>
71#include <IDocumentUndoRedo.hxx>
72#include <swwait.hxx>
73#include <swunohelper.hxx>
74#include <strings.hrc>
75#include <mmconfigitem.hxx>
76#include <com/sun/star/sdbc/XRowSet.hpp>
77#include <com/sun/star/sdbcx/XTablesSupplier.hpp>
78#include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
79#include <com/sun/star/sdb/XQueriesSupplier.hpp>
80#include <com/sun/star/sdb/XColumn.hpp>
81#include <com/sun/star/sdbc/DataType.hpp>
82#include <com/sun/star/sdbc/ResultSetType.hpp>
83#include <com/sun/star/sdbc/SQLException.hpp>
84#include <com/sun/star/mail/MailAttachment.hpp>
85#include <comphelper/processfactory.hxx>
86#include <comphelper/property.hxx>
87#include <comphelper/storagehelper.hxx>
88#include <comphelper/string.hxx>
89#include <comphelper/types.hxx>
90#include <mailmergehelper.hxx>
91#include <maildispatcher.hxx>
92#include <svtools/htmlcfg.hxx>
93#include <i18nlangtag/languagetag.hxx>
94#include <com/sun/star/util/XNumberFormatTypes.hpp>
95#include <svl/numuno.hxx>
96#include <connectivity/dbtools.hxx>
97#include <connectivity/dbconversion.hxx>
98#include <unotools/charclass.hxx>
99#include <tools/diagnose_ex.h>

101#include <unomailmerge.hxx>
102#include <sfx2/event.hxx>
103#include <svx/dataaccessdescriptor.hxx>
104#include <osl/mutex.hxx>
105#include <rtl/textenc.h>
106#include <rtl/tencinfo.h>
107#include <cppuhelper/implbase.hxx>
108#include <ndindex.hxx>
109#include <swevent.hxx>
110#include <sal/log.hxx>
111#include <swabstdlg.hxx>
112#include <vector>
113#include <section.hxx>
114#include <rootfrm.hxx>
115#include <calc.hxx>
116#include <dbfld.hxx>
117#include <IDocumentState.hxx>
118#include <imaildsplistener.hxx>
119#include <iodetect.hxx>
120#include <IDocumentDeviceAccess.hxx>

122#include <memory>
123#include <comphelper/propertysequence.hxx>

125using namespace ::com::sun::star;
126using namespace sw;

128namespace {

130void lcl_emitEvent(SfxEventHintId nEventId, sal_Int32 nStrId, SfxObjectShell* pDocShell)
131{
  SfxGetpApp()->NotifyEvent(SfxEventHint(nEventId,
                                         SwDocShell::GetEventName(nStrId),
                                         pDocShell));
135}

137}

139std::vector<std::pair<SwDocShell*, OUString>> SwDBManager::m_aUncommittedRegistrations;

141namespace {

143enum class SwDBNextRecord { NEXT, FIRST };

145}

147static bool lcl_ToNextRecord( SwDSParam* pParam, const SwDBNextRecord action = SwDBNextRecord::NEXT );

149namespace {

151enum class WorkingDocType { SOURCE, TARGET, COPY };

153}

155static SfxObjectShell* lcl_CreateWorkingDocument(
  const WorkingDocType aType, const SwWrtShell &rSourceWrtShell,
  const vcl::Window *pSourceWindow,
  SwDBManager** const ppDBManager,
  SwView** const pView, SwWrtShell** const pWrtShell, SwDoc** const pDoc );

161static bool lcl_getCountFromResultSet( sal_Int32& rCount, const SwDSParam* pParam )
162{
  rCount = pParam->aSelection.getLength();
  if ( rCount > 0 )
      return true;

  uno::Reference<beans::XPropertySet> xPrSet(pParam->xResultSet, uno::UNO_QUERY);
  if ( xPrSet.is() )
  {
      try
      {
          bool bFinal = false;
          uno::Any aFinal = xPrSet->getPropertyValue("IsRowCountFinal");
          aFinal >>= bFinal;
          if(!bFinal)
          {
              pParam->xResultSet->last();
              pParam->xResultSet->first();
          }
          uno::Any aCount = xPrSet->getPropertyValue("RowCount");
          if( aCount >>= rCount )
              return true;
      }
      catch(const uno::Exception&)
      {
      }
  }
  return false;
189}

191class SwDBManager::ConnectionDisposedListener_Impl
  : public cppu::WeakImplHelper< lang::XEventListener >
193{
194private:
  SwDBManager * m_pDBManager;

  virtual void SAL_CALL disposing( const lang::EventObject& Source ) override;

199public:
  explicit ConnectionDisposedListener_Impl(SwDBManager& rMgr);

  void Dispose() { m_pDBManager = nullptr; }

204};

206namespace {

208/// Listens to removed data sources, and if it's one that's embedded into this document, triggers embedding removal.
209class SwDataSourceRemovedListener : public cppu::WeakImplHelper<sdb::XDatabaseRegistrationsListener>
210{
  uno::Reference<sdb::XDatabaseContext> m_xDatabaseContext;
  SwDBManager* m_pDBManager;

214public:
  explicit SwDataSourceRemovedListener(SwDBManager& rDBManager);
  virtual ~SwDataSourceRemovedListener() override;
  virtual void SAL_CALL registeredDatabaseLocation(const sdb::DatabaseRegistrationEvent& rEvent) override;
  virtual void SAL_CALL revokedDatabaseLocation(const sdb::DatabaseRegistrationEvent& rEvent) override;
  virtual void SAL_CALL changedDatabaseLocation(const sdb::DatabaseRegistrationEvent& rEvent) override;
  virtual void SAL_CALL disposing(const lang::EventObject& rObject) override;
  void Dispose();
222};

224}

226SwDataSourceRemovedListener::SwDataSourceRemovedListener(SwDBManager& rDBManager)
  : m_pDBManager(&rDBManager)
228{
  uno::Reference<uno::XComponentContext> xComponentContext(comphelper::getProcessComponentContext());
  m_xDatabaseContext = sdb::DatabaseContext::create(xComponentContext);
  m_xDatabaseContext->addDatabaseRegistrationsListener(this);
232}

234SwDataSourceRemovedListener::~SwDataSourceRemovedListener()
235{
  if (m_xDatabaseContext.is())
      m_xDatabaseContext->removeDatabaseRegistrationsListener(this);
238}

240void SAL_CALL SwDataSourceRemovedListener::registeredDatabaseLocation(const sdb::DatabaseRegistrationEvent& /*rEvent*/)
241{
242}

244void SAL_CALL SwDataSourceRemovedListener::revokedDatabaseLocation(const sdb::DatabaseRegistrationEvent& rEvent)
245{
  if (!m_pDBManager || m_pDBManager->getEmbeddedName().isEmpty())
      return;

  SwDoc* pDoc = m_pDBManager->getDoc();
  if (!pDoc)
      return;

  SwDocShell* pDocShell = pDoc->GetDocShell();
  if (!pDocShell)
      return;

  OUString aOwnURL = pDocShell->GetMedium()->GetURLObject().GetMainURL(INetURLObject::DecodeMechanism::WithCharset);
  OUString sTmpName = "vnd.sun.star.pkg://" +
      INetURLObject::encode(aOwnURL, INetURLObject::PART_AUTHORITY, INetURLObject::EncodeMechanism::All);
  sTmpName += "/" + m_pDBManager->getEmbeddedName();

  if (sTmpName != rEvent.OldLocation)
      return;

  // The revoked database location is inside this document, then remove the
  // embedding, as otherwise it would be back on the next reload of the
  // document.
  pDocShell->GetStorage()->removeElement(m_pDBManager->getEmbeddedName());
  m_pDBManager->setEmbeddedName(OUString(), *pDocShell);
270}

272void SAL_CALL SwDataSourceRemovedListener::changedDatabaseLocation(const sdb::DatabaseRegistrationEvent& rEvent)
273{
  if (rEvent.OldLocation != rEvent.NewLocation)
      revokedDatabaseLocation(rEvent);
276}

278void SwDataSourceRemovedListener::disposing(const lang::EventObject& /*rObject*/)
279{
  m_xDatabaseContext.clear();
281}

283void SwDataSourceRemovedListener::Dispose()
284{
  m_pDBManager = nullptr;
286}

288struct SwDBManager::SwDBManager_Impl
289{
  std::unique_ptr<SwDSParam> pMergeData;
  VclPtr<AbstractMailMergeDlg>  pMergeDialog;
  rtl::Reference<SwDBManager::ConnectionDisposedListener_Impl> m_xDisposeListener;
  rtl::Reference<SwDataSourceRemovedListener> m_xDataSourceRemovedListener;
  osl::Mutex                    m_aAllEmailSendMutex;
  uno::Reference< mail::XMailMessage> m_xLastMessage;

  explicit SwDBManager_Impl(SwDBManager& rDBManager)
      : m_xDisposeListener(new ConnectionDisposedListener_Impl(rDBManager))
      {}

  ~SwDBManager_Impl()
  {
      m_xDisposeListener->Dispose();
      if (m_xDataSourceRemovedListener.is())
          m_xDataSourceRemovedListener->Dispose();
  }
307};

309static void lcl_InitNumberFormatter(SwDSParam& rParam, uno::Reference<sdbc::XDataSource> const & xSource)
310{
  uno::Reference<uno::XComponentContext> xContext = ::comphelper::getProcessComponentContext();
  rParam.xFormatter = util::NumberFormatter::create(xContext);
  uno::Reference<beans::XPropertySet> xSourceProps(
      (xSource.is()
       ? xSource
       : SwDBManager::getDataSourceAsParent(
           rParam.xConnection, rParam.sDataSource)),
      uno::UNO_QUERY);
  if(!xSourceProps.is())
      return;

  uno::Any aFormats = xSourceProps->getPropertyValue("NumberFormatsSupplier");
  if(!aFormats.hasValue())
      return;

  uno::Reference<util::XNumberFormatsSupplier> xSuppl;
  aFormats >>= xSuppl;
  if(xSuppl.is())
  {
      uno::Reference< beans::XPropertySet > xSettings = xSuppl->getNumberFormatSettings();
      uno::Any aNull = xSettings->getPropertyValue("NullDate");
      aNull >>= rParam.aNullDate;
      if(rParam.xFormatter.is())
          rParam.xFormatter->attachNumberFormatsSupplier(xSuppl);
  }
336}

338static bool lcl_MoveAbsolute(SwDSParam* pParam, long nAbsPos)
339{
  bool bRet = false;
  try
  {
      if(pParam->aSelection.hasElements())
      {
          if(pParam->aSelection.getLength() <= nAbsPos)
          {
              pParam->bEndOfDB = true;
              bRet = false;
          }
          else
          {
              pParam->nSelectionIndex = nAbsPos;
              sal_Int32 nPos = 0;
              pParam->aSelection.getConstArray()[ pParam->nSelectionIndex ] >>= nPos;
              pParam->bEndOfDB = !pParam->xResultSet->absolute( nPos );
              bRet = !pParam->bEndOfDB;
          }
      }
      else if(pParam->bScrollable)
      {
          bRet = pParam->xResultSet->absolute( nAbsPos );
      }
      else
      {
          OSL_FAIL("no absolute positioning available")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "365" ": "), "%s", "no absolute positioning available");
 } } while (false);
      }
  }
  catch(const uno::Exception&)
  {
  }
  return bRet;
372}

374static void lcl_GetColumnCnt(SwDSParam *pParam,
                           const uno::Reference< beans::XPropertySet > &rColumnProps,
                           LanguageType nLanguage, OUString &rResult, double* pNumber)
377{
  SwDBFormatData aFormatData;
  if(!pParam->xFormatter.is())
  {
      uno::Reference<sdbc::XDataSource> xSource = SwDBManager::getDataSourceAsParent(
                                  pParam->xConnection,pParam->sDataSource);
      lcl_InitNumberFormatter(*pParam, xSource );
  }
  aFormatData.aNullDate = pParam->aNullDate;
  aFormatData.xFormatter = pParam->xFormatter;

  aFormatData.aLocale = LanguageTag( nLanguage ).getLocale();

  rResult = SwDBManager::GetDBField( rColumnProps, aFormatData, pNumber);
391}

393static bool lcl_GetColumnCnt(SwDSParam* pParam, const OUString& rColumnName,
                           LanguageType nLanguage, OUString& rResult, double* pNumber)
395{
  uno::Reference< sdbcx::XColumnsSupplier > xColsSupp( pParam->xResultSet, uno::UNO_QUERY );
  uno::Reference<container::XNameAccess> xCols;
  try
  {
      xCols = xColsSupp->getColumns();
  }
  catch(const lang::DisposedException&)
  {
  }
  if(!xCols.is() || !xCols->hasByName(rColumnName))
      return false;
  uno::Any aCol = xCols->getByName(rColumnName);
  uno::Reference< beans::XPropertySet > xColumnProps;
  aCol >>= xColumnProps;
  lcl_GetColumnCnt( pParam, xColumnProps, nLanguage, rResult, pNumber );
  return true;
412};

414// import data
415bool SwDBManager::Merge( const SwMergeDescriptor& rMergeDesc )
416{
  assert( !m_bInMerge && !m_pImpl->pMergeData && "merge already activated!" )(static_cast <bool> (!m_bInMerge && !m_pImpl->
pMergeData && "merge already activated!") ? void (0) :
 __assert_fail ("!m_bInMerge && !m_pImpl->pMergeData && \"merge already activated!\""
, "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 417, __extension__ __PRETTY_FUNCTION__));

  SfxObjectShellLock  xWorkObjSh;
  SwWrtShell         *pWorkShell            = nullptr;
  SwDoc              *pWorkDoc              = nullptr;
  SwDBManager        *pWorkDocOrigDBManager = nullptr;

  switch( rMergeDesc.nMergeType )
  {
      case DBMGR_MERGE_PRINTER:
      case DBMGR_MERGE_EMAIL:
      case DBMGR_MERGE_FILE:
      case DBMGR_MERGE_SHELL:
      {
          SwDocShell *pSourceDocSh = rMergeDesc.rSh.GetView().GetDocShell();
          if( pSourceDocSh->IsModified() )
          {
              pWorkDocOrigDBManager = this;
              xWorkObjSh = lcl_CreateWorkingDocument(
                  WorkingDocType::SOURCE, rMergeDesc.rSh, nullptr,
                  &pWorkDocOrigDBManager, nullptr, &pWorkShell, &pWorkDoc );
          }
          [[fallthrough]];
      }

      default:
          if( !xWorkObjSh.Is() )
              pWorkShell = &rMergeDesc.rSh;
          break;
  }

  SwDBData aData;
  aData.nCommandType = sdb::CommandType::TABLE;
  uno::Reference<sdbc::XResultSet>  xResSet;
  uno::Sequence<uno::Any> aSelection;
  uno::Reference< sdbc::XConnection> xConnection;

  aData.sDataSource = rMergeDesc.rDescriptor.getDataSource();
  rMergeDesc.rDescriptor[svx::DataAccessDescriptorProperty::Command]      >>= aData.sCommand;
  rMergeDesc.rDescriptor[svx::DataAccessDescriptorProperty::CommandType]  >>= aData.nCommandType;

  if ( rMergeDesc.rDescriptor.has(svx::DataAccessDescriptorProperty::Cursor) )
      rMergeDesc.rDescriptor[svx::DataAccessDescriptorProperty::Cursor] >>= xResSet;
  if ( rMergeDesc.rDescriptor.has(svx::DataAccessDescriptorProperty::Selection) )
      rMergeDesc.rDescriptor[svx::DataAccessDescriptorProperty::Selection] >>= aSelection;
  if ( rMergeDesc.rDescriptor.has(svx::DataAccessDescriptorProperty::Connection) )
      rMergeDesc.rDescriptor[svx::DataAccessDescriptorProperty::Connection] >>= xConnection;

  if((aData.sDataSource.isEmpty() || aData.sCommand.isEmpty()) && !xResSet.is())
  {
      return false;
  }

  m_pImpl->pMergeData.reset(new SwDSParam(aData, xResSet, aSelection));
  SwDSParam*  pTemp = FindDSData(aData, false);
  if(pTemp)
      *pTemp = *m_pImpl->pMergeData;
  else
  {
      // calls from the calculator may have added a connection with an invalid commandtype
      //"real" data base connections added here have to re-use the already available
      //DSData and set the correct CommandType
      aData.nCommandType = -1;
      pTemp = FindDSData(aData, false);
      if(pTemp)
          *pTemp = *m_pImpl->pMergeData;
      else
      {
          m_DataSourceParams.push_back(std::make_unique<SwDSParam>(*m_pImpl->pMergeData));
          try
          {
              uno::Reference<lang::XComponent> xComponent(m_DataSourceParams.back()->xConnection, uno::UNO_QUERY);
              if(xComponent.is())
                  xComponent->addEventListener(m_pImpl->m_xDisposeListener.get());
          }
          catch(const uno::Exception&)
          {
          }
      }
  }
  if(!m_pImpl->pMergeData->xConnection.is())
      m_pImpl->pMergeData->xConnection = xConnection;
  // add an XEventListener

  lcl_ToNextRecord(m_pImpl->pMergeData.get(), SwDBNextRecord::FIRST);

  uno::Reference<sdbc::XDataSource> xSource = SwDBManager::getDataSourceAsParent(xConnection,aData.sDataSource);

  lcl_InitNumberFormatter(*m_pImpl->pMergeData, xSource);

  pWorkShell->ChgDBData(aData);
  m_bInMerge = true;

  if (IsInitDBFields())
  {
      // with database fields without DB-Name, use DB-Name from Doc
      std::vector<OUString> aDBNames;
      aDBNames.emplace_back();
      SwDBData aInsertData = pWorkShell->GetDBData();
      OUString sDBName = aInsertData.sDataSource
          + OUStringChar(DB_DELIMu'\x00ff') + aInsertData.sCommand
          + OUStringChar(DB_DELIMu'\x00ff')
          + OUString::number(aInsertData.nCommandType);
      pWorkShell->ChangeDBFields( aDBNames, sDBName);
      SetInitDBFields(false);
  }

  bool bRet = true;
  switch(rMergeDesc.nMergeType)
  {
      case DBMGR_MERGE:
          pWorkShell->StartAllAction();
          pWorkShell->SwViewShell::UpdateFields( true );
          pWorkShell->SetModified();
          pWorkShell->EndAllAction();
          break;

      case DBMGR_MERGE_PRINTER:
      case DBMGR_MERGE_EMAIL:
      case DBMGR_MERGE_FILE:
      case DBMGR_MERGE_SHELL:
          // save files and send them as e-Mail if required
          bRet = MergeMailFiles(pWorkShell, rMergeDesc);
          break;

      default:
          // insert selected entries
          // (was: InsertRecord)
          ImportFromConnection(pWorkShell);
          break;
  }

  m_pImpl->pMergeData.reset();

  if( xWorkObjSh.Is() )
  {
      pWorkDoc->SetDBManager( pWorkDocOrigDBManager );
      xWorkObjSh->DoClose();
  }

  m_bInMerge = false;

  return bRet;
560}

562void SwDBManager::ImportFromConnection(  SwWrtShell* pSh )
563{
  if(!m_pImpl->pMergeData || m_pImpl->pMergeData->bEndOfDB)
      return;

  pSh->StartAllAction();
  pSh->StartUndo();
  bool bGroupUndo(pSh->DoesGroupUndo());
  pSh->DoGroupUndo(false);

  if( pSh->HasSelection() )
      pSh->DelRight();

  std::unique_ptr<SwWait> pWait;

  {
      sal_uLong i = 0;
      do {

          ImportDBEntry(pSh);
          if( 10 == ++i )
              pWait.reset(new SwWait( *pSh->GetView().GetDocShell(), true));

      } while(ToNextMergeRecord());
  }

  pSh->DoGroupUndo(bGroupUndo);
  pSh->EndUndo();
  pSh->EndAllAction();
591}

593void SwDBManager::ImportDBEntry(SwWrtShell* pSh)
594{
  if(!m_pImpl->pMergeData || m_pImpl->pMergeData->bEndOfDB)
      return;

  uno::Reference< sdbcx::XColumnsSupplier > xColsSupp( m_pImpl->pMergeData->xResultSet, uno::UNO_QUERY );
  uno::Reference<container::XNameAccess> xCols = xColsSupp->getColumns();
  OUStringBuffer sStr;
  uno::Sequence<OUString> aColNames = xCols->getElementNames();
  const OUString* pColNames = aColNames.getConstArray();
  long nLength = aColNames.getLength();
  for(long i = 0; i < nLength; i++)
  {
      uno::Any aCol = xCols->getByName(pColNames[i]);
      uno::Reference< beans::XPropertySet > xColumnProp;
      aCol >>= xColumnProp;
      SwDBFormatData aDBFormat;
      sStr.append(GetDBField( xColumnProp, aDBFormat));
      if (i < nLength - 1)
          sStr.append("\t");
  }
  pSh->SwEditShell::Insert2(sStr.makeStringAndClear());
  pSh->SwFEShell::SplitNode();    // line feed
616}

618bool SwDBManager::GetTableNames(weld::ComboBox& rBox, const OUString& rDBName)
619{
  bool bRet = false;
  OUString sOldTableName(rBox.get_active_text());
  rBox.clear();
  SwDSParam* pParam = FindDSConnection(rDBName, false);
  uno::Reference< sdbc::XConnection> xConnection;
  if (pParam && pParam->xConnection.is())
      xConnection = pParam->xConnection;
  else
  {
      if ( !rDBName.isEmpty() )
          xConnection = RegisterConnection( rDBName );
  }
  if (xConnection.is())
  {
      uno::Reference<sdbcx::XTablesSupplier> xTSupplier(xConnection, uno::UNO_QUERY);
      if(xTSupplier.is())
      {
          uno::Reference<container::XNameAccess> xTables = xTSupplier->getTables();
          const uno::Sequence<OUString> aTables = xTables->getElementNames();
          for (const OUString& rTable : aTables)
              rBox.append("0", rTable);
      }
      uno::Reference<sdb::XQueriesSupplier> xQSupplier(xConnection, uno::UNO_QUERY);
      if(xQSupplier.is())
      {
          uno::Reference<container::XNameAccess> xQueries = xQSupplier->getQueries();
          const uno::Sequence<OUString> aQueries = xQueries->getElementNames();
          for (const OUString& rQuery : aQueries)
              rBox.append("1", rQuery);
      }
      if (!sOldTableName.isEmpty())
          rBox.set_active_text(sOldTableName);
      bRet = true;
  }
  return bRet;
655}

657// fill Listbox with column names of a database
658void SwDBManager::GetColumnNames(weld::ComboBox& rBox,
                           const OUString& rDBName, const OUString& rTableName)
660{
  SwDBData aData;
  aData.sDataSource = rDBName;
  aData.sCommand = rTableName;
  aData.nCommandType = -1;
  SwDSParam* pParam = FindDSData(aData, false);
  uno::Reference< sdbc::XConnection> xConnection;
  if(pParam && pParam->xConnection.is())
      xConnection = pParam->xConnection;
  else
  {
      xConnection = RegisterConnection( rDBName );
  }
  GetColumnNames(rBox, xConnection, rTableName);
674}

676void SwDBManager::GetColumnNames(weld::ComboBox& rBox,
      uno::Reference< sdbc::XConnection> const & xConnection,
      const OUString& rTableName)
679{
  rBox.clear();
  uno::Reference< sdbcx::XColumnsSupplier> xColsSupp = SwDBManager::GetColumnSupplier(xConnection, rTableName);
  if(xColsSupp.is())
  {
      uno::Reference<container::XNameAccess> xCols = xColsSupp->getColumns();
      const uno::Sequence<OUString> aColNames = xCols->getElementNames();
      for (const OUString& rColName : aColNames)
      {
          rBox.append_text(rColName);
      }
      ::comphelper::disposeComponent( xColsSupp );
  }
692}

694SwDBManager::SwDBManager(SwDoc* pDoc)
  : m_aMergeStatus( MergeStatus::Ok )
  , m_bInitDBFields(false)
  , m_bInMerge(false)
  , m_bMergeSilent(false)
  , m_pImpl(new SwDBManager_Impl(*this))
  , m_pMergeEvtSrc(nullptr)
  , m_pDoc(pDoc)
702{
703}

705SwDBManager::~SwDBManager() COVERITY_NOEXCEPT_FALSE
706{
  RevokeLastRegistrations();

  // copy required, m_DataSourceParams can be modified while disposing components
  std::vector<uno::Reference<sdbc::XConnection>> aCopiedConnections;
  for (const auto & pParam : m_DataSourceParams)
  {
      if(pParam->xConnection.is())
      {
          aCopiedConnections.push_back(pParam->xConnection);
      }
  }
  for (const auto & xConnection : aCopiedConnections)
  {
      try
      {
          uno::Reference<lang::XComponent> xComp(xConnection, uno::UNO_QUERY);
          if(xComp.is())
              xComp->dispose();
      }
      catch(const uno::RuntimeException&)
      {
          //may be disposed already since multiple entries may have used the same connection
      }
  }
731}

733static void lcl_RemoveSectionLinks( SwWrtShell& rWorkShell )
734{
  //reset all links of the sections of synchronized labels
  size_t nSections = rWorkShell.GetSectionFormatCount();
  for (size_t nSection = 0; nSection < nSections; ++nSection)
  {
      SwSectionData aSectionData( *rWorkShell.GetSectionFormat( nSection ).GetSection() );
      if( aSectionData.GetType() == SectionType::FileLink )
      {
          aSectionData.SetType( SectionType::Content );
          aSectionData.SetLinkFileName( OUString() );
          rWorkShell.UpdateSection( nSection, aSectionData );
      }
  }
  rWorkShell.SetLabelDoc( false );
748}

750static void lcl_SaveDebugDoc( SfxObjectShell *xTargetDocShell,
                            const char *name, int no = 0 )
752{
  static OUString sTempDirURL;
  if( sTempDirURL.isEmpty() )
  {
      SvtPathOptions aPathOpt;
      utl::TempFile aTempDir( &aPathOpt.GetTempPath(), true );
      if( aTempDir.IsValid() )
      {
          INetURLObject aTempDirURL( aTempDir.GetURL() );
          sTempDirURL = aTempDirURL.GetMainURL( INetURLObject::DecodeMechanism::NONE );
          SAL_INFO( "sw.mailmerge", "Dump directory: " << sTempDirURL )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.mailmerge")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "Dump directory: " <<
 sTempDirURL) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "762" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "Dump directory: " << sTempDirURL
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Dump directory: " << sTempDirURL; ::sal::detail
::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "762" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Dump directory: " << sTempDirURL) == 1) { ::
sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.mailmerge"
), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "762" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "Dump directory: " << sTempDirURL
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Dump directory: " << sTempDirURL; ::sal::detail
::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "762" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
      }
  }
  if( sTempDirURL.isEmpty() )
      return;

  const OUString sExt( ".odt" );
  OUString basename = OUString::createFromAscii( name );
  if (no > 0)
      basename += OUString::number(no) + "-";
  // aTempFile is not deleted, but that seems to be intentional
  utl::TempFile aTempFile( basename, true, &sExt, &sTempDirURL );
  INetURLObject aTempFileURL( aTempFile.GetURL() );
  auto pDstMed = std::make_unique<SfxMedium>(
      aTempFileURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ),
      StreamMode::STD_READWRITE );
  bool bAnyError = !xTargetDocShell->DoSaveAs( *pDstMed );
  // xObjectShell->DoSaveCompleted crashes the mail merge unit tests, so skip it
  bAnyError |= (ERRCODE_NONEErrCode(0) != xTargetDocShell->GetError());
  if( bAnyError )
      SAL_WARN( "sw.mailmerge", "Error saving: " << aTempFile.GetURL() )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.mailmerge")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "Error saving: " <<
 aTempFile.GetURL()) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "782" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "Error saving: " << aTempFile.GetURL
()), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Error saving: " << aTempFile.GetURL(); ::sal
::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"
), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "782" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Error saving: " << aTempFile.GetURL()) == 1
) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"
), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "782" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "Error saving: " << aTempFile.GetURL
()), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Error saving: " << aTempFile.GetURL(); ::sal
::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"
), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "782" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  else
      SAL_INFO( "sw.mailmerge", "Saved doc as: " << aTempFile.GetURL() )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.mailmerge")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "Saved doc as: " <<
 aTempFile.GetURL()) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "784" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "Saved doc as: " << aTempFile.GetURL
()), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Saved doc as: " << aTempFile.GetURL(); ::sal
::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.mailmerge"
), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "784" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Saved doc as: " << aTempFile.GetURL()) == 1
) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.mailmerge"
), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "784" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "Saved doc as: " << aTempFile.GetURL
()), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Saved doc as: " << aTempFile.GetURL(); ::sal
::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.mailmerge"
), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "784" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
785}

787static bool lcl_SaveDoc(
  const INetURLObject* pFileURL,
  const std::shared_ptr<const SfxFilter>& pStoreToFilter,
  const OUString* pStoreToFilterOptions,
  const uno::Sequence< beans::PropertyValue >* pSaveToFilterData,
  const bool bIsPDFexport,
  SfxObjectShell* xObjectShell,
  SwWrtShell& rWorkShell,
  OUString * const decodedURL = nullptr )
796{
  OUString url = pFileURL->GetMainURL( INetURLObject::DecodeMechanism::NONE );
  if( decodedURL )
      (*decodedURL) = url;

  SfxMedium* pDstMed = new SfxMedium( url, StreamMode::STD_READWRITE );
  pDstMed->SetFilter( pStoreToFilter );
  if( pDstMed->GetItemSet() )
  {
      if( pStoreToFilterOptions )
          pDstMed->GetItemSet()->Put( SfxStringItem(SID_FILE_FILTEROPTIONS(5000 + 527),
                                      *pStoreToFilterOptions));
      if( pSaveToFilterData->hasElements() )
          pDstMed->GetItemSet()->Put( SfxUnoAnyItem(SID_FILTER_DATA(5000 + 1375),
                                      uno::makeAny(*pSaveToFilterData)));
  }

  // convert fields to text if we are exporting to PDF.
  // this prevents a second merge while updating the fields
  // in SwXTextDocument::getRendererCount()
  if( bIsPDFexport )
      rWorkShell.ConvertFieldsToText();

  bool bAnyError = !xObjectShell->DoSaveAs(*pDstMed);
  // Actually this should be a bool... so in case of email and individual
  // files, where this is set, we skip the recently used handling
  bAnyError |= !xObjectShell->DoSaveCompleted( pDstMed, !decodedURL );
  bAnyError |= (ERRCODE_NONEErrCode(0) != xObjectShell->GetError());
  if( bAnyError )
  {
      // error message ??
      ErrorHandler::HandleError( xObjectShell->GetError() );
  }
  return !bAnyError;
830}

832static void lcl_PreparePrinterOptions(
  const uno::Sequence< beans::PropertyValue >& rInPrintOptions,
  uno::Sequence< beans::PropertyValue >& rOutPrintOptions)
835{
  // printing should be done synchronously otherwise the document
  // might already become invalid during the process

  const sal_Int32 nOffset = 1;
  rOutPrintOptions.realloc( nOffset );
  rOutPrintOptions[ 0 ].Name = "Wait";
  rOutPrintOptions[ 0 ].Value <<= true;

  // copy print options
  sal_Int32 nIndex = nOffset;
  for( const beans::PropertyValue& rOption : rInPrintOptions)
  {
      if( rOption.Name == "CopyCount" || rOption.Name == "FileName"
          || rOption.Name == "Collate" || rOption.Name == "Pages"
          || rOption.Name == "Wait" || rOption.Name == "PrinterName" )
      {
          // add an option
          rOutPrintOptions.realloc( nIndex + 1 );
          rOutPrintOptions[ nIndex ].Name = rOption.Name;
          rOutPrintOptions[ nIndex++ ].Value = rOption.Value ;
      }
  }
858}

860static void lcl_PrepareSaveFilterDataOptions(
  const uno::Sequence< beans::PropertyValue >& rInSaveFilterDataptions,
  uno::Sequence< beans::PropertyValue >& rOutSaveFilterDataOptions,
  const OUString& sPassword)
864{
  const sal_Int32 nOffset = 2;
  rOutSaveFilterDataOptions.realloc( nOffset );
  rOutSaveFilterDataOptions[ 0 ].Name = "EncryptFile";
  rOutSaveFilterDataOptions[ 0 ].Value <<= true;
  rOutSaveFilterDataOptions[ 1 ].Name = "DocumentOpenPassword";
  rOutSaveFilterDataOptions[ 1 ].Value <<= sPassword;

  // copy other options
  sal_Int32 nIndex = nOffset;
  for( const beans::PropertyValue& rOption : rInSaveFilterDataptions)
  {
       rOutSaveFilterDataOptions.realloc( nIndex + 1 );
       rOutSaveFilterDataOptions[ nIndex ].Name = rOption.Name;
       rOutSaveFilterDataOptions[ nIndex++ ].Value = rOption.Value ;
  }

881}


884static SfxObjectShell* lcl_CreateWorkingDocument(
  // input
  const WorkingDocType aType, const SwWrtShell &rSourceWrtShell,
  // optional input
  const vcl::Window *pSourceWindow,
  // optional in and output to swap the DB manager
  SwDBManager** const ppDBManager,
  // optional output
  SwView** const pView, SwWrtShell** const pWrtShell, SwDoc** const pDoc )
893{
  const SwDoc *pSourceDoc = rSourceWrtShell.GetDoc();
  SfxObjectShellRef xWorkObjectShell = pSourceDoc->CreateCopy( true, (aType == WorkingDocType::TARGET) );
  SfxViewFrame* pWorkFrame = SfxViewFrame::LoadHiddenDocument( *xWorkObjectShell, SFX_INTERFACE_NONE );

  if( pSourceWindow )
  {
      // the created window has to be located at the same position as the source window
      vcl::Window& rTargetWindow = pWorkFrame->GetFrame().GetWindow();
      rTargetWindow.SetPosPixel( pSourceWindow->GetPosPixel() );
  }

  SwView* pWorkView = static_cast< SwView* >( pWorkFrame->GetViewShell() );
  SwWrtShell* pWorkWrtShell = pWorkView->GetWrtShellPtr();
  pWorkWrtShell->GetViewOptions()->SetIdle( false );
  pWorkView->AttrChangedNotify(nullptr);// in order for SelectShell to be called
  SwDoc* pWorkDoc = pWorkWrtShell->GetDoc();
  pWorkDoc->GetIDocumentUndoRedo().DoUndo( false );
  pWorkDoc->ReplaceDocumentProperties( *pSourceDoc );

  // import print settings
  const SwPrintData &rPrintData = pSourceDoc->getIDocumentDeviceAccess().getPrintData();
  pWorkDoc->getIDocumentDeviceAccess().setPrintData(rPrintData);
  const JobSetup *pJobSetup = pSourceDoc->getIDocumentDeviceAccess().getJobsetup();
  if (pJobSetup)
      pWorkDoc->getIDocumentDeviceAccess().setJobsetup(*pJobSetup);

  if( aType == WorkingDocType::TARGET )
  {
      assert( !ppDBManager )(static_cast <bool> (!ppDBManager) ? void (0) : __assert_fail
 ("!ppDBManager", "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 922, __extension__ __PRETTY_FUNCTION__));
      pWorkDoc->SetInMailMerge( true );
      pWorkWrtShell->SetLabelDoc( false );
  }
  else
  {
      // We have to swap the DBmanager of the new doc, so we also need input
      assert(ppDBManager && *ppDBManager)(static_cast <bool> (ppDBManager && *ppDBManager
) ? void (0) : __assert_fail ("ppDBManager && *ppDBManager"
, "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 929, __extension__ __PRETTY_FUNCTION__));
      SwDBManager *pWorkDBManager = pWorkDoc->GetDBManager();
      pWorkDoc->SetDBManager( *ppDBManager );
      *ppDBManager = pWorkDBManager;

      if( aType == WorkingDocType::SOURCE )
      {
          // the GetDBData call constructs the data, if it's missing - kind of const...
          pWorkWrtShell->ChgDBData( const_cast<SwDoc*>(pSourceDoc)->GetDBData() );
          // some DocumentSettings are currently not copied by SwDoc::CreateCopy
          pWorkWrtShell->SetLabelDoc( rSourceWrtShell.IsLabelDoc() );
          pWorkDoc->getIDocumentState().ResetModified();
      }
      else
          pWorkDoc->getIDocumentLinksAdministration().EmbedAllLinks();
  }

  if( pView )     *pView     = pWorkView;
  if( pWrtShell ) *pWrtShell = pWorkWrtShell;
  if( pDoc )      *pDoc      = pWorkDoc;

  return xWorkObjectShell.get();
951}

953static SwMailMessage* lcl_CreateMailFromDoc(
  const SwMergeDescriptor &rMergeDescriptor,
  const OUString &sFileURL, const OUString &sMailRecipient,
  const OUString &sMailBodyMimeType, rtl_TextEncoding sMailEncoding,
  const OUString &sAttachmentMimeType )
958{
  SwMailMessage* pMessage = new SwMailMessage;
  if( rMergeDescriptor.pMailMergeConfigItem->IsMailReplyTo() )
      pMessage->setReplyToAddress(rMergeDescriptor.pMailMergeConfigItem->GetMailReplyTo());
  pMessage->addRecipient( sMailRecipient );
  pMessage->SetSenderAddress( rMergeDescriptor.pMailMergeConfigItem->GetMailAddress() );

  OUStringBuffer sBody;
  if( rMergeDescriptor.bSendAsAttachment )
  {
      sBody = rMergeDescriptor.sMailBody;
      mail::MailAttachment aAttach;
      aAttach.Data = new SwMailTransferable( sFileURL,
          rMergeDescriptor.sAttachmentName, sAttachmentMimeType );
      aAttach.ReadableName = rMergeDescriptor.sAttachmentName;
      pMessage->addAttachment( aAttach );
  }
  else
  {
      //read in the temporary file and use it as mail body
      SfxMedium aMedium( sFileURL, StreamMode::READ );
      SvStream* pInStream = aMedium.GetInStream();
      assert( pInStream && "no output file created?" )(static_cast <bool> (pInStream && "no output file created?"
) ? void (0) : __assert_fail ("pInStream && \"no output file created?\""
, "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 980, __extension__ __PRETTY_FUNCTION__));
      if( !pInStream )
          return pMessage;

      pInStream->SetStreamCharSet( sMailEncoding );
      OString sLine;
      while ( pInStream->ReadLine( sLine ) )
      {
          sBody.append(OStringToOUString( sLine, sMailEncoding ));
          sBody.append("\n");
      }
  }
  pMessage->setSubject( rMergeDescriptor.sSubject );
  uno::Reference< datatransfer::XTransferable> xBody =
              new SwMailTransferable( sBody.makeStringAndClear(), sMailBodyMimeType );
  pMessage->setBody( xBody );

  for( const OUString& sCcRecipient : rMergeDescriptor.aCopiesTo )
      pMessage->addCcRecipient( sCcRecipient );
  for( const OUString& sBccRecipient : rMergeDescriptor.aBlindCopiesTo )
      pMessage->addBccRecipient( sBccRecipient );

  return pMessage;
1003}

1005class SwDBManager::MailDispatcherListener_Impl : public IMailDispatcherListener
1006{
  SwDBManager &m_rDBManager;

1009public:
  explicit MailDispatcherListener_Impl( SwDBManager &rDBManager )
      : m_rDBManager( rDBManager ) {}

  virtual void idle() override {}

  virtual void mailDelivered( uno::Reference< mail::XMailMessage> xMessage ) override
  {
      osl::MutexGuard aGuard( m_rDBManager.m_pImpl->m_aAllEmailSendMutex );
      if ( m_rDBManager.m_pImpl->m_xLastMessage == xMessage )
          m_rDBManager.m_pImpl->m_xLastMessage.clear();
  }

  virtual void mailDeliveryError( ::rtl::Reference<MailDispatcher> xMailDispatcher,
              uno::Reference< mail::XMailMessage>, const OUString& ) override
  {
      osl::MutexGuard aGuard( m_rDBManager.m_pImpl->m_aAllEmailSendMutex );
      m_rDBManager.m_aMergeStatus = MergeStatus::Error;
      m_rDBManager.m_pImpl->m_xLastMessage.clear();
      xMailDispatcher->stop();
  }
1030};

1032/**
* Please have a look at the README in the same directory, before you make
* larger changes in this function!
*/
1036bool SwDBManager::MergeMailFiles(SwWrtShell* pSourceShell,
                               const SwMergeDescriptor& rMergeDescriptor)
1038{
  // deconstruct mail merge type for better readability.
  // uppercase naming is intentional!
  const bool bMT_EMAIL   = rMergeDescriptor.nMergeType == DBMGR_MERGE_EMAIL;
1
Assuming field 'nMergeType' is not equal to DBMGR_MERGE_EMAIL→
  const bool bMT_SHELL   = rMergeDescriptor.nMergeType == DBMGR_MERGE_SHELL;
2
←
Assuming field 'nMergeType' is not equal to DBMGR_MERGE_SHELL→
  const bool bMT_PRINTER = rMergeDescriptor.nMergeType == DBMGR_MERGE_PRINTER;
3
←
Assuming field 'nMergeType' is not equal to DBMGR_MERGE_PRINTER→
  const bool bMT_FILE    = rMergeDescriptor.nMergeType == DBMGR_MERGE_FILE;
4
←
Assuming field 'nMergeType' is not equal to DBMGR_MERGE_FILE→

  //check if the doc is synchronized and contains at least one linked section
  const bool bSynchronizedDoc = pSourceShell->IsLabelDoc() && pSourceShell->GetSectionFormatCount() > 1;
5
←
Assuming the condition is false→
  const bool bNeedsTempFiles = ( bMT_EMAIL5.1
'bMT_EMAIL' is false
1
'bMT_EMAIL' is false
1
'bMT_EMAIL' is false
 || bMT_FILE );
  const bool bIsMergeSilent = IsMergeSilent();

  bool bCheckSingleFile_ = rMergeDescriptor.bCreateSingleFile;
  OUString sPrefix_ = rMergeDescriptor.sPrefix;
  if( bMT_EMAIL5.2
'bMT_EMAIL' is false
2
'bMT_EMAIL' is false
2
'bMT_EMAIL' is false
 )
6
←
Taking false branch→
  {
      assert( !rMergeDescriptor.bPrefixIsFilename )(static_cast <bool> (!rMergeDescriptor.bPrefixIsFilename
) ? void (0) : __assert_fail ("!rMergeDescriptor.bPrefixIsFilename"
, "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 1055, __extension__ __PRETTY_FUNCTION__));
      assert(!bCheckSingleFile_)(static_cast <bool> (!bCheckSingleFile_) ? void (0) : __assert_fail
 ("!bCheckSingleFile_", "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 1056, __extension__ __PRETTY_FUNCTION__));
      bCheckSingleFile_ = false;
  }
  else if( bMT_SHELL6.1
'bMT_SHELL' is false
1
'bMT_SHELL' is false
1
'bMT_SHELL' is false
 || bMT_PRINTER6.2
'bMT_PRINTER' is false
2
'bMT_PRINTER' is false
2
'bMT_PRINTER' is false
 )
7
←
Taking false branch→
  {
      assert(bCheckSingleFile_)(static_cast <bool> (bCheckSingleFile_) ? void (0) : __assert_fail
 ("bCheckSingleFile_", "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 1061, __extension__ __PRETTY_FUNCTION__));
      bCheckSingleFile_ = true;
      assert(sPrefix_.isEmpty())(static_cast <bool> (sPrefix_.isEmpty()) ? void (0) : __assert_fail
 ("sPrefix_.isEmpty()", "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 1063, __extension__ __PRETTY_FUNCTION__));
      sPrefix_.clear();
  }
  const bool bCreateSingleFile = bCheckSingleFile_;
  const OUString sDescriptorPrefix = sPrefix_;

  // Setup for dumping debugging documents
  static const sal_Int32 nMaxDumpDocs = []() {
      if (const char* sEnv = getenv("SW_DEBUG_MAILMERGE_DOCS"))
          return OUString(sEnv, strlen(sEnv), osl_getThreadTextEncoding()).toInt32();
      else
          return sal_Int32(0);
  }();

  ::rtl::Reference< MailDispatcher >          xMailDispatcher;
  ::rtl::Reference< IMailDispatcherListener > xMailListener;
  OUString                            sMailBodyMimeType;
  rtl_TextEncoding                    sMailEncoding = ::osl_getThreadTextEncoding();

  uno::Reference< beans::XPropertySet > xColumnProp;
  uno::Reference< beans::XPropertySet > xPasswordColumnProp;

  // Check for (mandatory) email or (optional) filename column
  SwDBFormatData aColumnDBFormat;
  bool bColumnName = !rMergeDescriptor.sDBcolumn.isEmpty();
8
←
Calling 'OUString::isEmpty'→
11
←
Returning from 'OUString::isEmpty'→
  bool bPasswordColumnName = !rMergeDescriptor.sDBPasswordColumn.isEmpty();

  if( ! bColumnName11.1
'bColumnName' is false
1
'bColumnName' is false
1
'bColumnName' is false
 )
12
←
Taking true branch→
  {
      if( bMT_EMAIL12.1
'bMT_EMAIL' is false
1
'bMT_EMAIL' is false
1
'bMT_EMAIL' is false
 )
13
←
Taking false branch→
          return false;
  }
  else
  {
      uno::Reference< sdbcx::XColumnsSupplier > xColsSupp( m_pImpl->pMergeData->xResultSet, uno::UNO_QUERY );
      uno::Reference<container::XNameAccess> xCols = xColsSupp->getColumns();
      if( !xCols->hasByName( rMergeDescriptor.sDBcolumn ) )
          return false;
      uno::Any aCol = xCols->getByName( rMergeDescriptor.sDBcolumn );
      aCol >>= xColumnProp;

      if(bPasswordColumnName)
      {
          aCol = xCols->getByName( rMergeDescriptor.sDBPasswordColumn );
          aCol >>= xPasswordColumnProp;
      }

      aColumnDBFormat.xFormatter = m_pImpl->pMergeData->xFormatter;
      aColumnDBFormat.aNullDate  = m_pImpl->pMergeData->aNullDate;

      if( bMT_EMAIL )
      {
          // Reset internal mail accounting data
          m_pImpl->m_xLastMessage.clear();

          xMailDispatcher.set( new MailDispatcher(rMergeDescriptor.xSmtpServer) );
          xMailListener = new MailDispatcherListener_Impl( *this );
          xMailDispatcher->addListener( xMailListener );
          if(!rMergeDescriptor.bSendAsAttachment && rMergeDescriptor.bSendAsHTML)
          {
              sMailBodyMimeType = "text/html; charset=" + OUString::createFromAscii(
                                  rtl_getBestMimeCharsetFromTextEncoding( sMailEncoding ));
              SvxHtmlOptions& rHtmlOptions = SvxHtmlOptions::Get();
              sMailEncoding = rHtmlOptions.GetTextEncoding();
          }
          else
              sMailBodyMimeType = "text/plain; charset=UTF-8; format=flowed";
      }
  }

  SwDocShell  *pSourceDocSh = pSourceShell->GetView().GetDocShell();

  // setup the output format
  std::shared_ptr<const SfxFilter> pStoreToFilter = SwIoSystem::GetFileFilter(
      pSourceDocSh->GetMedium()->GetURLObject().GetMainURL(INetURLObject::DecodeMechanism::NONE));
  SfxFilterContainer* pFilterContainer = SwDocShell::Factory().GetFilterContainer();
  const OUString* pStoreToFilterOptions = nullptr;

  // if a save_to filter is set then use it - otherwise use the default
  if( bMT_EMAIL13.1
'bMT_EMAIL' is false
1
'bMT_EMAIL' is false
1
'bMT_EMAIL' is false
 && !rMergeDescriptor.bSendAsAttachment )
  {
      OUString sExtension = rMergeDescriptor.bSendAsHTML ? OUString("html") : OUString("txt");
      pStoreToFilter = pFilterContainer->GetFilter4Extension(sExtension, SfxFilterFlags::EXPORT);
  }
  else if( !rMergeDescriptor.sSaveToFilter.isEmpty())
14
←
Taking false branch→
  {
      std::shared_ptr<const SfxFilter> pFilter =
              pFilterContainer->GetFilter4FilterName( rMergeDescriptor.sSaveToFilter );
      if(pFilter)
      {
          pStoreToFilter = pFilter;
          if(!rMergeDescriptor.sSaveToFilterOptions.isEmpty())
              pStoreToFilterOptions = &rMergeDescriptor.sSaveToFilterOptions;
      }
  }
  const bool bIsPDFexport = pStoreToFilter && pStoreToFilter->GetFilterName() == "writer_pdf_Export";

  m_aMergeStatus = MergeStatus::Ok;

  // in case of creating a single resulting file this has to be created here
  SwView*           pTargetView     = rMergeDescriptor.pMailMergeConfigItem ?
15
←
Assuming field 'pMailMergeConfigItem' is null→
16
←
'?' condition is false→
                                      rMergeDescriptor.pMailMergeConfigItem->GetTargetView() : nullptr;
  SwWrtShell*       pTargetShell    = nullptr;
  SwDoc*            pTargetDoc      = nullptr;
  SfxObjectShellRef xTargetDocShell;

  std::unique_ptr< utl::TempFile > aTempFile;
  sal_uInt16 nStartingPageNo = 0;

  std::shared_ptr<weld::GenericDialogController> xProgressDlg;

  try
  {
      vcl::Window *pSourceWindow = nullptr;
      if( !bIsMergeSilent )
17
←
Assuming 'bIsMergeSilent' is false→
18
←
Taking true branch→
      {
          // construct the process dialog
          pSourceWindow = &pSourceShell->GetView().GetEditWin();
          if (!bMT_PRINTER18.1
'bMT_PRINTER' is false
1
'bMT_PRINTER' is false
1
'bMT_PRINTER' is false
)
19
←
Taking true branch→
              xProgressDlg = std::make_shared<CreateMonitor>(pSourceWindow->GetFrameWeld());
          else
          {
              xProgressDlg = std::make_shared<PrintMonitor>(pSourceWindow->GetFrameWeld());
              static_cast<PrintMonitor*>(xProgressDlg.get())->set_title(
                  pSourceDocSh->GetTitle(22));
          }
          weld::DialogController::runAsync(xProgressDlg, [this, &xProgressDlg](sal_Int32 nResult){
              if (nResult == RET_CANCEL)
                  MergeCancel();
              xProgressDlg.reset();
          });

          Application::Reschedule( true );
      }

      if( bCreateSingleFile && !pTargetView )
20
←
Assuming 'bCreateSingleFile' is false→
      {
          // create a target docshell to put the merged document into
          xTargetDocShell = lcl_CreateWorkingDocument( WorkingDocType::TARGET,
              *pSourceShell, bMT_SHELL ? pSourceWindow : nullptr,
              nullptr, &pTargetView, &pTargetShell, &pTargetDoc );

          if (nMaxDumpDocs)
              lcl_SaveDebugDoc( xTargetDocShell.get(), "MergeDoc" );
      }
      else if( pTargetView20.1
'pTargetView' is null
1
'pTargetView' is null
1
'pTargetView' is null
 )
21
←
Taking false branch→
      {
          pTargetShell = pTargetView->GetWrtShellPtr();
          pTargetDoc = pTargetShell->GetDoc();
          xTargetDocShell = pTargetView->GetDocShell();
      }

      if( bCreateSingleFile21.1
'bCreateSingleFile' is false
1
'bCreateSingleFile' is false
1
'bCreateSingleFile' is false
 )
22
←
Taking false branch→
      {
          // determine the page style and number used at the start of the source document
          pSourceShell->SttEndDoc(true);
          nStartingPageNo = pSourceShell->GetVirtPageNum();
      }

      // Progress, to prohibit KeyInputs
      SfxProgress aProgress(pSourceDocSh, OUString(), 1);

      // lock all dispatchers
      SfxViewFrame* pViewFrame = SfxViewFrame::GetFirst(pSourceDocSh);
      while (pViewFrame)
23
←
Loop condition is false. Execution continues on line 1233→
      {
          pViewFrame->GetDispatcher()->Lock(true);
          pViewFrame = SfxViewFrame::GetNext(*pViewFrame, pSourceDocSh);
      }

      sal_Int32 nDocNo = 1;

      // For single file mode, the number of pages in the target document so far, which is used
      // by AppendDoc() to adjust position of page-bound objects. Getting this information directly
      // from the target doc would require repeated layouts of the doc, which is expensive, but
      // it can be manually computed from the source documents (for which we do layouts, so the page
      // count is known, and there is a blank page between each of them in the target document).
      int targetDocPageCount = 0;

      if( !bIsMergeSilent23.1
'bIsMergeSilent' is false
1
'bIsMergeSilent' is false
1
'bIsMergeSilent' is false
 && !bMT_PRINTER23.2
'bMT_PRINTER' is false
2
'bMT_PRINTER' is false
2
'bMT_PRINTER' is false
 )
24
←
Taking true branch→
      {
          sal_Int32 nRecordCount = 1;
          lcl_getCountFromResultSet( nRecordCount, m_pImpl->pMergeData.get() );

          // Synchronized docs don't auto-advance the record set, but there is a
          // "security" check, which will always advance the record set, if there
          // is no "next record" field in a synchronized doc => nRecordPerDoc > 0
          sal_Int32 nRecordPerDoc = pSourceShell->GetDoc()
                  ->getIDocumentFieldsAccess().GetRecordsPerDocument();
          if ( bSynchronizedDoc24.1
'bSynchronizedDoc' is false
1
'bSynchronizedDoc' is false
1
'bSynchronizedDoc' is false
 && (nRecordPerDoc > 1) )
              --nRecordPerDoc;
          assert( nRecordPerDoc > 0 )(static_cast <bool> (nRecordPerDoc > 0) ? void (0) :
 __assert_fail ("nRecordPerDoc > 0", "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 1254, __extension__ __PRETTY_FUNCTION__));
25
←
Assuming 'nRecordPerDoc' is > 0→
26
←
'?' condition is true→

          sal_Int32 nMaxDocs = nRecordCount / nRecordPerDoc;
          if ( 0 != nRecordCount % nRecordPerDoc )
27
←
Assuming the condition is false→
28
←
Taking false branch→
              nMaxDocs += 1;
          static_cast<CreateMonitor*>(xProgressDlg.get())->SetTotalCount(nMaxDocs);
      }

      long nStartRow, nEndRow;
      bool bFreezedLayouts = false;
      // to collect temporary email files
      std::vector< OUString> aFilesToRemove;

      // The SfxObjectShell will be closed explicitly later but
      // it is more safe to use SfxObjectShellLock here
      SfxObjectShellLock xWorkDocSh;
      SwView*            pWorkView             = nullptr;
      SwDoc*             pWorkDoc              = nullptr;
29
←
'pWorkDoc' initialized to a null pointer value→
      SwDBManager*       pWorkDocOrigDBManager = nullptr;
      SwWrtShell*        pWorkShell            = nullptr;
      bool               bWorkDocInitialized   = false;

      do
40
←
Loop condition is false.  Exiting loop→
      {
          nStartRow = m_pImpl->pMergeData ? m_pImpl->pMergeData->xResultSet->getRow() : 0;
30
←
'?' condition is true→

          OUString sColumnData;

          // Read the indicated data column, which should contain a valid mail
          // address or an optional file name
          if( bMT_EMAIL30.1
'bMT_EMAIL' is false
1
'bMT_EMAIL' is false
1
'bMT_EMAIL' is false
 || bColumnName30.2
'bColumnName' is false
2
'bColumnName' is false
2
'bColumnName' is false
 )
31
←
Taking false branch→
          {
              sColumnData = GetDBField( xColumnProp, aColumnDBFormat );
          }

          // create a new temporary file name - only done once in case of bCreateSingleFile
          if( bNeedsTempFiles31.1
'bNeedsTempFiles' is false
1
'bNeedsTempFiles' is false
1
'bNeedsTempFiles' is false
 && ( !bWorkDocInitialized || !bCreateSingleFile ))
          {
              OUString sPrefix = sDescriptorPrefix;
              OUString sLeading;

              //#i97667# if the name is from a database field then it will be used _as is_
              if( bColumnName && !bMT_EMAIL )
              {
                  if (!sColumnData.isEmpty())
                      sLeading = sColumnData;
                  else
                      sLeading = "_";
              }
              else
              {
                  INetURLObject aEntry( sPrefix );
                  sLeading = aEntry.GetBase();
                  aEntry.removeSegment();
                  sPrefix = aEntry.GetMainURL( INetURLObject::DecodeMechanism::NONE );
              }

              OUString sExt(comphelper::string::stripStart(pStoreToFilter->GetDefaultExtension(), '*'));
              aTempFile.reset( new utl::TempFile(sLeading, sColumnData.isEmpty(), &sExt, &sPrefix, true) );
              if( !aTempFile->IsValid() )
              {
                  ErrorHandler::HandleError( ERRCODE_IO_NOTSUPPORTEDErrCode( ErrCodeArea::Io, ErrCodeClass::NotSupported, 12 ) );
                  m_aMergeStatus = MergeStatus::Error;
              }
          }

          uno::Sequence< beans::PropertyValue > aSaveToFilterDataOptions( rMergeDescriptor.aSaveToFilterData );

          if( bMT_EMAIL31.2
'bMT_EMAIL' is false
2
'bMT_EMAIL' is false
2
'bMT_EMAIL' is false
 || bPasswordColumnName31.3
'bPasswordColumnName' is true
3
'bPasswordColumnName' is true
3
'bPasswordColumnName' is true
 )
32
←
Taking true branch→
          {
              OUString sPasswordColumnData = GetDBField( xPasswordColumnProp, aColumnDBFormat );
              lcl_PrepareSaveFilterDataOptions( rMergeDescriptor.aSaveToFilterData, aSaveToFilterDataOptions, sPasswordColumnData );
          }

          if( IsMergeOk() )
33
←
Calling 'SwDBManager::IsMergeOk'→
36
←
Returning from 'SwDBManager::IsMergeOk'→
37
←
Taking false branch→
          {
              std::unique_ptr< INetURLObject > aTempFileURL;
              if( bNeedsTempFiles )
                  aTempFileURL.reset( new INetURLObject(aTempFile->GetURL()));
              if( !bIsMergeSilent ) {
                  if( !bMT_PRINTER )
                      static_cast<CreateMonitor*>(xProgressDlg.get())->SetCurrentPosition(nDocNo);
                  else {
                      PrintMonitor *pPrintMonDlg = static_cast<PrintMonitor*>(xProgressDlg.get());
                      pPrintMonDlg->m_xPrinter->set_label(bNeedsTempFiles
                          ? aTempFileURL->GetBase() : pSourceDocSh->GetTitle( 2));
                      OUString sStat = SwResId(STR_STATSTR_LETTERreinterpret_cast<char const *>("STR_STATSTR_LETTER" "\004"
 u8"Letter")) + " " + OUString::number( nDocNo );
                      pPrintMonDlg->m_xPrintInfo->set_label(sStat);
                  }
                  //TODO xProgressDlg->queue_draw();
              }

              Scheduler::ProcessEventsToIdle();

              // Create a copy of the source document and work with that one instead of the source.
              // If we're not in the single file mode (which requires modifying the document for the merging),
              // it is enough to do this just once. Currently PDF also has to be treated special.
              if( !bWorkDocInitialized || bCreateSingleFile || bIsPDFexport )
              {
                  assert( !xWorkDocSh.Is())(static_cast <bool> (!xWorkDocSh.Is()) ? void (0) : __assert_fail
 ("!xWorkDocSh.Is()", "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 1353, __extension__ __PRETTY_FUNCTION__));
                  pWorkDocOrigDBManager = this;
                  xWorkDocSh = lcl_CreateWorkingDocument( WorkingDocType::COPY,
                      *pSourceShell, nullptr, &pWorkDocOrigDBManager,
                      &pWorkView, &pWorkShell, &pWorkDoc );
                  if ( (nMaxDumpDocs < 0) || (nDocNo <= nMaxDumpDocs) )
                      lcl_SaveDebugDoc( xWorkDocSh, "WorkDoc", nDocNo );

                  // #i69458# lock fields to prevent access to the result set while calculating layout
                  // tdf#92324: and do not unlock: keep document locked during printing to avoid
                  // ExpFields update during printing, generation of preview, etc.
                  pWorkShell->LockExpFields();
                  pWorkShell->CalcLayout();
                  // tdf#121168: Now force correct page descriptions applied to page frames. Without
                  // this, e.g., page frames starting with sections could have page descriptions set
                  // wrong. This would lead to wrong page styles applied in SwDoc::AppendDoc below.
                  pWorkShell->GetViewOptions()->SetIdle(true);
                  for (auto aLayout : pWorkShell->GetDoc()->GetAllLayouts())
                  {
                      aLayout->FreezeLayout(false);
                      aLayout->AllCheckPageDescs();
                  }
              }

              lcl_emitEvent(SfxEventHintId::SwEventFieldMerge, STR_SW_EVENT_FIELD_MERGE3, xWorkDocSh);

              // tdf#92324: Allow ExpFields update only by explicit instruction to avoid
              // database cursor movement on any other fields update, for example during
              // print preview and other operations
              if ( pWorkShell->IsExpFieldsLocked() )
                  pWorkShell->UnlockExpFields();
              pWorkShell->SwViewShell::UpdateFields();
              pWorkShell->LockExpFields();

              lcl_emitEvent(SfxEventHintId::SwEventFieldMergeFinished, STR_SW_EVENT_FIELD_MERGE_FINISHED4, xWorkDocSh);

              // also emit MailMergeEvent on XInterface if possible
              const SwXMailMerge *pEvtSrc = GetMailMergeEvtSrc();
              if(pEvtSrc)
              {
                  rtl::Reference< SwXMailMerge > xRef(
                      const_cast<SwXMailMerge*>(pEvtSrc) );
                  text::MailMergeEvent aEvt( static_cast<text::XMailMergeBroadcaster*>(xRef.get()), xWorkDocSh->GetModel() );
                  SolarMutexReleaser rel;
                  xRef->LaunchMailMergeEvent( aEvt );
              }

              // working copy is merged - prepare final steps depending on merge options

              if( bCreateSingleFile )
              {
                  assert( pTargetShell && "no target shell available!" )(static_cast <bool> (pTargetShell && "no target shell available!"
) ? void (0) : __assert_fail ("pTargetShell && \"no target shell available!\""
, "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 1404, __extension__ __PRETTY_FUNCTION__));

                  // prepare working copy and target to append

                  pWorkDoc->RemoveInvisibleContent();
                  // remove of invisible content has influence on page count and so on fields for page count,
                  // therefore layout has to be updated before fields are converted to text
                  pWorkShell->CalcLayout();
                  pWorkShell->ConvertFieldsToText();
                  pWorkShell->SetNumberingRestart();
                  if( bSynchronizedDoc )
                  {
                      lcl_RemoveSectionLinks( *pWorkShell );
                  }

                  if ( (nMaxDumpDocs < 0) || (nDocNo <= nMaxDumpDocs) )
                      lcl_SaveDebugDoc( xWorkDocSh, "WorkDoc", nDocNo );

                  // append the working document to the target document
                  if( targetDocPageCount % 2 == 1 )
                      ++targetDocPageCount; // Docs always start on odd pages (so offset must be even).
                  SwNodeIndex appendedDocStart = pTargetDoc->AppendDoc( *pWorkDoc,
                      nStartingPageNo, !bWorkDocInitialized, targetDocPageCount, nDocNo);
                  targetDocPageCount += pWorkShell->GetPageCnt();

                  if ( (nMaxDumpDocs < 0) || (nDocNo <= nMaxDumpDocs) )
                      lcl_SaveDebugDoc( xTargetDocShell.get(), "MergeDoc" );

                  if (bMT_SHELL)
                  {
                      SwDocMergeInfo aMergeInfo;
                      // Name of the mark is actually irrelevant, UNO bookmarks have internals names.
                      aMergeInfo.startPageInTarget = pTargetDoc->getIDocumentMarkAccess()->makeMark(
                          appendedDocStart, "", IDocumentMarkAccess::MarkType::UNO_BOOKMARK,
                          ::sw::mark::InsertMode::New);
                      aMergeInfo.nDBRow = nStartRow;
                      rMergeDescriptor.pMailMergeConfigItem->AddMergedDocument( aMergeInfo );
                  }
              }
              else
              {
                  assert( bNeedsTempFiles )(static_cast <bool> (bNeedsTempFiles) ? void (0) : __assert_fail
 ("bNeedsTempFiles", "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 1445, __extension__ __PRETTY_FUNCTION__));
                  assert( pWorkShell->IsExpFieldsLocked() )(static_cast <bool> (pWorkShell->IsExpFieldsLocked()
) ? void (0) : __assert_fail ("pWorkShell->IsExpFieldsLocked()"
, "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 1446, __extension__ __PRETTY_FUNCTION__));

                  // fields are locked, so it's fine to
                  // restore the old / empty DB manager for save
                  pWorkDoc->SetDBManager( pWorkDocOrigDBManager );

                  // save merged document
                  OUString sFileURL;
                  if( !lcl_SaveDoc( aTempFileURL.get(), pStoreToFilter, pStoreToFilterOptions,
                                  &aSaveToFilterDataOptions, bIsPDFexport,
                                  xWorkDocSh, *pWorkShell, &sFileURL ) )
                  {
                      m_aMergeStatus = MergeStatus::Error;
                  }

                  // back to the MM DB manager
                  pWorkDoc->SetDBManager( this );

                  if( bMT_EMAIL && !IsMergeError() )
                  {
                      // schedule file for later removal
                      aFilesToRemove.push_back( sFileURL );

                      if( !SwMailMergeHelper::CheckMailAddress( sColumnData ) )
                      {
                          OSL_FAIL("invalid e-Mail address in database column")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1471" ": "), "%s", "invalid e-Mail address in database column"
); } } while (false);
                      }
                      else
                      {
                          uno::Reference< mail::XMailMessage > xMessage = lcl_CreateMailFromDoc(
                              rMergeDescriptor, sFileURL, sColumnData, sMailBodyMimeType,
                              sMailEncoding, pStoreToFilter->GetMimeType() );
                          if( xMessage.is() )
                          {
                              osl::MutexGuard aGuard( m_pImpl->m_aAllEmailSendMutex );
                              m_pImpl->m_xLastMessage.set( xMessage );
                              xMailDispatcher->enqueueMailMessage( xMessage );
                              if( !xMailDispatcher->isStarted() )
                                  xMailDispatcher->start();
                          }
                      }
                  }
              }
              if( bCreateSingleFile || bIsPDFexport )
              {
                  pWorkDoc->SetDBManager( pWorkDocOrigDBManager );
                  xWorkDocSh->DoClose();
                  xWorkDocSh = nullptr;
              }
          }

          bWorkDocInitialized = true;
          nDocNo++;
          nEndRow = m_pImpl->pMergeData ? m_pImpl->pMergeData->xResultSet->getRow() : 0;
38
←
'?' condition is true→

          // Freeze the layouts of the target document after the first inserted
          // sub-document, to get the correct PageDesc.
          if(!bFreezedLayouts38.1
'bFreezedLayouts' is false
1
'bFreezedLayouts' is false
1
'bFreezedLayouts' is false
 && bCreateSingleFile38.2
'bCreateSingleFile' is false
2
'bCreateSingleFile' is false
2
'bCreateSingleFile' is false
)
39
←
Taking false branch→
          {
              for ( auto aLayout : pTargetShell->GetDoc()->GetAllLayouts() )
                  aLayout->FreezeLayout(true);
              bFreezedLayouts = true;
          }
      } while( IsMergeOk() &&
          ((bSynchronizedDoc && (nStartRow != nEndRow)) ? IsValidMergeRecord() : ToNextMergeRecord()));

      if ( xWorkDocSh.Is() && pWorkView->GetWrtShell().IsExpFieldsLocked() )
      {
          // Unlock document fields after merge complete
          pWorkView->GetWrtShell().UnlockExpFields();
      }

      if( !bCreateSingleFile40.1
'bCreateSingleFile' is false
1
'bCreateSingleFile' is false
1
'bCreateSingleFile' is false
 )
41
←
Taking true branch→
      {
          if( bMT_PRINTER41.1
'bMT_PRINTER' is false
1
'bMT_PRINTER' is false
1
'bMT_PRINTER' is false
 )
42
←
Taking false branch→
              Printer::FinishPrintJob( pWorkView->GetPrinterController());
          if( !bIsPDFexport42.1
'bIsPDFexport' is false
1
'bIsPDFexport' is false
1
'bIsPDFexport' is false
 )
43
←
Taking true branch→
          {
              pWorkDoc->SetDBManager( pWorkDocOrigDBManager );
44
←
Called C++ object pointer is null
              xWorkDocSh->DoClose();
          }
      }
      else if( IsMergeOk() ) // && bCreateSingleFile
      {
          Application::Reschedule( true );

          // sw::DocumentLayoutManager::CopyLayoutFormat() did not generate
          // unique fly names, do it here once.
          pTargetDoc->SetInMailMerge(false);
          pTargetDoc->SetAllUniqueFlyNames();

          // Unfreeze target document layouts and correct all PageDescs.
          SAL_INFO( "sw.pageframe", "(MergeMailFiles pTargetShell->CalcLayout in" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.pageframe")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "(MergeMailFiles pTargetShell->CalcLayout in"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.pageframe"
), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1538" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "(MergeMailFiles pTargetShell->CalcLayout in"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "(MergeMailFiles pTargetShell->CalcLayout in"; ::
sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.pageframe"
), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1538" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "(MergeMailFiles pTargetShell->CalcLayout in")
 == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.pageframe"
), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1538" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "(MergeMailFiles pTargetShell->CalcLayout in"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "(MergeMailFiles pTargetShell->CalcLayout in"; ::
sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.pageframe"
), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1538" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
          pTargetShell->CalcLayout();
          SAL_INFO( "sw.pageframe", "MergeMailFiles pTargetShell->CalcLayout out)" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.pageframe")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "MergeMailFiles pTargetShell->CalcLayout out)"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.pageframe"
), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1540" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "MergeMailFiles pTargetShell->CalcLayout out)"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "MergeMailFiles pTargetShell->CalcLayout out)"; ::
sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.pageframe"
), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1540" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "MergeMailFiles pTargetShell->CalcLayout out)"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.pageframe"
), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1540" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "MergeMailFiles pTargetShell->CalcLayout out)"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "MergeMailFiles pTargetShell->CalcLayout out)"; ::
sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.pageframe"
), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1540" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
          pTargetShell->GetViewOptions()->SetIdle( true );
          pTargetDoc->GetIDocumentUndoRedo().DoUndo( true );
          for ( auto aLayout : pTargetShell->GetDoc()->GetAllLayouts() )
          {
              aLayout->FreezeLayout(false);
              aLayout->AllCheckPageDescs();
          }

          Application::Reschedule( true );

          if( IsMergeOk() && bMT_FILE )
          {
              // save merged document
              assert( aTempFile )(static_cast <bool> (aTempFile) ? void (0) : __assert_fail
 ("aTempFile", "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 1554, __extension__ __PRETTY_FUNCTION__));
              INetURLObject aTempFileURL;
              if (sDescriptorPrefix.isEmpty() || !rMergeDescriptor.bPrefixIsFilename)
                  aTempFileURL.SetURL( aTempFile->GetURL() );
              else
              {
                  aTempFileURL.SetURL(sDescriptorPrefix);
                  // remove the unneeded temporary file
                  aTempFile->EnableKillingFile();
              }
              if( !lcl_SaveDoc( &aTempFileURL, pStoreToFilter,
                      pStoreToFilterOptions, &rMergeDescriptor.aSaveToFilterData,
                      bIsPDFexport, xTargetDocShell.get(), *pTargetShell ) )
              {
                  m_aMergeStatus = MergeStatus::Error;
              }
          }
          else if( IsMergeOk() && bMT_PRINTER )
          {
              // print the target document
              uno::Sequence< beans::PropertyValue > aOptions( rMergeDescriptor.aPrintOptions );
              lcl_PreparePrinterOptions( rMergeDescriptor.aPrintOptions, aOptions );
              pTargetView->ExecPrint( aOptions, bIsMergeSilent, false/*bPrintAsync*/ );
          }
      }

      // we also show canceled documents, as long as there was no error
      if( !IsMergeError() && bMT_SHELL )
          // leave docshell available for caller (e.g. MM wizard)
          rMergeDescriptor.pMailMergeConfigItem->SetTargetView( pTargetView );
      else if( xTargetDocShell.is() )
          xTargetDocShell->DoClose();

      Application::Reschedule( true );

      if (xProgressDlg)
      {
          xProgressDlg->response(RET_OK);
      }

      // unlock all dispatchers
      pViewFrame = SfxViewFrame::GetFirst(pSourceDocSh);
      while (pViewFrame)
      {
          pViewFrame->GetDispatcher()->Lock(false);
          pViewFrame = SfxViewFrame::GetNext(*pViewFrame, pSourceDocSh);
      }

      SW_MOD()( static_cast<SwModule*>(SfxApplication::GetModule(SfxToolsModule
::Writer)))->SetView(&pSourceShell->GetView());

      if( xMailDispatcher.is() )
      {
          if( IsMergeOk() )
          {
              // TODO: Instead of polling via an AutoTimer, post an Idle event,
              // if the main loop has been made thread-safe.
              AutoTimer aEmailDispatcherPollTimer;
              aEmailDispatcherPollTimer.SetDebugName(
                  "sw::SwDBManager aEmailDispatcherPollTimer" );
              aEmailDispatcherPollTimer.SetTimeout( 500 );
              aEmailDispatcherPollTimer.Start();
              while( IsMergeOk() && m_pImpl->m_xLastMessage.is() )
                  Application::Yield();
              aEmailDispatcherPollTimer.Stop();
          }
          xMailDispatcher->stop();
          xMailDispatcher->shutdown();
      }

      // remove the temporary files
      // has to be done after xMailDispatcher is finished, as mails may be
      // delivered as message attachments!
      for( const OUString &sFileURL : aFilesToRemove )
          SWUnoHelper::UCB_DeleteFile( sFileURL );
  }
  catch (const uno::Exception&)
  {
      if (xProgressDlg)
      {
          xProgressDlg->response(RET_CANCEL);
      }
  }

  return !IsMergeError();
1638}

1640void SwDBManager::MergeCancel()
1641{
  if (m_aMergeStatus < MergeStatus::Cancel)
      m_aMergeStatus = MergeStatus::Cancel;
1644}

1646// determine the column's Numberformat and transfer to the forwarded Formatter,
1647// if applicable.
1648sal_uLong SwDBManager::GetColumnFormat( const OUString& rDBName,
                              const OUString& rTableName,
                              const OUString& rColNm,
                              SvNumberFormatter* pNFormatr,
                              LanguageType nLanguage )
1653{
  sal_uLong nRet = 0;
  if(pNFormatr)
  {
      uno::Reference< sdbc::XDataSource> xSource;
      uno::Reference< sdbc::XConnection> xConnection;
      bool bUseMergeData = false;
      uno::Reference< sdbcx::XColumnsSupplier> xColsSupp;
      bool bDisposeConnection = false;
      if(m_pImpl->pMergeData &&
          ((m_pImpl->pMergeData->sDataSource == rDBName && m_pImpl->pMergeData->sCommand == rTableName) ||
          (rDBName.isEmpty() && rTableName.isEmpty())))
      {
          xConnection = m_pImpl->pMergeData->xConnection;
          xSource = SwDBManager::getDataSourceAsParent(xConnection,rDBName);
          bUseMergeData = true;
          xColsSupp.set(m_pImpl->pMergeData->xResultSet, css::uno::UNO_QUERY);
      }
      if(!xConnection.is())
      {
          SwDBData aData;
          aData.sDataSource = rDBName;
          aData.sCommand = rTableName;
          aData.nCommandType = -1;
          SwDSParam* pParam = FindDSData(aData, false);
          if(pParam && pParam->xConnection.is())
          {
              xConnection = pParam->xConnection;
              xColsSupp.set(pParam->xResultSet, css::uno::UNO_QUERY);
          }
          else
          {
              xConnection = RegisterConnection( rDBName );
              bDisposeConnection = true;
          }
          if(bUseMergeData)
              m_pImpl->pMergeData->xConnection = xConnection;
      }
      bool bDispose = !xColsSupp.is();
      if(bDispose)
      {
          xColsSupp = SwDBManager::GetColumnSupplier(xConnection, rTableName);
      }
      if(xColsSupp.is())
      {
          uno::Reference<container::XNameAccess> xCols;
          try
          {
              xCols = xColsSupp->getColumns();
          }
          catch (const uno::Exception&)
          {
              TOOLS_WARN_EXCEPTION("sw.mailmerge", "Exception in getColumns()")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.mailmerge")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "Exception in getColumns()"
 << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1705" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Exception in getColumns()" <<
 " " << exceptionToString(tools_warn_exception)), 0); }
 else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Exception in getColumns()" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1705" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Exception in getColumns()" << " " <<
 exceptionToString(tools_warn_exception)) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1705" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Exception in getColumns()" <<
 " " << exceptionToString(tools_warn_exception)), 0); }
 else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Exception in getColumns()" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1705" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
          }
          if(!xCols.is() || !xCols->hasByName(rColNm))
              return nRet;
          uno::Any aCol = xCols->getByName(rColNm);
          uno::Reference< beans::XPropertySet > xColumn;
          aCol >>= xColumn;
          nRet = GetColumnFormat(xSource, xConnection, xColumn, pNFormatr, nLanguage);
          if(bDispose)
          {
              ::comphelper::disposeComponent( xColsSupp );
          }
          if(bDisposeConnection)
          {
              ::comphelper::disposeComponent( xConnection );
          }
      }
      else
          nRet = pNFormatr->GetFormatIndex( NF_NUMBER_STANDARD, LANGUAGE_SYSTEMLanguageType(0x0000) );
  }
  return nRet;
1726}

1728sal_uLong SwDBManager::GetColumnFormat( uno::Reference< sdbc::XDataSource> const & xSource_in,
                      uno::Reference< sdbc::XConnection> const & xConnection,
                      uno::Reference< beans::XPropertySet> const & xColumn,
                      SvNumberFormatter* pNFormatr,
                      LanguageType nLanguage )
1733{
  auto xSource = xSource_in;

  // set the NumberFormat in the doc if applicable
  sal_uLong nRet = 0;

  if(!xSource.is())
  {
      uno::Reference<container::XChild> xChild(xConnection, uno::UNO_QUERY);
      if ( xChild.is() )
          xSource.set(xChild->getParent(), uno::UNO_QUERY);
  }
  if(xSource.is() && xConnection.is() && xColumn.is() && pNFormatr)
  {
      SvNumberFormatsSupplierObj* pNumFormat = new SvNumberFormatsSupplierObj( pNFormatr );
      uno::Reference< util::XNumberFormatsSupplier >  xDocNumFormatsSupplier = pNumFormat;
      uno::Reference< util::XNumberFormats > xDocNumberFormats = xDocNumFormatsSupplier->getNumberFormats();
      uno::Reference< util::XNumberFormatTypes > xDocNumberFormatTypes(xDocNumberFormats, uno::UNO_QUERY);

      css::lang::Locale aLocale( LanguageTag( nLanguage ).getLocale());

      //get the number formatter of the data source
      uno::Reference<beans::XPropertySet> xSourceProps(xSource, uno::UNO_QUERY);
      uno::Reference< util::XNumberFormats > xNumberFormats;
      if(xSourceProps.is())
      {
          uno::Any aFormats = xSourceProps->getPropertyValue("NumberFormatsSupplier");
          if(aFormats.hasValue())
          {
              uno::Reference<util::XNumberFormatsSupplier> xSuppl;
              aFormats >>= xSuppl;
              if(xSuppl.is())
              {
                  xNumberFormats = xSuppl->getNumberFormats();
              }
          }
      }
      bool bUseDefault = true;
      try
      {
          uno::Any aFormatKey = xColumn->getPropertyValue("FormatKey");
          if(aFormatKey.hasValue())
          {
              sal_Int32 nFormat = 0;
              aFormatKey >>= nFormat;
              if(xNumberFormats.is())
              {
                  try
                  {
                      uno::Reference<beans::XPropertySet> xNumProps = xNumberFormats->getByKey( nFormat );
                      uno::Any aFormatString = xNumProps->getPropertyValue("FormatString");
                      uno::Any aLocaleVal = xNumProps->getPropertyValue("Locale");
                      OUString sFormat;
                      aFormatString >>= sFormat;
                      lang::Locale aLoc;
                      aLocaleVal >>= aLoc;
                      nFormat = xDocNumberFormats->queryKey( sFormat, aLoc, false );
                      if(NUMBERFORMAT_ENTRY_NOT_FOUND == sal::static_int_cast< sal_uInt32, sal_Int32>(nFormat))
                          nFormat = xDocNumberFormats->addNew( sFormat, aLoc );
                      nRet = nFormat;
                      bUseDefault = false;
                  }
                  catch (const uno::Exception&)
                  {
                      TOOLS_WARN_EXCEPTION("sw.mailmerge", "illegal number format key")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.mailmerge")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "illegal number format key"
 << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1797" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "illegal number format key" <<
 " " << exceptionToString(tools_warn_exception)), 0); }
 else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "illegal number format key" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1797" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "illegal number format key" << " " <<
 exceptionToString(tools_warn_exception)) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1797" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "illegal number format key" <<
 " " << exceptionToString(tools_warn_exception)), 0); }
 else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "illegal number format key" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1797" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
                  }
              }
          }
      }
      catch(const uno::Exception&)
      {
          SAL_WARN("sw.mailmerge", "no FormatKey property found")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.mailmerge")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "no FormatKey property found"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"
), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1804" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "no FormatKey property found"), 0); }
 else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "no FormatKey property found"; ::sal::detail::log( (
::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1804" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "no FormatKey property found") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1804" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "no FormatKey property found"), 0); }
 else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "no FormatKey property found"; ::sal::detail::log( (
::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1804" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
      }
      if(bUseDefault)
          nRet = dbtools::getDefaultNumberFormat(xColumn, xDocNumberFormatTypes,  aLocale);
  }
  return nRet;
1810}

1812sal_Int32 SwDBManager::GetColumnType( const OUString& rDBName,
                        const OUString& rTableName,
                        const OUString& rColNm )
1815{
  sal_Int32 nRet = sdbc::DataType::SQLNULL;
  SwDBData aData;
  aData.sDataSource = rDBName;
  aData.sCommand = rTableName;
  aData.nCommandType = -1;
  SwDSParam* pParam = FindDSData(aData, false);
  uno::Reference< sdbc::XConnection> xConnection;
  uno::Reference< sdbcx::XColumnsSupplier > xColsSupp;
  bool bDispose = false;
  if(pParam && pParam->xConnection.is())
  {
      xConnection = pParam->xConnection;
      xColsSupp.set( pParam->xResultSet, uno::UNO_QUERY );
  }
  else
  {
      xConnection = RegisterConnection( rDBName );
  }
  if( !xColsSupp.is() )
  {
      xColsSupp = SwDBManager::GetColumnSupplier(xConnection, rTableName);
      bDispose = true;
  }
  if(xColsSupp.is())
  {
      uno::Reference<container::XNameAccess> xCols = xColsSupp->getColumns();
      if(xCols->hasByName(rColNm))
      {
          uno::Any aCol = xCols->getByName(rColNm);
          uno::Reference<beans::XPropertySet> xCol;
          aCol >>= xCol;
          uno::Any aType = xCol->getPropertyValue("Type");
          aType >>= nRet;
      }
      if(bDispose)
          ::comphelper::disposeComponent( xColsSupp );
  }
  return nRet;
1854}

1856uno::Reference< sdbc::XConnection> SwDBManager::GetConnection(const OUString& rDataSource,
                                                            uno::Reference<sdbc::XDataSource>& rxSource, const SwView *pView)
1858{
  uno::Reference< sdbc::XConnection> xConnection;
  uno::Reference< uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
  try
  {
      uno::Reference<sdb::XCompletedConnection> xComplConnection(dbtools::getDataSource(rDataSource, xContext), uno::UNO_QUERY);
      if ( xComplConnection.is() )
      {
          rxSource.set(xComplConnection, uno::UNO_QUERY);
          weld::Window* pWindow = pView ? pView->GetFrameWeld() : nullptr;
          uno::Reference< task::XInteractionHandler > xHandler( task::InteractionHandler::createWithParent(xContext, pWindow ? pWindow->GetXWindow() : nullptr), uno::UNO_QUERY_THROW );
          xConnection = xComplConnection->connectWithCompletion( xHandler );
      }
  }
  catch(const uno::Exception&)
  {
  }

  return xConnection;
1877}

1879uno::Reference< sdbcx::XColumnsSupplier> SwDBManager::GetColumnSupplier(uno::Reference<sdbc::XConnection> const & xConnection,
                                  const OUString& rTableOrQuery,
                                  SwDBSelect   eTableOrQuery)
1882{
  uno::Reference< sdbcx::XColumnsSupplier> xRet;
  try
  {
      if(eTableOrQuery == SwDBSelect::UNKNOWN)
      {
          //search for a table with the given command name
          uno::Reference<sdbcx::XTablesSupplier> xTSupplier(xConnection, uno::UNO_QUERY);
          if(xTSupplier.is())
          {
              uno::Reference<container::XNameAccess> xTables = xTSupplier->getTables();
              eTableOrQuery = xTables->hasByName(rTableOrQuery) ?
                          SwDBSelect::TABLE : SwDBSelect::QUERY;
          }
      }
      sal_Int32 nCommandType = SwDBSelect::TABLE == eTableOrQuery ?
              sdb::CommandType::TABLE : sdb::CommandType::QUERY;
      uno::Reference< lang::XMultiServiceFactory > xMgr( ::comphelper::getProcessServiceFactory() );
      uno::Reference<sdbc::XRowSet> xRowSet(xMgr->createInstance("com.sun.star.sdb.RowSet"), uno::UNO_QUERY);

      OUString sDataSource;
      uno::Reference<sdbc::XDataSource> xSource = SwDBManager::getDataSourceAsParent(xConnection, sDataSource);
      uno::Reference<beans::XPropertySet> xSourceProperties(xSource, uno::UNO_QUERY);
      if(xSourceProperties.is())
      {
          xSourceProperties->getPropertyValue("Name") >>= sDataSource;
      }

      uno::Reference<beans::XPropertySet> xRowProperties(xRowSet, uno::UNO_QUERY);
      xRowProperties->setPropertyValue("DataSourceName", uno::makeAny(sDataSource));
      xRowProperties->setPropertyValue("Command", uno::makeAny(rTableOrQuery));
      xRowProperties->setPropertyValue("CommandType", uno::makeAny(nCommandType));
      xRowProperties->setPropertyValue("FetchSize", uno::makeAny(sal_Int32(10)));
      xRowProperties->setPropertyValue("ActiveConnection", uno::makeAny(xConnection));
      xRowSet->execute();
      xRet.set( xRowSet, uno::UNO_QUERY );
  }
  catch (const uno::Exception&)
  {
      TOOLS_WARN_EXCEPTION("sw.mailmerge", "Exception in SwDBManager::GetColumnSupplier")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.mailmerge")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "Exception in SwDBManager::GetColumnSupplier"
 << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1921" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Exception in SwDBManager::GetColumnSupplier"
 << " " << exceptionToString(tools_warn_exception
)), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Exception in SwDBManager::GetColumnSupplier" <<
 " " << exceptionToString(tools_warn_exception); ::sal::
detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"),
 ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1921" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Exception in SwDBManager::GetColumnSupplier" <<
 " " << exceptionToString(tools_warn_exception)) == 1) {
 ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"
), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1921" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Exception in SwDBManager::GetColumnSupplier"
 << " " << exceptionToString(tools_warn_exception
)), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Exception in SwDBManager::GetColumnSupplier" <<
 " " << exceptionToString(tools_warn_exception); ::sal::
detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"),
 ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1921" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
  }

  return xRet;
1925}

1927OUString SwDBManager::GetDBField(uno::Reference<beans::XPropertySet> const & xColumnProps,
                      const SwDBFormatData& rDBFormatData,
                      double* pNumber)
1930{
  uno::Reference< sdb::XColumn > xColumn(xColumnProps, uno::UNO_QUERY);
  OUString sRet;
  assert( xColumn.is() && "SwDBManager::::ImportDBField: illegal arguments" )(static_cast <bool> (xColumn.is() && "SwDBManager::::ImportDBField: illegal arguments"
) ? void (0) : __assert_fail ("xColumn.is() && \"SwDBManager::::ImportDBField: illegal arguments\""
, "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 1933, __extension__ __PRETTY_FUNCTION__));
  if(!xColumn.is())
      return sRet;

  uno::Any aType = xColumnProps->getPropertyValue("Type");
  sal_Int32 eDataType = sdbc::DataType::SQLNULL;
  aType >>= eDataType;
  switch(eDataType)
  {
      case sdbc::DataType::CHAR:
      case sdbc::DataType::VARCHAR:
      case sdbc::DataType::LONGVARCHAR:
          try
          {
              sRet = xColumn->getString();
              sRet = sRet.replace( '\xb', '\n' ); // MSWord uses \xb as a newline
          }
          catch(const sdbc::SQLException&)
          {
          }
      break;
      case sdbc::DataType::BIT:
      case sdbc::DataType::BOOLEAN:
      case sdbc::DataType::TINYINT:
      case sdbc::DataType::SMALLINT:
      case sdbc::DataType::INTEGER:
      case sdbc::DataType::BIGINT:
      case sdbc::DataType::FLOAT:
      case sdbc::DataType::REAL:
      case sdbc::DataType::DOUBLE:
      case sdbc::DataType::NUMERIC:
      case sdbc::DataType::DECIMAL:
      case sdbc::DataType::DATE:
      case sdbc::DataType::TIME:
      case sdbc::DataType::TIMESTAMP:
      {

          try
          {
              sRet = dbtools::DBTypeConversion::getFormattedValue(
                  xColumnProps,
                  rDBFormatData.xFormatter,
                  rDBFormatData.aLocale,
                  rDBFormatData.aNullDate);
              if (pNumber)
              {
                  double fVal = xColumn->getDouble();
                  if(!xColumn->wasNull())
                  {
                      *pNumber = fVal;
                  }
              }
          }
          catch (const uno::Exception&)
          {
              TOOLS_WARN_EXCEPTION("sw.mailmerge", "")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.mailmerge")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "" << " " <<
 exceptionToString(tools_warn_exception)) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1988" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1988" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "" << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1988" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "1988" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
          }

      }
      break;
  }

  return sRet;
1996}

1998// checks if a desired data source table or query is open
1999bool    SwDBManager::IsDataSourceOpen(const OUString& rDataSource,
                                const OUString& rTableOrQuery, bool bMergeShell)
2001{
  if(m_pImpl->pMergeData)
  {
      return ((rDataSource == m_pImpl->pMergeData->sDataSource
               && rTableOrQuery == m_pImpl->pMergeData->sCommand)
              || (rDataSource.isEmpty() && rTableOrQuery.isEmpty()))
             && m_pImpl->pMergeData->xResultSet.is();
  }
  else if(!bMergeShell)
  {
      SwDBData aData;
      aData.sDataSource = rDataSource;
      aData.sCommand = rTableOrQuery;
      aData.nCommandType = -1;
      SwDSParam* pFound = FindDSData(aData, false);
      return (pFound && pFound->xResultSet.is());
  }
  return false;
2019}

2021// read column data at a specified position
2022bool SwDBManager::GetColumnCnt(const OUString& rSourceName, const OUString& rTableName,
                         const OUString& rColumnName, sal_uInt32 nAbsRecordId,
                         LanguageType nLanguage,
                         OUString& rResult, double* pNumber)
2026{
  bool bRet = false;
  SwDSParam* pFound = nullptr;
  //check if it's the merge data source
  if(m_pImpl->pMergeData &&
      rSourceName == m_pImpl->pMergeData->sDataSource &&
      rTableName == m_pImpl->pMergeData->sCommand)
  {
      pFound = m_pImpl->pMergeData.get();
  }
  else
  {
      SwDBData aData;
      aData.sDataSource = rSourceName;
      aData.sCommand = rTableName;
      aData.nCommandType = -1;
      pFound = FindDSData(aData, false);
  }
  if (!pFound)
      return false;
  //check validity of supplied record Id
  if(pFound->aSelection.hasElements())
  {
      //the destination has to be an element of the selection
      bool bFound = std::any_of(pFound->aSelection.begin(), pFound->aSelection.end(),
          [nAbsRecordId](const uno::Any& rSelection) {
              sal_Int32 nSelection = 0;
              rSelection >>= nSelection;
              return nSelection == static_cast<sal_Int32>(nAbsRecordId);
          });
      if(!bFound)
          return false;
  }
  if( pFound->HasValidRecord() )
  {
      sal_Int32 nOldRow = 0;
      try
      {
          nOldRow = pFound->xResultSet->getRow();
      }
      catch(const uno::Exception&)
      {
          return false;
      }
      //position to the desired index
      bool bMove = true;
      if ( nOldRow != static_cast<sal_Int32>(nAbsRecordId) )
          bMove = lcl_MoveAbsolute(pFound, nAbsRecordId);
      if(bMove)
          bRet = lcl_GetColumnCnt(pFound, rColumnName, nLanguage, rResult, pNumber);
      if ( nOldRow != static_cast<sal_Int32>(nAbsRecordId) )
          lcl_MoveAbsolute(pFound, nOldRow);
  }
  return bRet;
2080}

2082// reads the column data at the current position
2083bool    SwDBManager::GetMergeColumnCnt(const OUString& rColumnName, LanguageType nLanguage,
                                 OUString &rResult, double *pNumber)
2085{
  if( !IsValidMergeRecord() )
  {
      rResult.clear();
      return false;
  }

  bool bRet = lcl_GetColumnCnt(m_pImpl->pMergeData.get(), rColumnName, nLanguage, rResult, pNumber);
  return bRet;
2094}

2096bool SwDBManager::ToNextMergeRecord()
2097{
  assert( m_pImpl->pMergeData && m_pImpl->pMergeData->xResultSet.is() && "no data source in merge" )(static_cast <bool> (m_pImpl->pMergeData && m_pImpl
->pMergeData->xResultSet.is() && "no data source in merge"
) ? void (0) : __assert_fail ("m_pImpl->pMergeData && m_pImpl->pMergeData->xResultSet.is() && \"no data source in merge\""
, "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 2098, __extension__ __PRETTY_FUNCTION__));
  return lcl_ToNextRecord( m_pImpl->pMergeData.get() );
2100}

2102bool SwDBManager::FillCalcWithMergeData( SvNumberFormatter *pDocFormatter,
                                       LanguageType nLanguage, SwCalc &rCalc )
2104{
  if( !IsValidMergeRecord() )
      return false;

  uno::Reference< sdbcx::XColumnsSupplier > xColsSupp( m_pImpl->pMergeData->xResultSet, uno::UNO_QUERY );
  if( !xColsSupp.is() )
      return false;

  {
      uno::Reference<container::XNameAccess> xCols = xColsSupp->getColumns();
      const uno::Sequence<OUString> aColNames = xCols->getElementNames();
      OUString aString;

      // add the "record number" variable, as SwCalc::VarLook would.
      rCalc.VarChange( GetAppCharClass().lowercase(
          SwFieldType::GetTypeStr(SwFieldTypesEnum::DatabaseSetNumber) ), GetSelectedRecordId() );

      for( const OUString& rColName : aColNames )
      {
          // get the column type
          sal_Int32 nColumnType = sdbc::DataType::SQLNULL;
          uno::Any aCol = xCols->getByName( rColName );
          uno::Reference<beans::XPropertySet> xColumnProps;
          aCol >>= xColumnProps;
          uno::Any aType = xColumnProps->getPropertyValue( "Type" );
          aType >>= nColumnType;
          double aNumber = DBL_MAX1.7976931348623157e+308;

          lcl_GetColumnCnt( m_pImpl->pMergeData.get(), xColumnProps, nLanguage, aString, &aNumber );

          sal_uInt32 nFormat = GetColumnFormat( m_pImpl->pMergeData->sDataSource,
                                          m_pImpl->pMergeData->sCommand,
                                          rColName, pDocFormatter, nLanguage );
          // aNumber is overwritten by SwDBField::FormatValue, so store initial status
          bool colIsNumber = aNumber != DBL_MAX1.7976931348623157e+308;
          bool bValidValue = SwDBField::FormatValue( pDocFormatter, aString, nFormat,
                                                     aNumber, nColumnType );
          if( colIsNumber )
          {
              if( bValidValue )
              {
                  SwSbxValue aValue;
                  aValue.PutDouble( aNumber );
                  aValue.SetDBvalue( true );
                  SAL_INFO( "sw.ui", "'" << rColName << "': " << aNumber << " / " << aString )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.ui")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case SAL_DETAIL_LOG_ACTION_LOG
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "'" << rColName << "': " << aNumber
 << " / " << aString) == 1) { ::sal_detail_log( (
::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ui"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "2148" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "'" << rColName << "': "
 << aNumber << " / " << aString), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "'" << rColName << "': " << aNumber <<
 " / " << aString; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ui"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "2148" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "'" << rColName << "': " << aNumber
 << " / " << aString) == 1) { ::sal_detail_log( (
::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ui"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "2148" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "'" << rColName << "': "
 << aNumber << " / " << aString), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "'" << rColName << "': " << aNumber <<
 " / " << aString; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ui"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "2148" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
                  rCalc.VarChange( rColName, aValue );
              }
          }
          else
          {
              SwSbxValue aValue;
              aValue.PutString( aString );
              aValue.SetDBvalue( true );
              SAL_INFO( "sw.ui", "'" << rColName << "': " << aString )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.ui")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case SAL_DETAIL_LOG_ACTION_LOG
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "'" << rColName << "': " << aString
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ui"
), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "2157" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "'" << rColName << "': "
 << aString), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "'" << rColName << "': "
 << aString; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ui"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "2157" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "'" << rColName << "': " << aString
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ui"
), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "2157" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "'" << rColName << "': "
 << aString), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "'" << rColName << "': "
 << aString; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ui"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "2157" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
              rCalc.VarChange( rColName, aValue );
          }
      }
  }

  return true;
2164}

2166void SwDBManager::ToNextRecord(
  const OUString& rDataSource, const OUString& rCommand)
2168{
  SwDSParam* pFound = nullptr;
  if(m_pImpl->pMergeData &&
      rDataSource == m_pImpl->pMergeData->sDataSource &&
      rCommand == m_pImpl->pMergeData->sCommand)
  {
      pFound = m_pImpl->pMergeData.get();
  }
  else
  {
      SwDBData aData;
      aData.sDataSource = rDataSource;
      aData.sCommand = rCommand;
      aData.nCommandType = -1;
      pFound = FindDSData(aData, false);
  }
  lcl_ToNextRecord( pFound );
2185}

2187static bool lcl_ToNextRecord( SwDSParam* pParam, const SwDBNextRecord action )
2188{
  bool bRet = true;

  assert( SwDBNextRecord::NEXT == action ||(static_cast <bool> (SwDBNextRecord::NEXT == action || (
SwDBNextRecord::FIRST == action && pParam)) ? void (0
) : __assert_fail ("SwDBNextRecord::NEXT == action || (SwDBNextRecord::FIRST == action && pParam)"
, "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 2192, __extension__ __PRETTY_FUNCTION__))
       (SwDBNextRecord::FIRST == action && pParam) )(static_cast <bool> (SwDBNextRecord::NEXT == action || (
SwDBNextRecord::FIRST == action && pParam)) ? void (0
) : __assert_fail ("SwDBNextRecord::NEXT == action || (SwDBNextRecord::FIRST == action && pParam)"
, "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 2192, __extension__ __PRETTY_FUNCTION__));
  if( nullptr == pParam )
      return false;

  if( action == SwDBNextRecord::FIRST )
  {
      pParam->nSelectionIndex = 0;
      pParam->bEndOfDB        = false;
  }

  if( !pParam->HasValidRecord() )
      return false;

  try
  {
      if( pParam->aSelection.hasElements() )
      {
          if( pParam->nSelectionIndex >= pParam->aSelection.getLength() )
              pParam->bEndOfDB = true;
          else
          {
              sal_Int32 nPos = 0;
              pParam->aSelection.getConstArray()[ pParam->nSelectionIndex ] >>= nPos;
              pParam->bEndOfDB = !pParam->xResultSet->absolute( nPos );
          }
      }
      else if( action == SwDBNextRecord::FIRST )
      {
          pParam->bEndOfDB = !pParam->xResultSet->first();
      }
      else
      {
          sal_Int32 nBefore = pParam->xResultSet->getRow();
          pParam->bEndOfDB = !pParam->xResultSet->next();
          if( !pParam->bEndOfDB && nBefore == pParam->xResultSet->getRow() )
          {
              // next returned true but it didn't move
              ::dbtools::throwFunctionSequenceException( pParam->xResultSet );
          }
      }

      ++pParam->nSelectionIndex;
      bRet = !pParam->bEndOfDB;
  }
  catch( const uno::Exception & )
  {
      // we allow merging with empty databases, so don't warn on init
      TOOLS_WARN_EXCEPTION_IF(action == SwDBNextRecord::NEXT,do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true && (action == SwDBNextRecord::NEXT
)) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.mailmerge")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "exception in ToNextRecord()"
 << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "2240" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "exception in ToNextRecord()" <<
 " " << exceptionToString(tools_warn_exception)), 0); }
 else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "exception in ToNextRecord()" << " " <<
 exceptionToString(tools_warn_exception); ::sal::detail::log(
 (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "2240" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "exception in ToNextRecord()" << " " <<
 exceptionToString(tools_warn_exception)) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "2240" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "exception in ToNextRecord()" <<
 " " << exceptionToString(tools_warn_exception)), 0); }
 else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "exception in ToNextRecord()" << " " <<
 exceptionToString(tools_warn_exception); ::sal::detail::log(
 (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "2240" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false)
                  "sw.mailmerge", "exception in ToNextRecord()")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true && (action == SwDBNextRecord::NEXT
)) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.mailmerge")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "exception in ToNextRecord()"
 << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "2240" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "exception in ToNextRecord()" <<
 " " << exceptionToString(tools_warn_exception)), 0); }
 else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "exception in ToNextRecord()" << " " <<
 exceptionToString(tools_warn_exception); ::sal::detail::log(
 (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "2240" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "exception in ToNextRecord()" << " " <<
 exceptionToString(tools_warn_exception)) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "2240" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "exception in ToNextRecord()" <<
 " " << exceptionToString(tools_warn_exception)), 0); }
 else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "exception in ToNextRecord()" << " " <<
 exceptionToString(tools_warn_exception); ::sal::detail::log(
 (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "2240" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
      pParam->bEndOfDB = true;
      bRet = false;
  }
  return bRet;
2245}

2247// synchronized labels contain a next record field at their end
2248// to assure that the next page can be created in mail merge
2249// the cursor position must be validated
2250bool SwDBManager::IsValidMergeRecord() const
2251{
  return( m_pImpl->pMergeData && m_pImpl->pMergeData->HasValidRecord() );
2253}

2255sal_uInt32  SwDBManager::GetSelectedRecordId()
2256{
  sal_uInt32  nRet = 0;
  assert( m_pImpl->pMergeData &&(static_cast <bool> (m_pImpl->pMergeData && m_pImpl
->pMergeData->xResultSet.is() && "no data source in merge"
) ? void (0) : __assert_fail ("m_pImpl->pMergeData && m_pImpl->pMergeData->xResultSet.is() && \"no data source in merge\""
, "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 2259, __extension__ __PRETTY_FUNCTION__))
          m_pImpl->pMergeData->xResultSet.is() && "no data source in merge" )(static_cast <bool> (m_pImpl->pMergeData && m_pImpl
->pMergeData->xResultSet.is() && "no data source in merge"
) ? void (0) : __assert_fail ("m_pImpl->pMergeData && m_pImpl->pMergeData->xResultSet.is() && \"no data source in merge\""
, "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 2259, __extension__ __PRETTY_FUNCTION__));
  if(!m_pImpl->pMergeData || !m_pImpl->pMergeData->xResultSet.is())
      return 0;
  try
  {
      nRet = m_pImpl->pMergeData->xResultSet->getRow();
  }
  catch(const uno::Exception&)
  {
  }
  return nRet;
2270}

2272bool SwDBManager::ToRecordId(sal_Int32 nSet)
2273{
  assert( m_pImpl->pMergeData &&(static_cast <bool> (m_pImpl->pMergeData && m_pImpl
->pMergeData->xResultSet.is() && "no data source in merge"
) ? void (0) : __assert_fail ("m_pImpl->pMergeData && m_pImpl->pMergeData->xResultSet.is() && \"no data source in merge\""
, "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 2275, __extension__ __PRETTY_FUNCTION__))
          m_pImpl->pMergeData->xResultSet.is() && "no data source in merge" )(static_cast <bool> (m_pImpl->pMergeData && m_pImpl
->pMergeData->xResultSet.is() && "no data source in merge"
) ? void (0) : __assert_fail ("m_pImpl->pMergeData && m_pImpl->pMergeData->xResultSet.is() && \"no data source in merge\""
, "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 2275, __extension__ __PRETTY_FUNCTION__));
  if(!m_pImpl->pMergeData || !m_pImpl->pMergeData->xResultSet.is()|| nSet < 0)
      return false;
  bool bRet = false;
  sal_Int32 nAbsPos = nSet;
  assert(nAbsPos >= 0)(static_cast <bool> (nAbsPos >= 0) ? void (0) : __assert_fail
 ("nAbsPos >= 0", "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 2280, __extension__ __PRETTY_FUNCTION__));
  bRet = lcl_MoveAbsolute(m_pImpl->pMergeData.get(), nAbsPos);
  m_pImpl->pMergeData->bEndOfDB = !bRet;
  return bRet;
2284}

2286bool SwDBManager::OpenDataSource(const OUString& rDataSource, const OUString& rTableOrQuery)
2287{
  SwDBData aData;
  aData.sDataSource = rDataSource;
  aData.sCommand = rTableOrQuery;
  aData.nCommandType = -1;

  SwDSParam* pFound = FindDSData(aData, true);
  if(pFound->xResultSet.is())
      return true;
  SwDSParam* pParam = FindDSConnection(rDataSource, false);
  if(pParam && pParam->xConnection.is())
      pFound->xConnection = pParam->xConnection;
  if(pFound->xConnection.is())
  {
      try
      {
          uno::Reference< sdbc::XDatabaseMetaData >  xMetaData = pFound->xConnection->getMetaData();
          try
          {
              pFound->bScrollable = xMetaData
                      ->supportsResultSetType(sal_Int32(sdbc::ResultSetType::SCROLL_INSENSITIVE));
          }
          catch(const uno::Exception&)
          {
              // DB driver may not be ODBC 3.0 compliant
              pFound->bScrollable = true;
          }
          pFound->xStatement = pFound->xConnection->createStatement();
          OUString aQuoteChar = xMetaData->getIdentifierQuoteString();
          OUString sStatement = "SELECT * FROM " + aQuoteChar + rTableOrQuery + aQuoteChar;
          pFound->xResultSet = pFound->xStatement->executeQuery( sStatement );

          //after executeQuery the cursor must be positioned
          pFound->bEndOfDB = !pFound->xResultSet->next();
          ++pFound->nSelectionIndex;
      }
      catch (const uno::Exception&)
      {
          pFound->xResultSet = nullptr;
          pFound->xStatement = nullptr;
          pFound->xConnection = nullptr;
      }
  }
  return pFound->xResultSet.is();
2331}

2333uno::Reference< sdbc::XConnection> const & SwDBManager::RegisterConnection(OUString const& rDataSource)
2334{
  SwDSParam* pFound = SwDBManager::FindDSConnection(rDataSource, true);
  uno::Reference< sdbc::XDataSource> xSource;
  if(!pFound->xConnection.is())
  {
      SwView* pView = (m_pDoc && m_pDoc->GetDocShell()) ? m_pDoc->GetDocShell()->GetView() : nullptr;
      pFound->xConnection = SwDBManager::GetConnection(rDataSource, xSource, pView);
      try
      {
          uno::Reference<lang::XComponent> xComponent(pFound->xConnection, uno::UNO_QUERY);
          if(xComponent.is())
              xComponent->addEventListener(m_pImpl->m_xDisposeListener.get());
      }
      catch(const uno::Exception&)
      {
      }
  }
  return pFound->xConnection;
2352}

2354sal_uInt32      SwDBManager::GetSelectedRecordId(
  const OUString& rDataSource, const OUString& rTableOrQuery, sal_Int32 nCommandType)
2356{
  sal_uInt32 nRet = 0xffffffff;
  //check for merge data source first
  if(m_pImpl->pMergeData &&
      ((rDataSource == m_pImpl->pMergeData->sDataSource &&
      rTableOrQuery == m_pImpl->pMergeData->sCommand) ||
      (rDataSource.isEmpty() && rTableOrQuery.isEmpty())) &&
      (nCommandType == -1 || nCommandType == m_pImpl->pMergeData->nCommandType) &&
      m_pImpl->pMergeData->xResultSet.is())
  {
      nRet = GetSelectedRecordId();
  }
  else
  {
      SwDBData aData;
      aData.sDataSource = rDataSource;
      aData.sCommand = rTableOrQuery;
      aData.nCommandType = nCommandType;
      SwDSParam* pFound = FindDSData(aData, false);
      if(pFound && pFound->xResultSet.is())
      {
          try
          {   //if a selection array is set the current row at the result set may not be set yet
              if(pFound->aSelection.hasElements())
              {
                  sal_Int32 nSelIndex = pFound->nSelectionIndex;
                  if(nSelIndex >= pFound->aSelection.getLength())
                      nSelIndex = pFound->aSelection.getLength() -1;
                  pFound->aSelection.getConstArray()[nSelIndex] >>= nRet;

              }
              else
                  nRet = pFound->xResultSet->getRow();
          }
          catch(const uno::Exception&)
          {
          }
      }
  }
  return nRet;
2396}

2398// close all data sources - after fields were updated
2399void    SwDBManager::CloseAll(bool bIncludingMerge)
2400{
  //the only thing done here is to reset the selection index
  //all connections stay open
  for (auto & pParam : m_DataSourceParams)
  {
      if (bIncludingMerge || pParam.get() != m_pImpl->pMergeData.get())
      {
          pParam->nSelectionIndex = 0;
          pParam->bEndOfDB = false;
          try
          {
              if(!m_bInMerge && pParam->xResultSet.is())
                  pParam->xResultSet->first();
          }
          catch(const uno::Exception&)
          {}
      }
  }
2418}

2420SwDSParam* SwDBManager::FindDSData(const SwDBData& rData, bool bCreate)
2421{
  //prefer merge data if available
  if(m_pImpl->pMergeData &&
      ((rData.sDataSource == m_pImpl->pMergeData->sDataSource &&
      rData.sCommand == m_pImpl->pMergeData->sCommand) ||
      (rData.sDataSource.isEmpty() && rData.sCommand.isEmpty())) &&
      (rData.nCommandType == -1 || rData.nCommandType == m_pImpl->pMergeData->nCommandType ||
      (bCreate && m_pImpl->pMergeData->nCommandType == -1)))
  {
      return m_pImpl->pMergeData.get();
  }

  SwDSParam* pFound = nullptr;
  for (size_t nPos = m_DataSourceParams.size(); nPos; nPos--)
  {
      SwDSParam* pParam = m_DataSourceParams[nPos - 1].get();
      if(rData.sDataSource == pParam->sDataSource &&
          rData.sCommand == pParam->sCommand &&
          (rData.nCommandType == -1 || rData.nCommandType == pParam->nCommandType ||
          (bCreate && pParam->nCommandType == -1)))
          {
              // calls from the calculator may add a connection with an invalid commandtype
              //later added "real" data base connections have to re-use the already available
              //DSData and set the correct CommandType
              if(bCreate && pParam->nCommandType == -1)
                  pParam->nCommandType = rData.nCommandType;
              pFound = pParam;
              break;
          }
  }
  if(bCreate && !pFound)
  {
      pFound = new SwDSParam(rData);
      m_DataSourceParams.push_back(std::unique_ptr<SwDSParam>(pFound));
      try
      {
          uno::Reference<lang::XComponent> xComponent(pFound->xConnection, uno::UNO_QUERY);
          if(xComponent.is())
              xComponent->addEventListener(m_pImpl->m_xDisposeListener.get());
      }
      catch(const uno::Exception&)
      {
      }
  }
  return pFound;
2466}

2468SwDSParam*  SwDBManager::FindDSConnection(const OUString& rDataSource, bool bCreate)
2469{
  //prefer merge data if available
  if(m_pImpl->pMergeData && rDataSource == m_pImpl->pMergeData->sDataSource )
  {
      SetAsUsed(rDataSource);
      return m_pImpl->pMergeData.get();
  }
  SwDSParam* pFound = nullptr;
  for (const auto & pParam : m_DataSourceParams)
  {
      if(rDataSource == pParam->sDataSource)
      {
          SetAsUsed(rDataSource);
          pFound = pParam.get();
          break;
      }
  }
  if(bCreate && !pFound)
  {
      SwDBData aData;
      aData.sDataSource = rDataSource;
      pFound = new SwDSParam(aData);
      SetAsUsed(rDataSource);
      m_DataSourceParams.push_back(std::unique_ptr<SwDSParam>(pFound));
      try
      {
          uno::Reference<lang::XComponent> xComponent(pFound->xConnection, uno::UNO_QUERY);
          if(xComponent.is())
              xComponent->addEventListener(m_pImpl->m_xDisposeListener.get());
      }
      catch(const uno::Exception&)
      {
      }
  }
  return pFound;
2504}

2506const SwDBData& SwDBManager::GetAddressDBName()
2507{
  return SW_MOD()( static_cast<SwModule*>(SfxApplication::GetModule(SfxToolsModule
::Writer)))->GetDBConfig()->GetAddressSource();
2509}

2511uno::Sequence<OUString> SwDBManager::GetExistingDatabaseNames()
2512{
  uno::Reference<uno::XComponentContext> xContext( ::comphelper::getProcessComponentContext() );
  uno::Reference<sdb::XDatabaseContext> xDBContext = sdb::DatabaseContext::create(xContext);
  return xDBContext->getElementNames();
2516}

2518namespace  sw
2519{
2520DBConnURIType GetDBunoType(const INetURLObject &rURL)
2521{
  OUString sExt(rURL.GetFileExtension());
  DBConnURIType type = DBConnURIType::UNKNOWN;

  if (sExt == "odb")
  {
      type = DBConnURIType::ODB;
  }
  else if (sExt.equalsIgnoreAsciiCase("sxc")
      || sExt.equalsIgnoreAsciiCase("ods")
      || sExt.equalsIgnoreAsciiCase("xls")
      || sExt.equalsIgnoreAsciiCase("xlsx"))
  {
      type = DBConnURIType::CALC;
  }
  else if (sExt.equalsIgnoreAsciiCase("sxw") || sExt.equalsIgnoreAsciiCase("odt") || sExt.equalsIgnoreAsciiCase("doc") || sExt.equalsIgnoreAsciiCase("docx"))
  {
      type = DBConnURIType::WRITER;
  }
  else if (sExt.equalsIgnoreAsciiCase("dbf"))
  {
      type = DBConnURIType::DBASE;
  }
  else if (sExt.equalsIgnoreAsciiCase("csv") || sExt.equalsIgnoreAsciiCase("txt"))
  {
      type = DBConnURIType::FLAT;
  }
2548#ifdef _WIN32
  else if (sExt.equalsIgnoreAsciiCase("mdb") || sExt.equalsIgnoreAsciiCase("mde"))
  {
      type = DBConnURIType::MSJET;
  }
  else if (sExt.equalsIgnoreAsciiCase("accdb") || sExt.equalsIgnoreAsciiCase("accde"))
  {
      type = DBConnURIType::MSACE;
  }
2557#endif
  return type;
2559}
2560}

2562namespace
2563{
2564uno::Any GetDBunoURI(const INetURLObject &rURL, DBConnURIType& rType)
2565{
  uno::Any aURLAny;

  if (rType == DBConnURIType::UNKNOWN)
      rType = GetDBunoType(rURL);

  switch (rType) {
  case DBConnURIType::UNKNOWN:
  case DBConnURIType::ODB:
      break;
  case DBConnURIType::CALC:
  {
      OUString sDBURL = "sdbc:calc:" +
          rURL.GetMainURL(INetURLObject::DecodeMechanism::NONE);
      aURLAny <<= sDBURL;
  }
  break;
  case DBConnURIType::WRITER:
  {
      OUString sDBURL = "sdbc:writer:" +
          rURL.GetMainURL(INetURLObject::DecodeMechanism::NONE);
      aURLAny <<= sDBURL;
  }
  break;
  case DBConnURIType::DBASE:
  {
      INetURLObject aUrlTmp(rURL);
      aUrlTmp.removeSegment();
      aUrlTmp.removeFinalSlash();
      OUString sDBURL = "sdbc:dbase:" +
          aUrlTmp.GetMainURL(INetURLObject::DecodeMechanism::NONE);
      aURLAny <<= sDBURL;
  }
  break;
  case DBConnURIType::FLAT:
  {
      INetURLObject aUrlTmp(rURL);
      aUrlTmp.removeSegment();
      aUrlTmp.removeFinalSlash();
      OUString sDBURL = "sdbc:flat:" +
          //only the 'path' has to be added
          aUrlTmp.GetMainURL(INetURLObject::DecodeMechanism::NONE);
      aURLAny <<= sDBURL;
  }
  break;
  case DBConnURIType::MSJET:
2611#ifdef _WIN32
  {
      OUString sDBURL("sdbc:ado:access:PROVIDER=Microsoft.Jet.OLEDB.4.0;DATA SOURCE=" + rURL.PathToFileName());
      aURLAny <<= sDBURL;
  }
2616#endif
  break;
  case DBConnURIType::MSACE:
2619#ifdef _WIN32
  {
      OUString sDBURL("sdbc:ado:PROVIDER=Microsoft.ACE.OLEDB.12.0;DATA SOURCE=" + rURL.PathToFileName());
      aURLAny <<= sDBURL;
  }
2624#endif
  break;
  }
  return aURLAny;
2628}

2630/// Returns the URL of this SwDoc.
2631OUString getOwnURL(SfxObjectShell const * pDocShell)
2632{
  OUString aRet;

  if (!pDocShell)
      return aRet;

  const INetURLObject& rURLObject = pDocShell->GetMedium()->GetURLObject();
  aRet = rURLObject.GetMainURL(INetURLObject::DecodeMechanism::NONE);
  return aRet;
2641}

2643/**
2644Loads a data source from file and registers it.

2646In case of success it returns the registered name, otherwise an empty string.
2647Optionally add a prefix to the registered DB name.
2648*/
2649OUString LoadAndRegisterDataSource_Impl(DBConnURIType type, const uno::Reference< beans::XPropertySet > *pSettings,
  const INetURLObject &rURL, const OUString *pDestDir, SfxObjectShell* pDocShell)
2651{
  OUString sExt(rURL.GetFileExtension());
  uno::Any aTableFilterAny;
  uno::Any aSuppressVersionsAny;
  uno::Any aInfoAny;
  bool bStore = true;
  OUString sFind;
  uno::Sequence<OUString> aFilters(1);

  uno::Any aURLAny = GetDBunoURI(rURL, type);
  switch (type) {
  case DBConnURIType::UNKNOWN:
  case DBConnURIType::CALC:
  case DBConnURIType::WRITER:
      break;
  case DBConnURIType::ODB:
      bStore = false;
      break;
  case DBConnURIType::FLAT:
  case DBConnURIType::DBASE:
      //set the filter to the file name without extension
      aFilters[0] = rURL.getBase(INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset);
      aTableFilterAny <<= aFilters;
      break;
  case DBConnURIType::MSJET:
  case DBConnURIType::MSACE:
      aSuppressVersionsAny <<= true;
      break;
  }

  try
  {
      uno::Reference<uno::XComponentContext> xContext(::comphelper::getProcessComponentContext());
      uno::Reference<sdb::XDatabaseContext> xDBContext = sdb::DatabaseContext::create(xContext);

      OUString sNewName = rURL.getName(
          INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::Unambiguous);
      sal_Int32 nExtLen = sExt.getLength();
      sNewName = sNewName.replaceAt(sNewName.getLength() - nExtLen - 1, nExtLen + 1, "");

      //find a unique name if sNewName already exists
      sFind = sNewName;
      sal_Int32 nIndex = 0;
      while (xDBContext->hasByName(sFind))
          sFind = sNewName + OUString::number(++nIndex);

      uno::Reference<uno::XInterface> xNewInstance;
      if (!bStore)
      {
          //odb-file
          uno::Any aDataSource = xDBContext->getByName(rURL.GetMainURL(INetURLObject::DecodeMechanism::NONE));
          aDataSource >>= xNewInstance;
      }
      else
      {
          xNewInstance = xDBContext->createInstance();
          uno::Reference<beans::XPropertySet> xDataProperties(xNewInstance, uno::UNO_QUERY);

          if (aURLAny.hasValue())
              xDataProperties->setPropertyValue("URL", aURLAny);
          if (aTableFilterAny.hasValue())
              xDataProperties->setPropertyValue("TableFilter", aTableFilterAny);
          if (aSuppressVersionsAny.hasValue())
              xDataProperties->setPropertyValue("SuppressVersionColumns", aSuppressVersionsAny);
          if (aInfoAny.hasValue())
              xDataProperties->setPropertyValue("Info", aInfoAny);

          if (DBConnURIType::FLAT == type && pSettings)
          {
              uno::Any aSettings = xDataProperties->getPropertyValue("Settings");
              uno::Reference < beans::XPropertySet > xDSSettings;
              aSettings >>= xDSSettings;
              ::comphelper::copyProperties(*pSettings, xDSSettings);
              xDSSettings->setPropertyValue("Extension", uno::makeAny(sExt));
          }

          uno::Reference<sdb::XDocumentDataSource> xDS(xNewInstance, uno::UNO_QUERY_THROW);
          uno::Reference<frame::XStorable> xStore(xDS->getDatabaseDocument(), uno::UNO_QUERY_THROW);
          OUString aOwnURL = getOwnURL(pDocShell);
          if (aOwnURL.isEmpty())
          {
              // Cannot embed, as embedded data source would need the URL of the parent document.
              OUString const sOutputExt = ".odb";
              OUString sHomePath(SvtPathOptions().GetWorkPath());
              utl::TempFile aTempFile(sNewName, true, &sOutputExt, pDestDir ? pDestDir : &sHomePath);
              const OUString& sTmpName = aTempFile.GetURL();
              xStore->storeAsURL(sTmpName, uno::Sequence<beans::PropertyValue>());
          }
          else
          {
              // Embed.
              OUString aStreamRelPath = "EmbeddedDatabase";
              uno::Reference<embed::XStorage> xStorage = pDocShell->GetStorage();

              // Refer to the sub-storage name in the document settings, so
              // we can load it again next time the file is imported.
              uno::Reference<lang::XMultiServiceFactory> xFactory(pDocShell->GetModel(), uno::UNO_QUERY);
              uno::Reference<beans::XPropertySet> xPropertySet(xFactory->createInstance("com.sun.star.document.Settings"), uno::UNO_QUERY);
              xPropertySet->setPropertyValue("EmbeddedDatabaseName", uno::makeAny(aStreamRelPath));

              // Store it only after setting the above property, so that only one data source gets registered.
              SwDBManager::StoreEmbeddedDataSource(xStore, xStorage, aStreamRelPath, aOwnURL);
          }
      }
      xDBContext->registerObject(sFind, xNewInstance);
  }
  catch (const uno::Exception&)
  {
      sFind.clear();
  }
  return sFind;
2762}

2764// Construct vnd.sun.star.pkg:// URL
2765OUString ConstructVndSunStarPkgUrl(const OUString& rMainURL, const OUString& rStreamRelPath)
2766{
  auto xContext(comphelper::getProcessComponentContext());
  auto xUri = css::uri::UriReferenceFactory::create(xContext)->parse(rMainURL);
  assert(xUri.is())(static_cast <bool> (xUri.is()) ? void (0) : __assert_fail
 ("xUri.is()", "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 2769, __extension__ __PRETTY_FUNCTION__));
  xUri = css::uri::VndSunStarPkgUrlReferenceFactory::create(xContext)
      ->createVndSunStarPkgUrlReference(xUri);
  assert(xUri.is())(static_cast <bool> (xUri.is()) ? void (0) : __assert_fail
 ("xUri.is()", "/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
, 2772, __extension__ __PRETTY_FUNCTION__));
  return xUri->getUriReference() + "/"
      + INetURLObject::encode(
          rStreamRelPath, INetURLObject::PART_FPATH,
          INetURLObject::EncodeMechanism::All);
2777}
2778}

2780OUString SwDBManager::LoadAndRegisterDataSource(weld::Window* pParent, SwDocShell* pDocShell)
2781{
  sfx2::FileDialogHelper aDlgHelper(ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE, FileDialogFlags::NONE, pParent);
  uno::Reference < ui::dialogs::XFilePicker3 > xFP = aDlgHelper.GetFilePicker();

  OUString sHomePath(SvtPathOptions().GetWorkPath());
  aDlgHelper.SetDisplayDirectory( sHomePath );

  OUString sFilterAll(SwResId(STR_FILTER_ALLreinterpret_cast<char const *>("STR_FILTER_ALL" "\004" u8"All files"
)));
  OUString sFilterAllData(SwResId(STR_FILTER_ALL_DATAreinterpret_cast<char const *>("STR_FILTER_ALL_DATA" "\004"
 u8"Address lists(*.*)")));
  OUString sFilterSXB(SwResId(STR_FILTER_SXBreinterpret_cast<char const *>("STR_FILTER_SXB" "\004" u8"%PRODUCTNAME Base (*.odb)"
)));
  OUString sFilterSXC(SwResId(STR_FILTER_SXCreinterpret_cast<char const *>("STR_FILTER_SXC" "\004" u8"%PRODUCTNAME Calc (*.ods;*.sxc)"
)));
  OUString sFilterSXW(SwResId(STR_FILTER_SXWreinterpret_cast<char const *>("STR_FILTER_SXW" "\004" u8"%PRODUCTNAME Writer (*.odt;*.sxw)"
)));
  OUString sFilterDBF(SwResId(STR_FILTER_DBFreinterpret_cast<char const *>("STR_FILTER_DBF" "\004" u8"dBase (*.dbf)"
)));
  OUString sFilterXLS(SwResId(STR_FILTER_XLSreinterpret_cast<char const *>("STR_FILTER_XLS" "\004" u8"Microsoft Excel (*.xls;*.xlsx)"
)));
  OUString sFilterDOC(SwResId(STR_FILTER_DOCreinterpret_cast<char const *>("STR_FILTER_DOC" "\004" u8"Microsoft Word (*.doc;*.docx)"
)));
  OUString sFilterTXT(SwResId(STR_FILTER_TXTreinterpret_cast<char const *>("STR_FILTER_TXT" "\004" u8"Plain text (*.txt)"
)));
  OUString sFilterCSV(SwResId(STR_FILTER_CSVreinterpret_cast<char const *>("STR_FILTER_CSV" "\004" u8"Text Comma Separated (*.csv)"
)));
2798#ifdef _WIN32
  OUString sFilterMDB(SwResId(STR_FILTER_MDBreinterpret_cast<char const *>("STR_FILTER_MDB" "\004" u8"Microsoft Access (*.mdb;*.mde)"
)));
  OUString sFilterACCDB(SwResId(STR_FILTER_ACCDBreinterpret_cast<char const *>("STR_FILTER_ACCDB" "\004"
 u8"Microsoft Access 2007 (*.accdb,*.accde)")));
2801#endif
  xFP->appendFilter( sFilterAll, "*" );
  xFP->appendFilter( sFilterAllData, "*.ods;*.sxc;*.odt;*.sxw;*.dbf;*.xls;*.xlsx;*.doc;*.docx;*.txt;*.csv");

  xFP->appendFilter( sFilterSXB, "*.odb" );
  xFP->appendFilter( sFilterSXC, "*.ods;*.sxc" );
  xFP->appendFilter( sFilterSXW, "*.odt;*.sxw" );
  xFP->appendFilter( sFilterDBF, "*.dbf" );
  xFP->appendFilter( sFilterXLS, "*.xls;*.xlsx" );
  xFP->appendFilter( sFilterDOC, "*.doc;*.docx" );
  xFP->appendFilter( sFilterTXT, "*.txt" );
  xFP->appendFilter( sFilterCSV, "*.csv" );
2813#ifdef _WIN32
  xFP->appendFilter(sFilterMDB, "*.mdb;*.mde");
  xFP->appendFilter(sFilterACCDB, "*.accdb;*.accde");
2816#endif

  xFP->setCurrentFilter( sFilterAll ) ;
  OUString sFind;
  if( ERRCODE_NONEErrCode(0) == aDlgHelper.Execute() )
  {
      uno::Reference< beans::XPropertySet > aSettings;
      const INetURLObject aURL( xFP->getSelectedFiles().getConstArray()[0] );
      const DBConnURIType type = GetDBunoType( aURL );

      if( DBConnURIType::FLAT == type )
      {
          uno::Reference<uno::XComponentContext> xContext( ::comphelper::getProcessComponentContext() );
          uno::Reference < sdb::XTextConnectionSettings > xSettingsDlg = sdb::TextConnectionSettings::create(xContext);
          if( xSettingsDlg->execute() )
              aSettings.set( uno::Reference < beans::XPropertySet >( xSettingsDlg, uno::UNO_QUERY_THROW ) );
      }
      sFind = LoadAndRegisterDataSource_Impl( type, DBConnURIType::FLAT == type ? &aSettings : nullptr, aURL, nullptr, pDocShell );

      m_aUncommittedRegistrations.push_back(std::pair<SwDocShell*, OUString>(pDocShell, sFind));
  }
  return sFind;
2838}

2840void SwDBManager::StoreEmbeddedDataSource(const uno::Reference<frame::XStorable>& xStorable,
                                        const uno::Reference<embed::XStorage>& xStorage,
                                        const OUString& rStreamRelPath,
                                        const OUString& rOwnURL, bool bCopyTo)
2844{
  // Construct vnd.sun.star.pkg:// URL for later loading, and TargetStorage/StreamRelPath for storing.
  OUString const sTmpName = ConstructVndSunStarPkgUrl(rOwnURL, rStreamRelPath);

  uno::Sequence<beans::PropertyValue> aSequence = comphelper::InitPropertySequence(
  {
      {"TargetStorage", uno::makeAny(xStorage)},
      {"StreamRelPath", uno::makeAny(rStreamRelPath)},
      {"BaseURI", uno::makeAny(rOwnURL)}
  });
  if (bCopyTo)
      xStorable->storeToURL(sTmpName, aSequence);
  else
      xStorable->storeAsURL(sTmpName, aSequence);
2858}

2860OUString SwDBManager::LoadAndRegisterDataSource(const OUString &rURI, const OUString *pDestDir)
2861{
  return LoadAndRegisterDataSource_Impl( DBConnURIType::UNKNOWN, nullptr, INetURLObject(rURI), pDestDir, nullptr );
2863}

2865namespace
2866{
  // tdf#117824 switch the embedded database away from using its current storage and point it to temporary storage
  // which allows the original storage to be deleted
  void switchEmbeddedDatabaseStorage(const uno::Reference<sdb::XDatabaseContext>& rDatabaseContext, const OUString& rName)
  {
      uno::Reference<sdb::XDocumentDataSource> xDS(rDatabaseContext->getByName(rName), uno::UNO_QUERY);
      if (!xDS)
          return;
      uno::Reference<document::XStorageBasedDocument> xStorageDoc(xDS->getDatabaseDocument(), uno::UNO_QUERY);
      if (!xStorageDoc)
          return;
      xStorageDoc->switchToStorage(comphelper::OStorageHelper::GetTemporaryStorage());
  }
2879}

2881void SwDBManager::RevokeDataSource(const OUString& rName)
2882{
  uno::Reference<sdb::XDatabaseContext> xDatabaseContext = sdb::DatabaseContext::create(comphelper::getProcessComponentContext());
  if (xDatabaseContext->hasByName(rName))
  {
      switchEmbeddedDatabaseStorage(xDatabaseContext, rName);
      xDatabaseContext->revokeObject(rName);
  }
2889}

2891void SwDBManager::LoadAndRegisterEmbeddedDataSource(const SwDBData& rData, const SwDocShell& rDocShell)
2892{
  uno::Reference<sdb::XDatabaseContext> xDatabaseContext = sdb::DatabaseContext::create(comphelper::getProcessComponentContext());

  OUString sDataSource = rData.sDataSource;

  // Fallback, just in case the document would contain an embedded data source, but no DB fields.
  if (sDataSource.isEmpty())
      sDataSource = "EmbeddedDatabase";

  SwDBManager::RevokeDataSource( sDataSource );

  // Encode the stream name and the real path into a single URL.
  const INetURLObject& rURLObject = rDocShell.GetMedium()->GetURLObject();
  OUString const aURL = ConstructVndSunStarPkgUrl(
      rURLObject.GetMainURL(INetURLObject::DecodeMechanism::NONE),
      m_sEmbeddedName);

  uno::Reference<uno::XInterface> xDataSource(xDatabaseContext->getByName(aURL), uno::UNO_QUERY);
  xDatabaseContext->registerObject( sDataSource, xDataSource );

  // temp file - don't remember connection
  if (rData.sDataSource.isEmpty())
      m_aUncommittedRegistrations.push_back(std::pair<SwDocShell*, OUString>(nullptr, sDataSource));
2915}

2917void SwDBManager::ExecuteFormLetter( SwWrtShell& rSh,
                      const uno::Sequence<beans::PropertyValue>& rProperties)
2919{
  //prevent second call
  if(m_pImpl->pMergeDialog)
      return ;
  OUString sDataSource, sDataTableOrQuery;
  uno::Sequence<uno::Any> aSelection;

  sal_Int32 nCmdType = sdb::CommandType::TABLE;
  uno::Reference< sdbc::XConnection> xConnection;

  svx::ODataAccessDescriptor aDescriptor(rProperties);
  sDataSource = aDescriptor.getDataSource();
  OSL_VERIFY(aDescriptor[svx::DataAccessDescriptorProperty::Command]      >>= sDataTableOrQuery)do { if (!(aDescriptor[svx::DataAccessDescriptorProperty::Command
] >>= sDataTableOrQuery)) do { if (true && (!(0
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "2931" ": "), "OSL_ASSERT: %s", "0"); } } while (false);
 } while (0);
  OSL_VERIFY(aDescriptor[svx::DataAccessDescriptorProperty::CommandType]  >>= nCmdType)do { if (!(aDescriptor[svx::DataAccessDescriptorProperty::CommandType
] >>= nCmdType)) do { if (true && (!(0))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "2932" ": "), "OSL_ASSERT: %s", "0"); } } while (false);
 } while (0);

  if ( aDescriptor.has(svx::DataAccessDescriptorProperty::Selection) )
      aDescriptor[svx::DataAccessDescriptorProperty::Selection] >>= aSelection;
  if ( aDescriptor.has(svx::DataAccessDescriptorProperty::Connection) )
      aDescriptor[svx::DataAccessDescriptorProperty::Connection] >>= xConnection;

  if(sDataSource.isEmpty() || sDataTableOrQuery.isEmpty())
  {
      OSL_FAIL("PropertyValues missing or unset")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "2941" ": "), "%s", "PropertyValues missing or unset"); }
 } while (false);
      return;
  }

  //always create a connection for the dialog and dispose it after the dialog has been closed
  SwDSParam* pFound = nullptr;
  if(!xConnection.is())
  {
      xConnection = SwDBManager::RegisterConnection(sDataSource);
      pFound = FindDSConnection(sDataSource, true);
  }
  SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
  m_pImpl->pMergeDialog = pFact->CreateMailMergeDlg(rSh.GetView().GetViewFrame()->GetWindow().GetFrameWeld(), rSh,
                                                   sDataSource,
                                                   sDataTableOrQuery,
                                                   nCmdType,
                                                   xConnection);
  if(m_pImpl->pMergeDialog->Execute() == RET_OK)
  {
      aDescriptor[svx::DataAccessDescriptorProperty::Selection] <<= m_pImpl->pMergeDialog->GetSelection();

      uno::Reference<sdbc::XResultSet> xResSet = m_pImpl->pMergeDialog->GetResultSet();
      if(xResSet.is())
          aDescriptor[svx::DataAccessDescriptorProperty::Cursor] <<= xResSet;

      // SfxObjectShellRef is ok, since there should be no control over the document lifetime here
      SfxObjectShellRef xDocShell = rSh.GetView().GetViewFrame()->GetObjectShell();

      lcl_emitEvent(SfxEventHintId::SwMailMerge, STR_SW_EVENT_MAIL_MERGE1, xDocShell.get());

      // prepare mail merge descriptor
      SwMergeDescriptor aMergeDesc( m_pImpl->pMergeDialog->GetMergeType(), rSh, aDescriptor );
      aMergeDesc.sSaveToFilter = m_pImpl->pMergeDialog->GetSaveFilter();
      aMergeDesc.bCreateSingleFile = m_pImpl->pMergeDialog->IsSaveSingleDoc();
      aMergeDesc.bPrefixIsFilename = aMergeDesc.bCreateSingleFile;
      aMergeDesc.sPrefix = m_pImpl->pMergeDialog->GetTargetURL();

      if(!aMergeDesc.bCreateSingleFile)
      {
          if(m_pImpl->pMergeDialog->IsGenerateFromDataBase())
              aMergeDesc.sDBcolumn = m_pImpl->pMergeDialog->GetColumnName();

          if(m_pImpl->pMergeDialog->IsFileEncryptedFromDataBase())
              aMergeDesc.sDBPasswordColumn = m_pImpl->pMergeDialog->GetPasswordColumnName();
      }

      Merge( aMergeDesc );

      lcl_emitEvent(SfxEventHintId::SwMailMergeEnd, STR_SW_EVENT_MAIL_MERGE_END2, xDocShell.get());

      // reset the cursor inside
      xResSet = nullptr;
      aDescriptor[svx::DataAccessDescriptorProperty::Cursor] <<= xResSet;
  }
  if(pFound)
  {
      for (const auto & pParam : m_DataSourceParams)
      {
          if (pParam.get() == pFound)
          {
              try
              {
                  uno::Reference<lang::XComponent> xComp(pParam->xConnection, uno::UNO_QUERY);
                  if(xComp.is())
                      xComp->dispose();
              }
              catch(const uno::RuntimeException&)
              {
                  //may be disposed already since multiple entries may have used the same connection
              }
              break;
          }
          //pFound doesn't need to be removed/deleted -
          //this has been done by the SwConnectionDisposedListener_Impl already
      }
  }
  m_pImpl->pMergeDialog.disposeAndClear();
3018}

3020void SwDBManager::InsertText(SwWrtShell& rSh,
                      const uno::Sequence< beans::PropertyValue>& rProperties)
3022{
  OUString sDataSource, sDataTableOrQuery;
  uno::Reference<sdbc::XResultSet>  xResSet;
  uno::Sequence<uno::Any> aSelection;
  sal_Int16 nCmdType = sdb::CommandType::TABLE;
  uno::Reference< sdbc::XConnection> xConnection;
  for(const beans::PropertyValue& rValue : rProperties)
  {
      if ( rValue.Name == "DataSourceName" )
          rValue.Value >>= sDataSource;
      else if ( rValue.Name == "Command" )
          rValue.Value >>= sDataTableOrQuery;
      else if ( rValue.Name == "Cursor" )
          rValue.Value >>= xResSet;
      else if ( rValue.Name == "Selection" )
          rValue.Value >>= aSelection;
      else if ( rValue.Name == "CommandType" )
          rValue.Value >>= nCmdType;
      else if ( rValue.Name == "ActiveConnection" )
          rValue.Value >>= xConnection;
  }
  if(sDataSource.isEmpty() || sDataTableOrQuery.isEmpty() || !xResSet.is())
  {
      OSL_FAIL("PropertyValues missing or unset")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "3045" ": "), "%s", "PropertyValues missing or unset"); }
 } while (false);
      return;
  }
  uno::Reference< uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
  uno::Reference<sdbc::XDataSource> xSource;
  uno::Reference<container::XChild> xChild(xConnection, uno::UNO_QUERY);
  if(xChild.is())
      xSource.set(xChild->getParent(), uno::UNO_QUERY);
  if(!xSource.is())
      xSource = dbtools::getDataSource(sDataSource, xContext);
  uno::Reference< sdbcx::XColumnsSupplier > xColSupp( xResSet, uno::UNO_QUERY );
  SwDBData aDBData;
  aDBData.sDataSource = sDataSource;
  aDBData.sCommand = sDataTableOrQuery;
  aDBData.nCommandType = nCmdType;

  SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
  ScopedVclPtr<AbstractSwInsertDBColAutoPilot> pDlg(pFact->CreateSwInsertDBColAutoPilot( rSh.GetView(),
                                                                              xSource,
                                                                              xColSupp,
                                                                              aDBData ));
  if( RET_OK != pDlg->Execute() )
      return;

  OUString sDummy;
  if(!xConnection.is())
      xConnection = xSource->getConnection(sDummy, sDummy);
  try
  {
      pDlg->DataToDoc( aSelection , xSource, xConnection, xResSet);
  }
  catch (const uno::Exception&)
  {
      TOOLS_WARN_EXCEPTION("sw.mailmerge", "")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.mailmerge")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "" << " " <<
 exceptionToString(tools_warn_exception)) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "3078" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "3078" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "" << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "3078" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "3078" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
  }
3080}

3082uno::Reference<sdbc::XDataSource> SwDBManager::getDataSourceAsParent(const uno::Reference< sdbc::XConnection>& _xConnection,const OUString& _sDataSourceName)
3083{
  uno::Reference<sdbc::XDataSource> xSource;
  try
  {
      uno::Reference<container::XChild> xChild(_xConnection, uno::UNO_QUERY);
      if ( xChild.is() )
          xSource.set(xChild->getParent(), uno::UNO_QUERY);
      if ( !xSource.is() )
          xSource = dbtools::getDataSource(_sDataSourceName, ::comphelper::getProcessComponentContext());
  }
  catch (const uno::Exception&)
  {
      TOOLS_WARN_EXCEPTION("sw.mailmerge", "getDataSourceAsParent()")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.mailmerge")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "getDataSourceAsParent()"
 << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "3095" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "getDataSourceAsParent()" << " "
 << exceptionToString(tools_warn_exception)), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "getDataSourceAsParent()" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "3095" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "getDataSourceAsParent()" << " " << exceptionToString
(tools_warn_exception)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "3095" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "getDataSourceAsParent()" << " "
 << exceptionToString(tools_warn_exception)), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "getDataSourceAsParent()" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "3095" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
  }
  return xSource;
3098}

3100uno::Reference<sdbc::XResultSet> SwDBManager::createCursor(const OUString& _sDataSourceName,
                                     const OUString& _sCommand,
                                     sal_Int32 _nCommandType,
                                     const uno::Reference<sdbc::XConnection>& _xConnection,
                                     const SwView* pView)
3105{
  uno::Reference<sdbc::XResultSet> xResultSet;
  try
  {
      uno::Reference< lang::XMultiServiceFactory > xMgr( ::comphelper::getProcessServiceFactory() );
      if( xMgr.is() )
      {
          uno::Reference<uno::XInterface> xInstance = xMgr->createInstance("com.sun.star.sdb.RowSet");
          uno::Reference<beans::XPropertySet> xRowSetPropSet(xInstance, uno::UNO_QUERY);
          if(xRowSetPropSet.is())
          {
              xRowSetPropSet->setPropertyValue("DataSourceName", uno::makeAny(_sDataSourceName));
              xRowSetPropSet->setPropertyValue("ActiveConnection", uno::makeAny(_xConnection));
              xRowSetPropSet->setPropertyValue("Command", uno::makeAny(_sCommand));
              xRowSetPropSet->setPropertyValue("CommandType", uno::makeAny(_nCommandType));

              uno::Reference< sdb::XCompletedExecution > xRowSet(xInstance, uno::UNO_QUERY);

              if ( xRowSet.is() )
              {
                  weld::Window* pWindow = pView ? pView->GetFrameWeld() : nullptr;
                  uno::Reference< task::XInteractionHandler > xHandler( task::InteractionHandler::createWithParent(comphelper::getComponentContext(xMgr), pWindow ? pWindow->GetXWindow() : nullptr), uno::UNO_QUERY_THROW );
                  xRowSet->executeWithCompletion(xHandler);
              }
              xResultSet.set(xRowSet, uno::UNO_QUERY);
          }
      }
  }
  catch (const uno::Exception&)
  {
      TOOLS_WARN_EXCEPTION("sw.mailmerge", "Caught exception while creating a new RowSet")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.mailmerge")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "Caught exception while creating a new RowSet"
 << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"sw.mailmerge"), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "3135" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Caught exception while creating a new RowSet"
 << " " << exceptionToString(tools_warn_exception
)), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Caught exception while creating a new RowSet" <<
 " " << exceptionToString(tools_warn_exception); ::sal::
detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"),
 ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "3135" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Caught exception while creating a new RowSet" <<
 " " << exceptionToString(tools_warn_exception)) == 1) {
 ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"
), ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "3135" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Caught exception while creating a new RowSet"
 << " " << exceptionToString(tools_warn_exception
)), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Caught exception while creating a new RowSet" <<
 " " << exceptionToString(tools_warn_exception); ::sal::
detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.mailmerge"),
 ("/home/maarten/src/libreoffice/core/sw/source/uibase/dbui/dbmgr.cxx"
 ":" "3135" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
  }
  return xResultSet;
3138}

3140void SwDBManager::setEmbeddedName(const OUString& rEmbeddedName, SwDocShell& rDocShell)
3141{
  bool bLoad = m_sEmbeddedName != rEmbeddedName && !rEmbeddedName.isEmpty();
  bool bRegisterListener = m_sEmbeddedName.isEmpty() && !rEmbeddedName.isEmpty();

  m_sEmbeddedName = rEmbeddedName;

  if (bLoad)
  {
      uno::Reference<embed::XStorage> xStorage = rDocShell.GetStorage();
      // It's OK that we don't have the named sub-storage yet, in case
      // we're in the process of creating it.
      if (xStorage->hasByName(rEmbeddedName))
          LoadAndRegisterEmbeddedDataSource(rDocShell.GetDoc()->GetDBData(), rDocShell);
  }

  if (bRegisterListener)
      // Register a remove listener, so we know when the embedded data source is removed.
      m_pImpl->m_xDataSourceRemovedListener = new SwDataSourceRemovedListener(*this);
3159}

3161const OUString& SwDBManager::getEmbeddedName() const
3162{
  return m_sEmbeddedName;
3164}

3166SwDoc* SwDBManager::getDoc() const
3167{
  return m_pDoc;
3169}

3171void SwDBManager::releaseRevokeListener()
3172{
  if (m_pImpl->m_xDataSourceRemovedListener.is())
  {
      m_pImpl->m_xDataSourceRemovedListener->Dispose();
      m_pImpl->m_xDataSourceRemovedListener.clear();
  }
3178}

3180SwDBManager::ConnectionDisposedListener_Impl::ConnectionDisposedListener_Impl(SwDBManager& rManager)
  : m_pDBManager(&rManager)
3182{
3183}

3185void SwDBManager::ConnectionDisposedListener_Impl::disposing( const lang::EventObject& rSource )
3186{
  ::SolarMutexGuard aGuard;

  if (!m_pDBManager) return; // we're disposed too!

  uno::Reference<sdbc::XConnection> xSource(rSource.Source, uno::UNO_QUERY);
  for (size_t nPos = m_pDBManager->m_DataSourceParams.size(); nPos; nPos--)
  {
      SwDSParam* pParam = m_pDBManager->m_DataSourceParams[nPos - 1].get();
      if(pParam->xConnection.is() &&
              (xSource == pParam->xConnection))
      {
          m_pDBManager->m_DataSourceParams.erase(
                  m_pDBManager->m_DataSourceParams.begin() + nPos - 1);
      }
  }
3202}

3204std::shared_ptr<SwMailMergeConfigItem> SwDBManager::PerformMailMerge(SwView const * pView)
3205{
  std::shared_ptr<SwMailMergeConfigItem> xConfigItem = pView->GetMailMergeConfigItem();
  if (!xConfigItem)
      return xConfigItem;

  svx::ODataAccessDescriptor aDescriptor;
  aDescriptor.setDataSource(xConfigItem->GetCurrentDBData().sDataSource);
  aDescriptor[ svx::DataAccessDescriptorProperty::Connection ]  <<= xConfigItem->GetConnection().getTyped();
  aDescriptor[ svx::DataAccessDescriptorProperty::Cursor ]      <<= xConfigItem->GetResultSet();
  aDescriptor[ svx::DataAccessDescriptorProperty::Command ]     <<= xConfigItem->GetCurrentDBData().sCommand;
  aDescriptor[ svx::DataAccessDescriptorProperty::CommandType ] <<= xConfigItem->GetCurrentDBData().nCommandType;
  aDescriptor[ svx::DataAccessDescriptorProperty::Selection ]   <<= xConfigItem->GetSelection();

  SwWrtShell& rSh = pView->GetWrtShell();
  xConfigItem->SetTargetView(nullptr);

  SwMergeDescriptor aMergeDesc(DBMGR_MERGE_SHELL, rSh, aDescriptor);
  aMergeDesc.pMailMergeConfigItem = xConfigItem.get();
  aMergeDesc.bCreateSingleFile = true;
  rSh.GetDBManager()->Merge(aMergeDesc);

  return xConfigItem;
3227}

3229void SwDBManager::RevokeLastRegistrations()
3230{
  if (m_aUncommittedRegistrations.empty())
      return;

  SwView* pView = ( m_pDoc && m_pDoc->GetDocShell() ) ? m_pDoc->GetDocShell()->GetView() : nullptr;
  if (pView)
  {
      const std::shared_ptr<SwMailMergeConfigItem>& xConfigItem = pView->GetMailMergeConfigItem();
      if (xConfigItem)
      {
          xConfigItem->DisposeResultSet();
          xConfigItem->DocumentReloaded();
      }
  }

  for (auto it = m_aUncommittedRegistrations.begin(); it != m_aUncommittedRegistrations.end();)
  {
      if ((m_pDoc && it->first == m_pDoc->GetDocShell()) || it->first == nullptr)
      {
          RevokeDataSource(it->second);
          it = m_aUncommittedRegistrations.erase(it);
      }
      else
          ++it;
  }
3255}

3257void SwDBManager::CommitLastRegistrations()
3258{
  for (auto aIt = m_aUncommittedRegistrations.begin(); aIt != m_aUncommittedRegistrations.end();)
  {
      if (aIt->first == m_pDoc->GetDocShell() || aIt->first == nullptr)
      {
          m_aNotUsedConnections.push_back(aIt->second);
          aIt = m_aUncommittedRegistrations.erase(aIt);
      }
      else
          aIt++;
  }
3269}

3271void SwDBManager::SetAsUsed(const OUString& rName)
3272{
  auto aFound = std::find(m_aNotUsedConnections.begin(), m_aNotUsedConnections.end(), rName);
  if (aFound != m_aNotUsedConnections.end())
      m_aNotUsedConnections.erase(aFound);
3276}

3278void SwDBManager::RevokeNotUsedConnections()
3279{
  for (auto aIt = m_aNotUsedConnections.begin(); aIt != m_aNotUsedConnections.end();)
  {
      RevokeDataSource(*aIt);
      aIt = m_aNotUsedConnections.erase(aIt);
  }
3285}

3287/* 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;
9
←
Assuming field 'length' is equal to 0→
10
←
Returning the value 1, which participates in a condition later→
  }

  /**
    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 != asciiStrLength )
          return false;

      return rtl_ustr_asciil_reverseEquals_WithLength(
                  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__))
          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(
          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/sw/inc/dbmgr.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 .
*/
19#ifndef INCLUDED_SW_INC_DBMGR_HXX
20#define INCLUDED_SW_INC_DBMGR_HXX

22#include <rtl/ustring.hxx>
23#include <tools/solar.h>
24#include <i18nlangtag/lang.h>
25#include <com/sun/star/util/Date.hpp>
26#include "swdllapi.h"
27#include "swdbdata.hxx"
28#include <com/sun/star/uno/Reference.h>
29#include <com/sun/star/uno/Sequence.hxx>
30#include <com/sun/star/lang/Locale.hpp>
31#include <com/sun/star/beans/PropertyValue.hpp>

33#include <memory>
34#include <vector>

36namespace com::sun::star{
  namespace sdbc{
      class XConnection;
      class XStatement;
      class XDataSource;
      class XResultSet;
  }
  namespace beans{

      class XPropertySet;
  }
  namespace sdbcx{
      class XColumnsSupplier;
  }
  namespace util{
      class XNumberFormatter;
  }
  namespace mail{
      class XSmtpService;
  }
  namespace embed { class XStorage; }
  namespace frame { class XStorable; }
58}
59namespace svx {
  class ODataAccessDescriptor;
61}

63struct SwDBFormatData
64{
  css::util::Date aNullDate;
  css::uno::Reference< css::util::XNumberFormatter> xFormatter;
  css::lang::Locale aLocale;
68};

70namespace weld {
  class ComboBox;
  class Window;
73}

75class SwView;
76class SwWrtShell;
77class ListBox;
78class SvNumberFormatter;
79class SwXMailMerge;
80class SwMailMergeConfigItem;
81class SwCalc;
82class INetURLObject;
83class SwDocShell;

85enum DBManagerOptions
86{
  DBMGR_MERGE,             ///< Data records in fields.
  DBMGR_MERGE_PRINTER,     ///< Print mail merge.
  DBMGR_MERGE_EMAIL,       ///< Send mail merge as email.
  DBMGR_MERGE_FILE,        ///< Save mail merge as files.
  DBMGR_MERGE_SHELL        ///< Create merge doc and keep the doc shell.
92};

94// Administration of (new) logical databases.
95enum class SwDBSelect
96{
  UNKNOWN, TABLE, QUERY
98};

100struct SwDSParam : public SwDBData
101{
  css::util::Date  aNullDate;

  css::uno::Reference<css::util::XNumberFormatter>    xFormatter;
  css::uno::Reference< css::sdbc::XConnection>       xConnection;
  css::uno::Reference< css::sdbc::XStatement>        xStatement;
  css::uno::Reference< css::sdbc::XResultSet>        xResultSet;
  css::uno::Sequence<  css::uno::Any >               aSelection;
  bool bScrollable;
  bool bEndOfDB;
  long nSelectionIndex;

  SwDSParam(const SwDBData& rData) :
      SwDBData(rData),
      bScrollable(false),
      bEndOfDB(false),
      nSelectionIndex(0)
      {}

  SwDSParam(const SwDBData& rData,
      const css::uno::Reference< css::sdbc::XResultSet>&    xResSet,
      const css::uno::Sequence<  css::uno::Any >&   rSelection) :
      SwDBData(rData),
      xResultSet(xResSet),
      aSelection(rSelection),
      bScrollable(true),
      bEndOfDB(false),
      nSelectionIndex(0)
      {}

  bool HasValidRecord() const
      { return( !bEndOfDB && xResultSet.is() ); }
133};

135typedef std::vector<std::unique_ptr<SwDSParam>> SwDSParams_t;

137struct SwMergeDescriptor
138{
  const DBManagerOptions                              nMergeType;
  SwWrtShell&                                         rSh;
  const svx::ODataAccessDescriptor&                   rDescriptor;

  /**
   * Create a single or multiple results
   *
   * This currently just affects FILE, as EMAIL is always
   * multiple and SHELL and PRINTER are always single.
   */
  bool                                                bCreateSingleFile;

  /**
   * @defgroup save Export filter settings
   * @addtogroup save
   * @{ */
  OUString                                            sSaveToFilter;
  OUString                                            sSaveToFilterOptions;
  css::uno::Sequence< css::beans::PropertyValue >     aSaveToFilterData;
  /** @} */

  /**
   * @defgroup file Mail merge as File settings
   * @addtogroup file
   * @{ */

  /**
   * Basename incl. the path for the generated files.
   *
   * The final filename will be created by concatenating a number to prevent
   * overwriting an existing file and the extension based on the filter
   * settings.
   */
  OUString                                            sPrefix;
  /**
   * Use the sPrefix as the target filename also overwriting an existing
   * target file.
   *
   * Just used for the internal mail merge dialogs as mail merge never
   * overwrites existing files (see SwDBManager::ExecuteFormLetter).
   */
  bool                                                bPrefixIsFilename;
  /** @} */

  /**
   * @defgroup email Mail merge as eMail settings
   * @addtogroup email
   * @{ */
  OUString                                            sSubject;
  OUString                                            sMailBody;
  OUString                                            sAttachmentName;
  css::uno::Sequence< OUString >                      aCopiesTo;
  css::uno::Sequence< OUString >                      aBlindCopiesTo;
  css::uno::Reference< css::mail::XSmtpService >      xSmtpServer;
  bool                                                bSendAsHTML;
  bool                                                bSendAsAttachment;
  /** @} */

  /**
   * @addtogroup file email
   * @{ */

  /** DB column to fetch EMail of Filename from
   */
  OUString                                            sDBcolumn;

  /** DB column to fetch password
   */
  OUString                                            sDBPasswordColumn;

  /** @} */

  /**
   * @defgroup print Mail merge to Printer
   * @addtogroup print
   * @{ */
  css::uno::Sequence<  css::beans::PropertyValue >    aPrintOptions;
  /** @} */

  SwMailMergeConfigItem*                              pMailMergeConfigItem;

  SwMergeDescriptor( const DBManagerOptions nType,
                     SwWrtShell& rShell,
                     const svx::ODataAccessDescriptor& rDesc ) :
      nMergeType(nType),
      rSh(rShell),
      rDescriptor(rDesc),
      bCreateSingleFile( false ),
      bPrefixIsFilename( false ),
      bSendAsHTML( true ),
      bSendAsAttachment( false ),
      pMailMergeConfigItem( nullptr )
  {
      if( nType == DBMGR_MERGE_SHELL || nType == DBMGR_MERGE_PRINTER )
          bCreateSingleFile = true;
  }
235};

237class SwDoc;

239class SW_DLLPUBLIC__attribute__ ((visibility("default"))) SwDBManager
240{
  struct SwDBManager_Impl;
  class SAL_DLLPRIVATE__attribute__ ((visibility("hidden"))) ConnectionDisposedListener_Impl;
  class MailDispatcherListener_Impl;

  enum class MergeStatus
  {
      Ok = 0, Cancel, Error
  };

  MergeStatus     m_aMergeStatus;     ///< current / last merge status
  bool            m_bInitDBFields : 1;
  bool            m_bInMerge    : 1;    ///< merge process active
  bool            m_bMergeSilent : 1;   ///< suppress display of dialogs/boxes (used when called over API)
  SwDSParams_t    m_DataSourceParams;
  std::unique_ptr<SwDBManager_Impl>  m_pImpl;
  const SwXMailMerge* m_pMergeEvtSrc;   ///< != 0 if mail merge events are to be send
  /// Name of the embedded database that's included in the current document.
  OUString     m_sEmbeddedName;

  /// Store last registrations to revoke or commit
  static std::vector<std::pair<SwDocShell*, OUString>> m_aUncommittedRegistrations;

  /// Not used connections.
  std::vector<OUString> m_aNotUsedConnections;

  /// Set connection as used.
  void SetAsUsed(const OUString& rName);

  /// The document that owns this manager.
  SwDoc* m_pDoc;

  SAL_DLLPRIVATE__attribute__ ((visibility("hidden"))) SwDSParam*          FindDSData(const SwDBData& rData, bool bCreate);
  SAL_DLLPRIVATE__attribute__ ((visibility("hidden"))) SwDSParam*          FindDSConnection(const OUString& rSource, bool bCreate);

  /// Insert data record as text into document.
  SAL_DLLPRIVATE__attribute__ ((visibility("hidden"))) void ImportFromConnection( SwWrtShell* pSh);

  /// Insert a single data record as text into document.
  SAL_DLLPRIVATE__attribute__ ((visibility("hidden"))) void ImportDBEntry(SwWrtShell* pSh);

  /// Run the mail merge for defined modes, except DBMGR_MERGE
  SAL_DLLPRIVATE__attribute__ ((visibility("hidden"))) bool MergeMailFiles( SwWrtShell* pSh,
                                      const SwMergeDescriptor& rMergeDescriptor );

  SAL_DLLPRIVATE__attribute__ ((visibility("hidden"))) bool ToNextMergeRecord();
  SAL_DLLPRIVATE__attribute__ ((visibility("hidden"))) bool IsValidMergeRecord() const;

  SwDBManager(SwDBManager const&) = delete;
  SwDBManager& operator=(SwDBManager const&) = delete;

291public:
  SwDBManager(SwDoc* pDoc);
  ~SwDBManager() COVERITY_NOEXCEPT_FALSE;

  /// MailMergeEvent source
  const SwXMailMerge *    GetMailMergeEvtSrc() const  { return m_pMergeEvtSrc; }
  void SetMailMergeEvtSrc( const SwXMailMerge *pSrc ) { m_pMergeEvtSrc = pSrc; }

  bool     IsMergeSilent() const           { return m_bMergeSilent; }
  void     SetMergeSilent( bool bVal )     { m_bMergeSilent = bVal; }

  /// Merging of data records into fields.
  bool            Merge( const SwMergeDescriptor& rMergeDesc );
  void            MergeCancel();

  bool     IsMergeOk() const     { return MergeStatus::Ok     == m_aMergeStatus; }
34
←
Assuming Ok is not equal to field 'm_aMergeStatus'→
35
←
Returning zero, which participates in a condition later→
  bool     IsMergeError() const  { return MergeStatus::Error  <= m_aMergeStatus; }

  static std::shared_ptr<SwMailMergeConfigItem> PerformMailMerge(SwView const * pView);

  /// Initialize data fields that lack name of database.
  bool     IsInitDBFields() const  { return m_bInitDBFields; }
  void     SetInitDBFields(bool b) { m_bInitDBFields = b;    }

  /// Fill listbox with all table names of a database.
  bool            GetTableNames(weld::ComboBox& rBox, const OUString& rDBName);

  /// Fill listbox with all column names of a database table.
  void            GetColumnNames(weld::ComboBox& rBox,
                          const OUString& rDBName, const OUString& rTableName);
  static void GetColumnNames(weld::ComboBox& rBox,
                          css::uno::Reference< css::sdbc::XConnection> const & xConnection,
                          const OUString& rTableName);

  static sal_uLong GetColumnFormat( css::uno::Reference< css::sdbc::XDataSource> const & xSource,
                          css::uno::Reference< css::sdbc::XConnection> const & xConnection,
                          css::uno::Reference< css::beans::XPropertySet> const & xColumn,
                          SvNumberFormatter* pNFormatr,
                          LanguageType nLanguage );

  sal_uLong GetColumnFormat( const OUString& rDBName,
                          const OUString& rTableName,
                          const OUString& rColNm,
                          SvNumberFormatter* pNFormatr,
                          LanguageType nLanguage );
  sal_Int32 GetColumnType( const OUString& rDBName,
                        const OUString& rTableName,
                        const OUString& rColNm );

  bool     IsInMerge() const   { return m_bInMerge; }

  void            ExecuteFormLetter(SwWrtShell& rSh,
                      const css::uno::Sequence< css::beans::PropertyValue>& rProperties);

  static void     InsertText(SwWrtShell& rSh,
                      const css::uno::Sequence< css::beans::PropertyValue>& rProperties);

  /// check if a data source is open
  bool            IsDataSourceOpen(const OUString& rDataSource,
                                  const OUString& rTableOrQuery, bool bMergeShell);

  /// open the source while fields are updated - for the calculator only!
  bool            OpenDataSource(const OUString& rDataSource, const OUString& rTableOrQuery);
  sal_uInt32      GetSelectedRecordId(const OUString& rDataSource, const OUString& rTableOrQuery, sal_Int32 nCommandType = -1);
  bool            GetColumnCnt(const OUString& rSourceName, const OUString& rTableName,
                          const OUString& rColumnName, sal_uInt32 nAbsRecordId, LanguageType nLanguage,
                          OUString& rResult, double* pNumber);
  /** create and store or find an already stored connection to a data source for use
  in SwFieldMgr and SwDBTreeList */
  css::uno::Reference< css::sdbc::XConnection> const &
                  RegisterConnection(OUString const& rSource);

  void            CreateDSData(const SwDBData& rData)
                      { FindDSData(rData, true); }
  const SwDSParams_t& GetDSParamArray() const { return m_DataSourceParams; }

  /// close all data sources - after fields were updated
  void            CloseAll(bool bIncludingMerge = true);

  bool            GetMergeColumnCnt(const OUString& rColumnName, LanguageType nLanguage,
                                    OUString &rResult, double *pNumber);
  bool            FillCalcWithMergeData(SvNumberFormatter *pDocFormatter,
                                        LanguageType nLanguage, SwCalc &aCalc);
  void            ToNextRecord(const OUString& rDataSource, const OUString& rTableOrQuery);

  sal_uInt32      GetSelectedRecordId();
  bool            ToRecordId(sal_Int32 nSet);

  static const SwDBData& GetAddressDBName();

  static OUString GetDBField(
                  css::uno::Reference< css::beans::XPropertySet > const & xColumnProp,
                  const SwDBFormatData& rDBFormatData,
                  double *pNumber = nullptr);

  static css::uno::Reference< css::sdbc::XConnection>
          GetConnection(const OUString& rDataSource,
              css::uno::Reference< css::sdbc::XDataSource>& rxSource,
              const SwView* pView);

  static css::uno::Reference< css::sdbcx::XColumnsSupplier>
          GetColumnSupplier(css::uno::Reference< css::sdbc::XConnection> const & xConnection,
                                  const OUString& rTableOrQuery,
                                  SwDBSelect eTableOrQuery = SwDBSelect::UNKNOWN);

  static css::uno::Sequence<OUString> GetExistingDatabaseNames();

  /**
   Loads a data source from file and registers it.

   This function requires GUI interaction, as it loads the data source from
   the filename returned by a file picker and additional settings dialog.
   In case of success it returns the registered name, otherwise an empty string.
   */
  static OUString            LoadAndRegisterDataSource(weld::Window* pParent, SwDocShell* pDocShell = nullptr);

  /**
   Loads a data source from file and registers it.

   Convenience function, which calls GetDBunoURI and has just one mandatory parameter.
   In case of success it returns the registered name, otherwise an empty string.
   */
  static OUString            LoadAndRegisterDataSource(const OUString& rURI, const OUString *pDestDir);

  /// Load the embedded data source of the document and also register it.
  void LoadAndRegisterEmbeddedDataSource(const SwDBData& rData, const SwDocShell& rDocShell);

  /// Unregister a data source.
  static void RevokeDataSource(const OUString& rName);

  /** try to get the data source from the given connection through the XChild interface.
      If this is not possible, the data source will be created through its name.
      @param _xConnection
          The connection which should support the XChild interface. (not a must)
      @param _sDataSourceName
          The data source name will be used to create the data source when the connection can not be used for it.
      @return
          The data source.
  */
  static css::uno::Reference< css::sdbc::XDataSource>
          getDataSourceAsParent(const css::uno::Reference< css::sdbc::XConnection>& _xConnection,const OUString& _sDataSourceName);

  /** creates a RowSet, which must be disposed after use.
      @param  _sDataSourceName
          The data source name
      @param  _sCommand
          The command.
      @param  _nCommandType
          The type of the command.
      @param  _xConnection
          The active connection which may be <NULL/>.
      @return
          The new created RowSet.

  */
  static css::uno::Reference< css::sdbc::XResultSet>
          createCursor(const OUString& _sDataSourceName,
                       const OUString& _sCommand,
                       sal_Int32 _nCommandType,
                       const css::uno::Reference< css::sdbc::XConnection>& _xConnection,
                       const SwView* pView);

  void setEmbeddedName(const OUString& rEmbeddedName, SwDocShell& rDocShell);
  const OUString& getEmbeddedName() const;

  // rOwnURL should be taken using INetURLObject::GetMainURL(INetURLObject::DecodeMechanism::NONE)
  static void StoreEmbeddedDataSource(const css::uno::Reference<css::frame::XStorable>& xStorable,
                                      const css::uno::Reference<css::embed::XStorage>& xStorage,
                                      const OUString& rStreamRelPath,
                                      const OUString& rOwnURL, bool bCopyTo = false);

  SwDoc* getDoc() const;
  /// Stop reacting to removed database registrations.
  void releaseRevokeListener();

  /// Revoke not committed registrations in case of mail merge cancel
  void RevokeLastRegistrations();

  /// Accept not committed registrations
  void CommitLastRegistrations();

  /// Remove not used connections.
  void RevokeNotUsedConnections();
474};

476namespace sw
477{
478enum class DBConnURIType
479{
  UNKNOWN = 0,
  ODB,
  CALC,
  DBASE,
  FLAT,
  MSJET,
  MSACE,
  WRITER
488};

490DBConnURIType SW_DLLPUBLIC__attribute__ ((visibility("default"))) GetDBunoType(const INetURLObject &rURL);
491}

493#endif

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