/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx

Bug Summary

File:	home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx
Warning:	line 3101, column 18 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 unostyle.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/core/unocore/unostyle.cxx

/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.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 <o3tl/safeint.hxx>
23#include <svx/svxids.hrc>
24#include <hintids.hxx>
25#include <vcl/svapp.hxx>
26#include <svl/hint.hxx>
27#include <svtools/ctrltool.hxx>
28#include <svl/style.hxx>
29#include <svl/itemiter.hxx>
30#include <svl/listener.hxx>
31#include <svl/zforlist.hxx>
32#include <svl/zformat.hxx>
33#include <svx/pageitem.hxx>
34#include <editeng/colritem.hxx>
35#include <editeng/contouritem.hxx>
36#include <editeng/crossedoutitem.hxx>
37#include <editeng/fontitem.hxx>
38#include <editeng/sizeitem.hxx>
39#include <editeng/udlnitem.hxx>
40#include <editeng/ulspitem.hxx>
41#include <editeng/lrspitem.hxx>
42#include <editeng/boxitem.hxx>
43#include <editeng/postitem.hxx>
44#include <editeng/shdditem.hxx>
45#include <editeng/brushitem.hxx>
46#include <editeng/flstitem.hxx>
47#include <editeng/fhgtitem.hxx>
48#include <editeng/paperinf.hxx>
49#include <editeng/wghtitem.hxx>
50#include <pagedesc.hxx>
51#include <doc.hxx>
52#include <IDocumentUndoRedo.hxx>
53#include <IDocumentDeviceAccess.hxx>
54#include <IDocumentStylePoolAccess.hxx>
55#include <docary.hxx>
56#include <charfmt.hxx>
57#include <cmdid.h>
58#include <unomid.h>
59#include <unomap.hxx>
60#include <unostyle.hxx>
61#include <unosett.hxx>
62#include <docsh.hxx>
63#include <paratr.hxx>
64#include <unoprnms.hxx>
65#include <shellio.hxx>
66#include <docstyle.hxx>
67#include <unotextbodyhf.hxx>
68#include <fmthdft.hxx>
69#include <fmtpdsc.hxx>
70#include <strings.hrc>
71#include <poolfmt.hxx>
72#include <unoevent.hxx>
73#include <fmtruby.hxx>
74#include <SwStyleNameMapper.hxx>
75#include <sfx2/printer.hxx>
76#include <com/sun/star/frame/XModel.hpp>
77#include <com/sun/star/io/IOException.hpp>
78#include <com/sun/star/style/ParagraphStyleCategory.hpp>
79#include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
80#include <com/sun/star/beans/PropertyAttribute.hpp>
81#include <com/sun/star/beans/NamedValue.hpp>
82#include <com/sun/star/drawing/BitmapMode.hpp>
83#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
84#include <com/sun/star/lang/IllegalArgumentException.hpp>
85#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
86#include <com/sun/star/document/XEventsSupplier.hpp>
87#include <com/sun/star/io/XInputStream.hpp>
88#include <istyleaccess.hxx>
89#include <GetMetricVal.hxx>
90#include <fmtfsize.hxx>
91#include <numrule.hxx>
92#include <tblafmt.hxx>
93#include <frameformats.hxx>

95#include <comphelper/servicehelper.hxx>
96#include <cppuhelper/exc_hlp.hxx>
97#include <cppuhelper/supportsservice.hxx>
98#include <cppuhelper/typeprovider.hxx>
99#include <comphelper/sequence.hxx>
100#include <sal/log.hxx>

102#include <svl/stylepool.hxx>
103#include <svx/unobrushitemhelper.hxx>
104#include <editeng/unoipset.hxx>
105#include <editeng/memberids.h>
106#include <svx/unomid.hxx>
107#include <svx/unoshape.hxx>
108#include <svx/xflbstit.hxx>
109#include <svx/xflbmtit.hxx>
110#include <swunohelper.hxx>
111#include <svx/xbtmpit.hxx>

113#include <ccoll.hxx>
114#include <hints.hxx>

116#include <cassert>
117#include <memory>
118#include <set>
119#include <limits>

121using namespace css;
122using namespace css::io;
123using namespace css::lang;
124using namespace css::uno;

126namespace {

128class SwXStyle;
129class SwStyleProperties_Impl;

  struct StyleFamilyEntry
  {
      using GetCountOrName_t = std::function<sal_Int32 (const SwDoc&, OUString*, sal_Int32)>;
      using CreateStyle_t = std::function<uno::Reference<css::style::XStyle>(SfxStyleSheetBasePool*, SwDocShell*, const OUString&)>;
      using TranslateIndex_t = std::function<sal_uInt16(const sal_uInt16)>;
      SfxStyleFamily m_eFamily;
      sal_uInt16 m_nPropMapType;
      uno::Reference<beans::XPropertySetInfo> m_xPSInfo;
      SwGetPoolIdFromName m_aPoolId;
      OUString m_sName;
      const char* m_pResId;
      GetCountOrName_t m_fGetCountOrName;
      CreateStyle_t m_fCreateStyle;
      TranslateIndex_t m_fTranslateIndex;
      StyleFamilyEntry(SfxStyleFamily eFamily, sal_uInt16 nPropMapType, SwGetPoolIdFromName aPoolId, OUString const& sName, const char* pResId, GetCountOrName_t const & fGetCountOrName, CreateStyle_t const & fCreateStyle, TranslateIndex_t const & fTranslateIndex)
              : m_eFamily(eFamily)
              , m_nPropMapType(nPropMapType)
              , m_xPSInfo(aSwMapProvider.GetPropertySet(nPropMapType)->getPropertySetInfo())
              , m_aPoolId(aPoolId)
              , m_sName(sName)
              , m_pResId(pResId)
              , m_fGetCountOrName(fGetCountOrName)
              , m_fCreateStyle(fCreateStyle)
              , m_fTranslateIndex(fTranslateIndex)
          { }
  };
  const std::vector<StyleFamilyEntry>* our_pStyleFamilyEntries;
  // these should really be constexprs, but MSVC still is apparently too stupid for them
  #define nPoolChrNormalRange(RES_POOLCHR_NORMAL_END - RES_POOLCHR_NORMAL_BEGIN) (RES_POOLCHR_NORMAL_END - RES_POOLCHR_NORMAL_BEGIN)
  #define nPoolChrHtmlRange(RES_POOLCHR_HTML_END - RES_POOLCHR_HTML_BEGIN)   (RES_POOLCHR_HTML_END   - RES_POOLCHR_HTML_BEGIN)
  #define nPoolCollTextRange( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN)     ( RES_POOLCOLL_TEXT_END  - RES_POOLCOLL_TEXT_BEGIN)
  #define nPoolCollListsRange( RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN)    ( RES_POOLCOLL_LISTS_END    - RES_POOLCOLL_LISTS_BEGIN)
  #define nPoolCollExtraRange( RES_POOLCOLL_EXTRA_END - RES_POOLCOLL_EXTRA_BEGIN)    ( RES_POOLCOLL_EXTRA_END    - RES_POOLCOLL_EXTRA_BEGIN)
  #define nPoolCollRegisterRange( RES_POOLCOLL_REGISTER_END - RES_POOLCOLL_REGISTER_BEGIN) ( RES_POOLCOLL_REGISTER_END - RES_POOLCOLL_REGISTER_BEGIN)
  #define nPoolCollDocRange( RES_POOLCOLL_DOC_END - RES_POOLCOLL_DOC_BEGIN)      ( RES_POOLCOLL_DOC_END      - RES_POOLCOLL_DOC_BEGIN)
  #define nPoolCollHtmlRange( RES_POOLCOLL_HTML_END - RES_POOLCOLL_HTML_BEGIN)     ( RES_POOLCOLL_HTML_END     - RES_POOLCOLL_HTML_BEGIN)
  #define nPoolFrameRange( RES_POOLFRM_END - RES_POOLFRM_BEGIN) ( RES_POOLFRM_END - RES_POOLFRM_BEGIN)
  #define nPoolPageRange( RES_POOLPAGE_END - RES_POOLPAGE_BEGIN)  ( RES_POOLPAGE_END - RES_POOLPAGE_BEGIN)
  #define nPoolNumRange( RES_POOLNUMRULE_END - RES_POOLNUMRULE_BEGIN)   ( RES_POOLNUMRULE_END - RES_POOLNUMRULE_BEGIN)
  #define nPoolCollListsStackedStart( ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN))    ( nPoolCollTextRange( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN))
  #define nPoolCollExtraStackedStart( ( ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN)) + ( RES_POOLCOLL_LISTS_END
 - RES_POOLCOLL_LISTS_BEGIN))    ( nPoolCollListsStackedStart( ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN))    + nPoolCollListsRange( RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN))
  #define nPoolCollRegisterStackedStart( ( ( ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN)) + (
 RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN)) + ( RES_POOLCOLL_EXTRA_END
 - RES_POOLCOLL_EXTRA_BEGIN)) ( nPoolCollExtraStackedStart( ( ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN)) + ( RES_POOLCOLL_LISTS_END
 - RES_POOLCOLL_LISTS_BEGIN))    + nPoolCollExtraRange( RES_POOLCOLL_EXTRA_END - RES_POOLCOLL_EXTRA_BEGIN))
  #define nPoolCollDocStackedStart( ( ( ( ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN)) +
 ( RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN)) + ( RES_POOLCOLL_EXTRA_END
 - RES_POOLCOLL_EXTRA_BEGIN)) + ( RES_POOLCOLL_REGISTER_END -
 RES_POOLCOLL_REGISTER_BEGIN))      ( nPoolCollRegisterStackedStart( ( ( ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN)) + (
 RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN)) + ( RES_POOLCOLL_EXTRA_END
 - RES_POOLCOLL_EXTRA_BEGIN)) + nPoolCollRegisterRange( RES_POOLCOLL_REGISTER_END - RES_POOLCOLL_REGISTER_BEGIN))
  #define nPoolCollHtmlStackedStart( ( ( ( ( ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN))
 + ( RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN)) + ( RES_POOLCOLL_EXTRA_END
 - RES_POOLCOLL_EXTRA_BEGIN)) + ( RES_POOLCOLL_REGISTER_END -
 RES_POOLCOLL_REGISTER_BEGIN)) + ( RES_POOLCOLL_DOC_END - RES_POOLCOLL_DOC_BEGIN
))     ( nPoolCollDocStackedStart( ( ( ( ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN)) +
 ( RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN)) + ( RES_POOLCOLL_EXTRA_END
 - RES_POOLCOLL_EXTRA_BEGIN)) + ( RES_POOLCOLL_REGISTER_END -
 RES_POOLCOLL_REGISTER_BEGIN))      + nPoolCollDocRange( RES_POOLCOLL_DOC_END - RES_POOLCOLL_DOC_BEGIN))
  using paragraphstyle_t = std::remove_const<decltype(style::ParagraphStyleCategory::TEXT)>::type;
  using collectionbits_t = sal_uInt16;
  struct ParagraphStyleCategoryEntry
  {
      paragraphstyle_t m_eCategory;
      SfxStyleSearchBits m_nSwStyleBits;
      collectionbits_t m_nCollectionBits;
      ParagraphStyleCategoryEntry(paragraphstyle_t eCategory, SfxStyleSearchBits nSwStyleBits, collectionbits_t nCollectionBits)
              : m_eCategory(eCategory)
              , m_nSwStyleBits(nSwStyleBits)
              , m_nCollectionBits(nCollectionBits)
          { }
  };
  const std::vector<ParagraphStyleCategoryEntry>* our_pParagraphStyleCategoryEntries;
189}
190static const std::vector<StyleFamilyEntry>* lcl_GetStyleFamilyEntries();

192using namespace ::com::sun::star;

194namespace sw
195{
  namespace {

  class XStyleFamily : public cppu::WeakImplHelper
  <
      container::XNameContainer,
      lang::XServiceInfo,
      container::XIndexAccess,
      beans::XPropertySet
  >
  , public SfxListener
  {
      const StyleFamilyEntry& m_rEntry;
      SfxStyleSheetBasePool* m_pBasePool;
      SwDocShell* m_pDocShell;

      SwXStyle* FindStyle(const OUString& rStyleName) const;
      sal_Int32 GetCountOrName(OUString* pString, sal_Int32 nIndex = SAL_MAX_INT32((sal_Int32) 0x7FFFFFFF))
          { return m_rEntry.m_fGetCountOrName(*m_pDocShell->GetDoc(), pString, nIndex); };
      static const StyleFamilyEntry& InitEntry(SfxStyleFamily eFamily)
      {
          auto pEntries = lcl_GetStyleFamilyEntries();
          const auto pEntry = std::find_if(pEntries->begin(), pEntries->end(),
                  [eFamily] (const StyleFamilyEntry& e) { return e.m_eFamily == eFamily; });
          assert(pEntry != pEntries->end())(static_cast <bool> (pEntry != pEntries->end()) ? void
 (0) : __assert_fail ("pEntry != pEntries->end()", "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
, 219, __extension__ __PRETTY_FUNCTION__));
          return *pEntry;
      }
  public:
      XStyleFamily(SwDocShell* pDocShell, const SfxStyleFamily eFamily)
          : m_rEntry(InitEntry(eFamily))
          , m_pBasePool(pDocShell->GetStyleSheetPool())
          , m_pDocShell(pDocShell)
      {
          if (m_pBasePool) //tdf#124142 html docs can have no styles
              StartListening(*m_pBasePool);
      }

      //XIndexAccess
      virtual sal_Int32 SAL_CALL getCount() override
      {
          SolarMutexGuard aGuard;
          return GetCountOrName(nullptr);
      };
      virtual uno::Any SAL_CALL getByIndex(sal_Int32 nIndex) override;

      //XElementAccess
      virtual uno::Type SAL_CALL getElementType(  ) override
          { return cppu::UnoType<style::XStyle>::get(); };
      virtual sal_Bool SAL_CALL hasElements(  ) override
      {
          if(!m_pBasePool)
              throw uno::RuntimeException();
          return true;
      }

      //XNameAccess
      virtual uno::Any SAL_CALL getByName(const OUString& Name) override;
      virtual uno::Sequence< OUString > SAL_CALL getElementNames() override;
      virtual sal_Bool SAL_CALL hasByName(const OUString& Name) override;

      //XNameContainer
      virtual void SAL_CALL insertByName(const OUString& Name, const uno::Any& Element) override;
      virtual void SAL_CALL replaceByName(const OUString& Name, const uno::Any& Element) override;
      virtual void SAL_CALL removeByName(const OUString& Name) override;

      //XPropertySet
      virtual uno::Reference< beans::XPropertySetInfo > SAL_CALL getPropertySetInfo(  ) override
          { return {}; };
      virtual void SAL_CALL setPropertyValue( const OUString&, const uno::Any&) override
          { SAL_WARN("sw.uno", "###unexpected!")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "###unexpected!") == 1
) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "264" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "###unexpected!"), 0); } else { ::std::
ostringstream sal_detail_stream; sal_detail_stream << "###unexpected!"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "264" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "###unexpected!") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "264" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "###unexpected!"), 0); } else { ::std::
ostringstream sal_detail_stream; sal_detail_stream << "###unexpected!"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "264" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); };
      virtual uno::Any SAL_CALL getPropertyValue( const OUString& PropertyName ) override;
      virtual void SAL_CALL addPropertyChangeListener( const OUString&, const uno::Reference<beans::XPropertyChangeListener>&) override
          { SAL_WARN("sw.uno", "###unexpected!")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "###unexpected!") == 1
) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "267" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "###unexpected!"), 0); } else { ::std::
ostringstream sal_detail_stream; sal_detail_stream << "###unexpected!"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "267" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "###unexpected!") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "267" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "###unexpected!"), 0); } else { ::std::
ostringstream sal_detail_stream; sal_detail_stream << "###unexpected!"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "267" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); };
      virtual void SAL_CALL removePropertyChangeListener( const OUString&, const uno::Reference<beans::XPropertyChangeListener>&) override
          { SAL_WARN("sw.uno", "###unexpected!")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "###unexpected!") == 1
) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "269" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "###unexpected!"), 0); } else { ::std::
ostringstream sal_detail_stream; sal_detail_stream << "###unexpected!"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "269" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "###unexpected!") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "269" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "###unexpected!"), 0); } else { ::std::
ostringstream sal_detail_stream; sal_detail_stream << "###unexpected!"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "269" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); };
      virtual void SAL_CALL addVetoableChangeListener(const OUString&, const uno::Reference<beans::XVetoableChangeListener>&) override
          { SAL_WARN("sw.uno", "###unexpected!")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "###unexpected!") == 1
) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "271" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "###unexpected!"), 0); } else { ::std::
ostringstream sal_detail_stream; sal_detail_stream << "###unexpected!"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "271" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "###unexpected!") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "271" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "###unexpected!"), 0); } else { ::std::
ostringstream sal_detail_stream; sal_detail_stream << "###unexpected!"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "271" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); };
      virtual void SAL_CALL removeVetoableChangeListener(const OUString&, const uno::Reference<beans::XVetoableChangeListener>&) override
          { SAL_WARN("sw.uno", "###unexpected!")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "###unexpected!") == 1
) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "273" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "###unexpected!"), 0); } else { ::std::
ostringstream sal_detail_stream; sal_detail_stream << "###unexpected!"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "273" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "###unexpected!") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "273" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "###unexpected!"), 0); } else { ::std::
ostringstream sal_detail_stream; sal_detail_stream << "###unexpected!"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "273" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); };

      //SfxListener
      virtual void Notify(SfxBroadcaster& rBC, const SfxHint& rHint) override
      {
          if(rHint.GetId() == SfxHintId::Dying)
          {
              m_pBasePool = nullptr;
              m_pDocShell = nullptr;
              EndListening(rBC);
          }
      }

      //XServiceInfo
      virtual OUString SAL_CALL getImplementationName() override
          { return {"XStyleFamily"}; };
      virtual sal_Bool SAL_CALL supportsService(const OUString& rServiceName) override
          { return cppu::supportsService(this, rServiceName); };
      virtual uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override
          { return { "com.sun.star.style.StyleFamily" }; }
  };

  }
296}

298namespace {

300class SwStyleBase_Impl;
301class SwXStyle : public cppu::WeakImplHelper
  <
      css::style::XStyle,
      css::beans::XPropertySet,
      css::beans::XMultiPropertySet,
      css::lang::XServiceInfo,
      css::lang::XUnoTunnel,
      css::beans::XPropertyState,
      css::beans::XMultiPropertyStates
  >
  , public SfxListener
  , public SvtListener
313{
  SwDoc* m_pDoc;
  OUString m_sStyleName;
  const StyleFamilyEntry& m_rEntry;
  bool m_bIsDescriptor;
  bool m_bIsConditional;
  OUString m_sParentStyleName;

321protected:
  SfxStyleSheetBasePool* m_pBasePool;
  std::unique_ptr<SwStyleProperties_Impl> m_pPropertiesImpl;
  css::uno::Reference<css::container::XNameAccess> m_xStyleFamily;
  css::uno::Reference<css::beans::XPropertySet> m_xStyleData;

  template<sal_uInt16>
  void SetPropertyValue(const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, const uno::Any&, SwStyleBase_Impl&);
  void SetPropertyValues_Impl( const css::uno::Sequence< OUString >& aPropertyNames, const css::uno::Sequence< css::uno::Any >& aValues );
  SfxStyleSheetBase* GetStyleSheetBase();
  void PrepareStyleBase(SwStyleBase_Impl& rBase);
  template<sal_uInt16>
  uno::Any GetStyleProperty(const SfxItemPropertySimpleEntry& rEntry, const SfxItemPropertySet& rPropSet, SwStyleBase_Impl& rBase);
  uno::Any GetStyleProperty_Impl(const SfxItemPropertySimpleEntry& rEntry, const SfxItemPropertySet& rPropSet, SwStyleBase_Impl& rBase);
  uno::Any GetPropertyValue_Impl(const SfxItemPropertySet* pPropSet, SwStyleBase_Impl& rBase, const OUString& rPropertyName);

337public:
  SwXStyle(SwDoc* pDoc, SfxStyleFamily eFam, bool bConditional = false);
  SwXStyle(SfxStyleSheetBasePool* pPool, SfxStyleFamily eFamily, SwDoc* pDoc, const OUString& rStyleName);
  virtual ~SwXStyle() override;


  static const css::uno::Sequence< sal_Int8 > & getUnoTunnelId();

  //XUnoTunnel
  virtual sal_Int64 SAL_CALL getSomething( const css::uno::Sequence< sal_Int8 >& aIdentifier ) override;

  //XNamed
  virtual OUString SAL_CALL getName() override;
  virtual void SAL_CALL setName(const OUString& Name_) override;

  //XStyle
  virtual sal_Bool SAL_CALL isUserDefined() override;
  virtual sal_Bool SAL_CALL isInUse() override;
  virtual OUString SAL_CALL getParentStyle() override;
  virtual void SAL_CALL setParentStyle(const OUString& aParentStyle) override;

  //XPropertySet
  virtual css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL getPropertySetInfo(  ) override;
  virtual void SAL_CALL setPropertyValue( const OUString& aPropertyName, const css::uno::Any& aValue ) override;
  virtual css::uno::Any SAL_CALL getPropertyValue( const OUString& PropertyName ) override;
  virtual void SAL_CALL addPropertyChangeListener( const OUString&, const css::uno::Reference< css::beans::XPropertyChangeListener >& ) override
          { OSL_FAIL("not implemented")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "363" ": "), "%s", "not implemented"); } } while (false); };
  virtual void SAL_CALL removePropertyChangeListener( const OUString&, const css::uno::Reference< css::beans::XPropertyChangeListener >& ) override
          { OSL_FAIL("not implemented")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "365" ": "), "%s", "not implemented"); } } while (false); };
  virtual void SAL_CALL addVetoableChangeListener( const OUString&, const css::uno::Reference< css::beans::XVetoableChangeListener >& ) override
          { OSL_FAIL("not implemented")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "367" ": "), "%s", "not implemented"); } } while (false); };
  virtual void SAL_CALL removeVetoableChangeListener( const OUString&, const css::uno::Reference< css::beans::XVetoableChangeListener >& ) override
          { OSL_FAIL("not implemented")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "369" ": "), "%s", "not implemented"); } } while (false); };

  //XMultiPropertySet
  virtual void SAL_CALL setPropertyValues( const css::uno::Sequence< OUString >& aPropertyNames, const css::uno::Sequence< css::uno::Any >& aValues ) override;
  virtual css::uno::Sequence< css::uno::Any > SAL_CALL getPropertyValues( const css::uno::Sequence< OUString >& aPropertyNames ) override;
  virtual void SAL_CALL addPropertiesChangeListener( const css::uno::Sequence< OUString >&, const css::uno::Reference< css::beans::XPropertiesChangeListener >& ) override
          {};
  virtual void SAL_CALL removePropertiesChangeListener( const css::uno::Reference< css::beans::XPropertiesChangeListener >& ) override
          {};
  virtual void SAL_CALL firePropertiesChangeEvent( const css::uno::Sequence< OUString >&, const css::uno::Reference< css::beans::XPropertiesChangeListener >& ) override
          {};

  //XPropertyState
  virtual css::beans::PropertyState SAL_CALL getPropertyState( const OUString& PropertyName ) override;
  virtual css::uno::Sequence< css::beans::PropertyState > SAL_CALL getPropertyStates( const css::uno::Sequence< OUString >& aPropertyName ) override;
  virtual void SAL_CALL setPropertyToDefault( const OUString& PropertyName ) override;
  virtual css::uno::Any SAL_CALL getPropertyDefault( const OUString& aPropertyName ) override;

  //XMultiPropertyStates
  virtual void SAL_CALL setAllPropertiesToDefault(  ) override;
  virtual void SAL_CALL setPropertiesToDefault( const css::uno::Sequence< OUString >& aPropertyNames ) override;
  virtual css::uno::Sequence< css::uno::Any > SAL_CALL getPropertyDefaults( const css::uno::Sequence< OUString >& aPropertyNames ) override;

  //XServiceInfo
  virtual OUString SAL_CALL getImplementationName() override
          { return {"SwXStyle"}; };
  virtual sal_Bool SAL_CALL supportsService(const OUString& rServiceName) override
          { return cppu::supportsService(this, rServiceName); };
  virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;

  //SfxListener
  virtual void        Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override;
  //SvtListener
  virtual void Notify(const SfxHint&) override;
  const OUString&     GetStyleName() const { return m_sStyleName;}
  SfxStyleFamily      GetFamily() const {return m_rEntry.m_eFamily;}

  bool                IsDescriptor() const {return m_bIsDescriptor;}
  bool                IsConditional() const { return m_bIsConditional;}
  const OUString&     GetParentStyleName() const { return m_sParentStyleName;}
  void                SetDoc(SwDoc* pDc, SfxStyleSheetBasePool*   pPool)
                          {
                              m_bIsDescriptor = false; m_pDoc = pDc;
                              m_pBasePool = pPool;
                              SfxListener::StartListening(*m_pBasePool);
                          }
  SwDoc*                GetDoc() const { return m_pDoc; }
  void Invalidate();
  void ApplyDescriptorProperties();
  void SetStyleName(const OUString& rSet){ m_sStyleName = rSet;}
  /// @throws beans::PropertyVetoException
  /// @throws lang::IllegalArgumentException
  /// @throws lang::WrappedTargetException
  /// @throws uno::RuntimeException
  void SetStyleProperty(const SfxItemPropertySimpleEntry& rEntry, const SfxItemPropertySet& rPropSet, const uno::Any& rValue, SwStyleBase_Impl& rBase);
  void PutItemToSet(const SvxSetItem* pSetItem, const SfxItemPropertySet& rPropSet, const SfxItemPropertySimpleEntry& rEntry, const uno::Any& rVal, SwStyleBase_Impl& rBaseImpl);
425};

427class SwXFrameStyle
  : public SwXStyle
  , public css::document::XEventsSupplier
  , public sw::ICoreFrameStyle
431{
432public:
  SwXFrameStyle(SfxStyleSheetBasePool& rPool,
                              SwDoc*  pDoc,
                              const OUString& rStyleName) :
      SwXStyle(&rPool, SfxStyleFamily::Frame, pDoc, rStyleName){}
  explicit SwXFrameStyle(SwDoc *pDoc);

  virtual void SAL_CALL acquire(  ) throw() override {SwXStyle::acquire();}
  virtual void SAL_CALL release(  ) throw() override {SwXStyle::release();}

  virtual css::uno::Sequence< css::uno::Type > SAL_CALL getTypes(  ) override;
  virtual css::uno::Any SAL_CALL queryInterface( const css::uno::Type& aType ) override;
  virtual css::uno::Reference< css::container::XNameReplace > SAL_CALL getEvents(  ) override;

  //ICoreStyle
  virtual void SetItem(sal_uInt16 eAtr, const SfxPoolItem& rItem) override;
  virtual const SfxPoolItem* GetItem(sal_uInt16 eAtr) override;
  virtual css::document::XEventsSupplier& GetEventsSupplier() override
          { return *this; };
451};

453class SwXPageStyle
  : public SwXStyle
455{
456protected:
  void SetPropertyValues_Impl( const css::uno::Sequence< OUString >& aPropertyNames, const css::uno::Sequence< css::uno::Any >& aValues );
  css::uno::Sequence< css::uno::Any > GetPropertyValues_Impl( const css::uno::Sequence< OUString >& aPropertyNames );

460public:
  SwXPageStyle(SfxStyleSheetBasePool& rPool, SwDocShell* pDocSh, const OUString& rStyleName);
  explicit SwXPageStyle(SwDocShell* pDocSh);

  virtual void SAL_CALL setPropertyValue( const OUString& aPropertyName, const css::uno::Any& aValue ) override;
  virtual css::uno::Any SAL_CALL getPropertyValue( const OUString& PropertyName ) override;

  virtual void SAL_CALL setPropertyValues( const css::uno::Sequence< OUString >& aPropertyNames, const css::uno::Sequence< css::uno::Any >& aValues ) override;
  virtual css::uno::Sequence< css::uno::Any > SAL_CALL getPropertyValues( const css::uno::Sequence< OUString >& aPropertyNames ) override;
469};

471}

473using sw::XStyleFamily;

475OUString SwXStyleFamilies::getImplementationName()
  { return {"SwXStyleFamilies"}; }

478sal_Bool SwXStyleFamilies::supportsService(const OUString& rServiceName)
479{
  return cppu::supportsService(this, rServiceName);
481}

483uno::Sequence< OUString > SwXStyleFamilies::getSupportedServiceNames()
  { return { "com.sun.star.style.StyleFamilies" }; }

486SwXStyleFamilies::SwXStyleFamilies(SwDocShell& rDocShell) :
      SwUnoCollection(rDocShell.GetDoc()),
      m_pDocShell(&rDocShell)
  { }

491SwXStyleFamilies::~SwXStyleFamilies()
  { }

494uno::Any SAL_CALL SwXStyleFamilies::getByName(const OUString& Name)
495{
  SolarMutexGuard aGuard;
  if(!IsValid())
      throw uno::RuntimeException();
  auto pEntries(lcl_GetStyleFamilyEntries());
  const auto pEntry = std::find_if(pEntries->begin(), pEntries->end(),
      [&Name] (const StyleFamilyEntry& e) { return e.m_sName == Name; });
  if(pEntry == pEntries->end())
      throw container::NoSuchElementException();
  return getByIndex(pEntry-pEntries->begin());
505}

507uno::Sequence< OUString > SwXStyleFamilies::getElementNames()
508{
  auto pEntries(lcl_GetStyleFamilyEntries());
  uno::Sequence<OUString> aNames(pEntries->size());
  std::transform(pEntries->begin(), pEntries->end(),
          aNames.begin(), [] (const StyleFamilyEntry& e) { return e.m_sName; });
  return aNames;
514}

516sal_Bool SwXStyleFamilies::hasByName(const OUString& Name)
517{
  auto pEntries(lcl_GetStyleFamilyEntries());
  return std::any_of(pEntries->begin(), pEntries->end(),
      [&Name] (const StyleFamilyEntry& e) { return e.m_sName == Name; });
521}

523sal_Int32 SwXStyleFamilies::getCount()
524{
  return lcl_GetStyleFamilyEntries()->size();
526}

528uno::Any SwXStyleFamilies::getByIndex(sal_Int32 nIndex)
529{
  auto pEntries(lcl_GetStyleFamilyEntries());
  SolarMutexGuard aGuard;
  if(nIndex < 0 || nIndex >= static_cast<sal_Int32>(pEntries->size()))
      throw lang::IndexOutOfBoundsException();
  if(!IsValid())
      throw uno::RuntimeException();
  auto eFamily = (*pEntries)[nIndex].m_eFamily;
  assert(eFamily != SfxStyleFamily::All)(static_cast <bool> (eFamily != SfxStyleFamily::All) ? void
 (0) : __assert_fail ("eFamily != SfxStyleFamily::All", "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
, 537, __extension__ __PRETTY_FUNCTION__));
  auto& rxFamily = m_vFamilies[eFamily];
  if(!rxFamily.is())
      rxFamily = new XStyleFamily(m_pDocShell, eFamily);
  return uno::makeAny(rxFamily);
542}

544uno::Type SwXStyleFamilies::getElementType()
545{
  return cppu::UnoType<container::XNameContainer>::get();
547}

549sal_Bool SwXStyleFamilies::hasElements()
  { return true; }

552void SwXStyleFamilies::loadStylesFromURL(const OUString& rURL,
  const uno::Sequence< beans::PropertyValue >& aOptions)
554{
  SolarMutexGuard aGuard;
  if(!IsValid() || rURL.isEmpty())
      throw uno::RuntimeException();
  SwgReaderOption aOpt;
  aOpt.SetFrameFormats(true);
  aOpt.SetTextFormats(true);
  aOpt.SetPageDescs(true);
  aOpt.SetNumRules(true);
  aOpt.SetMerge(false);
  for(const auto& rProperty: aOptions)
  {
      bool bValue = false;
      if(rProperty.Value.getValueType() == cppu::UnoType<bool>::get())
          bValue = rProperty.Value.get<bool>();

      if(rProperty.Name == UNO_NAME_OVERWRITE_STYLES"OverwriteStyles")
          aOpt.SetMerge(!bValue);
      else if(rProperty.Name == UNO_NAME_LOAD_NUMBERING_STYLES"LoadNumberingStyles")
          aOpt.SetNumRules(bValue);
      else if(rProperty.Name == UNO_NAME_LOAD_PAGE_STYLES"LoadPageStyles")
          aOpt.SetPageDescs(bValue);
      else if(rProperty.Name == UNO_NAME_LOAD_FRAME_STYLES"LoadFrameStyles")
          aOpt.SetFrameFormats(bValue);
      else if(rProperty.Name == UNO_NAME_LOAD_TEXT_STYLES"LoadTextStyles")
          aOpt.SetTextFormats(bValue);
      else if(rProperty.Name == "InputStream")
      {
          Reference<XInputStream> xInputStream;
          if (!(rProperty.Value >>= xInputStream))
              throw IllegalArgumentException("Parameter 'InputStream' could not be converted to "
                                             "type 'com::sun::star::io::XInputStream'",
                                             nullptr, 0);

          aOpt.SetInputStream(xInputStream);

      }
  }
  const ErrCode nErr = m_pDocShell->LoadStylesFromFile( rURL, aOpt, true );
  if(nErr)
      throw io::IOException();
595}

597uno::Sequence< beans::PropertyValue > SwXStyleFamilies::getStyleLoaderOptions()
598{
  SolarMutexGuard aGuard;
  uno::Sequence< beans::PropertyValue > aSeq(5);
  beans::PropertyValue* pArray = aSeq.getArray();
  const uno::Any aVal(true);
  pArray[0] = beans::PropertyValue(UNO_NAME_LOAD_TEXT_STYLES"LoadTextStyles", -1, aVal, beans::PropertyState_DIRECT_VALUE);
  pArray[1] = beans::PropertyValue(UNO_NAME_LOAD_FRAME_STYLES"LoadFrameStyles", -1, aVal, beans::PropertyState_DIRECT_VALUE);
  pArray[2] = beans::PropertyValue(UNO_NAME_LOAD_PAGE_STYLES"LoadPageStyles", -1, aVal, beans::PropertyState_DIRECT_VALUE);
  pArray[3] = beans::PropertyValue(UNO_NAME_LOAD_NUMBERING_STYLES"LoadNumberingStyles", -1, aVal, beans::PropertyState_DIRECT_VALUE);
  pArray[4] = beans::PropertyValue(UNO_NAME_OVERWRITE_STYLES"OverwriteStyles", -1, aVal, beans::PropertyState_DIRECT_VALUE);
  return aSeq;
609}

611static bool lcl_GetHeaderFooterItem(
      SfxItemSet const& rSet, OUString const& rPropName, bool const bFooter,
      SvxSetItem const*& o_rpItem)
614{
  SfxItemState eState = rSet.GetItemState(
      bFooter ? SID_ATTR_PAGE_FOOTERSETTypedWhichId<SvxSetItem>( 10000 + 58 ) : SID_ATTR_PAGE_HEADERSETTypedWhichId<SvxSetItem>( 10000 + 57 ),
      false, reinterpret_cast<const SfxPoolItem**>(&o_rpItem));
  if (SfxItemState::SET != eState &&
      rPropName == UNO_NAME_FIRST_IS_SHARED"FirstIsShared")
  {   // fdo#79269 header may not exist, check footer then
      eState = rSet.GetItemState(
          (!bFooter) ? SID_ATTR_PAGE_FOOTERSETTypedWhichId<SvxSetItem>( 10000 + 58 ) : SID_ATTR_PAGE_HEADERSETTypedWhichId<SvxSetItem>( 10000 + 57 ),
          false, reinterpret_cast<const SfxPoolItem**>(&o_rpItem));
  }
  return SfxItemState::SET == eState;
626}

628template<enum SfxStyleFamily>
629static sal_Int32 lcl_GetCountOrName(const SwDoc&, OUString*, sal_Int32);

631template<>
632sal_Int32 lcl_GetCountOrName<SfxStyleFamily::Char>(const SwDoc& rDoc, OUString* pString, sal_Int32 nIndex)
633{
  const sal_uInt16 nBaseCount = nPoolChrHtmlRange(RES_POOLCHR_HTML_END - RES_POOLCHR_HTML_BEGIN) + nPoolChrNormalRange(RES_POOLCHR_NORMAL_END - RES_POOLCHR_NORMAL_BEGIN);
  nIndex -= nBaseCount;
  sal_Int32 nCount = 0;
  for(auto pFormat : *rDoc.GetCharFormats())
  {
      if(pFormat->IsDefault() && pFormat != rDoc.GetDfltCharFormat())
          continue;
      if(!IsPoolUserFormat(pFormat->GetPoolFormatId()))
          continue;
      if(nIndex == nCount)
      {
          // the default character format needs to be set to "Default!"
          if(rDoc.GetDfltCharFormat() == pFormat)
              *pString = SwResId(STR_POOLCHR_STANDARDreinterpret_cast<char const *>("STR_POOLCHR_STANDARD" "\004"
 u8"Default Character Style"));
          else
              *pString = pFormat->GetName();
          break;
      }
      ++nCount;
  }
  return nCount + nBaseCount;
655}

657template<>
658sal_Int32 lcl_GetCountOrName<SfxStyleFamily::Para>(const SwDoc& rDoc, OUString* pString, sal_Int32 nIndex)
659{
  const sal_uInt16 nBaseCount = nPoolCollHtmlStackedStart( ( ( ( ( ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN))
 + ( RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN)) + ( RES_POOLCOLL_EXTRA_END
 - RES_POOLCOLL_EXTRA_BEGIN)) + ( RES_POOLCOLL_REGISTER_END -
 RES_POOLCOLL_REGISTER_BEGIN)) + ( RES_POOLCOLL_DOC_END - RES_POOLCOLL_DOC_BEGIN
)) + nPoolCollHtmlRange( RES_POOLCOLL_HTML_END - RES_POOLCOLL_HTML_BEGIN);
  nIndex -= nBaseCount;
  sal_Int32 nCount = 0;
  for(auto pColl : *rDoc.GetTextFormatColls())
  {
      if(pColl->IsDefault())
          continue;
      if(!IsPoolUserFormat(pColl->GetPoolFormatId()))
          continue;
      if(nIndex == nCount)
      {
          *pString = pColl->GetName();
          break;
      }
      ++nCount;
  }
  return nCount + nBaseCount;
677}

679template<>
680sal_Int32 lcl_GetCountOrName<SfxStyleFamily::Frame>(const SwDoc& rDoc, OUString* pString, sal_Int32 nIndex)
681{
  nIndex -= nPoolFrameRange( RES_POOLFRM_END - RES_POOLFRM_BEGIN);
  sal_Int32 nCount = 0;
  for(const auto pFormat : *rDoc.GetFrameFormats())
  {
      if(pFormat->IsDefault() || pFormat->IsAuto())
          continue;
      if(!IsPoolUserFormat(pFormat->GetPoolFormatId()))
          continue;
      if(nIndex == nCount)
      {
          *pString = pFormat->GetName();
          break;
      }
      ++nCount;
  }
  return nCount + nPoolFrameRange( RES_POOLFRM_END - RES_POOLFRM_BEGIN);
698}

700template<>
701sal_Int32 lcl_GetCountOrName<SfxStyleFamily::Page>(const SwDoc& rDoc, OUString* pString, sal_Int32 nIndex)
702{
  nIndex -= nPoolPageRange( RES_POOLPAGE_END - RES_POOLPAGE_BEGIN);
  sal_Int32 nCount = 0;
  const size_t nArrLen = rDoc.GetPageDescCnt();
  for(size_t i = 0; i < nArrLen; ++i)
  {
      const SwPageDesc& rDesc = rDoc.GetPageDesc(i);
      if(!IsPoolUserFormat(rDesc.GetPoolFormatId()))
          continue;
      if(nIndex == nCount)
      {
          *pString = rDesc.GetName();
          break;
      }
      ++nCount;
  }
  nCount += nPoolPageRange( RES_POOLPAGE_END - RES_POOLPAGE_BEGIN);
  return nCount;
720}

722template<>
723sal_Int32 lcl_GetCountOrName<SfxStyleFamily::Pseudo>(const SwDoc& rDoc, OUString* pString, sal_Int32 nIndex)
724{
  nIndex -= nPoolNumRange( RES_POOLNUMRULE_END - RES_POOLNUMRULE_BEGIN);
  sal_Int32 nCount = 0;
  for(const auto pRule : rDoc.GetNumRuleTable())
  {
      if(pRule->IsAutoRule())
          continue;
      if(!IsPoolUserFormat(pRule->GetPoolFormatId()))
          continue;
      if(nIndex == nCount)
      {
          *pString = pRule->GetName();
          break;
      }
      ++nCount;
  }
  return nCount + nPoolNumRange( RES_POOLNUMRULE_END - RES_POOLNUMRULE_BEGIN);
741}

743template<>
744sal_Int32 lcl_GetCountOrName<SfxStyleFamily::Table>(const SwDoc& rDoc, OUString* pString, sal_Int32 nIndex)
745{
  if (!rDoc.HasTableStyles())
      return 0;

  const auto pAutoFormats = &rDoc.GetTableStyles();
  const sal_Int32 nCount = pAutoFormats->size();
  if (0 <= nIndex && nIndex < nCount)
      *pString = pAutoFormats->operator[](nIndex).GetName();

  return nCount;
755}

757template<>
758sal_Int32 lcl_GetCountOrName<SfxStyleFamily::Cell>(const SwDoc& rDoc, OUString* pString, sal_Int32 nIndex)
759{
  const auto& rAutoFormats = rDoc.GetTableStyles();
  const auto& rTableTemplateMap = SwTableAutoFormat::GetTableTemplateMap();
  const sal_Int32 nUsedCellStylesCount = rAutoFormats.size() * rTableTemplateMap.size();
  const sal_Int32 nCount = nUsedCellStylesCount + rDoc.GetCellStyles().size();
  if (0 <= nIndex && nIndex < nCount)
  {
      if (nUsedCellStylesCount > nIndex)
      {
          const sal_Int32 nAutoFormat = nIndex / rTableTemplateMap.size();
          const sal_Int32 nBoxFormat = rTableTemplateMap[nIndex % rTableTemplateMap.size()];
          const SwTableAutoFormat& rTableFormat = rAutoFormats[nAutoFormat];
          SwStyleNameMapper::FillProgName(rTableFormat.GetName(), *pString, SwGetPoolIdFromName::TabStyle);
          *pString += rTableFormat.GetTableTemplateCellSubName(rTableFormat.GetBoxFormat(nBoxFormat));
      }
      else
          *pString = rDoc.GetCellStyles()[nIndex-nUsedCellStylesCount].GetName();
  }
  return nCount;
778}

780template<SfxStyleFamily eFamily>
781static uno::Reference< css::style::XStyle> lcl_CreateStyle(SfxStyleSheetBasePool* pBasePool, SwDocShell* pDocShell, const OUString& sStyleName)
  { return pBasePool ? new SwXStyle(pBasePool, eFamily, pDocShell->GetDoc(), sStyleName) : new SwXStyle(pDocShell->GetDoc(), eFamily, false); };

784template<>
785uno::Reference< css::style::XStyle> lcl_CreateStyle<SfxStyleFamily::Para>(SfxStyleSheetBasePool* pBasePool, SwDocShell* pDocShell, const OUString& sStyleName)
  { return pBasePool ? new SwXStyle(pBasePool, SfxStyleFamily::Para, pDocShell->GetDoc(), sStyleName) : new SwXStyle(pDocShell->GetDoc(), SfxStyleFamily::Para, false); };
787template<>
788uno::Reference< css::style::XStyle> lcl_CreateStyle<SfxStyleFamily::Frame>(SfxStyleSheetBasePool* pBasePool, SwDocShell* pDocShell, const OUString& sStyleName)
  { return pBasePool ? new SwXFrameStyle(*pBasePool, pDocShell->GetDoc(), sStyleName) : new SwXFrameStyle(pDocShell->GetDoc()); };

791template<>
792uno::Reference< css::style::XStyle> lcl_CreateStyle<SfxStyleFamily::Page>(SfxStyleSheetBasePool* pBasePool, SwDocShell* pDocShell, const OUString& sStyleName)
  { return pBasePool ? new SwXPageStyle(*pBasePool, pDocShell, sStyleName) : new SwXPageStyle(pDocShell); };

795template<>
796uno::Reference< css::style::XStyle> lcl_CreateStyle<SfxStyleFamily::Table>(SfxStyleSheetBasePool* /*pBasePool*/, SwDocShell* pDocShell, const OUString& sStyleName)
  { return SwXTextTableStyle::CreateXTextTableStyle(pDocShell, sStyleName); };

799template<>
800uno::Reference< css::style::XStyle> lcl_CreateStyle<SfxStyleFamily::Cell>(SfxStyleSheetBasePool* /*pBasePool*/, SwDocShell* pDocShell, const OUString& sStyleName)
  { return SwXTextCellStyle::CreateXTextCellStyle(pDocShell, sStyleName); };

803uno::Reference<css::style::XStyle> SwXStyleFamilies::CreateStyle(SfxStyleFamily eFamily, SwDoc& rDoc)
804{
  auto pEntries(lcl_GetStyleFamilyEntries());
  const auto pEntry = std::find_if(pEntries->begin(), pEntries->end(),
          [eFamily] (const StyleFamilyEntry& e) { return e.m_eFamily == eFamily; });
  return pEntry == pEntries->end() ? nullptr : pEntry->m_fCreateStyle(nullptr, rDoc.GetDocShell(), "");
809}

811// FIXME: Ugly special casing that should die.
812uno::Reference<css::style::XStyle> SwXStyleFamilies::CreateStyleCondParagraph(SwDoc& rDoc)
  { return new SwXStyle(&rDoc, SfxStyleFamily::Para, true); };

815template<enum SfxStyleFamily>
816static sal_uInt16 lcl_TranslateIndex(const sal_uInt16 nIndex);

818template<>
819sal_uInt16 lcl_TranslateIndex<SfxStyleFamily::Char>(const sal_uInt16 nIndex)
820{
  static_assert(nPoolChrNormalRange(RES_POOLCHR_NORMAL_END - RES_POOLCHR_NORMAL_BEGIN) > 0 && nPoolChrHtmlRange(RES_POOLCHR_HTML_END - RES_POOLCHR_HTML_BEGIN) > 0, "invalid pool range");
  if(nIndex < nPoolChrNormalRange(RES_POOLCHR_NORMAL_END - RES_POOLCHR_NORMAL_BEGIN))
      return nIndex + RES_POOLCHR_NORMAL_BEGIN;
  else if(nIndex < (nPoolChrHtmlRange(RES_POOLCHR_HTML_END - RES_POOLCHR_HTML_BEGIN)+nPoolChrNormalRange(RES_POOLCHR_NORMAL_END - RES_POOLCHR_NORMAL_BEGIN)))
      return nIndex + RES_POOLCHR_HTML_BEGIN - nPoolChrNormalRange(RES_POOLCHR_NORMAL_END - RES_POOLCHR_NORMAL_BEGIN);
  throw lang::IndexOutOfBoundsException();
827}

829template<>
830sal_uInt16 lcl_TranslateIndex<SfxStyleFamily::Para>(const sal_uInt16 nIndex)
831{
  static_assert(nPoolCollTextRange( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN) > 0 && nPoolCollListsRange( RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN) > 0 && nPoolCollExtraRange( RES_POOLCOLL_EXTRA_END - RES_POOLCOLL_EXTRA_BEGIN) > 0 && nPoolCollRegisterRange( RES_POOLCOLL_REGISTER_END - RES_POOLCOLL_REGISTER_BEGIN) > 0 && nPoolCollDocRange( RES_POOLCOLL_DOC_END - RES_POOLCOLL_DOC_BEGIN) > 0 && nPoolCollHtmlRange( RES_POOLCOLL_HTML_END - RES_POOLCOLL_HTML_BEGIN) > 0, "weird pool range");
  if(nIndex < nPoolCollListsStackedStart( ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN)))
      return nIndex + RES_POOLCOLL_TEXT_BEGIN;
  else if(nIndex < nPoolCollExtraStackedStart( ( ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN)) + ( RES_POOLCOLL_LISTS_END
 - RES_POOLCOLL_LISTS_BEGIN)))
      return nIndex + RES_POOLCOLL_LISTS_BEGIN - nPoolCollListsStackedStart( ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN));
  else if(nIndex < nPoolCollRegisterStackedStart( ( ( ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN)) + (
 RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN)) + ( RES_POOLCOLL_EXTRA_END
 - RES_POOLCOLL_EXTRA_BEGIN)))
      return nIndex + RES_POOLCOLL_EXTRA_BEGIN - nPoolCollExtraStackedStart( ( ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN)) + ( RES_POOLCOLL_LISTS_END
 - RES_POOLCOLL_LISTS_BEGIN));
  else if(nIndex < nPoolCollDocStackedStart( ( ( ( ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN)) +
 ( RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN)) + ( RES_POOLCOLL_EXTRA_END
 - RES_POOLCOLL_EXTRA_BEGIN)) + ( RES_POOLCOLL_REGISTER_END -
 RES_POOLCOLL_REGISTER_BEGIN)))
      return nIndex + RES_POOLCOLL_REGISTER_BEGIN - nPoolCollRegisterStackedStart( ( ( ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN)) + (
 RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN)) + ( RES_POOLCOLL_EXTRA_END
 - RES_POOLCOLL_EXTRA_BEGIN));
  else if(nIndex < nPoolCollHtmlStackedStart( ( ( ( ( ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN))
 + ( RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN)) + ( RES_POOLCOLL_EXTRA_END
 - RES_POOLCOLL_EXTRA_BEGIN)) + ( RES_POOLCOLL_REGISTER_END -
 RES_POOLCOLL_REGISTER_BEGIN)) + ( RES_POOLCOLL_DOC_END - RES_POOLCOLL_DOC_BEGIN
)))
      return nIndex + RES_POOLCOLL_DOC_BEGIN - nPoolCollDocStackedStart( ( ( ( ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN)) +
 ( RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN)) + ( RES_POOLCOLL_EXTRA_END
 - RES_POOLCOLL_EXTRA_BEGIN)) + ( RES_POOLCOLL_REGISTER_END -
 RES_POOLCOLL_REGISTER_BEGIN));
  else if(nIndex < nPoolCollHtmlStackedStart( ( ( ( ( ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN))
 + ( RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN)) + ( RES_POOLCOLL_EXTRA_END
 - RES_POOLCOLL_EXTRA_BEGIN)) + ( RES_POOLCOLL_REGISTER_END -
 RES_POOLCOLL_REGISTER_BEGIN)) + ( RES_POOLCOLL_DOC_END - RES_POOLCOLL_DOC_BEGIN
)) + nPoolCollTextRange( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN))
      return nIndex + RES_POOLCOLL_HTML_BEGIN - nPoolCollHtmlStackedStart( ( ( ( ( ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN))
 + ( RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN)) + ( RES_POOLCOLL_EXTRA_END
 - RES_POOLCOLL_EXTRA_BEGIN)) + ( RES_POOLCOLL_REGISTER_END -
 RES_POOLCOLL_REGISTER_BEGIN)) + ( RES_POOLCOLL_DOC_END - RES_POOLCOLL_DOC_BEGIN
));
  throw lang::IndexOutOfBoundsException();
846}

848template<>
849sal_uInt16 lcl_TranslateIndex<SfxStyleFamily::Table>(const sal_uInt16 nIndex)
850{
  return nIndex;
852}

854template<>
855sal_uInt16 lcl_TranslateIndex<SfxStyleFamily::Cell>(const sal_uInt16 nIndex)
856{
  return nIndex;
858}

860template<sal_uInt16 nRangeBegin, sal_uInt16 nRangeSize>
861static sal_uInt16 lcl_TranslateIndexRange(const sal_uInt16 nIndex)
862{
  if(nIndex < nRangeSize)
      return nIndex + nRangeBegin;
  throw lang::IndexOutOfBoundsException();
866}

868uno::Any XStyleFamily::getByIndex(sal_Int32 nIndex)
869{
  SolarMutexGuard aGuard;
  if(nIndex < 0)
      throw lang::IndexOutOfBoundsException();
  if(!m_pBasePool)
      throw uno::RuntimeException();
  OUString sStyleName;
  try
  {
      SwStyleNameMapper::FillUIName(m_rEntry.m_fTranslateIndex(nIndex), sStyleName);
  } catch(...) {}
  if (sStyleName.isEmpty())
      GetCountOrName(&sStyleName, nIndex);
  if(sStyleName.isEmpty())
      throw lang::IndexOutOfBoundsException();
  return getByName(sStyleName);
885}

887uno::Any XStyleFamily::getByName(const OUString& rName)
888{
  SolarMutexGuard aGuard;
  OUString sStyleName;
  SwStyleNameMapper::FillUIName(rName, sStyleName, m_rEntry.m_aPoolId);
  if(!m_pBasePool)
      throw uno::RuntimeException();
  SfxStyleSheetBase* pBase = m_pBasePool->Find(sStyleName, m_rEntry.m_eFamily);
  if(!pBase)
      throw container::NoSuchElementException();
  uno::Reference<style::XStyle> xStyle = FindStyle(sStyleName);
  if(!xStyle.is())
      xStyle = m_rEntry.m_fCreateStyle(m_pBasePool, m_pDocShell, m_rEntry.m_eFamily == SfxStyleFamily::Frame ? pBase->GetName() : sStyleName);
  return uno::makeAny(xStyle);
901}

903uno::Sequence<OUString> XStyleFamily::getElementNames()
904{
  SolarMutexGuard aGuard;
  if(!m_pBasePool)
      throw uno::RuntimeException();
  std::vector<OUString> vRet;
  std::unique_ptr<SfxStyleSheetIterator> pIt = m_pBasePool->CreateIterator(m_rEntry.m_eFamily);
  for (SfxStyleSheetBase* pStyle = pIt->First(); pStyle; pStyle = pIt->Next())
  {
      OUString sName;
      SwStyleNameMapper::FillProgName(pStyle->GetName(), sName, m_rEntry.m_aPoolId);
      vRet.push_back(sName);
  }
  return comphelper::containerToSequence(vRet);
917}

919sal_Bool XStyleFamily::hasByName(const OUString& rName)
920{
  SolarMutexGuard aGuard;
  if(!m_pBasePool)
      throw uno::RuntimeException();
  OUString sStyleName;
  SwStyleNameMapper::FillUIName(rName, sStyleName, m_rEntry.m_aPoolId);
  SfxStyleSheetBase* pBase = m_pBasePool->Find(sStyleName, m_rEntry.m_eFamily);
  return nullptr != pBase;
928}

930void XStyleFamily::insertByName(const OUString& rName, const uno::Any& rElement)
931{
  SolarMutexGuard aGuard;
  if(!m_pBasePool)
      throw uno::RuntimeException();
  OUString sStyleName;
  SwStyleNameMapper::FillUIName(rName, sStyleName, m_rEntry.m_aPoolId);
  SfxStyleSheetBase* pBase = m_pBasePool->Find(sStyleName, m_rEntry.m_eFamily);
  SfxStyleSheetBase* pUINameBase = m_pBasePool->Find(sStyleName, m_rEntry.m_eFamily);
  if(pBase || pUINameBase)
      throw container::ElementExistException();
  if(rElement.getValueType().getTypeClass() != uno::TypeClass_INTERFACE)
      throw lang::IllegalArgumentException();
  if (SwGetPoolIdFromName::CellStyle == m_rEntry.m_aPoolId)
  {
      // handle cell style
      uno::Reference<style::XStyle> xStyle = rElement.get<uno::Reference<style::XStyle>>();
      SwXTextCellStyle* pNewStyle = dynamic_cast<SwXTextCellStyle*>(xStyle.get());
      if (!pNewStyle)
          throw lang::IllegalArgumentException();

      pNewStyle->setName(sStyleName); // insertByName sets the element name
      m_pDocShell->GetDoc()->GetCellStyles().AddBoxFormat(*pNewStyle->GetBoxFormat(), sStyleName);
      pNewStyle->SetPhysical();
  }
  else if (SwGetPoolIdFromName::TabStyle == m_rEntry.m_aPoolId)
  {
      // handle table style
      uno::Reference<style::XStyle> xStyle = rElement.get<uno::Reference<style::XStyle>>();
      SwXTextTableStyle* pNewStyle = dynamic_cast<SwXTextTableStyle*>(xStyle.get());
      if (!pNewStyle)
          throw lang::IllegalArgumentException();

      pNewStyle->setName(sStyleName); // insertByName sets the element name
      m_pDocShell->GetDoc()->GetTableStyles().AddAutoFormat(*pNewStyle->GetTableFormat());
      pNewStyle->SetPhysical();
  }
  else
  {
      uno::Reference<lang::XUnoTunnel> xStyleTunnel = rElement.get<uno::Reference<lang::XUnoTunnel>>();
      SwXStyle* pNewStyle = nullptr;
      if(xStyleTunnel.is())
      {
          pNewStyle = reinterpret_cast< SwXStyle * >(
                  sal::static_int_cast< sal_IntPtr >( xStyleTunnel->getSomething( SwXStyle::getUnoTunnelId()) ));
      }

      if (!pNewStyle || !pNewStyle->IsDescriptor() || pNewStyle->GetFamily() != m_rEntry.m_eFamily)
          throw lang::IllegalArgumentException();

      SfxStyleSearchBits nMask = SfxStyleSearchBits::All;
      if(m_rEntry.m_eFamily == SfxStyleFamily::Para && !pNewStyle->IsConditional())
          nMask &= ~SfxStyleSearchBits::SwCondColl;
      m_pBasePool->Make(sStyleName, m_rEntry.m_eFamily, nMask);
      pNewStyle->SetDoc(m_pDocShell->GetDoc(), m_pBasePool);
      pNewStyle->SetStyleName(sStyleName);
      const OUString sParentStyleName(pNewStyle->GetParentStyleName());
      if (!sParentStyleName.isEmpty())
      {
          SfxStyleSheetBase* pParentBase = m_pBasePool->Find(sParentStyleName, m_rEntry.m_eFamily);
          if(pParentBase && pParentBase->GetFamily() == m_rEntry.m_eFamily &&
              pParentBase->GetPool() == m_pBasePool)
              m_pBasePool->SetParent(m_rEntry.m_eFamily, sStyleName, sParentStyleName);
      }
      // after all, we still need to apply the properties of the descriptor
      pNewStyle->ApplyDescriptorProperties();
  }
997}

999void XStyleFamily::replaceByName(const OUString& rName, const uno::Any& rElement)
1000{
  SolarMutexGuard aGuard;
  if(!m_pBasePool)
      throw uno::RuntimeException();
  OUString sStyleName;
  SwStyleNameMapper::FillUIName(rName, sStyleName, m_rEntry.m_aPoolId);
  SfxStyleSheetBase* pBase = m_pBasePool->Find(sStyleName, m_rEntry.m_eFamily);
  // replacements only for userdefined styles
  if(!pBase)
      throw container::NoSuchElementException();
  if (SwGetPoolIdFromName::CellStyle == m_rEntry.m_aPoolId)
  {
      // handle cell styles, don't call on assigned cell styles (TableStyle child)
      OUString sParent;
      SwBoxAutoFormat* pBoxAutoFormat = SwXTextCellStyle::GetBoxAutoFormat(m_pDocShell, sStyleName, &sParent);
      if (pBoxAutoFormat && sParent.isEmpty())// if parent exists then this style is assigned to a table style. Don't replace.
      {
          uno::Reference<style::XStyle> xStyle = rElement.get<uno::Reference<style::XStyle>>();
          SwXTextCellStyle* pStyleToReplaceWith = dynamic_cast<SwXTextCellStyle*>(xStyle.get());
          if (!pStyleToReplaceWith)
              throw lang::IllegalArgumentException();

          pStyleToReplaceWith->setName(sStyleName);
          *pBoxAutoFormat = *pStyleToReplaceWith->GetBoxFormat();
          pStyleToReplaceWith->SetPhysical();
      }
  }
  else if (SwGetPoolIdFromName::TabStyle == m_rEntry.m_aPoolId)
  {
      // handle table styles
      SwTableAutoFormat* pTableAutoFormat = SwXTextTableStyle::GetTableAutoFormat(m_pDocShell, sStyleName);
      if (pTableAutoFormat)
      {
          uno::Reference<style::XStyle> xStyle = rElement.get<uno::Reference<style::XStyle>>();
          SwXTextTableStyle* pStyleToReplaceWith = dynamic_cast<SwXTextTableStyle*>(xStyle.get());
          if (!pStyleToReplaceWith)
              throw lang::IllegalArgumentException();

          pStyleToReplaceWith->setName(sStyleName);
          *pTableAutoFormat = *pStyleToReplaceWith->GetTableFormat();
          pStyleToReplaceWith->SetPhysical();
      }
  }
  else
  {
      if(!pBase->IsUserDefined())
          throw lang::IllegalArgumentException();
      //if there's an object available to this style then it must be invalidated
      uno::Reference<style::XStyle> xStyle = FindStyle(pBase->GetName());
      if(xStyle.is())
      {
          SwXStyle* pStyle = comphelper::getUnoTunnelImplementation<SwXStyle>(xStyle);
          if(pStyle)
              pStyle->Invalidate();
      }
      m_pBasePool->Remove(pBase);
      insertByName(rName, rElement);
  }
1058}

1060void XStyleFamily::removeByName(const OUString& rName)
1061{
  SolarMutexGuard aGuard;
  if(!m_pBasePool)
      throw uno::RuntimeException();
  OUString sName;
  SwStyleNameMapper::FillUIName(rName, sName, m_rEntry.m_aPoolId);
  SfxStyleSheetBase* pBase = m_pBasePool->Find(sName, m_rEntry.m_eFamily);
  if(!pBase)
      throw container::NoSuchElementException();
  if (SwGetPoolIdFromName::CellStyle == m_rEntry.m_aPoolId)
  {
      // handle cell style
      m_pDocShell->GetDoc()->GetCellStyles().RemoveBoxFormat(rName);
  }
  else if (SwGetPoolIdFromName::TabStyle == m_rEntry.m_aPoolId)
  {
      // handle table style
      m_pDocShell->GetDoc()->GetTableStyles().EraseAutoFormat(rName);
  }
  else
      m_pBasePool->Remove(pBase);
1082}

1084uno::Any SAL_CALL XStyleFamily::getPropertyValue( const OUString& sPropertyName )
1085{
  if(sPropertyName != "DisplayName")
      throw beans::UnknownPropertyException( "unknown property: " + sPropertyName, static_cast<OWeakObject *>(this) );
  SolarMutexGuard aGuard;
  return uno::makeAny(SwResId(m_rEntry.m_pResId));
1090}


1093SwXStyle* XStyleFamily::FindStyle(const OUString& rStyleName) const
1094{
  const size_t nLCount = m_pBasePool->GetSizeOfVector();
  for(size_t i = 0; i < nLCount; ++i)
  {
      SfxListener* pListener = m_pBasePool->GetListener(i);
      SwXStyle* pTempStyle = dynamic_cast<SwXStyle*>(pListener);
      if(pTempStyle && pTempStyle->GetFamily() == m_rEntry.m_eFamily && pTempStyle->GetStyleName() == rStyleName)
          return pTempStyle;
  }
  return nullptr;
1104}

1106static const std::vector<StyleFamilyEntry>* lcl_GetStyleFamilyEntries()
1107{
  if(!our_pStyleFamilyEntries)
  {
      our_pStyleFamilyEntries = new std::vector<StyleFamilyEntry>{
          { SfxStyleFamily::Char,   PROPERTY_MAP_CHAR_STYLE1,  SwGetPoolIdFromName::ChrFmt,   "CharacterStyles", STR_STYLE_FAMILY_CHARACTERreinterpret_cast<char const *>("STR_STYLE_FAMILY_CHARACTER"
 "\004" u8"Character"), &lcl_GetCountOrName<SfxStyleFamily::Char>,   &lcl_CreateStyle<SfxStyleFamily::Char>,   &lcl_TranslateIndex<SfxStyleFamily::Char>                       },
          { SfxStyleFamily::Para,   PROPERTY_MAP_PARA_STYLE2,  SwGetPoolIdFromName::TxtColl,  "ParagraphStyles", STR_STYLE_FAMILY_PARAGRAPHreinterpret_cast<char const *>("STR_STYLE_FAMILY_PARAGRAPH"
 "\004" u8"Paragraph"), &lcl_GetCountOrName<SfxStyleFamily::Para>,   &lcl_CreateStyle<SfxStyleFamily::Para>,   &lcl_TranslateIndex<SfxStyleFamily::Para>                       },
          { SfxStyleFamily::Page,   PROPERTY_MAP_PAGE_STYLE4,  SwGetPoolIdFromName::PageDesc, "PageStyles",      STR_STYLE_FAMILY_PAGEreinterpret_cast<char const *>("STR_STYLE_FAMILY_PAGE" "\004"
 u8"Pages"),      &lcl_GetCountOrName<SfxStyleFamily::Page>,   &lcl_CreateStyle<SfxStyleFamily::Page>,   &lcl_TranslateIndexRange<RES_POOLPAGE_BEGIN,    nPoolPageRange( RES_POOLPAGE_END - RES_POOLPAGE_BEGIN)>  },
          { SfxStyleFamily::Frame,  PROPERTY_MAP_FRAME_STYLE3, SwGetPoolIdFromName::FrmFmt,   "FrameStyles",     STR_STYLE_FAMILY_FRAMEreinterpret_cast<char const *>("STR_STYLE_FAMILY_FRAME"
 "\004" u8"Frame"),     &lcl_GetCountOrName<SfxStyleFamily::Frame>,  &lcl_CreateStyle<SfxStyleFamily::Frame>,  &lcl_TranslateIndexRange<RES_POOLFRM_BEGIN,     nPoolFrameRange( RES_POOLFRM_END - RES_POOLFRM_BEGIN)> },
          { SfxStyleFamily::Pseudo, PROPERTY_MAP_NUM_STYLE5,   SwGetPoolIdFromName::NumRule,  "NumberingStyles", STR_STYLE_FAMILY_NUMBERINGreinterpret_cast<char const *>("STR_STYLE_FAMILY_NUMBERING"
 "\004" u8"Numbering"), &lcl_GetCountOrName<SfxStyleFamily::Pseudo>, &lcl_CreateStyle<SfxStyleFamily::Pseudo>, &lcl_TranslateIndexRange<RES_POOLNUMRULE_BEGIN, nPoolNumRange( RES_POOLNUMRULE_END - RES_POOLNUMRULE_BEGIN)>   },
          { SfxStyleFamily::Table,  PROPERTY_MAP_TABLE_STYLE100, SwGetPoolIdFromName::TabStyle, "TableStyles",     STR_STYLE_FAMILY_TABLEreinterpret_cast<char const *>("STR_STYLE_FAMILY_TABLE"
 "\004" u8"Table"),     &lcl_GetCountOrName<SfxStyleFamily::Table>,  &lcl_CreateStyle<SfxStyleFamily::Table>,  &lcl_TranslateIndex<SfxStyleFamily::Table>                       },
          { SfxStyleFamily::Cell,   PROPERTY_MAP_CELL_STYLE101,  SwGetPoolIdFromName::CellStyle,"CellStyles",      STR_STYLE_FAMILY_CELLreinterpret_cast<char const *>("STR_STYLE_FAMILY_CELL" "\004"
 u8"Cell"),      &lcl_GetCountOrName<SfxStyleFamily::Cell>,   &lcl_CreateStyle<SfxStyleFamily::Cell>,   &lcl_TranslateIndex<SfxStyleFamily::Cell>                        }
     };
  }
  return our_pStyleFamilyEntries;
1121}

1123static const std::vector<ParagraphStyleCategoryEntry>* lcl_GetParagraphStyleCategoryEntries()
1124{
  if(!our_pParagraphStyleCategoryEntries)
  {
      our_pParagraphStyleCategoryEntries = new std::vector<ParagraphStyleCategoryEntry>{
          { style::ParagraphStyleCategory::TEXT,    SfxStyleSearchBits::SwText,    COLL_TEXT_BITS     },
          { style::ParagraphStyleCategory::CHAPTER, SfxStyleSearchBits::SwChapter, COLL_DOC_BITS      },
          { style::ParagraphStyleCategory::LIST,    SfxStyleSearchBits::SwList,    COLL_LISTS_BITS    },
          { style::ParagraphStyleCategory::INDEX,   SfxStyleSearchBits::SwIndex,     COLL_REGISTER_BITS },
          { style::ParagraphStyleCategory::EXTRA,   SfxStyleSearchBits::SwExtra,   COLL_EXTRA_BITS    },
          { style::ParagraphStyleCategory::HTML,    SfxStyleSearchBits::SwHtml,    COLL_HTML_BITS     }
      };
  }
  return our_pParagraphStyleCategoryEntries;
1137}

1139namespace {

1141class SwStyleProperties_Impl
1142{
  const PropertyEntryVector_t aPropertyEntries;
  std::map<OUString, uno::Any> m_vPropertyValues;
1145public:
  explicit SwStyleProperties_Impl(const SfxItemPropertyMap& rMap)
      : aPropertyEntries(rMap.getPropertyEntries())
  { }

  bool AllowsKey(const OUString& rName)
  {
      return std::any_of(aPropertyEntries.begin(), aPropertyEntries.end(),
11
←
Calling 'any_of<__gnu_cxx::__normal_iterator<const SfxItemPropertyNamedEntry *, std::vector<SfxItemPropertyNamedEntry, std::allocator<SfxItemPropertyNamedEntry>>>, (lambda at /home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx:1153:13)>'→
20
←
Returning from 'any_of<__gnu_cxx::__normal_iterator<const SfxItemPropertyNamedEntry *, std::vector<SfxItemPropertyNamedEntry, std::allocator<SfxItemPropertyNamedEntry>>>, (lambda at /home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx:1153:13)>'→
21
←
Returning zero, which participates in a condition later→
          [rName] (const SfxItemPropertyNamedEntry& rEntry) {return rName == rEntry.sName;} );
  }
  bool SetProperty(const OUString& rName, const uno::Any& rValue)
  {
      if(!AllowsKey(rName))
          return false;
      m_vPropertyValues[rName] = rValue;
      return true;
  }
  void GetProperty(const OUString& rName, const uno::Any*& pAny)
  {
      if(!AllowsKey(rName))
10
←
Calling 'SwStyleProperties_Impl::AllowsKey'→
22
←
Returning from 'SwStyleProperties_Impl::AllowsKey'→
23
←
Taking true branch→
      {
          pAny = nullptr;
24
←
Null pointer value stored to 'pAny'→
          return;
      }
      pAny = &m_vPropertyValues[rName];
      return;
  }
  bool ClearProperty( const OUString& rName )
  {
      if(!AllowsKey(rName))
          return false;
      m_vPropertyValues[rName] = uno::Any();
      return true;
  }
  void ClearAllProperties( )
          { m_vPropertyValues.clear(); }
  void Apply(SwXStyle& rStyle)
  {
      for(const auto& rPropertyPair : m_vPropertyValues)
      {
          if(rPropertyPair.second.hasValue())
              rStyle.setPropertyValue(rPropertyPair.first, rPropertyPair.second);
      }
  }
  static void GetProperty(const OUString &rPropertyName, const uno::Reference < beans::XPropertySet > &rxPropertySet, uno::Any& rAny )
  {
      rAny = rxPropertySet->getPropertyValue( rPropertyName );
  }
1193};

1195}

1197static SwGetPoolIdFromName lcl_GetSwEnumFromSfxEnum(SfxStyleFamily eFamily)
1198{
  auto pEntries(lcl_GetStyleFamilyEntries());
  const auto pEntry = std::find_if(pEntries->begin(), pEntries->end(),
          [eFamily] (const StyleFamilyEntry& e) { return e.m_eFamily == eFamily; });
  if(pEntry != pEntries->end())
      return pEntry->m_aPoolId;
  SAL_WARN("sw.uno", "someone asking for all styles in unostyle.cxx!" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "someone asking for all styles in unostyle.cxx!"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "1204" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "someone asking for all styles in unostyle.cxx!"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "someone asking for all styles in unostyle.cxx!"; ::
sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"), (
"/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "1204" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "someone asking for all styles in unostyle.cxx!")
 == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "1204" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "someone asking for all styles in unostyle.cxx!"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "someone asking for all styles in unostyle.cxx!"; ::
sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"), (
"/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "1204" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  return SwGetPoolIdFromName::ChrFmt;
1206}

1208namespace
1209{
  class theSwXStyleUnoTunnelId : public rtl::Static<UnoTunnelIdInit, theSwXStyleUnoTunnelId> {};
1211}

1213const uno::Sequence<sal_Int8>& SwXStyle::getUnoTunnelId()
1214{
  return theSwXStyleUnoTunnelId::get().getSeq();
1216}

1218sal_Int64 SAL_CALL SwXStyle::getSomething(const uno::Sequence<sal_Int8>& rId)
1219{
  if(isUnoTunnelId<SwXStyle>(rId))
  {
      return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
  }
  return 0;
1225}


1228uno::Sequence< OUString > SwXStyle::getSupportedServiceNames()
1229{
  long nCount = 1;
  if(SfxStyleFamily::Para == m_rEntry.m_eFamily)
  {
      nCount = 5;
      if(m_bIsConditional)
          nCount++;
  }
  else if(SfxStyleFamily::Char == m_rEntry.m_eFamily)
      nCount = 5;
  else if(SfxStyleFamily::Page == m_rEntry.m_eFamily)
      nCount = 3;
  uno::Sequence< OUString > aRet(nCount);
  OUString* pArray = aRet.getArray();
  pArray[0] = "com.sun.star.style.Style";
  switch(m_rEntry.m_eFamily)
  {
      case SfxStyleFamily::Char:
          pArray[1] = "com.sun.star.style.CharacterStyle";
          pArray[2] = "com.sun.star.style.CharacterProperties";
          pArray[3] = "com.sun.star.style.CharacterPropertiesAsian";
          pArray[4] = "com.sun.star.style.CharacterPropertiesComplex";
      break;
      case SfxStyleFamily::Page:
          pArray[1] = "com.sun.star.style.PageStyle";
          pArray[2] = "com.sun.star.style.PageProperties";
      break;
      case SfxStyleFamily::Para:
          pArray[1] = "com.sun.star.style.ParagraphStyle";
          pArray[2] = "com.sun.star.style.ParagraphProperties";
          pArray[3] = "com.sun.star.style.ParagraphPropertiesAsian";
          pArray[4] = "com.sun.star.style.ParagraphPropertiesComplex";
      if(m_bIsConditional)
          pArray[5] = "com.sun.star.style.ConditionalParagraphStyle";
      break;

      default:
          ;
  }
  return aRet;
1269}

1271static uno::Reference<beans::XPropertySet> lcl_InitStandardStyle(const SfxStyleFamily eFamily,  uno::Reference<container::XNameAccess> const & rxStyleFamily)
1272{
  using return_t = decltype(lcl_InitStandardStyle(eFamily, rxStyleFamily));
  if(eFamily != SfxStyleFamily::Para && eFamily != SfxStyleFamily::Page)
      return {};
  auto aResult(rxStyleFamily->getByName("Standard"));
  if(!aResult.has<return_t>())
      return {};
  return aResult.get<return_t>();
1280}

1282static uno::Reference<container::XNameAccess> lcl_InitStyleFamily(SwDoc* pDoc, const StyleFamilyEntry& rEntry)
1283{
  using return_t = decltype(lcl_InitStyleFamily(pDoc, rEntry));
  if(rEntry.m_eFamily != SfxStyleFamily::Char
          && rEntry.m_eFamily != SfxStyleFamily::Para
          && rEntry.m_eFamily != SfxStyleFamily::Page)
      return {};
  auto xModel(pDoc->GetDocShell()->GetBaseModel());
  uno::Reference<style::XStyleFamiliesSupplier> xFamilySupplier(xModel, uno::UNO_QUERY);
  auto xFamilies = xFamilySupplier->getStyleFamilies();
  auto aResult(xFamilies->getByName(rEntry.m_sName));
  if(!aResult.has<return_t>())
      return {};
  return aResult.get<return_t>();
1296}

1298static bool lcl_InitConditional(SfxStyleSheetBasePool* pBasePool, const SfxStyleFamily eFamily, const OUString& rStyleName)
1299{
  if(!pBasePool || eFamily != SfxStyleFamily::Para)
      return false;
  SfxStyleSheetBase* pBase = pBasePool->Find(rStyleName, eFamily);
  SAL_WARN_IF(!pBase, "sw.uno", "where is the style?" )do { if (true && (!pBase)) { switch (sal_detail_log_report
(::SAL_DETAIL_LOG_LEVEL_WARN, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE
: break; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail
::getResult( ::sal::detail::StreamStart() << "where is the style?"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "1303" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "where is the style?"), 0); } else {
 ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "where is the style?"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "1303" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "where is the style?") == 1) { ::sal_detail_log( (
::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "1303" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "where is the style?"), 0); } else {
 ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "where is the style?"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "1303" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  if(!pBase)
      return false;
  const sal_uInt16 nId(SwStyleNameMapper::GetPoolIdFromUIName(rStyleName, SwGetPoolIdFromName::TxtColl));
  if(nId != USHRT_MAX(32767 *2 +1))
      return ::IsConditionalByPoolId(nId);
  return RES_CONDTXTFMTCOLL == static_cast<SwDocStyleSheet*>(pBase)->GetCollection()->Which();
1310}

1312static const StyleFamilyEntry& lcl_GetStyleEntry(const SfxStyleFamily eFamily)
1313{
  auto pEntries = lcl_GetStyleFamilyEntries();
  const auto pEntry = std::find_if(pEntries->begin(), pEntries->end(),
          [eFamily] (const StyleFamilyEntry& e) { return e.m_eFamily == eFamily; });
  assert(pEntry != pEntries->end())(static_cast <bool> (pEntry != pEntries->end()) ? void
 (0) : __assert_fail ("pEntry != pEntries->end()", "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
, 1317, __extension__ __PRETTY_FUNCTION__));
  return *pEntry;
1319}

1321SwXStyle::SwXStyle(SwDoc* pDoc, SfxStyleFamily eFamily, bool bConditional)
  : m_pDoc(pDoc)
  , m_rEntry(lcl_GetStyleEntry(eFamily))
  , m_bIsDescriptor(true)
  , m_bIsConditional(bConditional)
  , m_pBasePool(nullptr)
  , m_xStyleFamily(lcl_InitStyleFamily(pDoc, m_rEntry))
  , m_xStyleData(lcl_InitStandardStyle(eFamily, m_xStyleFamily))
1329{
  assert(!m_bIsConditional || m_rEntry.m_eFamily == SfxStyleFamily::Para)(static_cast <bool> (!m_bIsConditional || m_rEntry.m_eFamily
 == SfxStyleFamily::Para) ? void (0) : __assert_fail ("!m_bIsConditional || m_rEntry.m_eFamily == SfxStyleFamily::Para"
, "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
, 1330, __extension__ __PRETTY_FUNCTION__)); // only paragraph styles are conditional
  // Register ourselves as a listener to the document (via the page descriptor)
  SvtListener::StartListening(pDoc->getIDocumentStylePoolAccess().GetPageDescFromPool(RES_POOLPAGE_STANDARD)->GetNotifier());
  m_pPropertiesImpl = std::make_unique<SwStyleProperties_Impl>(
          aSwMapProvider.GetPropertySet(m_bIsConditional ? PROPERTY_MAP_CONDITIONAL_PARA_STYLE93 :  m_rEntry.m_nPropMapType)->getPropertyMap());
1335}

1337SwXStyle::SwXStyle(SfxStyleSheetBasePool* pPool, SfxStyleFamily eFamily, SwDoc* pDoc, const OUString& rStyleName)
  : m_pDoc(pDoc)
  , m_sStyleName(rStyleName)
  , m_rEntry(lcl_GetStyleEntry(eFamily))
  , m_bIsDescriptor(false)
  , m_bIsConditional(lcl_InitConditional(pPool, eFamily, rStyleName))
  , m_pBasePool(pPool)
1344{ }

1346SwXStyle::~SwXStyle()
1347{
  SolarMutexGuard aGuard;
  if(m_pBasePool)
      SfxListener::EndListening(*m_pBasePool);
  m_pPropertiesImpl.reset();
  SvtListener::EndListeningAll();
1353}

1355void SwXStyle::Notify(const SfxHint& rHint)
1356{
  if(rHint.GetId() == SfxHintId::Dying)
  {
      m_pDoc = nullptr;
      m_xStyleData.clear();
      m_xStyleFamily.clear();
  }
1363}

1365OUString SwXStyle::getName()
1366{
  SolarMutexGuard aGuard;
  if(!m_pBasePool)
      return m_sStyleName;
  SfxStyleSheetBase* pBase = m_pBasePool->Find(m_sStyleName, m_rEntry.m_eFamily);
  SAL_WARN_IF(!pBase, "sw.uno", "where is the style?")do { if (true && (!pBase)) { switch (sal_detail_log_report
(::SAL_DETAIL_LOG_LEVEL_WARN, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE
: break; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail
::getResult( ::sal::detail::StreamStart() << "where is the style?"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "1371" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "where is the style?"), 0); } else {
 ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "where is the style?"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "1371" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "where is the style?") == 1) { ::sal_detail_log( (
::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "1371" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "where is the style?"), 0); } else {
 ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "where is the style?"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "1371" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  if(!pBase)
      throw uno::RuntimeException();
  OUString aString;
  SwStyleNameMapper::FillProgName(pBase->GetName(), aString, lcl_GetSwEnumFromSfxEnum ( m_rEntry.m_eFamily ));
  return aString;
1377}

1379void SwXStyle::setName(const OUString& rName)
1380{
  SolarMutexGuard aGuard;
  if(!m_pBasePool)
  {
      m_sStyleName = rName;
      return;
  }
  SfxStyleSheetBase* pBase = m_pBasePool->Find(m_sStyleName, m_rEntry.m_eFamily);
  SAL_WARN_IF(!pBase, "sw.uno", "where is the style?")do { if (true && (!pBase)) { switch (sal_detail_log_report
(::SAL_DETAIL_LOG_LEVEL_WARN, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE
: break; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail
::getResult( ::sal::detail::StreamStart() << "where is the style?"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "1388" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "where is the style?"), 0); } else {
 ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "where is the style?"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "1388" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "where is the style?") == 1) { ::sal_detail_log( (
::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "1388" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "where is the style?"), 0); } else {
 ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "where is the style?"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "1388" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  if(!pBase || !pBase->IsUserDefined())
      throw uno::RuntimeException();
  rtl::Reference<SwDocStyleSheet> xTmp(new SwDocStyleSheet(*static_cast<SwDocStyleSheet*>(pBase)));
  if(!xTmp->SetName(rName))
      throw uno::RuntimeException();
  m_sStyleName = rName;
1395}

1397sal_Bool SwXStyle::isUserDefined()
1398{
  SolarMutexGuard aGuard;
  if(!m_pBasePool)
      throw uno::RuntimeException();
  SfxStyleSheetBase* pBase = m_pBasePool->Find(m_sStyleName, m_rEntry.m_eFamily);
  //if it is not found it must be non user defined
  return pBase && pBase->IsUserDefined();
1405}

1407sal_Bool SwXStyle::isInUse()
1408{
  SolarMutexGuard aGuard;
  if(!m_pBasePool)
      throw uno::RuntimeException();
  SfxStyleSheetBase* pBase = m_pBasePool->Find(m_sStyleName, m_rEntry.m_eFamily, SfxStyleSearchBits::Used);
  return pBase && pBase->IsUsed();
1414}

1416OUString SwXStyle::getParentStyle()
1417{
  SolarMutexGuard aGuard;
  if(!m_pBasePool)
  {
      if(!m_bIsDescriptor)
          throw uno::RuntimeException();
      return m_sParentStyleName;
  }
  SfxStyleSheetBase* pBase = m_pBasePool->Find(m_sStyleName, m_rEntry.m_eFamily);
  OUString aString;
  if(pBase)
      aString = pBase->GetParent();
  SwStyleNameMapper::FillProgName(aString, aString, lcl_GetSwEnumFromSfxEnum(m_rEntry.m_eFamily));
  return aString;
1431}

1433void SwXStyle::setParentStyle(const OUString& rParentStyle)
1434{
  SolarMutexGuard aGuard;
  OUString sParentStyle;
  SwStyleNameMapper::FillUIName(rParentStyle, sParentStyle, lcl_GetSwEnumFromSfxEnum ( m_rEntry.m_eFamily ) );
  if(!m_pBasePool)
  {
      if(!m_bIsDescriptor)
          throw uno::RuntimeException();
      m_sParentStyleName = sParentStyle;
      try
      {
          const auto aAny = m_xStyleFamily->getByName(sParentStyle);
          m_xStyleData = aAny.get<decltype(m_xStyleData)>();
      }
      catch(...)
      { }
      return;
  }
  SfxStyleSheetBase* pBase = m_pBasePool->Find(m_sStyleName, m_rEntry.m_eFamily);
  if(!pBase)
      throw uno::RuntimeException();
  rtl::Reference<SwDocStyleSheet> xBase(new SwDocStyleSheet(*static_cast<SwDocStyleSheet*>(pBase)));
  //make it a 'real' style - necessary for pooled styles
  xBase->GetItemSet();
  if(xBase->GetParent() != sParentStyle)
  {
      if(!xBase->SetParent(sParentStyle))
          throw uno::RuntimeException();
  }
1463}

1465uno::Reference<beans::XPropertySetInfo> SwXStyle::getPropertySetInfo()
1466{
  if(m_bIsConditional)
  {
      assert(m_rEntry.m_eFamily == SfxStyleFamily::Para)(static_cast <bool> (m_rEntry.m_eFamily == SfxStyleFamily
::Para) ? void (0) : __assert_fail ("m_rEntry.m_eFamily == SfxStyleFamily::Para"
, "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
, 1469, __extension__ __PRETTY_FUNCTION__));
      static uno::Reference<beans::XPropertySetInfo> xCondParaRef;
      xCondParaRef = aSwMapProvider.GetPropertySet(PROPERTY_MAP_CONDITIONAL_PARA_STYLE93)->getPropertySetInfo();
      return xCondParaRef;
  }
  return m_rEntry.m_xPSInfo;
1475}

1477void SwXStyle::ApplyDescriptorProperties()
1478{
  m_bIsDescriptor = false;
  m_xStyleData.clear();
  m_xStyleFamily.clear();
  m_pPropertiesImpl->Apply(*this);
1483}

1485namespace {

1487class SwStyleBase_Impl
1488{
1489private:
  SwDoc& m_rDoc;
  const SwPageDesc* m_pOldPageDesc;
  rtl::Reference<SwDocStyleSheet> m_xNewBase;
  SfxItemSet* m_pItemSet;
  std::unique_ptr<SfxItemSet> m_pMyItemSet;
  OUString m_rStyleName;
  const SwAttrSet* m_pParentStyle;
1497public:
  SwStyleBase_Impl(SwDoc& rSwDoc, const OUString& rName, const SwAttrSet* pParentStyle)
      : m_rDoc(rSwDoc)
      , m_pOldPageDesc(nullptr)
      , m_pItemSet(nullptr)
      , m_rStyleName(rName)
      , m_pParentStyle(pParentStyle)
  { }

  rtl::Reference<SwDocStyleSheet>& getNewBase()
  {
      return m_xNewBase;
  }

  void setNewBase(SwDocStyleSheet* pNew)
  {
      m_xNewBase = pNew;
  }

  bool HasItemSet() const
  {
      return m_xNewBase.is();
  }

  SfxItemSet& GetItemSet()
  {
      assert(m_xNewBase.is())(static_cast <bool> (m_xNewBase.is()) ? void (0) : __assert_fail
 ("m_xNewBase.is()", "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
, 1523, __extension__ __PRETTY_FUNCTION__));
      if(!m_pItemSet)
      {
          m_pMyItemSet.reset(new SfxItemSet(m_xNewBase->GetItemSet()));
          m_pItemSet = m_pMyItemSet.get();

          // set parent style to have the correct XFillStyle setting as XFILL_NONE
          if(!m_pItemSet->GetParent() && m_pParentStyle)
              m_pItemSet->SetParent(m_pParentStyle);
      }
      return *m_pItemSet;
  }

  const SwPageDesc* GetOldPageDesc();

  // still a hack, but a bit more explicit and with a proper scope
  struct ItemSetOverrider
  {
      SwStyleBase_Impl& m_rStyleBase;
      SfxItemSet* m_pOldSet;
      ItemSetOverrider(SwStyleBase_Impl& rStyleBase, SfxItemSet* pTemp)
              : m_rStyleBase(rStyleBase)
              , m_pOldSet(m_rStyleBase.m_pItemSet)
      { m_rStyleBase.m_pItemSet = pTemp; }
      ~ItemSetOverrider()
      { m_rStyleBase.m_pItemSet = m_pOldSet; };
  };
1550};

  const char* STR_POOLPAGE_ARY[] =
  {
      // Page styles
      STR_POOLPAGE_STANDARDreinterpret_cast<char const *>("STR_POOLPAGE_STANDARD" "\004"
 u8"Default Page Style"),
      STR_POOLPAGE_FIRSTreinterpret_cast<char const *>("STR_POOLPAGE_FIRST" "\004"
 u8"First Page"),
      STR_POOLPAGE_LEFTreinterpret_cast<char const *>("STR_POOLPAGE_LEFT" "\004"
 u8"Left Page"),
      STR_POOLPAGE_RIGHTreinterpret_cast<char const *>("STR_POOLPAGE_RIGHT" "\004"
 u8"Right Page"),
      STR_POOLPAGE_ENVELOPEreinterpret_cast<char const *>("STR_POOLPAGE_ENVELOPE" "\004"
 u8"Envelope"),
      STR_POOLPAGE_REGISTERreinterpret_cast<char const *>("STR_POOLPAGE_REGISTER" "\004"
 u8"Index"),
      STR_POOLPAGE_HTMLreinterpret_cast<char const *>("STR_POOLPAGE_HTML" "\004"
 u8"HTML"),
      STR_POOLPAGE_FOOTNOTEreinterpret_cast<char const *>("STR_POOLPAGE_FOOTNOTE" "\004"
 u8"Footnote"),
      STR_POOLPAGE_ENDNOTEreinterpret_cast<char const *>("STR_POOLPAGE_ENDNOTE" "\004"
 u8"Endnote"),
      STR_POOLPAGE_LANDSCAPEreinterpret_cast<char const *>("STR_POOLPAGE_LANDSCAPE"
 "\004" u8"Landscape")
  };
1566}

1568const SwPageDesc* SwStyleBase_Impl::GetOldPageDesc()
1569{
  if(!m_pOldPageDesc)
  {
      SwPageDesc *pd = m_rDoc.FindPageDesc(m_rStyleName);
      if(pd)
          m_pOldPageDesc = pd;

      if(!m_pOldPageDesc)
      {
          for (size_t i = 0; i < SAL_N_ELEMENTS(STR_POOLPAGE_ARY)(sizeof(sal_n_array_size(STR_POOLPAGE_ARY))); ++i)
          {
              if (SwResId(STR_POOLPAGE_ARY[i]) == m_rStyleName)
              {
                  m_pOldPageDesc = m_rDoc.getIDocumentStylePoolAccess().GetPageDescFromPool(RES_POOLPAGE_BEGIN + i);
                  break;
              }
          }
      }
  }
  return m_pOldPageDesc;
1589}



1593static sal_uInt8 lcl_TranslateMetric(const SfxItemPropertySimpleEntry& rEntry, SwDoc* pDoc, uno::Any& o_aValue)
1594{
  // check for needed metric translation
  if(!(rEntry.nMoreFlags & PropertyMoreFlags::METRIC_ITEM))
      return rEntry.nMemberId;
  // exception: If these ItemTypes are used, do not convert when these are negative
  // since this means they are intended as percent values
  if((XATTR_FILLBMP_SIZEX == rEntry.nWID || XATTR_FILLBMP_SIZEY == rEntry.nWID)
          && o_aValue.has<sal_Int32>()
          && o_aValue.get<sal_Int32>() < 0)
      return rEntry.nMemberId;
  if(!pDoc)
      return rEntry.nMemberId;

  const SfxItemPool& rPool = pDoc->GetAttrPool();
  const MapUnit eMapUnit(rPool.GetMetric(rEntry.nWID));
  if(eMapUnit != MapUnit::Map100thMM)
      SvxUnoConvertFromMM(eMapUnit, o_aValue);
  return rEntry.nMemberId;
1612}
1613template<>
1614void SwXStyle::SetPropertyValue<HINT_BEGIN>(const SfxItemPropertySimpleEntry& rEntry, const SfxItemPropertySet& rPropSet, const uno::Any& rValue, SwStyleBase_Impl& o_rStyleBase)
1615{
  // default ItemSet handling
  SfxItemSet& rStyleSet = o_rStyleBase.GetItemSet();
  SfxItemSet aSet(*rStyleSet.GetPool(), {{rEntry.nWID, rEntry.nWID}});
  aSet.SetParent(&rStyleSet);
  rPropSet.setPropertyValue(rEntry, rValue, aSet);
  rStyleSet.Put(aSet);
1622}
1623template<>
1624void SwXStyle::SetPropertyValue<FN_UNO_HIDDEN((20000 + 2200) + 122)>(const SfxItemPropertySimpleEntry& rEntry, const SfxItemPropertySet& rPropSet, const uno::Any& rValue, SwStyleBase_Impl& o_rStyleBase)
1625{
  bool bHidden = false;
  if(rValue >>= bHidden)
  {
      //make it a 'real' style - necessary for pooled styles
      o_rStyleBase.getNewBase()->GetItemSet();
      o_rStyleBase.getNewBase()->SetHidden(bHidden);
  }
  SetPropertyValue<HINT_BEGIN>(rEntry, rPropSet, rValue, o_rStyleBase);
1634}
1635template<>
1636void SwXStyle::SetPropertyValue<FN_UNO_STYLE_INTEROP_GRAB_BAG((20000 + 2200) + 123)>(const SfxItemPropertySimpleEntry& rEntry, const SfxItemPropertySet& rPropSet, const uno::Any& rValue, SwStyleBase_Impl& o_rStyleBase)
1637{
  o_rStyleBase.getNewBase()->GetItemSet();
  o_rStyleBase.getNewBase()->SetGrabBagItem(rValue);
  SetPropertyValue<HINT_BEGIN>(rEntry, rPropSet, rValue, o_rStyleBase);
1641}
1642template<>
1643void SwXStyle::SetPropertyValue<sal_uInt16(XATTR_FILLGRADIENT)>(const SfxItemPropertySimpleEntry& rEntry, const SfxItemPropertySet& rPropSet, const uno::Any& rValue, SwStyleBase_Impl& o_rStyleBase)
1644{
  uno::Any aValue(rValue);
  const auto nMemberId(lcl_TranslateMetric(rEntry, m_pDoc, aValue));
  if(MID_NAME16 == nMemberId)
  {
      // add set commands for FillName items
      SfxItemSet& rStyleSet = o_rStyleBase.GetItemSet();
      if(!aValue.has<OUString>())
          throw lang::IllegalArgumentException();
      SvxShape::SetFillAttribute(rEntry.nWID, aValue.get<OUString>(), rStyleSet);
  }
  else if(MID_BITMAP8 == nMemberId)
  {
      if(sal_uInt16(XATTR_FILLBITMAP) == rEntry.nWID)
      {
          const Graphic aNullGraphic;
          SfxItemSet& rStyleSet = o_rStyleBase.GetItemSet();
          XFillBitmapItem aXFillBitmapItem(aNullGraphic);
          aXFillBitmapItem.PutValue(aValue, nMemberId);
          rStyleSet.Put(aXFillBitmapItem);
      }
  }
  else
      SetPropertyValue<HINT_BEGIN>(rEntry, rPropSet, aValue, o_rStyleBase);
1668}
1669template<>
1670void SwXStyle::SetPropertyValue<sal_uInt16(RES_BACKGROUND)>(const SfxItemPropertySimpleEntry& rEntry, const SfxItemPropertySet&, const uno::Any& rValue, SwStyleBase_Impl& o_rStyleBase)
1671{
  SfxItemSet& rStyleSet = o_rStyleBase.GetItemSet();
  const std::unique_ptr<SvxBrushItem> aOriginalBrushItem(getSvxBrushItemFromSourceSet(rStyleSet, RES_BACKGROUND, true, m_pDoc->IsInXMLImport()));
  std::unique_ptr<SvxBrushItem> aChangedBrushItem(aOriginalBrushItem->Clone());

  uno::Any aValue(rValue);
  const auto nMemberId(lcl_TranslateMetric(rEntry, m_pDoc, aValue));
  aChangedBrushItem->PutValue(aValue, nMemberId);

  // 0xff is already the default - but if BackTransparent is set
  // to true, it must be applied in the item set on ODF import
  // to potentially override parent style, which is unknown yet
  if(*aChangedBrushItem == *aOriginalBrushItem && (MID_GRAPHIC_TRANSPARENT3 != nMemberId || !aValue.has<bool>() || !aValue.get<bool>()))
      return;

  setSvxBrushItemAsFillAttributesToTargetSet(*aChangedBrushItem, rStyleSet);
1687}
1688template<>
1689void SwXStyle::SetPropertyValue<OWN_ATTR_FILLBMP_MODE(3900 +45)>(const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, const uno::Any& rValue, SwStyleBase_Impl& o_rStyleBase)
1690{
  drawing::BitmapMode eMode;
  if(!(rValue >>= eMode))
  {
      if(!rValue.has<sal_Int32>())
          throw lang::IllegalArgumentException();
      eMode = static_cast<drawing::BitmapMode>(rValue.get<sal_Int32>());
  }
  SfxItemSet& rStyleSet = o_rStyleBase.GetItemSet();
  rStyleSet.Put(XFillBmpStretchItem(drawing::BitmapMode_STRETCH == eMode));
  rStyleSet.Put(XFillBmpTileItem(drawing::BitmapMode_REPEAT == eMode));
1701}
1702template<>
1703void SwXStyle::SetPropertyValue<sal_uInt16(RES_PAPER_BIN)>(const SfxItemPropertySimpleEntry& rEntry, const SfxItemPropertySet& rPropSet, const uno::Any& rValue, SwStyleBase_Impl& o_rStyleBase)
1704{
  if(!rValue.has<OUString>())
      throw lang::IllegalArgumentException();
  SfxPrinter* pPrinter = m_pDoc->getIDocumentDeviceAccess().getPrinter(true);
  OUString sValue(rValue.get<OUString>());
  using printeridx_t = decltype(pPrinter->GetPaperBinCount());
  printeridx_t nBin = std::numeric_limits<printeridx_t>::max();
  if(sValue == "[From printer settings]")
      nBin = std::numeric_limits<printeridx_t>::max()-1;
  else if(pPrinter)
  {
      for(sal_uInt16 i=0, nEnd = pPrinter->GetPaperBinCount(); i < nEnd; ++i)
      {
          if (sValue == pPrinter->GetPaperBinName(i))
          {
              nBin = i;
              break;
          }
      }
  }
  if(nBin == std::numeric_limits<printeridx_t>::max())
      throw lang::IllegalArgumentException();
  SfxItemSet& rStyleSet = o_rStyleBase.GetItemSet();
  SfxItemSet aSet(*rStyleSet.GetPool(), {{rEntry.nWID, rEntry.nWID}});
  aSet.SetParent(&rStyleSet);
  rPropSet.setPropertyValue(rEntry, uno::makeAny(static_cast<sal_Int8>(nBin == std::numeric_limits<printeridx_t>::max()-1 ? -1 : nBin)), aSet);
  rStyleSet.Put(aSet);
1731}
1732template<>
1733void SwXStyle::SetPropertyValue<FN_UNO_NUM_RULES((20000 + 2200) + 15)>(const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, const uno::Any& rValue, SwStyleBase_Impl& o_rStyleBase)
1734{
  if(!rValue.has<uno::Reference<container::XIndexReplace>>() || !rValue.has<uno::Reference<lang::XUnoTunnel>>())
      throw lang::IllegalArgumentException();
  auto xNumberTunnel(rValue.get<uno::Reference<lang::XUnoTunnel>>());
  SwXNumberingRules* pSwXRules = reinterpret_cast<SwXNumberingRules*>(sal::static_int_cast<sal_IntPtr>(xNumberTunnel->getSomething(SwXNumberingRules::getUnoTunnelId())));
  if(!pSwXRules)
      return;
  SwNumRule aSetRule(*pSwXRules->GetNumRule());
  for(sal_uInt16 i = 0; i < MAXLEVEL; ++i)
  {
      const SwNumFormat* pFormat = aSetRule.GetNumFormat(i);
      if(!pFormat)
          continue;
      SwNumFormat aFormat(*pFormat);
      const auto& rCharName(pSwXRules->GetNewCharStyleNames()[i]);
      if(!rCharName.isEmpty()
             && !SwXNumberingRules::isInvalidStyle(rCharName)
             && (!pFormat->GetCharFormat() || pFormat->GetCharFormat()->GetName() != rCharName))
      {
          auto pCharFormatIt(std::find_if(m_pDoc->GetCharFormats()->begin(), m_pDoc->GetCharFormats()->end(),
                  [&rCharName] (SwCharFormat* pF) { return pF->GetName() == rCharName; }));
          if(pCharFormatIt != m_pDoc->GetCharFormats()->end())
              aFormat.SetCharFormat(*pCharFormatIt);
          else if(m_pBasePool)
          {
              auto pBase(m_pBasePool->Find(rCharName, SfxStyleFamily::Char));
              if(!pBase)
                  pBase = &m_pBasePool->Make(rCharName, SfxStyleFamily::Char);
              aFormat.SetCharFormat(static_cast<SwDocStyleSheet*>(pBase)->GetCharFormat());
          }
          else
              aFormat.SetCharFormat(nullptr);
      }
      // same for fonts:
      const auto& rBulletName(pSwXRules->GetBulletFontNames()[i]);
      if(!rBulletName.isEmpty()
              && !SwXNumberingRules::isInvalidStyle(rBulletName)
              && (!pFormat->GetBulletFont() || pFormat->GetBulletFont()->GetFamilyName() != rBulletName))
      {
          const auto pFontListItem(static_cast<const SvxFontListItem*>(m_pDoc->GetDocShell()->GetItem(SID_ATTR_CHAR_FONTLIST( 10000 + 22 ))));
          const auto pList(pFontListItem->GetFontList());
          FontMetric aFontInfo(pList->Get(rBulletName, WEIGHT_NORMAL, ITALIC_NONE));
          vcl::Font aFont(aFontInfo);
          aFormat.SetBulletFont(&aFont);
      }
      aSetRule.Set(i, &aFormat);
  }
  o_rStyleBase.getNewBase()->SetNumRule(aSetRule);
1782}
1783template<>
1784void SwXStyle::SetPropertyValue<sal_uInt16(RES_PARATR_OUTLINELEVEL)>(const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, const uno::Any& rValue, SwStyleBase_Impl& o_rStyleBase)
1785{
  if(!rValue.has<sal_Int16>())
      return;
  const auto nLevel(rValue.get<sal_Int16>());
  if(0 <= nLevel && nLevel <= MAXLEVEL)
      o_rStyleBase.getNewBase()->GetCollection()->SetAttrOutlineLevel(nLevel);
1791}
1792template<>
1793void SwXStyle::SetPropertyValue<FN_UNO_FOLLOW_STYLE((20000 + 2200) + 59)>(const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, const uno::Any& rValue, SwStyleBase_Impl& o_rStyleBase)
1794{
  if(!rValue.has<OUString>())
      return;
  const auto sValue(rValue.get<OUString>());
  OUString aString;
  SwStyleNameMapper::FillUIName(sValue, aString, m_rEntry.m_aPoolId);
  o_rStyleBase.getNewBase()->SetFollow(aString);
1801}
1802template<>
1803void SwXStyle::SetPropertyValue<sal_uInt16(RES_PAGEDESC)>(const SfxItemPropertySimpleEntry& rEntry, const SfxItemPropertySet& rPropSet, const uno::Any& rValue, SwStyleBase_Impl& o_rStyleBase)
1804{
  if(MID_PAGEDESC_PAGEDESCNAME0 != rEntry.nMemberId)
  {
      SetPropertyValue<HINT_BEGIN>(rEntry, rPropSet, rValue, o_rStyleBase);
      return;
  }
  if(!rValue.has<OUString>())
      throw lang::IllegalArgumentException();
  // special handling for RES_PAGEDESC
  SfxItemSet& rStyleSet = o_rStyleBase.GetItemSet();
  std::unique_ptr<SwFormatPageDesc> pNewDesc;
  const SfxPoolItem* pItem;
  if(SfxItemState::SET == rStyleSet.GetItemState(RES_PAGEDESC, true, &pItem))
      pNewDesc.reset(new SwFormatPageDesc(*static_cast<const SwFormatPageDesc*>(pItem)));
  else
      pNewDesc.reset(new SwFormatPageDesc);
  const auto sValue(rValue.get<OUString>());
  OUString sDescName;
  SwStyleNameMapper::FillUIName(sValue, sDescName, SwGetPoolIdFromName::PageDesc);
  if(pNewDesc->GetPageDesc() && pNewDesc->GetPageDesc()->GetName() == sDescName)
      return;
  if(sDescName.isEmpty())
  {
      rStyleSet.ClearItem(RES_BREAK);
      rStyleSet.Put(SwFormatPageDesc());
  }
  else
  {
      SwPageDesc* pPageDesc(SwPageDesc::GetByName(*m_pDoc, sDescName));
      if(!pPageDesc)
          throw lang::IllegalArgumentException();
      pNewDesc->RegisterToPageDesc(*pPageDesc);
      rStyleSet.Put(*pNewDesc);
  }
1838}
1839template<>
1840void SwXStyle::SetPropertyValue<sal_uInt16(RES_TEXT_VERT_ADJUST)>(const SfxItemPropertySimpleEntry& rEntry, const SfxItemPropertySet& rPropSet, const uno::Any& rValue, SwStyleBase_Impl& o_rStyleBase)
1841{
  if(m_rEntry.m_eFamily != SfxStyleFamily::Page)
  {
      SetPropertyValue<HINT_BEGIN>(rEntry, rPropSet, rValue, o_rStyleBase);
      return;
  }
  if(!m_pDoc || !rValue.has<drawing::TextVerticalAdjust>() || !o_rStyleBase.GetOldPageDesc())
      return;
  SwPageDesc* pPageDesc = m_pDoc->FindPageDesc(o_rStyleBase.GetOldPageDesc()->GetName());
  if(pPageDesc)
      pPageDesc->SetVerticalAdjustment(rValue.get<drawing::TextVerticalAdjust>());
1852}
1853template<>
1854void SwXStyle::SetPropertyValue<FN_UNO_IS_AUTO_UPDATE((20000 + 2200) + 62)>(const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, const uno::Any& rValue, SwStyleBase_Impl& o_rStyleBase)
1855{
  if(!rValue.has<bool>())
      throw lang::IllegalArgumentException();
  const bool bAuto(rValue.get<bool>());
  if(SfxStyleFamily::Para == m_rEntry.m_eFamily)
      o_rStyleBase.getNewBase()->GetCollection()->SetAutoUpdateFormat(bAuto);
  else if(SfxStyleFamily::Frame == m_rEntry.m_eFamily)
      o_rStyleBase.getNewBase()->GetFrameFormat()->SetAutoUpdateFormat(bAuto);
1863}
1864template<>
1865void SwXStyle::SetPropertyValue<FN_UNO_PARA_STYLE_CONDITIONS((20000 + 2200) + 100)>(const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, const uno::Any& rValue, SwStyleBase_Impl& o_rStyleBase)
1866{
  static_assert(COND_COMMAND_COUNT28 == 28, "invalid size of command count?");
  using expectedarg_t = uno::Sequence<beans::NamedValue>;
  if(!rValue.has<expectedarg_t>() || !m_pBasePool)
      throw lang::IllegalArgumentException();
  SwCondCollItem aCondItem;
  const auto aNamedValues = rValue.get<expectedarg_t>();
  for(const auto& rNamedValue : aNamedValues)
  {
      if(!rNamedValue.Value.has<OUString>())
          throw lang::IllegalArgumentException();

      const OUString sValue(rNamedValue.Value.get<OUString>());
      // get UI style name from programmatic style name
      OUString aStyleName;
      SwStyleNameMapper::FillUIName(sValue, aStyleName, lcl_GetSwEnumFromSfxEnum(m_rEntry.m_eFamily));

      // check for correct context and style name
      const auto nIdx(GetCommandContextIndex(rNamedValue.Name));
      if (nIdx == -1)
          throw lang::IllegalArgumentException();
      bool bStyleFound = false;
      for(auto pBase = m_pBasePool->First(SfxStyleFamily::Para); pBase; pBase = m_pBasePool->Next())
      {
          bStyleFound = pBase->GetName() == aStyleName;
          if (bStyleFound)
              break;
      }
      if (!bStyleFound)
          throw lang::IllegalArgumentException();
      aCondItem.SetStyle(&aStyleName, nIdx);
  }
  o_rStyleBase.GetItemSet().Put(aCondItem);
1899}
1900template<>
1901void SwXStyle::SetPropertyValue<FN_UNO_CATEGORY((20000 + 2200) + 68)>(const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, const uno::Any& rValue, SwStyleBase_Impl& o_rStyleBase)
1902{
  if(!o_rStyleBase.getNewBase()->IsUserDefined() || !rValue.has<paragraphstyle_t>())
      throw lang::IllegalArgumentException();
  static std::unique_ptr<std::map<paragraphstyle_t, SfxStyleSearchBits>> pUnoToCore;
  if(!pUnoToCore)
  {
      pUnoToCore.reset(new std::map<paragraphstyle_t, SfxStyleSearchBits>);
      auto pEntries = lcl_GetParagraphStyleCategoryEntries();
      std::transform(pEntries->begin(), pEntries->end(), std::inserter(*pUnoToCore, pUnoToCore->end()),
          [] (const ParagraphStyleCategoryEntry& rEntry) { return std::pair<paragraphstyle_t, SfxStyleSearchBits>(rEntry.m_eCategory, rEntry.m_nSwStyleBits); });
  }
  const auto pUnoToCoreIt(pUnoToCore->find(rValue.get<paragraphstyle_t>()));
  if(pUnoToCoreIt == pUnoToCore->end())
      throw lang::IllegalArgumentException();
  o_rStyleBase.getNewBase()->SetMask( pUnoToCoreIt->second|SfxStyleSearchBits::UserDefined );
1917}
1918template<>
1919void SwXStyle::SetPropertyValue<SID_SWREGISTER_COLLECTION( 10000 + 451 )>(const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, const uno::Any& rValue, SwStyleBase_Impl& o_rStyleBase)
1920{
  OUString sName;
  rValue >>= sName;
  SwRegisterItem aReg(!sName.isEmpty());
  aReg.SetWhich(SID_SWREGISTER_MODE( 10000 + 467 ));
  o_rStyleBase.GetItemSet().Put(aReg);
  OUString aString;
  SwStyleNameMapper::FillUIName(sName, aString, SwGetPoolIdFromName::TxtColl);
  o_rStyleBase.GetItemSet().Put(SfxStringItem(SID_SWREGISTER_COLLECTION( 10000 + 451 ), aString ) );
1929}
1930template<>
1931void SwXStyle::SetPropertyValue<sal_uInt16(RES_TXTATR_CJK_RUBY)>(const SfxItemPropertySimpleEntry& rEntry, const SfxItemPropertySet& rPropSet, const uno::Any& rValue, SwStyleBase_Impl& o_rStyleBase)
1932{
  if(MID_RUBY_CHARSTYLE2 != rEntry.nMemberId)
      return;
  if(!rValue.has<OUString>())
      throw lang::IllegalArgumentException();
  const auto sValue(rValue.get<OUString>());
  SfxItemSet& rStyleSet(o_rStyleBase.GetItemSet());
  std::unique_ptr<SwFormatRuby> pRuby;
  const SfxPoolItem* pItem;
  if(SfxItemState::SET == rStyleSet.GetItemState(RES_TXTATR_CJK_RUBY, true, &pItem))
      pRuby.reset(new SwFormatRuby(*static_cast<const SwFormatRuby*>(pItem)));
  else
      pRuby.reset(new SwFormatRuby(OUString()));
  OUString sStyle;
  SwStyleNameMapper::FillUIName(sValue, sStyle, SwGetPoolIdFromName::ChrFmt);
  pRuby->SetCharFormatName(sValue);
  pRuby->SetCharFormatId(0);
  if(!sValue.isEmpty())
  {
      const sal_uInt16 nId(SwStyleNameMapper::GetPoolIdFromUIName(sValue, SwGetPoolIdFromName::ChrFmt));
      pRuby->SetCharFormatId(nId);
  }
  rStyleSet.Put(*pRuby);
  SetPropertyValue<HINT_BEGIN>(rEntry, rPropSet, rValue, o_rStyleBase);
1956}
1957template<>
1958void SwXStyle::SetPropertyValue<sal_uInt16(RES_PARATR_DROP)>(const SfxItemPropertySimpleEntry& rEntry, const SfxItemPropertySet& rPropSet, const uno::Any& rValue, SwStyleBase_Impl& o_rStyleBase)
1959{
  if(MID_DROPCAP_CHAR_STYLE_NAME2 != rEntry.nMemberId)
  {
      SetPropertyValue<HINT_BEGIN>(rEntry, rPropSet, rValue, o_rStyleBase);
      return;
  }
  if(!rValue.has<OUString>())
      throw lang::IllegalArgumentException();
  SfxItemSet& rStyleSet(o_rStyleBase.GetItemSet());
  std::unique_ptr<SwFormatDrop> pDrop;
  const SfxPoolItem* pItem;
  if(SfxItemState::SET == rStyleSet.GetItemState(RES_PARATR_DROP, true, &pItem))
      pDrop.reset(new SwFormatDrop(*static_cast<const SwFormatDrop*>(pItem)));
  else
      pDrop.reset(new SwFormatDrop);
  const auto sValue(rValue.get<OUString>());
  OUString sStyle;
  SwStyleNameMapper::FillUIName(sValue, sStyle, SwGetPoolIdFromName::ChrFmt);
  auto pStyle(static_cast<SwDocStyleSheet*>(m_pDoc->GetDocShell()->GetStyleSheetPool()->Find(sStyle, SfxStyleFamily::Char)));
  //default character style must not be set as default format
  if(!pStyle || pStyle->GetCharFormat() == m_pDoc->GetDfltCharFormat() )
  {
      throw lang::IllegalArgumentException();
  }
  pDrop->SetCharFormat(pStyle->GetCharFormat());
  rStyleSet.Put(*pDrop);
1985}
1986template<>
1987void SwXStyle::SetPropertyValue<sal_uInt16(RES_PARATR_NUMRULE)>(const SfxItemPropertySimpleEntry& rEntry, const SfxItemPropertySet& rPropSet, const uno::Any& rValue, SwStyleBase_Impl& o_rStyleBase)
1988{
  uno::Any aValue(rValue);
  lcl_TranslateMetric(rEntry, m_pDoc, aValue);
  SetPropertyValue<HINT_BEGIN>(rEntry, rPropSet, aValue, o_rStyleBase);
  // --> OD 2006-10-18 #i70223#
  if(SfxStyleFamily::Para == m_rEntry.m_eFamily &&
          o_rStyleBase.getNewBase().is() && o_rStyleBase.getNewBase()->GetCollection() &&
          //rBase.getNewBase()->GetCollection()->GetOutlineLevel() < MAXLEVEL /* assigned to list level of outline style */) //#outline level,removed by zhaojianwei
          o_rStyleBase.getNewBase()->GetCollection()->IsAssignedToListLevelOfOutlineStyle())       ////<-end,add by zhaojianwei
  {
      OUString sNewNumberingRuleName;
      aValue >>= sNewNumberingRuleName;
      if(sNewNumberingRuleName.isEmpty() || sNewNumberingRuleName != m_pDoc->GetOutlineNumRule()->GetName())
          o_rStyleBase.getNewBase()->GetCollection()->DeleteAssignmentToListLevelOfOutlineStyle();
  }
2003}

2005void SwXStyle::SetStyleProperty(const SfxItemPropertySimpleEntry& rEntry, const SfxItemPropertySet& rPropSet, const uno::Any& rValue, SwStyleBase_Impl& rBase)
2006{
  using propertytype_t = decltype(rEntry.nWID);
  using coresetter_t = std::function<void(SwXStyle&, const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, const uno::Any&, SwStyleBase_Impl&)>;
  static std::unique_ptr<std::map<propertytype_t, coresetter_t>> pUnoToCore;
  if(!pUnoToCore)
  {
      pUnoToCore.reset(new std::map<propertytype_t, coresetter_t> {
          // these explicit std::mem_fn() calls shouldn't be needed, but apparently MSVC is currently too stupid for C++11 again
          { FN_UNO_HIDDEN((20000 + 2200) + 122),                 std::mem_fn(&SwXStyle::SetPropertyValue<FN_UNO_HIDDEN((20000 + 2200) + 122)>)                 },
          { FN_UNO_STYLE_INTEROP_GRAB_BAG((20000 + 2200) + 123), std::mem_fn(&SwXStyle::SetPropertyValue<FN_UNO_STYLE_INTEROP_GRAB_BAG((20000 + 2200) + 123)>) },
          { XATTR_FILLGRADIENT,            std::mem_fn(&SwXStyle::SetPropertyValue<sal_uInt16(XATTR_FILLGRADIENT)>)            },
          { XATTR_FILLHATCH,               std::mem_fn(&SwXStyle::SetPropertyValue<sal_uInt16(XATTR_FILLGRADIENT)>)            },
          { XATTR_FILLBITMAP,              std::mem_fn(&SwXStyle::SetPropertyValue<sal_uInt16(XATTR_FILLGRADIENT)>)            },
          { XATTR_FILLFLOATTRANSPARENCE,   std::mem_fn(&SwXStyle::SetPropertyValue<sal_uInt16(XATTR_FILLGRADIENT)>)            },
          { RES_BACKGROUND,                std::mem_fn(&SwXStyle::SetPropertyValue<sal_uInt16(RES_BACKGROUND)>)                },
          { OWN_ATTR_FILLBMP_MODE(3900 +45),         std::mem_fn(&SwXStyle::SetPropertyValue<OWN_ATTR_FILLBMP_MODE(3900 +45)>)         },
          { RES_PAPER_BIN,                 std::mem_fn(&SwXStyle::SetPropertyValue<sal_uInt16(RES_PAPER_BIN)>)                 },
          { FN_UNO_NUM_RULES((20000 + 2200) + 15),              std::mem_fn(&SwXStyle::SetPropertyValue<FN_UNO_NUM_RULES((20000 + 2200) + 15)>)              },
          { RES_PARATR_OUTLINELEVEL,       std::mem_fn(&SwXStyle::SetPropertyValue<sal_uInt16(RES_PARATR_OUTLINELEVEL)>)       },
          { FN_UNO_FOLLOW_STYLE((20000 + 2200) + 59),           std::mem_fn(&SwXStyle::SetPropertyValue<FN_UNO_FOLLOW_STYLE((20000 + 2200) + 59)>)           },
          { RES_PAGEDESC,                  std::mem_fn(&SwXStyle::SetPropertyValue<sal_uInt16(RES_PAGEDESC)>)                  },
          { RES_TEXT_VERT_ADJUST,          std::mem_fn(&SwXStyle::SetPropertyValue<sal_uInt16(RES_TEXT_VERT_ADJUST)>)          },
          { FN_UNO_IS_AUTO_UPDATE((20000 + 2200) + 62),         std::mem_fn(&SwXStyle::SetPropertyValue<FN_UNO_IS_AUTO_UPDATE((20000 + 2200) + 62)>)         },
          { FN_UNO_PARA_STYLE_CONDITIONS((20000 + 2200) + 100),  std::mem_fn(&SwXStyle::SetPropertyValue<FN_UNO_PARA_STYLE_CONDITIONS((20000 + 2200) + 100)>)  },
          { FN_UNO_CATEGORY((20000 + 2200) + 68),               std::mem_fn(&SwXStyle::SetPropertyValue<FN_UNO_CATEGORY((20000 + 2200) + 68)>)               },
          { SID_SWREGISTER_COLLECTION( 10000 + 451 ),     std::mem_fn(&SwXStyle::SetPropertyValue<SID_SWREGISTER_COLLECTION( 10000 + 451 )>)     },
          { RES_TXTATR_CJK_RUBY,           std::mem_fn(&SwXStyle::SetPropertyValue<sal_uInt16(RES_TXTATR_CJK_RUBY)>)           },
          { RES_PARATR_DROP,               std::mem_fn(&SwXStyle::SetPropertyValue<sal_uInt16(RES_PARATR_DROP)>)               },
          { RES_PARATR_NUMRULE,            std::mem_fn(&SwXStyle::SetPropertyValue<sal_uInt16(RES_PARATR_NUMRULE)>)            }
      });
  }
  const auto pUnoToCoreIt(pUnoToCore->find(rEntry.nWID));
  if(pUnoToCoreIt != pUnoToCore->end())
      pUnoToCoreIt->second(*this, rEntry, rPropSet, rValue, rBase);
  else
  {
      // adapted switch logic to a more readable state; removed goto's and made
      // execution of standard setting of property in ItemSet dependent of this variable
      uno::Any aValue(rValue);
      lcl_TranslateMetric(rEntry, m_pDoc, aValue);
      SetPropertyValue<HINT_BEGIN>(rEntry, rPropSet, aValue, rBase);
  }
2048}

2050void SwXStyle::SetPropertyValues_Impl(const uno::Sequence<OUString>& rPropertyNames, const uno::Sequence<uno::Any>& rValues)
2051{
  if(!m_pDoc)
      throw uno::RuntimeException();
  sal_Int8 nPropSetId = m_bIsConditional ? PROPERTY_MAP_CONDITIONAL_PARA_STYLE93 : m_rEntry.m_nPropMapType;
  const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(nPropSetId);
  const SfxItemPropertyMap &rMap = pPropSet->getPropertyMap();
  if(rPropertyNames.getLength() != rValues.getLength())
      throw lang::IllegalArgumentException();

  SwStyleBase_Impl aBaseImpl(*m_pDoc, m_sStyleName, &GetDoc()->GetDfltTextFormatColl()->GetAttrSet()); // add pDfltTextFormatColl as parent
  if(m_pBasePool)
  {
      SfxStyleSheetBase* pBase = m_pBasePool->Find(m_sStyleName, m_rEntry.m_eFamily);
      SAL_WARN_IF(!pBase, "sw.uno", "where is the style?")do { if (true && (!pBase)) { switch (sal_detail_log_report
(::SAL_DETAIL_LOG_LEVEL_WARN, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE
: break; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail
::getResult( ::sal::detail::StreamStart() << "where is the style?"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "2064" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "where is the style?"), 0); } else {
 ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "where is the style?"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "2064" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "where is the style?") == 1) { ::sal_detail_log( (
::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "2064" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "where is the style?"), 0); } else {
 ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "where is the style?"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "2064" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
      if(!pBase)
          throw uno::RuntimeException();
      aBaseImpl.setNewBase(new SwDocStyleSheet(*static_cast<SwDocStyleSheet*>(pBase)));
  }
  if(!aBaseImpl.getNewBase().is() && !m_bIsDescriptor)
      throw uno::RuntimeException();

  const OUString* pNames = rPropertyNames.getConstArray();
  const uno::Any* pValues = rValues.getConstArray();
  for(sal_Int32 nProp = 0; nProp < rPropertyNames.getLength(); ++nProp)
  {
      const SfxItemPropertySimpleEntry* pEntry = rMap.getByName(pNames[nProp]);
      if(!pEntry || (!m_bIsConditional && pNames[nProp] == UNO_NAME_PARA_STYLE_CONDITIONS"ParaStyleConditions"))
          throw beans::UnknownPropertyException("Unknown property: " + pNames[nProp], static_cast<cppu::OWeakObject*>(this));
      if(pEntry->nFlags & beans::PropertyAttribute::READONLY)
          throw beans::PropertyVetoException ("Property is read-only: " + pNames[nProp], static_cast<cppu::OWeakObject*>(this));
      if(aBaseImpl.getNewBase().is())
          SetStyleProperty(*pEntry, *pPropSet, pValues[nProp], aBaseImpl);
      else if(!m_pPropertiesImpl->SetProperty(pNames[nProp], pValues[nProp]))
          throw lang::IllegalArgumentException();
  }

  if(aBaseImpl.HasItemSet())
      aBaseImpl.getNewBase()->SetItemSet(aBaseImpl.GetItemSet());
2089}

2091void SwXStyle::setPropertyValues(const uno::Sequence<OUString>& rPropertyNames, const uno::Sequence<uno::Any>& rValues)
2092{
  SolarMutexGuard aGuard;
  // workaround for bad designed API
  try
  {
      SetPropertyValues_Impl( rPropertyNames, rValues );
  }
  catch (const beans::UnknownPropertyException &rException)
  {
      // wrap the original (here not allowed) exception in
      // a lang::WrappedTargetException that gets thrown instead.
      lang::WrappedTargetException aWExc;
      aWExc.TargetException <<= rException;
      throw aWExc;
  }
2107}

2109SfxStyleSheetBase* SwXStyle::GetStyleSheetBase()
2110{
  if(!m_pBasePool)
      return nullptr;
  SfxStyleSheetBase* pBase = m_pBasePool->Find(m_sStyleName, m_rEntry.m_eFamily);
  return pBase;
2115}
2116void SwXStyle::PrepareStyleBase(SwStyleBase_Impl& rBase)
2117{
  SfxStyleSheetBase* pBase(GetStyleSheetBase());
  if(!pBase)
      throw uno::RuntimeException();
  if(!rBase.getNewBase().is())
      rBase.setNewBase(new SwDocStyleSheet(*static_cast<SwDocStyleSheet*>(pBase)));
2123}

2125template<>
2126uno::Any SwXStyle::GetStyleProperty<HINT_BEGIN>(const SfxItemPropertySimpleEntry& rEntry, const SfxItemPropertySet& rPropSet, SwStyleBase_Impl& rBase);
2127template<>
2128uno::Any SwXStyle::GetStyleProperty<FN_UNO_IS_PHYSICAL((20000 + 2200) + 61)>(const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, SwStyleBase_Impl&)
2129{
  SfxStyleSheetBase* pBase(GetStyleSheetBase());
  if(!pBase)
      return uno::makeAny(false);
  bool bPhys = static_cast<SwDocStyleSheet*>(pBase)->IsPhysical();
  // The standard character format is not existing physically
  if( bPhys && SfxStyleFamily::Char == GetFamily() &&
      static_cast<SwDocStyleSheet*>(pBase)->GetCharFormat() &&
      static_cast<SwDocStyleSheet*>(pBase)->GetCharFormat()->IsDefault() )
      bPhys = false;
  return uno::makeAny<bool>(bPhys);
2140}
2141template<>
2142uno::Any SwXStyle::GetStyleProperty<FN_UNO_HIDDEN((20000 + 2200) + 122)>(const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, SwStyleBase_Impl&)
2143{
  SfxStyleSheetBase* pBase(GetStyleSheetBase());
  if(!pBase)
      return uno::makeAny(false);
  rtl::Reference<SwDocStyleSheet> xBase(new SwDocStyleSheet(*static_cast<SwDocStyleSheet*>(pBase)));
  return uno::makeAny(xBase->IsHidden());
2149}
2150template<>
2151uno::Any SwXStyle::GetStyleProperty<FN_UNO_STYLE_INTEROP_GRAB_BAG((20000 + 2200) + 123)>(const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, SwStyleBase_Impl&)
2152{
  SfxStyleSheetBase* pBase(GetStyleSheetBase());
  if(!pBase)
      return uno::Any();
  uno::Any aRet;
  rtl::Reference<SwDocStyleSheet> xBase(new SwDocStyleSheet(*static_cast<SwDocStyleSheet*>(pBase)));
  xBase->GetGrabBagItem(aRet);
  return aRet;
2160}
2161template<>
2162uno::Any SwXStyle::GetStyleProperty<sal_uInt16(RES_PAPER_BIN)>(const SfxItemPropertySimpleEntry& rEntry, const SfxItemPropertySet& rPropSet, SwStyleBase_Impl& rBase)
2163{
  PrepareStyleBase(rBase);
  SfxItemSet& rSet = rBase.GetItemSet();
  uno::Any aValue;
  rPropSet.getPropertyValue(rEntry, rSet, aValue);
  sal_Int8 nBin(aValue.get<sal_Int8>());
  if(nBin == -1)
      return uno::makeAny<OUString>("[From printer settings]");
  SfxPrinter* pPrinter = GetDoc()->getIDocumentDeviceAccess().getPrinter(false);
  if(!pPrinter)
      return uno::Any();
  return uno::makeAny(pPrinter->GetPaperBinName(nBin));
2175}
2176template<>
2177uno::Any SwXStyle::GetStyleProperty<FN_UNO_NUM_RULES((20000 + 2200) + 15)>(const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, SwStyleBase_Impl& rBase)
2178{
  PrepareStyleBase(rBase);
  const SwNumRule* pRule = rBase.getNewBase()->GetNumRule();
  assert(pRule && "Where is the NumRule?")(static_cast <bool> (pRule && "Where is the NumRule?"
) ? void (0) : __assert_fail ("pRule && \"Where is the NumRule?\""
, "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
, 2181, __extension__ __PRETTY_FUNCTION__));
  uno::Reference<container::XIndexReplace> xRules(new SwXNumberingRules(*pRule, GetDoc()));
  return uno::makeAny<uno::Reference<container::XIndexReplace>>(xRules);
2184}
2185template<>
2186uno::Any SwXStyle::GetStyleProperty<sal_uInt16(RES_PARATR_OUTLINELEVEL)>(const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, SwStyleBase_Impl& rBase)
2187{
  PrepareStyleBase(rBase);
  SAL_WARN_IF(SfxStyleFamily::Para != GetFamily(), "sw.uno", "only paras")do { if (true && (SfxStyleFamily::Para != GetFamily()
)) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "only paras") == 1) {
 ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"),
 ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "2189" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "only paras"), 0); } else { ::std::ostringstream
 sal_detail_stream; sal_detail_stream << "only paras"; ::
sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"), (
"/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "2189" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "only paras") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "2189" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "only paras"), 0); } else { ::std::ostringstream
 sal_detail_stream; sal_detail_stream << "only paras"; ::
sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"), (
"/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "2189" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  return uno::makeAny<sal_Int16>(rBase.getNewBase()->GetCollection()->GetAttrOutlineLevel());
2191}
2192template<>
2193uno::Any SwXStyle::GetStyleProperty<FN_UNO_FOLLOW_STYLE((20000 + 2200) + 59)>(const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, SwStyleBase_Impl& rBase)
2194{
  PrepareStyleBase(rBase);
  OUString aString;
  SwStyleNameMapper::FillProgName(rBase.getNewBase()->GetFollow(), aString, lcl_GetSwEnumFromSfxEnum(GetFamily()));
  return uno::makeAny(aString);
2199}
2200template<>
2201uno::Any SwXStyle::GetStyleProperty<sal_uInt16(RES_PAGEDESC)>(const SfxItemPropertySimpleEntry& rEntry, const SfxItemPropertySet& rPropSet, SwStyleBase_Impl& rBase)
2202{
  PrepareStyleBase(rBase);
  if(MID_PAGEDESC_PAGEDESCNAME0 != rEntry.nMemberId)
      return GetStyleProperty<HINT_BEGIN>(rEntry, rPropSet, rBase);
  // special handling for RES_PAGEDESC
  const SfxPoolItem* pItem;
  if(SfxItemState::SET != rBase.GetItemSet().GetItemState(RES_PAGEDESC, true, &pItem))
      return uno::Any();
  const SwPageDesc* pDesc = static_cast<const SwFormatPageDesc*>(pItem)->GetPageDesc();
  if(!pDesc)
      return uno::Any();
  OUString aString;
  SwStyleNameMapper::FillProgName(pDesc->GetName(), aString, SwGetPoolIdFromName::PageDesc);
  return uno::makeAny(aString);
2216}
2217template<>
2218uno::Any SwXStyle::GetStyleProperty<FN_UNO_IS_AUTO_UPDATE((20000 + 2200) + 62)>(const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, SwStyleBase_Impl& rBase)
2219{
  PrepareStyleBase(rBase);
  switch(GetFamily())
  {
      case SfxStyleFamily::Para : return uno::makeAny<bool>(rBase.getNewBase()->GetCollection()->IsAutoUpdateFormat());
      case SfxStyleFamily::Frame: return uno::makeAny<bool>(rBase.getNewBase()->GetFrameFormat()->IsAutoUpdateFormat());
      default: return uno::Any();
  }
2227}
2228template<>
2229uno::Any SwXStyle::GetStyleProperty<FN_UNO_DISPLAY_NAME((20000 + 2200) + 63)>(const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, SwStyleBase_Impl& rBase)
2230{
  PrepareStyleBase(rBase);
  return uno::makeAny(rBase.getNewBase()->GetName());
2233}
2234template<>
2235uno::Any SwXStyle::GetStyleProperty<FN_UNO_PARA_STYLE_CONDITIONS((20000 + 2200) + 100)>(const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, SwStyleBase_Impl& rBase)
2236{
  PrepareStyleBase(rBase);
  static_assert(COND_COMMAND_COUNT28 == 28, "invalid size of command count?");
  uno::Sequence<beans::NamedValue> aSeq(COND_COMMAND_COUNT28);
  sal_uInt16 nIndex = 0;
  for(auto& rNV : aSeq)
  {
      rNV.Name = GetCommandContextByIndex(nIndex++);
      rNV.Value <<= OUString();
  }
  SwFormat* pFormat = static_cast<SwDocStyleSheet*>(GetStyleSheetBase())->GetCollection();
  if(pFormat && RES_CONDTXTFMTCOLL == pFormat->Which())
  {
      const CommandStruct* pCmds = SwCondCollItem::GetCmds();
      beans::NamedValue* pSeq = aSeq.getArray();
      for(sal_uInt16 n = 0;  n < COND_COMMAND_COUNT28; ++n)
      {
          const SwCollCondition* pCond = static_cast<SwConditionTextFormatColl*>(pFormat)->HasCondition(SwCollCondition(nullptr, pCmds[n].nCnd, pCmds[n].nSubCond));
          if(!pCond || !pCond->GetTextFormatColl())
              continue;
          // get programmatic style name from UI style name
          OUString aStyleName = pCond->GetTextFormatColl()->GetName();
          SwStyleNameMapper::FillProgName(aStyleName, aStyleName, lcl_GetSwEnumFromSfxEnum(GetFamily()));
          pSeq[n].Value <<= aStyleName;
      }
  }
  return uno::makeAny(aSeq);
2263}
2264template<>
2265uno::Any SwXStyle::GetStyleProperty<FN_UNO_CATEGORY((20000 + 2200) + 68)>(const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, SwStyleBase_Impl& rBase)
2266{
  PrepareStyleBase(rBase);
  static std::unique_ptr<std::map<collectionbits_t, paragraphstyle_t>> pUnoToCore;
  if(!pUnoToCore)
  {
      pUnoToCore.reset(new std::map<collectionbits_t, paragraphstyle_t>);
      auto pEntries = lcl_GetParagraphStyleCategoryEntries();
      std::transform(pEntries->begin(), pEntries->end(), std::inserter(*pUnoToCore, pUnoToCore->end()),
          [] (const ParagraphStyleCategoryEntry& rEntry) { return std::pair<collectionbits_t, paragraphstyle_t>(rEntry.m_nCollectionBits, rEntry.m_eCategory); });
  }
  const sal_uInt16 nPoolId = rBase.getNewBase()->GetCollection()->GetPoolFormatId();
  const auto pUnoToCoreIt(pUnoToCore->find(COLL_GET_RANGE_BITS & nPoolId));
  if(pUnoToCoreIt == pUnoToCore->end())
      return uno::makeAny<sal_Int16>(-1);
  return uno::makeAny(pUnoToCoreIt->second);
2281}
2282template<>
2283uno::Any SwXStyle::GetStyleProperty<SID_SWREGISTER_COLLECTION( 10000 + 451 )>(const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, SwStyleBase_Impl& rBase)
2284{
  PrepareStyleBase(rBase);
  const SwPageDesc *pPageDesc = rBase.getNewBase()->GetPageDesc();
  if(!pPageDesc)
      return uno::makeAny(OUString());
  const SwTextFormatColl* pCol = pPageDesc->GetRegisterFormatColl();
  if(!pCol)
      return uno::makeAny(OUString());
  OUString aName;
  SwStyleNameMapper::FillProgName(pCol->GetName(), aName, SwGetPoolIdFromName::TxtColl);
  return uno::makeAny(aName);
2295}
2296template<>
2297uno::Any SwXStyle::GetStyleProperty<sal_uInt16(RES_BACKGROUND)>(const SfxItemPropertySimpleEntry& rEntry, const SfxItemPropertySet&, SwStyleBase_Impl& rBase)
2298{
  PrepareStyleBase(rBase);
  const SfxItemSet& rSet = rBase.GetItemSet();
  const std::unique_ptr<SvxBrushItem> aOriginalBrushItem(getSvxBrushItemFromSourceSet(rSet, RES_BACKGROUND));
  uno::Any aResult;
  if(!aOriginalBrushItem->QueryValue(aResult, rEntry.nMemberId))
      SAL_WARN("sw.uno", "error getting attribute from RES_BACKGROUND.")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "error getting attribute from RES_BACKGROUND."
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "2304" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "error getting attribute from RES_BACKGROUND."
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "error getting attribute from RES_BACKGROUND."; ::sal
::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "2304" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "error getting attribute from RES_BACKGROUND.") ==
 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "2304" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "error getting attribute from RES_BACKGROUND."
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "error getting attribute from RES_BACKGROUND."; ::sal
::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "2304" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  return aResult;
2306}
2307template<>
2308uno::Any SwXStyle::GetStyleProperty<OWN_ATTR_FILLBMP_MODE(3900 +45)>(const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, SwStyleBase_Impl& rBase)
2309{
  PrepareStyleBase(rBase);
  const SfxItemSet& rSet = rBase.GetItemSet();
  if (rSet.Get(XATTR_FILLBMP_TILE).GetValue())
      return uno::makeAny(drawing::BitmapMode_REPEAT);
  if (rSet.Get(XATTR_FILLBMP_STRETCH).GetValue())
      return uno::makeAny(drawing::BitmapMode_STRETCH);
  return uno::makeAny(drawing::BitmapMode_NO_REPEAT);
2317}
2318template<>
2319uno::Any SwXStyle::GetStyleProperty<HINT_BEGIN>(const SfxItemPropertySimpleEntry& rEntry, const SfxItemPropertySet& rPropSet, SwStyleBase_Impl& rBase)
2320{
  PrepareStyleBase(rBase);
  SfxItemSet& rSet = rBase.GetItemSet();
  uno::Any aResult;
  rPropSet.getPropertyValue(rEntry, rSet, aResult);
  //
  // since the sfx uint16 item now exports a sal_Int32, we may have to fix this here
  if(rEntry.aType == cppu::UnoType<sal_Int16>::get() && aResult.getValueType() == cppu::UnoType<sal_Int32>::get())
      aResult <<= static_cast<sal_Int16>(aResult.get<sal_Int32>());
  // check for needed metric translation
  if(rEntry.nMoreFlags & PropertyMoreFlags::METRIC_ITEM && GetDoc())
  {
      const SfxItemPool& rPool = GetDoc()->GetAttrPool();
      const MapUnit eMapUnit(rPool.GetMetric(rEntry.nWID));
      bool bAllowedConvert(true);
      // exception: If these ItemTypes are used, do not convert when these are negative
      // since this means they are intended as percent values
      if(XATTR_FILLBMP_SIZEX == rEntry.nWID || XATTR_FILLBMP_SIZEY == rEntry.nWID)
          bAllowedConvert = !aResult.has<sal_Int32>() || aResult.get<sal_Int32>() > 0;
      if(eMapUnit != MapUnit::Map100thMM && bAllowedConvert)
          SvxUnoConvertToMM(eMapUnit, aResult);
  }
  return aResult;
2343}

2345uno::Any SwXStyle::GetStyleProperty_Impl(const SfxItemPropertySimpleEntry& rEntry, const SfxItemPropertySet& rPropSet, SwStyleBase_Impl& rBase)
2346{
  using propertytype_t = decltype(rEntry.nWID);
  using coresetter_t = std::function<uno::Any(SwXStyle&, const SfxItemPropertySimpleEntry&, const SfxItemPropertySet&, SwStyleBase_Impl&)>;
  static std::unique_ptr<std::map<propertytype_t, coresetter_t>> pUnoToCore;
  if(!pUnoToCore)
  {
      pUnoToCore.reset(new std::map<propertytype_t, coresetter_t> {
          // these explicit std::mem_fn() calls shouldn't be needed, but apparently MSVC is currently too stupid for C++11 again
          { FN_UNO_IS_PHYSICAL((20000 + 2200) + 61),            std::mem_fn(&SwXStyle::GetStyleProperty<FN_UNO_IS_PHYSICAL((20000 + 2200) + 61)>)            },
          { FN_UNO_HIDDEN((20000 + 2200) + 122),                 std::mem_fn(&SwXStyle::GetStyleProperty<FN_UNO_HIDDEN((20000 + 2200) + 122)>)                 },
          { FN_UNO_STYLE_INTEROP_GRAB_BAG((20000 + 2200) + 123), std::mem_fn(&SwXStyle::GetStyleProperty<FN_UNO_STYLE_INTEROP_GRAB_BAG((20000 + 2200) + 123)>) },
          { RES_PAPER_BIN,                 std::mem_fn(&SwXStyle::GetStyleProperty<sal_uInt16(RES_PAPER_BIN)>)                 },
          { FN_UNO_NUM_RULES((20000 + 2200) + 15),              std::mem_fn(&SwXStyle::GetStyleProperty<FN_UNO_NUM_RULES((20000 + 2200) + 15)>)              },
          { RES_PARATR_OUTLINELEVEL,       std::mem_fn(&SwXStyle::GetStyleProperty<sal_uInt16(RES_PARATR_OUTLINELEVEL)>)       },
          { FN_UNO_FOLLOW_STYLE((20000 + 2200) + 59),           std::mem_fn(&SwXStyle::GetStyleProperty<FN_UNO_FOLLOW_STYLE((20000 + 2200) + 59)>)           },
          { RES_PAGEDESC,                  std::mem_fn(&SwXStyle::GetStyleProperty<sal_uInt16(RES_PAGEDESC)>)                  },
          { FN_UNO_IS_AUTO_UPDATE((20000 + 2200) + 62),         std::mem_fn(&SwXStyle::GetStyleProperty<FN_UNO_IS_AUTO_UPDATE((20000 + 2200) + 62)>)         },
          { FN_UNO_DISPLAY_NAME((20000 + 2200) + 63),           std::mem_fn(&SwXStyle::GetStyleProperty<FN_UNO_DISPLAY_NAME((20000 + 2200) + 63)>)           },
          { FN_UNO_PARA_STYLE_CONDITIONS((20000 + 2200) + 100),  std::mem_fn(&SwXStyle::GetStyleProperty<FN_UNO_PARA_STYLE_CONDITIONS((20000 + 2200) + 100)>)  },
          { FN_UNO_CATEGORY((20000 + 2200) + 68),               std::mem_fn(&SwXStyle::GetStyleProperty<FN_UNO_CATEGORY((20000 + 2200) + 68)>)               },
          { SID_SWREGISTER_COLLECTION( 10000 + 451 ),     std::mem_fn(&SwXStyle::GetStyleProperty<SID_SWREGISTER_COLLECTION( 10000 + 451 )>)     },
          { RES_BACKGROUND,                std::mem_fn(&SwXStyle::GetStyleProperty<sal_uInt16(RES_BACKGROUND)>)                },
          { OWN_ATTR_FILLBMP_MODE(3900 +45),         std::mem_fn(&SwXStyle::GetStyleProperty<OWN_ATTR_FILLBMP_MODE(3900 +45)>)         }
      });
  }
  const auto pUnoToCoreIt(pUnoToCore->find(rEntry.nWID));
  if(pUnoToCoreIt != pUnoToCore->end())
      return pUnoToCoreIt->second(*this, rEntry, rPropSet, rBase);
  return GetStyleProperty<HINT_BEGIN>(rEntry, rPropSet, rBase);
2375}

2377uno::Any SwXStyle::GetPropertyValue_Impl(const SfxItemPropertySet* pPropSet, SwStyleBase_Impl& rBase, const OUString& rPropertyName)
2378{
  const SfxItemPropertyMap& rMap = pPropSet->getPropertyMap();
  const SfxItemPropertySimpleEntry* pEntry = rMap.getByName(rPropertyName);
  if(!pEntry || (!m_bIsConditional && rPropertyName == UNO_NAME_PARA_STYLE_CONDITIONS"ParaStyleConditions"))
      throw beans::UnknownPropertyException("Unknown property: " + rPropertyName, static_cast<cppu::OWeakObject*>(this));
  if(m_pBasePool)
      return GetStyleProperty_Impl(*pEntry, *pPropSet, rBase);
  const uno::Any* pAny = nullptr;
  m_pPropertiesImpl->GetProperty(rPropertyName, pAny);
  if(pAny->hasValue())
      return *pAny;
  uno::Any aValue;
  switch(m_rEntry.m_eFamily)
  {
      case SfxStyleFamily::Pseudo:
          throw uno::RuntimeException("No default value for: " + rPropertyName);
      break;
      case SfxStyleFamily::Para:
      case SfxStyleFamily::Page:
          SwStyleProperties_Impl::GetProperty(rPropertyName, m_xStyleData, aValue);
      break;
      case SfxStyleFamily::Char:
      case SfxStyleFamily::Frame:
      {
          if(pEntry->nWID < POOLATTR_BEGIN || pEntry->nWID >= RES_UNKNOWNATR_END)
              throw uno::RuntimeException("No default value for: " + rPropertyName);
          SwFormat* pFormat;
          if(m_rEntry.m_eFamily == SfxStyleFamily::Char)
              pFormat = m_pDoc->GetDfltCharFormat();
          else
              pFormat = m_pDoc->GetDfltFrameFormat();
          const SwAttrPool* pPool = pFormat->GetAttrSet().GetPool();
          const SfxPoolItem& rItem = pPool->GetDefaultItem(pEntry->nWID);
          rItem.QueryValue(aValue, pEntry->nMemberId);
      }
      break;
      default:
      ;
  }
  return aValue;
2418}

2420uno::Any SwXStyle::getPropertyValue(const OUString& rPropertyName)
2421{
  SolarMutexGuard aGuard;
  if(!m_pDoc)
      throw uno::RuntimeException();
  if(!m_pBasePool && !m_bIsDescriptor)
      throw uno::RuntimeException();
  sal_Int8 nPropSetId = m_bIsConditional ? PROPERTY_MAP_CONDITIONAL_PARA_STYLE93 : m_rEntry.m_nPropMapType;
  const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(nPropSetId);
  SwStyleBase_Impl aBase(*m_pDoc, m_sStyleName, &m_pDoc->GetDfltTextFormatColl()->GetAttrSet()); // add pDfltTextFormatColl as parent
  return GetPropertyValue_Impl(pPropSet, aBase, rPropertyName);
2431}

2433uno::Sequence<uno::Any> SwXStyle::getPropertyValues(const uno::Sequence<OUString>& rPropertyNames)
2434{
  SolarMutexGuard aGuard;
  if(!m_pDoc)
      throw uno::RuntimeException();
  if(!m_pBasePool && !m_bIsDescriptor)
      throw uno::RuntimeException();
  sal_Int8 nPropSetId = m_bIsConditional ? PROPERTY_MAP_CONDITIONAL_PARA_STYLE93 : m_rEntry.m_nPropMapType;
  const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(nPropSetId);
  SwStyleBase_Impl aBase(*m_pDoc, m_sStyleName, &m_pDoc->GetDfltTextFormatColl()->GetAttrSet()); // add pDfltTextFormatColl as parent
  uno::Sequence<uno::Any> aValues(rPropertyNames.getLength());
  // workaround for bad designed API
  try
  {
      for(sal_Int32 nProp = 0; nProp < rPropertyNames.getLength(); ++nProp)
          aValues[nProp] = GetPropertyValue_Impl(pPropSet, aBase, rPropertyNames[nProp]);
  }
  catch(beans::UnknownPropertyException&)
  {
      css::uno::Any anyEx = cppu::getCaughtException();
      throw css::lang::WrappedTargetRuntimeException("Unknown property exception caught",
              static_cast < cppu::OWeakObject * > ( this ), anyEx );
  }
  catch(lang::WrappedTargetException&)
  {
      css::uno::Any anyEx = cppu::getCaughtException();
      throw lang::WrappedTargetRuntimeException("WrappedTargetException caught",
              static_cast < cppu::OWeakObject * > ( this ), anyEx );
  }
  return aValues;
2463}

2465void SwXStyle::setPropertyValue(const OUString& rPropertyName, const uno::Any& rValue)
2466{
  SolarMutexGuard aGuard;
  const uno::Sequence<OUString> aProperties(&rPropertyName, 1);
  const uno::Sequence<uno::Any> aValues(&rValue, 1);
  SetPropertyValues_Impl(aProperties, aValues);
2471}

2473beans::PropertyState SwXStyle::getPropertyState(const OUString& rPropertyName)
2474{
  SolarMutexGuard aGuard;
  uno::Sequence<OUString> aNames{rPropertyName};
  uno::Sequence<beans::PropertyState> aStates = getPropertyStates(aNames);
  return aStates.getConstArray()[0];
2479}

2481// allow to retarget the SfxItemSet working on, default correctly. Only
2482// use pSourceSet below this point (except in header/footer processing)
2483static const SfxItemSet* lcl_GetItemsetForProperty(const SfxItemSet& rSet, SfxStyleFamily eFamily, const OUString& rPropertyName)
2484{
  if(eFamily != SfxStyleFamily::Page)
      return &rSet;
  const bool isFooter = rPropertyName.startsWith("Footer");
  if(!isFooter && !rPropertyName.startsWith("Header") && rPropertyName != UNO_NAME_FIRST_IS_SHARED"FirstIsShared")
      return &rSet;
  const SvxSetItem* pSetItem;
  if(!lcl_GetHeaderFooterItem(rSet, rPropertyName, isFooter, pSetItem))
      return nullptr;
  return &pSetItem->GetItemSet();
2494}
2495uno::Sequence<beans::PropertyState> SwXStyle::getPropertyStates(const uno::Sequence<OUString>& rPropertyNames)
2496{
  SolarMutexGuard aGuard;
  uno::Sequence<beans::PropertyState> aRet(rPropertyNames.getLength());
  beans::PropertyState* pStates = aRet.getArray();

  if(!m_pBasePool)
      throw uno::RuntimeException();
  SfxStyleSheetBase* pBase = m_pBasePool->Find(m_sStyleName, m_rEntry.m_eFamily);

  SAL_WARN_IF(!pBase, "sw.uno", "where is the style?")do { if (true && (!pBase)) { switch (sal_detail_log_report
(::SAL_DETAIL_LOG_LEVEL_WARN, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE
: break; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail
::getResult( ::sal::detail::StreamStart() << "where is the style?"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "2505" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "where is the style?"), 0); } else {
 ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "where is the style?"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "2505" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "where is the style?") == 1) { ::sal_detail_log( (
::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "2505" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "where is the style?"), 0); } else {
 ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "where is the style?"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "2505" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  if(!pBase)
      throw uno::RuntimeException();

  const OUString* pNames = rPropertyNames.getConstArray();
  rtl::Reference<SwDocStyleSheet> xStyle(new SwDocStyleSheet(*static_cast<SwDocStyleSheet*>(pBase)));
  sal_Int8 nPropSetId = m_bIsConditional ? PROPERTY_MAP_CONDITIONAL_PARA_STYLE93 : m_rEntry.m_nPropMapType;

  const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(nPropSetId);
  const SfxItemPropertyMap& rMap = pPropSet->getPropertyMap();
  const SfxItemSet& rSet = xStyle->GetItemSet();

  for(sal_Int32 i = 0; i < rPropertyNames.getLength(); ++i)
  {
      const OUString sPropName = pNames[i];
      const SfxItemPropertySimpleEntry* pEntry = rMap.getByName(sPropName);

      if(!pEntry)
          throw beans::UnknownPropertyException("Unknown property: " + sPropName, static_cast<cppu::OWeakObject*>(this));

      if(FN_UNO_NUM_RULES((20000 + 2200) + 15) == pEntry->nWID || FN_UNO_FOLLOW_STYLE((20000 + 2200) + 59) == pEntry->nWID)
      {
          // handle NumRules first, done
          pStates[i] = beans::PropertyState_DIRECT_VALUE;
          continue;
      }
      const SfxItemSet* pSourceSet = lcl_GetItemsetForProperty(rSet, m_rEntry.m_eFamily, sPropName);
      if(!pSourceSet)
      {
          // if no SetItem, value is ambiguous and we are done
          pStates[i] = beans::PropertyState_AMBIGUOUS_VALUE;
          continue;
      }
      switch(pEntry->nWID)
      {
          case OWN_ATTR_FILLBMP_MODE(3900 +45):
          {
              if(SfxItemState::SET == pSourceSet->GetItemState(XATTR_FILLBMP_STRETCH, false)
                  || SfxItemState::SET == pSourceSet->GetItemState(XATTR_FILLBMP_TILE, false))
              {
                  pStates[i] = beans::PropertyState_DIRECT_VALUE;
              }
              else
              {
                  pStates[i] = beans::PropertyState_AMBIGUOUS_VALUE;
              }
          }
          break;
          case RES_BACKGROUND:
          {
              // for FlyFrames we need to mark the used properties from type RES_BACKGROUND
              // as beans::PropertyState_DIRECT_VALUE to let users of this property call
              // getPropertyValue where the member properties will be mapped from the
              // fill attributes to the according SvxBrushItem entries
              if (SWUnoHelper::needToMapFillItemsToSvxBrushItemTypes(*pSourceSet, pEntry->nMemberId))
              {
                  pStates[i] = beans::PropertyState_DIRECT_VALUE;
              }
              else
              {
                  pStates[i] = beans::PropertyState_DEFAULT_VALUE;
              }
          }
          break;
          default:
          {
              pStates[i] = pPropSet->getPropertyState(*pEntry, *pSourceSet);

              if(SfxStyleFamily::Page == m_rEntry.m_eFamily && SID_ATTR_PAGE_SIZETypedWhichId<SvxSizeItem>( 10000 + 51 ) == pEntry->nWID && beans::PropertyState_DIRECT_VALUE == pStates[i])
              {
                  const SvxSizeItem& rSize = rSet.Get(SID_ATTR_PAGE_SIZETypedWhichId<SvxSizeItem>( 10000 + 51 ));
                  sal_uInt8 nMemberId = pEntry->nMemberId & 0x7f;

                  if((LONG_MAX9223372036854775807L == rSize.GetSize().Width() && (MID_SIZE_WIDTH1 == nMemberId || MID_SIZE_SIZE0 == nMemberId)) ||
                      (LONG_MAX9223372036854775807L == rSize.GetSize().Height() && MID_SIZE_HEIGHT2 == nMemberId))
                  {
                      pStates[i] = beans::PropertyState_DEFAULT_VALUE;
                  }
              }
          }
      }
  }
  return aRet;
2588}

2590void SwXStyle::setPropertyToDefault(const OUString& rPropertyName)
2591{
  const uno::Sequence<OUString> aSequence(&rPropertyName, 1);
  setPropertiesToDefault(aSequence);
2594}

2596static SwFormat* lcl_GetFormatForStyle(SwDoc const * pDoc, const rtl::Reference<SwDocStyleSheet>& xStyle, const SfxStyleFamily eFamily)
2597{
  if(!xStyle.is())
      return nullptr;
  switch(eFamily)
  {
      case SfxStyleFamily::Char: return xStyle->GetCharFormat();
      case SfxStyleFamily::Para: return xStyle->GetCollection();
      case SfxStyleFamily::Frame: return xStyle->GetFrameFormat();
      case SfxStyleFamily::Page:
      {
          SwPageDesc* pDesc(pDoc->FindPageDesc(xStyle->GetPageDesc()->GetName()));
          if(pDesc)
              return &pDesc->GetMaster();
      }
      break;
      default: ;
  }
  return nullptr;
2615}

2617void SAL_CALL SwXStyle::setPropertiesToDefault(const uno::Sequence<OUString>& aPropertyNames)
2618{
  SolarMutexGuard aGuard;
  const rtl::Reference<SwDocStyleSheet> xStyle(new SwDocStyleSheet(*static_cast<SwDocStyleSheet*>(GetStyleSheetBase())));
  SwFormat* pTargetFormat = lcl_GetFormatForStyle(m_pDoc, xStyle, m_rEntry.m_eFamily);
  if(!pTargetFormat)
  {
      if(!m_bIsDescriptor)
          return;
      for(const auto& rName : aPropertyNames)
          m_pPropertiesImpl->ClearProperty(rName);
      return;
  }
  const sal_Int8 nPropSetId = m_bIsConditional ? PROPERTY_MAP_CONDITIONAL_PARA_STYLE93 : m_rEntry.m_nPropMapType;
  const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(nPropSetId);
  const SfxItemPropertyMap &rMap = pPropSet->getPropertyMap();
  for(const auto& rName : aPropertyNames)
  {
      const SfxItemPropertySimpleEntry* pEntry = rMap.getByName(rName);
      if(!pEntry)
          throw beans::UnknownPropertyException("Unknown property: " + rName, static_cast<cppu::OWeakObject*>(this));
      if(pEntry->nWID == FN_UNO_FOLLOW_STYLE((20000 + 2200) + 59) || pEntry->nWID == FN_UNO_NUM_RULES((20000 + 2200) + 15))
          throw uno::RuntimeException("Cannot reset: " + rName, static_cast<cppu::OWeakObject*>(this));
      if(pEntry->nFlags & beans::PropertyAttribute::READONLY)
          throw uno::RuntimeException("setPropertiesToDefault: property is read-only: " + rName, static_cast<cppu::OWeakObject*>(this));
      if(pEntry->nWID == RES_PARATR_OUTLINELEVEL)
      {
          static_cast<SwTextFormatColl*>(pTargetFormat)->DeleteAssignmentToListLevelOfOutlineStyle();
          continue;
      }
      pTargetFormat->ResetFormatAttr(pEntry->nWID);
      if(OWN_ATTR_FILLBMP_MODE(3900 +45) == pEntry->nWID)
      {
          //
          SwDoc* pDoc = pTargetFormat->GetDoc();
          SfxItemSet aSet(pDoc->GetAttrPool(), svl::Items<XATTR_FILL_FIRST, XATTR_FILL_LAST>{});
          aSet.SetParent(&pTargetFormat->GetAttrSet());

          aSet.ClearItem(XATTR_FILLBMP_STRETCH);
          aSet.ClearItem(XATTR_FILLBMP_TILE);

          pTargetFormat->SetFormatAttr(aSet);
      }
  }
2661}

2663void SAL_CALL SwXStyle::setAllPropertiesToDefault()
2664{
  SolarMutexGuard aGuard;
  if(!m_pBasePool)
  {
      if(!m_bIsDescriptor)
          throw uno::RuntimeException();
      m_pPropertiesImpl->ClearAllProperties();
      return;
  }
  const rtl::Reference<SwDocStyleSheet> xStyle(new SwDocStyleSheet(*static_cast<SwDocStyleSheet*>(GetStyleSheetBase())));
  if(!xStyle.is())
      throw uno::RuntimeException();
  if(SfxStyleFamily::Page == m_rEntry.m_eFamily)
  {
      size_t nPgDscPos(0);
      SwPageDesc* pDesc = m_pDoc->FindPageDesc(xStyle->GetPageDesc()->GetName(), &nPgDscPos);
      SwFormat* pPageFormat(nullptr);
      if(pDesc)
      {
          pPageFormat = &pDesc->GetMaster();
          pDesc->SetUseOn(UseOnPage::All);
      }
      else
          pPageFormat = lcl_GetFormatForStyle(m_pDoc, xStyle, m_rEntry.m_eFamily);
      SwPageDesc& rPageDesc = m_pDoc->GetPageDesc(nPgDscPos);
      rPageDesc.ResetAllMasterAttr();

      SvxLRSpaceItem aLR(RES_LR_SPACE);
      sal_Int32 nSize = GetMetricVal(CM_10) * 2;
      aLR.SetLeft(nSize);
      aLR.SetLeft(nSize);
      SvxULSpaceItem aUL(RES_UL_SPACE);
      aUL.SetUpper(static_cast<sal_uInt16>(nSize));
      aUL.SetLower(static_cast<sal_uInt16>(nSize));
      pPageFormat->SetFormatAttr(aLR);
      pPageFormat->SetFormatAttr(aUL);
      SwPageDesc* pStdPgDsc = m_pDoc->getIDocumentStylePoolAccess().GetPageDescFromPool(RES_POOLPAGE_STANDARD);
      std::shared_ptr<SwFormatFrameSize> aFrameSz(std::make_shared<SwFormatFrameSize>(SwFrameSize::Fixed));

      if(RES_POOLPAGE_STANDARD == rPageDesc.GetPoolFormatId())
      {
          if(m_pDoc->getIDocumentDeviceAccess().getPrinter(false))
          {
              const Size aPhysSize( SvxPaperInfo::GetPaperSize(
                  static_cast<Printer*>(m_pDoc->getIDocumentDeviceAccess().getPrinter(false))));
              aFrameSz->SetSize(aPhysSize);
          }
          else
          {
              aFrameSz->SetSize(SvxPaperInfo::GetDefaultPaperSize());
          }

      }
      else
      {
          aFrameSz.reset(pStdPgDsc->GetMaster().GetFrameSize().Clone());
      }

      if(pStdPgDsc->GetLandscape())
      {
          SwTwips nTmp = aFrameSz->GetHeight();
          aFrameSz->SetHeight(aFrameSz->GetWidth());
          aFrameSz->SetWidth(nTmp);
      }

      pPageFormat->SetFormatAttr(*aFrameSz);
      m_pDoc->ChgPageDesc(nPgDscPos, m_pDoc->GetPageDesc(nPgDscPos));
      return;
  }
  if(SfxStyleFamily::Para == m_rEntry.m_eFamily)
  {
      if(xStyle->GetCollection())
          xStyle->GetCollection()->DeleteAssignmentToListLevelOfOutlineStyle();
  }
  SwFormat* const pTargetFormat = lcl_GetFormatForStyle(m_pDoc, xStyle, m_rEntry.m_eFamily);
  if(!pTargetFormat)
      return;
  pTargetFormat->ResetAllFormatAttr();
2742}

2744uno::Sequence<uno::Any> SAL_CALL SwXStyle::getPropertyDefaults(const uno::Sequence<OUString>& aPropertyNames)
2745{
  SolarMutexGuard aGuard;
  sal_Int32 nCount = aPropertyNames.getLength();
  uno::Sequence<uno::Any> aRet(nCount);
  if(!nCount)
      return aRet;
  SfxStyleSheetBase* pBase = GetStyleSheetBase();
  if(!pBase)
      throw uno::RuntimeException();
  rtl::Reference<SwDocStyleSheet> xStyle(new SwDocStyleSheet(*static_cast<SwDocStyleSheet*>(pBase)));
  const sal_Int8 nPropSetId = m_bIsConditional ? PROPERTY_MAP_CONDITIONAL_PARA_STYLE93 : m_rEntry.m_nPropMapType;
  const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(nPropSetId);
  const SfxItemPropertyMap& rMap = pPropSet->getPropertyMap();

  const SfxItemSet &rSet = xStyle->GetItemSet(), *pParentSet = rSet.GetParent();
  for(sal_Int32 i = 0; i < nCount; ++i)
  {
      const SfxItemPropertySimpleEntry* pEntry = rMap.getByName(aPropertyNames[i]);

      if(!pEntry)
          throw beans::UnknownPropertyException("Unknown property: " + aPropertyNames[i], static_cast < cppu::OWeakObject * >(this));
      // these cannot be in an item set, especially not the
      // parent set, so the default value is void
      if (pEntry->nWID >= RES_UNKNOWNATR_END)
          continue;

      if(pParentSet)
      {
          aSwMapProvider.GetPropertySet(nPropSetId)->getPropertyValue(aPropertyNames[i], *pParentSet, aRet[i]);
      }
      else if(pEntry->nWID != rSet.GetPool()->GetSlotId(pEntry->nWID))
      {
          const SfxPoolItem& rItem = rSet.GetPool()->GetDefaultItem(pEntry->nWID);
          rItem.QueryValue(aRet[i], pEntry->nMemberId);
      }
  }
  return aRet;
2782}

2784uno::Any SwXStyle::getPropertyDefault(const OUString& rPropertyName)
2785{
  const uno::Sequence<OUString> aSequence(&rPropertyName, 1);
  return getPropertyDefaults(aSequence)[0];
2788}

2790void SwXStyle::Notify(SfxBroadcaster& rBC, const SfxHint& rHint)
2791{
  if((rHint.GetId() == SfxHintId::Dying) || (rHint.GetId() == SfxHintId::StyleSheetErased))
  {
      m_pBasePool = nullptr;
      SfxListener::EndListening(rBC);
  }
  else if(rHint.GetId() == SfxHintId::StyleSheetChanged)
  {
      SfxStyleSheetBasePool& rBP = static_cast<SfxStyleSheetBasePool&>(rBC);
      SfxStyleSheetBase* pOwnBase = rBP.Find(m_sStyleName, m_rEntry.m_eFamily);
      if(!pOwnBase)
      {
          SfxListener::EndListening(rBC);
          Invalidate();
      }
  }
2807}

2809void SwXStyle::Invalidate()
2810{
  m_sStyleName.clear();
  m_pBasePool = nullptr;
  m_pDoc = nullptr;
  m_xStyleData.clear();
  m_xStyleFamily.clear();
2816}

2818SwXPageStyle::SwXPageStyle(SfxStyleSheetBasePool& rPool, SwDocShell* pDocSh, const OUString& rStyleName)
  : SwXStyle(&rPool, SfxStyleFamily::Page, pDocSh->GetDoc(), rStyleName)
2820{ }

2822SwXPageStyle::SwXPageStyle(SwDocShell* pDocSh)
  : SwXStyle(pDocSh->GetDoc(), SfxStyleFamily::Page)
2824{ }

2826void SwXStyle::PutItemToSet(const SvxSetItem* pSetItem, const SfxItemPropertySet& rPropSet, const SfxItemPropertySimpleEntry& rEntry, const uno::Any& rVal, SwStyleBase_Impl& rBaseImpl)
2827{
  // create a new SvxSetItem and get it's ItemSet as new target
  const std::unique_ptr<SvxSetItem> pNewSetItem(pSetItem->Clone());
  SfxItemSet& rSetSet = pNewSetItem->GetItemSet();

  // set parent to ItemSet to ensure XFILL_NONE as XFillStyleItem
  rSetSet.SetParent(&m_pDoc->GetDfltFrameFormat()->GetAttrSet());

  // replace the used SfxItemSet at the SwStyleBase_Impl temporarily and use the
  // default method to set the property
  {
      SwStyleBase_Impl::ItemSetOverrider o(rBaseImpl, &rSetSet);
      SetStyleProperty(rEntry, rPropSet, rVal, rBaseImpl);
  }

  // reset parent at ItemSet from SetItem
  rSetSet.SetParent(nullptr);

  // set the new SvxSetItem at the real target and delete it
  rBaseImpl.GetItemSet().Put(*pNewSetItem);
2847}

2849void SwXPageStyle::SetPropertyValues_Impl(const uno::Sequence<OUString>& rPropertyNames, const uno::Sequence<uno::Any>& rValues)
2850{
  if(!GetDoc())
      throw uno::RuntimeException();

  if(rPropertyNames.getLength() != rValues.getLength())
      throw lang::IllegalArgumentException();

  const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(PROPERTY_MAP_PAGE_STYLE4);
  const SfxItemPropertyMap& rMap = pPropSet->getPropertyMap();
  SwStyleBase_Impl aBaseImpl(*GetDoc(), GetStyleName(), &GetDoc()->GetDfltFrameFormat()->GetAttrSet()); // add pDfltFrameFormat as parent
  if(!m_pBasePool)
  {
      if(!IsDescriptor())
          throw uno::RuntimeException();
      for(sal_Int32 nProp = 0; nProp < rPropertyNames.getLength(); ++nProp)
          if(!m_pPropertiesImpl->SetProperty(rPropertyNames[nProp], rValues[nProp]))
              throw lang::IllegalArgumentException();
      return;
  }
  SfxStyleSheetBase* pBase = GetStyleSheetBase();
  if(!pBase)
      throw uno::RuntimeException();
  aBaseImpl.setNewBase(new SwDocStyleSheet(*static_cast<SwDocStyleSheet*>(pBase)));
  for(sal_Int32 nProp = 0; nProp < rPropertyNames.getLength(); ++nProp)
  {
      const OUString& rPropName = rPropertyNames[nProp];
      const SfxItemPropertySimpleEntry* pEntry = rMap.getByName(rPropName);

      if(!pEntry)
          throw beans::UnknownPropertyException("Unknown property: " + rPropName, static_cast<cppu::OWeakObject*>(this));
      if(pEntry->nFlags & beans::PropertyAttribute::READONLY)
          throw beans::PropertyVetoException("Property is read-only: " + rPropName, static_cast<cppu::OWeakObject*>(this));

      const bool bHeader(rPropName.startsWith("Header"));
      const bool bFooter(rPropName.startsWith("Footer"));
      const bool bFirstIsShared(rPropName == UNO_NAME_FIRST_IS_SHARED"FirstIsShared");
      if(bHeader || bFooter || bFirstIsShared)
      {
          switch(pEntry->nWID)
          {
              case SID_ATTR_PAGE_ONTypedWhichId<SfxBoolItem>( 10000 + 59 ):
              case RES_BACKGROUND:
              case RES_BOX:
              case RES_LR_SPACE:
              case RES_SHADOW:
              case RES_UL_SPACE:
              case SID_ATTR_PAGE_DYNAMICTypedWhichId<SfxBoolItem>( 10000 + 60 ):
              case SID_ATTR_PAGE_SHAREDTypedWhichId<SfxBoolItem>( 10000 + 61 ):
              case SID_ATTR_PAGE_SHARED_FIRST( 10000 + 1114 ):
              case SID_ATTR_PAGE_SIZETypedWhichId<SvxSizeItem>( 10000 + 51 ):
              case RES_HEADER_FOOTER_EAT_SPACING:
              {
                  // it is a Header/Footer entry, access the SvxSetItem containing it's information
                  const SvxSetItem* pSetItem = nullptr;
                  if (lcl_GetHeaderFooterItem(aBaseImpl.GetItemSet(), rPropName, bFooter, pSetItem))
                  {
                      PutItemToSet(pSetItem, *pPropSet, *pEntry, rValues[nProp], aBaseImpl);

                      if (pEntry->nWID == SID_ATTR_PAGE_SHARED_FIRST( 10000 + 1114 ))
                      {
                          // Need to add this to the other as well
                          if (SfxItemState::SET == aBaseImpl.GetItemSet().GetItemState(
                                      bFooter ? SID_ATTR_PAGE_HEADERSETTypedWhichId<SvxSetItem>( 10000 + 57 ) : SID_ATTR_PAGE_FOOTERSETTypedWhichId<SvxSetItem>( 10000 + 58 ),
                                      false, reinterpret_cast<const SfxPoolItem**>(&pSetItem)))
                          {
                              PutItemToSet(pSetItem, *pPropSet, *pEntry, rValues[nProp], aBaseImpl);
                          }
                      }
                  }
                  else if(pEntry->nWID == SID_ATTR_PAGE_ONTypedWhichId<SfxBoolItem>( 10000 + 59 ) && rValues[nProp].get<bool>())
                  {
                      // Header/footer gets switched on, create defaults and the needed SfxSetItem
                      SfxItemSet aTempSet(*aBaseImpl.GetItemSet().GetPool(),
                          svl::Items<RES_FRMATR_BEGIN,RES_FRMATR_END - 1,            // [82

                          // FillAttribute support
                          XATTR_FILL_FIRST, XATTR_FILL_LAST,              // [1014

                          SID_ATTR_BORDER_INNERTypedWhichId<SvxBoxInfoItem>( 10000 + 23 ),SID_ATTR_BORDER_INNERTypedWhichId<SvxBoxInfoItem>( 10000 + 23 ),    // [10023
                          SID_ATTR_PAGE_SIZETypedWhichId<SvxSizeItem>( 10000 + 51 ),SID_ATTR_PAGE_SIZETypedWhichId<SvxSizeItem>( 10000 + 51 ),          // [10051
                          SID_ATTR_PAGE_ONTypedWhichId<SfxBoolItem>( 10000 + 59 ),SID_ATTR_PAGE_SHAREDTypedWhichId<SfxBoolItem>( 10000 + 61 ),          // [10060
                          SID_ATTR_PAGE_SHARED_FIRST( 10000 + 1114 ),SID_ATTR_PAGE_SHARED_FIRST( 10000 + 1114 )>{});

                      // set correct parent to get the XFILL_NONE FillStyle as needed
                      aTempSet.SetParent(&GetDoc()->GetDfltFrameFormat()->GetAttrSet());

                      aTempSet.Put(SfxBoolItem(SID_ATTR_PAGE_ONTypedWhichId<SfxBoolItem>( 10000 + 59 ), true));
                      aTempSet.Put(SvxSizeItem(SID_ATTR_PAGE_SIZETypedWhichId<SvxSizeItem>( 10000 + 51 ), Size(MM50283, MM50283)));
                      aTempSet.Put(SvxLRSpaceItem(RES_LR_SPACE));
                      aTempSet.Put(SvxULSpaceItem(RES_UL_SPACE));
                      aTempSet.Put(SfxBoolItem(SID_ATTR_PAGE_SHAREDTypedWhichId<SfxBoolItem>( 10000 + 61 ), true));
                      aTempSet.Put(SfxBoolItem(SID_ATTR_PAGE_SHARED_FIRST( 10000 + 1114 ), true));
                      aTempSet.Put(SfxBoolItem(SID_ATTR_PAGE_DYNAMICTypedWhichId<SfxBoolItem>( 10000 + 60 ), true));

                      SvxSetItem aNewSetItem(bFooter ? SID_ATTR_PAGE_FOOTERSETTypedWhichId<SvxSetItem>( 10000 + 58 ) : SID_ATTR_PAGE_HEADERSETTypedWhichId<SvxSetItem>( 10000 + 57 ), aTempSet);
                      aBaseImpl.GetItemSet().Put(aNewSetItem);
                  }
              }
              continue;
              case XATTR_FILLBMP_SIZELOG:
              case XATTR_FILLBMP_TILEOFFSETX:
              case XATTR_FILLBMP_TILEOFFSETY:
              case XATTR_FILLBMP_POSOFFSETX:
              case XATTR_FILLBMP_POSOFFSETY:
              case XATTR_FILLBMP_POS:
              case XATTR_FILLBMP_SIZEX:
              case XATTR_FILLBMP_SIZEY:
              case XATTR_FILLBMP_STRETCH:
              case XATTR_FILLBMP_TILE:
              case OWN_ATTR_FILLBMP_MODE(3900 +45):
              case XATTR_FILLCOLOR:
              case XATTR_FILLBACKGROUND:
              case XATTR_FILLBITMAP:
              case XATTR_GRADIENTSTEPCOUNT:
              case XATTR_FILLGRADIENT:
              case XATTR_FILLHATCH:
              case XATTR_FILLSTYLE:
              case XATTR_FILLTRANSPARENCE:
              case XATTR_FILLFLOATTRANSPARENCE:
              case XATTR_SECONDARYFILLCOLOR:
              if(bFirstIsShared) // only special handling for headers/footers here
                  break;
              {
                  const SvxSetItem* pSetItem = nullptr;

                  if(SfxItemState::SET == aBaseImpl.GetItemSet().GetItemState(bFooter ? SID_ATTR_PAGE_FOOTERSETTypedWhichId<SvxSetItem>( 10000 + 58 ) : SID_ATTR_PAGE_HEADERSETTypedWhichId<SvxSetItem>( 10000 + 57 ), false, reinterpret_cast<const SfxPoolItem**>(&pSetItem)))
                  {
                      // create a new SvxSetItem and get it's ItemSet as new target
                      std::unique_ptr<SvxSetItem> pNewSetItem(pSetItem->Clone());
                      SfxItemSet& rSetSet = pNewSetItem->GetItemSet();

                      // set parent to ItemSet to ensure XFILL_NONE as XFillStyleItem
                      rSetSet.SetParent(&GetDoc()->GetDfltFrameFormat()->GetAttrSet());

                      // replace the used SfxItemSet at the SwStyleBase_Impl temporarily and use the
                      // default method to set the property
                      {
                          SwStyleBase_Impl::ItemSetOverrider o(aBaseImpl, &rSetSet);
                          SetStyleProperty(*pEntry, *pPropSet, rValues[nProp], aBaseImpl);
                      }

                      // reset paret at ItemSet from SetItem
                      rSetSet.SetParent(nullptr);

                      // set the new SvxSetItem at the real target and delete it
                      aBaseImpl.GetItemSet().Put(*pNewSetItem);
                  }
              }
              continue;
              default: ;
          }
      }
      switch(pEntry->nWID)
      {
          case SID_ATTR_PAGE_DYNAMICTypedWhichId<SfxBoolItem>( 10000 + 60 ):
          case SID_ATTR_PAGE_SHAREDTypedWhichId<SfxBoolItem>( 10000 + 61 ):
          case SID_ATTR_PAGE_SHARED_FIRST( 10000 + 1114 ):
          case SID_ATTR_PAGE_ONTypedWhichId<SfxBoolItem>( 10000 + 59 ):
          case RES_HEADER_FOOTER_EAT_SPACING:
              // these slots are exclusive to Header/Footer, thus this is an error
              throw beans::UnknownPropertyException("Unknown property: " + rPropName, static_cast<cppu::OWeakObject*>(this));
          case FN_UNO_HEADER((20000 + 2200) + 35):
          case FN_UNO_HEADER_LEFT((20000 + 2200) + 36):
          case FN_UNO_HEADER_RIGHT((20000 + 2200) + 37):
          case FN_UNO_HEADER_FIRST((20000 + 2200) + 118):
          case FN_UNO_FOOTER((20000 + 2200) + 38):
          case FN_UNO_FOOTER_LEFT((20000 + 2200) + 39):
          case FN_UNO_FOOTER_RIGHT((20000 + 2200) + 40):
          case FN_UNO_FOOTER_FIRST((20000 + 2200) + 119):
              throw lang::IllegalArgumentException();
          case FN_PARAM_FTN_INFO((20000 + 1100)+23):
          {
              const SfxPoolItem& rItem = aBaseImpl.GetItemSet().Get(FN_PARAM_FTN_INFO((20000 + 1100)+23));
              std::unique_ptr<SfxPoolItem> pNewFootnoteItem(rItem.Clone());
              if(!pNewFootnoteItem->PutValue(rValues[nProp], pEntry->nMemberId))
                  throw lang::IllegalArgumentException();
              aBaseImpl.GetItemSet().Put(std::move(pNewFootnoteItem));
              break;
          }
          default:
          {
              SetStyleProperty(*pEntry, *pPropSet, rValues[nProp], aBaseImpl);
              break;
          }
      }
  }

  if(aBaseImpl.HasItemSet())
  {
      ::sw::UndoGuard const undoGuard(GetDoc()->GetIDocumentUndoRedo());

      if (undoGuard.UndoWasEnabled())
      {
          // Fix i64460: as long as Undo of page styles with header/footer causes trouble...
          GetDoc()->GetIDocumentUndoRedo().DelAllUndoObj();
      }

      aBaseImpl.getNewBase()->SetItemSet(aBaseImpl.GetItemSet());
  }
3049}

3051void SwXPageStyle::setPropertyValues(const uno::Sequence<OUString>& rPropertyNames, const uno::Sequence<uno::Any>& rValues)
3052{
  SolarMutexGuard aGuard;

  // workaround for bad designed API
  try
  {
      SetPropertyValues_Impl(rPropertyNames, rValues);
  }
  catch (const beans::UnknownPropertyException &rException)
  {
      // wrap the original (here not allowed) exception in
      // a lang::WrappedTargetException that gets thrown instead.
      lang::WrappedTargetException aWExc;
      aWExc.TargetException <<= rException;
      throw aWExc;
  }
3068}

3070static uno::Reference<text::XText> lcl_makeHeaderFooter(const sal_uInt16 nRes, const bool bHeader, SwFrameFormat const*const pFrameFormat)
3071{
  if (!pFrameFormat)
      return nullptr;
  const SfxItemSet& rSet = pFrameFormat->GetAttrSet();
  const SfxPoolItem* pItem;
  if(SfxItemState::SET != rSet.GetItemState(nRes, true, &pItem))
      return nullptr;
  SwFrameFormat* const pHeadFootFormat = bHeader
      ? static_cast<SwFormatHeader*>(const_cast<SfxPoolItem*>(pItem))->GetHeaderFormat()
      : static_cast<SwFormatFooter*>(const_cast<SfxPoolItem*>(pItem))->GetFooterFormat();
  if(!pHeadFootFormat)
      return nullptr;
  return SwXHeadFootText::CreateXHeadFootText(*pHeadFootFormat, bHeader);
3084}

3086uno::Sequence<uno::Any> SwXPageStyle::GetPropertyValues_Impl(const uno::Sequence<OUString>& rPropertyNames)
3087{
  if(!GetDoc())
1
Assuming the condition is false→
2
←
Taking false branch→
      throw uno::RuntimeException();

  sal_Int32 nLength = rPropertyNames.getLength();
  uno::Sequence<uno::Any> aRet (nLength);
  if(!m_pBasePool)
3
←
Assuming field 'm_pBasePool' is null→
4
←
Taking true branch→
  {
      if(!IsDescriptor())
5
←
Assuming the condition is false→
6
←
Taking false branch→
          throw uno::RuntimeException();
      for(sal_Int32 nProp = 0; nProp < rPropertyNames.getLength(); ++nProp)
7
←
Assuming the condition is true→
8
←
Loop condition is true.  Entering loop body→
      {
          const uno::Any* pAny = nullptr;
          m_pPropertiesImpl->GetProperty(rPropertyNames[nProp], pAny);
9
←
Calling 'SwStyleProperties_Impl::GetProperty'→
25
←
Returning from 'SwStyleProperties_Impl::GetProperty'→
          if (!pAny->hasValue())
26
←
Called C++ object pointer is null
              SwStyleProperties_Impl::GetProperty(rPropertyNames[nProp], m_xStyleData, aRet[nProp]);
          else
              aRet[nProp] = *pAny;
      }
      return aRet;
  }
  const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(PROPERTY_MAP_PAGE_STYLE4);
  const SfxItemPropertyMap& rMap = pPropSet->getPropertyMap();
  SwStyleBase_Impl aBase(*GetDoc(), GetStyleName(), &GetDoc()->GetDfltFrameFormat()->GetAttrSet()); // add pDfltFrameFormat as parent
  SfxStyleSheetBase* pBase = GetStyleSheetBase();
  if(!pBase)
      throw uno::RuntimeException();
  for(sal_Int32 nProp = 0; nProp < nLength; ++nProp)
  {
      const OUString& rPropName = rPropertyNames[nProp];
      const SfxItemPropertySimpleEntry* pEntry = rMap.getByName(rPropName);

      if (!pEntry)
          throw beans::UnknownPropertyException("Unknown property: " + rPropName, static_cast < cppu::OWeakObject * > ( this ) );
      const bool bHeader(rPropName.startsWith("Header"));
      const bool bFooter(rPropName.startsWith("Footer"));
      const bool bFirstIsShared(rPropName == UNO_NAME_FIRST_IS_SHARED"FirstIsShared");
      if(bHeader || bFooter || bFirstIsShared)
      {
          switch(pEntry->nWID)
          {
              case SID_ATTR_PAGE_ONTypedWhichId<SfxBoolItem>( 10000 + 59 ):
              case RES_BACKGROUND:
              case RES_BOX:
              case RES_LR_SPACE:
              case RES_SHADOW:
              case RES_UL_SPACE:
              case SID_ATTR_PAGE_DYNAMICTypedWhichId<SfxBoolItem>( 10000 + 60 ):
              case SID_ATTR_PAGE_SHAREDTypedWhichId<SfxBoolItem>( 10000 + 61 ):
              case SID_ATTR_PAGE_SHARED_FIRST( 10000 + 1114 ):
              case SID_ATTR_PAGE_SIZETypedWhichId<SvxSizeItem>( 10000 + 51 ):
              case RES_HEADER_FOOTER_EAT_SPACING:
              {
                  // slot is a Header/Footer slot
                  rtl::Reference< SwDocStyleSheet > xStyle( new SwDocStyleSheet( *static_cast<SwDocStyleSheet*>(pBase) ) );
                  const SfxItemSet& rSet = xStyle->GetItemSet();
                  const SvxSetItem* pSetItem;

                  if (lcl_GetHeaderFooterItem(rSet, rPropName, bFooter, pSetItem))
                  {
                      // get from SfxItemSet of the corresponding SfxSetItem
                      const SfxItemSet& rSetSet = pSetItem->GetItemSet();
                      {
                          SwStyleBase_Impl::ItemSetOverrider o(aBase, &const_cast< SfxItemSet& >(rSetSet));
                          aRet[nProp] = GetStyleProperty_Impl(*pEntry, *pPropSet, aBase);
                      }
                  }
                  else if(pEntry->nWID == SID_ATTR_PAGE_ONTypedWhichId<SfxBoolItem>( 10000 + 59 ))
                  {
                      // header/footer is not available, thus off. Default is <false>, though
                      aRet[nProp] <<= false;
                  }
              }
              continue;
              case XATTR_FILLBMP_SIZELOG:
              case XATTR_FILLBMP_TILEOFFSETX:
              case XATTR_FILLBMP_TILEOFFSETY:
              case XATTR_FILLBMP_POSOFFSETX:
              case XATTR_FILLBMP_POSOFFSETY:
              case XATTR_FILLBMP_POS:
              case XATTR_FILLBMP_SIZEX:
              case XATTR_FILLBMP_SIZEY:
              case XATTR_FILLBMP_STRETCH:
              case XATTR_FILLBMP_TILE:
              case OWN_ATTR_FILLBMP_MODE(3900 +45):
              case XATTR_FILLCOLOR:
              case XATTR_FILLBACKGROUND:
              case XATTR_FILLBITMAP:
              case XATTR_GRADIENTSTEPCOUNT:
              case XATTR_FILLGRADIENT:
              case XATTR_FILLHATCH:
              case XATTR_FILLSTYLE:
              case XATTR_FILLTRANSPARENCE:
              case XATTR_FILLFLOATTRANSPARENCE:
              case XATTR_SECONDARYFILLCOLOR:
              if(bFirstIsShared) // only special handling for headers/footers here
                  break;
              {
                  rtl::Reference< SwDocStyleSheet > xStyle( new SwDocStyleSheet( *static_cast<SwDocStyleSheet*>(pBase) ) );
                  const SfxItemSet& rSet = xStyle->GetItemSet();
                  const SvxSetItem* pSetItem;
                  if(SfxItemState::SET == rSet.GetItemState(bFooter ? SID_ATTR_PAGE_FOOTERSETTypedWhichId<SvxSetItem>( 10000 + 58 ) : SID_ATTR_PAGE_HEADERSETTypedWhichId<SvxSetItem>( 10000 + 57 ), false, reinterpret_cast<const SfxPoolItem**>(&pSetItem)))
                  {
                      // set at SfxItemSet of the corresponding SfxSetItem
                      const SfxItemSet& rSetSet = pSetItem->GetItemSet();
                      {
                          SwStyleBase_Impl::ItemSetOverrider o(aBase, &const_cast<SfxItemSet&>(rSetSet));
                          aRet[nProp] = GetStyleProperty_Impl(*pEntry, *pPropSet, aBase);
                      }
                  }
              }
              continue;
              default: ;
          }
      }
      switch(pEntry->nWID)
      {
          // these slots are exclusive to Header/Footer, thus this is an error
          case SID_ATTR_PAGE_DYNAMICTypedWhichId<SfxBoolItem>( 10000 + 60 ):
          case SID_ATTR_PAGE_SHAREDTypedWhichId<SfxBoolItem>( 10000 + 61 ):
          case SID_ATTR_PAGE_SHARED_FIRST( 10000 + 1114 ):
          case SID_ATTR_PAGE_ONTypedWhichId<SfxBoolItem>( 10000 + 59 ):
          case RES_HEADER_FOOTER_EAT_SPACING:
              throw beans::UnknownPropertyException( "Unknown property: " + rPropName, static_cast < cppu::OWeakObject * > ( this ) );
          case FN_UNO_HEADER((20000 + 2200) + 35):
          case FN_UNO_HEADER_LEFT((20000 + 2200) + 36):
          case FN_UNO_HEADER_FIRST((20000 + 2200) + 118):
          case FN_UNO_HEADER_RIGHT((20000 + 2200) + 37):
          case FN_UNO_FOOTER((20000 + 2200) + 38):
          case FN_UNO_FOOTER_LEFT((20000 + 2200) + 39):
          case FN_UNO_FOOTER_FIRST((20000 + 2200) + 119):
          case FN_UNO_FOOTER_RIGHT((20000 + 2200) + 40):
          {
              bool bLeft(false);
              bool bFirst(false);
              sal_uInt16 nRes = 0;
              switch(pEntry->nWID)
              {
                  case FN_UNO_HEADER((20000 + 2200) + 35):       nRes = RES_HEADER; break;
                  case FN_UNO_HEADER_LEFT((20000 + 2200) + 36):  nRes = RES_HEADER; bLeft = true;  break;
                  case FN_UNO_HEADER_FIRST((20000 + 2200) + 118): nRes = RES_HEADER; bFirst = true; break;
                  case FN_UNO_HEADER_RIGHT((20000 + 2200) + 37): nRes = RES_HEADER; break;
                  case FN_UNO_FOOTER((20000 + 2200) + 38):       nRes = RES_FOOTER; break;
                  case FN_UNO_FOOTER_LEFT((20000 + 2200) + 39):  nRes = RES_FOOTER; bLeft = true;  break;
                  case FN_UNO_FOOTER_FIRST((20000 + 2200) + 119): nRes = RES_FOOTER; bFirst = true; break;
                  case FN_UNO_FOOTER_RIGHT((20000 + 2200) + 40): nRes = RES_FOOTER; break;
                  default: ;
              }

              const SwPageDesc* pDesc = aBase.GetOldPageDesc();
              assert(pDesc)(static_cast <bool> (pDesc) ? void (0) : __assert_fail (
"pDesc", "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
, 3237, __extension__ __PRETTY_FUNCTION__));
              const SwFrameFormat* pFrameFormat = nullptr;
              bool bShare = (nRes == RES_HEADER && pDesc->IsHeaderShared()) || (nRes == RES_FOOTER && pDesc->IsFooterShared());
              bool bShareFirst = pDesc->IsFirstShared();
              // TextLeft returns the left content if there is one,
              // Text and TextRight return the master content.
              // TextRight does the same as Text and is for
              // compatibility only.
              if(bLeft && !bShare)
                  pFrameFormat = &pDesc->GetLeft();
              else if(bFirst && !bShareFirst)
              {
                  pFrameFormat = &pDesc->GetFirstMaster();
                  // no need to make GetFirstLeft() accessible
                  // since it is always shared
              }
              else
                  pFrameFormat = &pDesc->GetMaster();
              const uno::Reference<text::XText> xRet = lcl_makeHeaderFooter(nRes, nRes == RES_HEADER, pFrameFormat);
              if (xRet.is())
                  aRet[nProp] <<= xRet;
          }
          break;
          case FN_PARAM_FTN_INFO((20000 + 1100)+23):
          {
              rtl::Reference<SwDocStyleSheet> xStyle(new SwDocStyleSheet(*static_cast<SwDocStyleSheet*>(pBase)));
              const SfxItemSet& rSet = xStyle->GetItemSet();
              const SfxPoolItem& rItem = rSet.Get(FN_PARAM_FTN_INFO((20000 + 1100)+23));
              rItem.QueryValue(aRet[nProp], pEntry->nMemberId);
          }
          break;
          default:
              aRet[nProp] = GetStyleProperty_Impl(*pEntry, *pPropSet, aBase);
      }
  }
  return aRet;
3273}

3275uno::Sequence<uno::Any> SwXPageStyle::getPropertyValues(const uno::Sequence<OUString>& rPropertyNames)
3276{
  SolarMutexGuard aGuard;
  uno::Sequence<uno::Any> aValues;

  // workaround for bad designed API
  try
  {
      aValues = GetPropertyValues_Impl(rPropertyNames);
  }
  catch(beans::UnknownPropertyException &)
  {
      css::uno::Any anyEx = cppu::getCaughtException();
      throw lang::WrappedTargetRuntimeException("Unknown property exception caught",
              static_cast < cppu::OWeakObject * > ( this ), anyEx );
  }
  catch(lang::WrappedTargetException &)
  {
      css::uno::Any anyEx = cppu::getCaughtException();
      throw lang::WrappedTargetRuntimeException("WrappedTargetException caught",
              static_cast < cppu::OWeakObject * > ( this ), anyEx );
  }

  return aValues;
3299}

3301uno::Any SwXPageStyle::getPropertyValue(const OUString& rPropertyName)
3302{
  SolarMutexGuard aGuard;
  const uno::Sequence<OUString> aProperties(&rPropertyName, 1);
  return GetPropertyValues_Impl(aProperties)[0];
3306}

3308void SwXPageStyle::setPropertyValue(const OUString& rPropertyName, const uno::Any& rValue)
3309{
  SolarMutexGuard aGuard;
  const uno::Sequence<OUString> aProperties(&rPropertyName, 1);
  const uno::Sequence<uno::Any> aValues(&rValue, 1);
  SetPropertyValues_Impl(aProperties, aValues);
3314}

3316SwXFrameStyle::SwXFrameStyle(SwDoc *pDoc)
  : SwXStyle(pDoc, SfxStyleFamily::Frame, false)
3318{ }

3320void SwXFrameStyle::SetItem(sal_uInt16 eAtr, const SfxPoolItem& rItem)
3321{
  assert(eAtr >= RES_FRMATR_BEGIN && eAtr < RES_FRMATR_END)(static_cast <bool> (eAtr >= RES_FRMATR_BEGIN &&
 eAtr < RES_FRMATR_END) ? void (0) : __assert_fail ("eAtr >= RES_FRMATR_BEGIN && eAtr < RES_FRMATR_END"
, "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
, 3322, __extension__ __PRETTY_FUNCTION__));
  SfxStyleSheetBase* pBase = GetStyleSheetBase();
  if(!pBase)
      return;
  rtl::Reference<SwDocStyleSheet> xStyle(new SwDocStyleSheet(*static_cast<SwDocStyleSheet*>(pBase)));
  SfxItemSet& rStyleSet = xStyle->GetItemSet();
  SfxItemSet aSet(*rStyleSet.GetPool(), {{sal_uInt16(eAtr), sal_uInt16(eAtr)}});
  aSet.Put(rItem);
  xStyle->SetItemSet(aSet);
3331}

3333const SfxPoolItem* SwXFrameStyle::GetItem(sal_uInt16 eAtr)
3334{
  assert(eAtr >= RES_FRMATR_BEGIN && eAtr < RES_FRMATR_END)(static_cast <bool> (eAtr >= RES_FRMATR_BEGIN &&
 eAtr < RES_FRMATR_END) ? void (0) : __assert_fail ("eAtr >= RES_FRMATR_BEGIN && eAtr < RES_FRMATR_END"
, "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
, 3335, __extension__ __PRETTY_FUNCTION__));
  SfxStyleSheetBase* pBase = GetStyleSheetBase();
  if(!pBase)
      return nullptr;
  rtl::Reference<SwDocStyleSheet> xStyle(new SwDocStyleSheet(*static_cast<SwDocStyleSheet*>(pBase)));
  return &xStyle->GetItemSet().Get(eAtr);
3341}

3343uno::Sequence<uno::Type> SwXFrameStyle::getTypes()
3344{
  return cppu::OTypeCollection(
          cppu::UnoType<XEventsSupplier>::get(),
          SwXStyle::getTypes()
      ).getTypes();
3349}

3351uno::Any SwXFrameStyle::queryInterface(const uno::Type& rType)
3352{
  if(rType == cppu::UnoType<XEventsSupplier>::get())
      return uno::makeAny(uno::Reference<XEventsSupplier>(this));
  return SwXStyle::queryInterface(rType);
3356}

3358uno::Reference<container::XNameReplace> SwXFrameStyle::getEvents()
3359{
  return new SwFrameStyleEventDescriptor(*this);
3361}

3363// Already implemented autostyle families: 3
3364#define AUTOSTYLE_FAMILY_COUNT3 3
3365const IStyleAccess::SwAutoStyleFamily aAutoStyleByIndex[] =
3366{
  IStyleAccess::AUTO_STYLE_CHAR,
  IStyleAccess::AUTO_STYLE_RUBY,
  IStyleAccess::AUTO_STYLE_PARA
3370};

3372class SwAutoStylesEnumImpl
3373{
  std::vector<std::shared_ptr<SfxItemSet>> mAutoStyles;
  std::vector<std::shared_ptr<SfxItemSet>>::iterator aIter;
  SwDoc& rDoc;
  IStyleAccess::SwAutoStyleFamily eFamily;
3378public:
  SwAutoStylesEnumImpl( SwDoc& rInitDoc, IStyleAccess::SwAutoStyleFamily eFam );
  bool hasMoreElements() { return aIter != mAutoStyles.end(); }
  std::shared_ptr<SfxItemSet> const & nextElement() { return *(aIter++); }
  IStyleAccess::SwAutoStyleFamily getFamily() const { return eFamily; }
  SwDoc& getDoc() const { return rDoc; }
3384};

3386SwXAutoStyles::SwXAutoStyles(SwDocShell& rDocShell) :
  SwUnoCollection(rDocShell.GetDoc()), m_pDocShell( &rDocShell )
3388{
3389}

3391SwXAutoStyles::~SwXAutoStyles()
3392{
3393}

3395sal_Int32 SwXAutoStyles::getCount()
3396{
  return AUTOSTYLE_FAMILY_COUNT3;
3398}

3400uno::Any SwXAutoStyles::getByIndex(sal_Int32 nIndex)
3401{
  SolarMutexGuard aGuard;
  uno::Any aRet;
  if(nIndex < 0 || nIndex >= AUTOSTYLE_FAMILY_COUNT3)
      throw lang::IndexOutOfBoundsException();
  if(!IsValid())
      throw uno::RuntimeException();

  uno::Reference< style::XAutoStyleFamily >  aRef;
  IStyleAccess::SwAutoStyleFamily nType = aAutoStyleByIndex[nIndex];
  switch( nType )
  {
      case IStyleAccess::AUTO_STYLE_CHAR:
      {
          if(!m_xAutoCharStyles.is())
              m_xAutoCharStyles = new SwXAutoStyleFamily(m_pDocShell, nType);
          aRef = m_xAutoCharStyles;
      }
      break;
      case IStyleAccess::AUTO_STYLE_RUBY:
      {
          if(!m_xAutoRubyStyles.is())
              m_xAutoRubyStyles = new SwXAutoStyleFamily(m_pDocShell, nType );
          aRef = m_xAutoRubyStyles;
      }
      break;
      case IStyleAccess::AUTO_STYLE_PARA:
      {
          if(!m_xAutoParaStyles.is())
              m_xAutoParaStyles = new SwXAutoStyleFamily(m_pDocShell, nType );
          aRef = m_xAutoParaStyles;
      }
      break;

      default:
          ;
  }
  aRet <<= aRef;

  return aRet;
3441}

3443uno::Type SwXAutoStyles::getElementType(  )
3444{
  return cppu::UnoType<style::XAutoStyleFamily>::get();
3446}

3448sal_Bool SwXAutoStyles::hasElements(  )
3449{
  return true;
3451}

3453uno::Any SwXAutoStyles::getByName(const OUString& Name)
3454{
  uno::Any aRet;
  if(Name == "CharacterStyles")
      aRet = getByIndex(0);
  else if(Name == "RubyStyles")
      aRet = getByIndex(1);
  else if(Name == "ParagraphStyles")
      aRet = getByIndex(2);
  else
      throw container::NoSuchElementException();
  return aRet;
3465}

3467uno::Sequence< OUString > SwXAutoStyles::getElementNames()
3468{
  uno::Sequence< OUString > aNames(AUTOSTYLE_FAMILY_COUNT3);
  OUString* pNames = aNames.getArray();
  pNames[0] = "CharacterStyles";
  pNames[1] = "RubyStyles";
  pNames[2] = "ParagraphStyles";
  return aNames;
3475}

3477sal_Bool SwXAutoStyles::hasByName(const OUString& Name)
3478{
  if( Name == "CharacterStyles" ||
      Name == "RubyStyles" ||
      Name == "ParagraphStyles" )
      return true;
  else
      return false;
3485}

3487SwXAutoStyleFamily::SwXAutoStyleFamily(SwDocShell* pDocSh, IStyleAccess::SwAutoStyleFamily nFamily) :
  m_pDocShell( pDocSh ), m_eFamily(nFamily)
3489{
  // Register ourselves as a listener to the document (via the page descriptor)
  StartListening(pDocSh->GetDoc()->getIDocumentStylePoolAccess().GetPageDescFromPool(RES_POOLPAGE_STANDARD)->GetNotifier());
3492}

3494SwXAutoStyleFamily::~SwXAutoStyleFamily()
3495{
3496}

3498void SwXAutoStyleFamily::Notify(const SfxHint& rHint)
3499{
  if(rHint.GetId() == SfxHintId::Dying)
      m_pDocShell = nullptr;
3502}

3504uno::Reference< style::XAutoStyle > SwXAutoStyleFamily::insertStyle(
  const uno::Sequence< beans::PropertyValue >& Values )
3506{
  if (!m_pDocShell)
  {
      throw uno::RuntimeException();
  }

  const sal_uInt16* pRange = nullptr;
  const SfxItemPropertySet* pPropSet = nullptr;
  switch( m_eFamily )
  {
      case IStyleAccess::AUTO_STYLE_CHAR:
      {
          pRange = aCharAutoFormatSetRange;
          pPropSet = aSwMapProvider.GetPropertySet(PROPERTY_MAP_CHAR_AUTO_STYLE94);
          break;
      }
      case IStyleAccess::AUTO_STYLE_RUBY:
      {
          pRange = nullptr;//aTextNodeSetRange;
          pPropSet = aSwMapProvider.GetPropertySet(PROPERTY_MAP_RUBY_AUTO_STYLE95);
          break;
      }
      case IStyleAccess::AUTO_STYLE_PARA:
      {
          pRange = aTextNodeSetRange; // checked, already added support for [XATTR_FILL_FIRST, XATTR_FILL_LAST]
          pPropSet = aSwMapProvider.GetPropertySet(PROPERTY_MAP_PARA_AUTO_STYLE96);
          break;
      }
      default: ;
  }

  if( !pPropSet)
      throw uno::RuntimeException();

  SwAttrSet aSet( m_pDocShell->GetDoc()->GetAttrPool(), pRange );
  const bool bTakeCareOfDrawingLayerFillStyle(IStyleAccess::AUTO_STYLE_PARA == m_eFamily);

  if(!bTakeCareOfDrawingLayerFillStyle)
  {
      for( const beans::PropertyValue& rValue : Values )
      {
          try
          {
              pPropSet->setPropertyValue( rValue.Name, rValue.Value, aSet );
          }
          catch (const beans::UnknownPropertyException &)
          {
              OSL_FAIL( "Unknown property" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "3553" ": "), "%s", "Unknown property"); } } while (false
);
          }
          catch (const lang::IllegalArgumentException &)
          {
              OSL_FAIL( "Illegal argument" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "3557" ": "), "%s", "Illegal argument"); } } while (false
);
          }
      }
  }
  else
  {
      // set parent to ItemSet to ensure XFILL_NONE as XFillStyleItem
      // to make cases in RES_BACKGROUND work correct; target *is* a style
      // where this is the case
      aSet.SetParent(&m_pDocShell->GetDoc()->GetDfltTextFormatColl()->GetAttrSet());

      // here the used DrawingLayer FillStyles are imported when family is
      // equal to IStyleAccess::AUTO_STYLE_PARA, thus we will need to serve the
      // used slots functionality here to do this correctly
      const SfxItemPropertyMap& rMap = pPropSet->getPropertyMap();

      for( const beans::PropertyValue& rValue : Values )
      {
          const OUString& rPropName = rValue.Name;
          uno::Any aValue(rValue.Value);
          const SfxItemPropertySimpleEntry* pEntry = rMap.getByName(rPropName);

          if (!pEntry)
          {
              SAL_WARN("sw.core", "SwXAutoStyleFamily::insertStyle: Unknown property: " << rPropName)do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.core")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "SwXAutoStyleFamily::insertStyle: Unknown property: "
 << rPropName) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.core"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "3581" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "SwXAutoStyleFamily::insertStyle: Unknown property: "
 << rPropName), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "SwXAutoStyleFamily::insertStyle: Unknown property: "
 << rPropName; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.core"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "3581" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "SwXAutoStyleFamily::insertStyle: Unknown property: "
 << rPropName) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.core"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "3581" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "SwXAutoStyleFamily::insertStyle: Unknown property: "
 << rPropName), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "SwXAutoStyleFamily::insertStyle: Unknown property: "
 << rPropName; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.core"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "3581" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
              continue;
          }

          const sal_uInt8 nMemberId(pEntry->nMemberId);
          bool bDone(false);

          // check for needed metric translation
          if(pEntry->nMoreFlags & PropertyMoreFlags::METRIC_ITEM)
          {
              bool bDoIt(true);

              if(XATTR_FILLBMP_SIZEX == pEntry->nWID || XATTR_FILLBMP_SIZEY == pEntry->nWID)
              {
                  // exception: If these ItemTypes are used, do not convert when these are negative
                  // since this means they are intended as percent values
                  sal_Int32 nValue = 0;

                  if(aValue >>= nValue)
                  {
                      bDoIt = nValue > 0;
                  }
              }

              if(bDoIt)
              {
                  const SfxItemPool& rPool = m_pDocShell->GetDoc()->GetAttrPool();
                  const MapUnit eMapUnit(rPool.GetMetric(pEntry->nWID));

                  if(eMapUnit != MapUnit::Map100thMM)
                  {
                      SvxUnoConvertFromMM(eMapUnit, aValue);
                  }
              }
          }

          switch(pEntry->nWID)
          {
              case XATTR_FILLGRADIENT:
              case XATTR_FILLHATCH:
              case XATTR_FILLBITMAP:
              case XATTR_FILLFLOATTRANSPARENCE:
              // not yet needed; activate when LineStyle support may be added
              // case XATTR_LINESTART:
              // case XATTR_LINEEND:
              // case XATTR_LINEDASH:
              {
                  if(MID_NAME16 == nMemberId)
                  {
                      // add set commands for FillName items
                      OUString aTempName;

                      if(!(aValue >>= aTempName))
                      {
                          throw lang::IllegalArgumentException();
                      }

                      SvxShape::SetFillAttribute(pEntry->nWID, aTempName, aSet);
                      bDone = true;
                  }
                  else if (MID_BITMAP8 == nMemberId)
                  {
                      if(XATTR_FILLBITMAP == pEntry->nWID)
                      {
                          const Graphic aNullGraphic;
                          XFillBitmapItem aXFillBitmapItem(aNullGraphic);

                          aXFillBitmapItem.PutValue(aValue, nMemberId);
                          aSet.Put(aXFillBitmapItem);
                          bDone = true;
                      }
                  }

                  break;
              }
              case RES_BACKGROUND:
              {
                  const std::unique_ptr<SvxBrushItem> aOriginalBrushItem(getSvxBrushItemFromSourceSet(aSet, RES_BACKGROUND, true, m_pDocShell->GetDoc()->IsInXMLImport()));
                  std::unique_ptr<SvxBrushItem> aChangedBrushItem(aOriginalBrushItem->Clone());

                  aChangedBrushItem->PutValue(aValue, nMemberId);

                  if(*aChangedBrushItem != *aOriginalBrushItem)
                  {
                      setSvxBrushItemAsFillAttributesToTargetSet(*aChangedBrushItem, aSet);
                  }

                  bDone = true;
                  break;
              }
              case OWN_ATTR_FILLBMP_MODE(3900 +45):
              {
                  drawing::BitmapMode eMode;

                  if(!(aValue >>= eMode))
                  {
                      sal_Int32 nMode = 0;

                      if(!(aValue >>= nMode))
                      {
                          throw lang::IllegalArgumentException();
                      }

                      eMode = static_cast<drawing::BitmapMode>(nMode);
                  }

                  aSet.Put(XFillBmpStretchItem(drawing::BitmapMode_STRETCH == eMode));
                  aSet.Put(XFillBmpTileItem(drawing::BitmapMode_REPEAT == eMode));

                  bDone = true;
                  break;
              }
              default: break;
          }

          if(!bDone)
          {
              try
              {
                  pPropSet->setPropertyValue( rPropName, aValue, aSet );
              }
              catch (const beans::UnknownPropertyException &)
              {
                  OSL_FAIL( "Unknown property" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "3704" ": "), "%s", "Unknown property"); } } while (false
);
              }
              catch (const lang::IllegalArgumentException &)
              {
                  OSL_FAIL( "Illegal argument" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "3708" ": "), "%s", "Illegal argument"); } } while (false
);
              }
          }
       }

      // clear parent again
      aSet.SetParent(nullptr);
  }

  // need to ensure uniqueness of evtl. added NameOrIndex items
  // currently in principle only needed when bTakeCareOfDrawingLayerFillStyle,
  // but does not hurt and is easily forgotten later eventually, so keep it
  // as common case
  m_pDocShell->GetDoc()->CheckForUniqueItemForLineFillNameOrIndex(aSet);

  // AutomaticStyle creation
  std::shared_ptr<SfxItemSet> pSet = m_pDocShell->GetDoc()->GetIStyleAccess().cacheAutomaticStyle( aSet, m_eFamily );
  uno::Reference<style::XAutoStyle> xRet = new SwXAutoStyle(m_pDocShell->GetDoc(), pSet, m_eFamily);

  return xRet;
3728}

3730uno::Reference< container::XEnumeration > SwXAutoStyleFamily::createEnumeration(  )
3731{
  if( !m_pDocShell )
      throw uno::RuntimeException();
  return uno::Reference< container::XEnumeration >
      (new SwXAutoStylesEnumerator( *m_pDocShell->GetDoc(), m_eFamily ));
3736}

3738uno::Type SwXAutoStyleFamily::getElementType(  )
3739{
  return cppu::UnoType<style::XAutoStyle>::get();
3741}

3743sal_Bool SwXAutoStyleFamily::hasElements(  )
3744{
  return false;
3746}

3748SwAutoStylesEnumImpl::SwAutoStylesEnumImpl( SwDoc& rInitDoc, IStyleAccess::SwAutoStyleFamily eFam )
rDoc( rInitDoc ), eFamily( eFam )
3750{
  // special case for ruby auto styles:
  if ( IStyleAccess::AUTO_STYLE_RUBY == eFam )
  {
      std::set< std::pair< sal_uInt16, text::RubyAdjust > > aRubyMap;
      SwAttrPool& rAttrPool = rDoc.GetAttrPool();

      // do this in two phases otherwise we invalidate the iterators when we insert into the pool
      std::vector<const SwFormatRuby*> vRubyItems;
      for (const SfxPoolItem* pItem : rAttrPool.GetItemSurrogates(RES_TXTATR_CJK_RUBY))
      {
          auto pRubyItem = dynamic_cast<const SwFormatRuby*>(pItem);
          if ( pRubyItem && pRubyItem->GetTextRuby() )
              vRubyItems.push_back(pRubyItem);
      }
      for (const SwFormatRuby* pRubyItem : vRubyItems)
      {
          std::pair< sal_uInt16, text::RubyAdjust > aPair( pRubyItem->GetPosition(), pRubyItem->GetAdjustment() );
          if ( aRubyMap.insert( aPair ).second )
          {
              auto pItemSet = std::make_shared<SfxItemSet>( rAttrPool, svl::Items<RES_TXTATR_CJK_RUBY, RES_TXTATR_CJK_RUBY>{} );
              pItemSet->Put( *pRubyItem );
              mAutoStyles.push_back( pItemSet );
          }
      }
  }
  else
  {
      rDoc.GetIStyleAccess().getAllStyles( mAutoStyles, eFamily );
  }

  aIter = mAutoStyles.begin();
3782}

3784SwXAutoStylesEnumerator::SwXAutoStylesEnumerator( SwDoc& rDoc, IStyleAccess::SwAutoStyleFamily eFam )
m_pImpl( new SwAutoStylesEnumImpl( rDoc, eFam ) )
3786{
  // Register ourselves as a listener to the document (via the page descriptor)
  StartListening(rDoc.getIDocumentStylePoolAccess().GetPageDescFromPool(RES_POOLPAGE_STANDARD)->GetNotifier());
3789}

3791SwXAutoStylesEnumerator::~SwXAutoStylesEnumerator()
3792{
3793}

3795void SwXAutoStylesEnumerator::Notify( const SfxHint& rHint)
3796{
  if(rHint.GetId() == SfxHintId::Dying)
      m_pImpl.reset();
3799}

3801sal_Bool SwXAutoStylesEnumerator::hasMoreElements(  )
3802{
  if( !m_pImpl )
      throw uno::RuntimeException();
  return m_pImpl->hasMoreElements();
3806}

3808uno::Any SwXAutoStylesEnumerator::nextElement(  )
3809{
  if( !m_pImpl )
      throw uno::RuntimeException();
  uno::Any aRet;
  if( m_pImpl->hasMoreElements() )
  {
      std::shared_ptr<SfxItemSet> pNextSet = m_pImpl->nextElement();
      uno::Reference< style::XAutoStyle > xAutoStyle = new SwXAutoStyle(&m_pImpl->getDoc(),
                                                      pNextSet, m_pImpl->getFamily());
      aRet <<= xAutoStyle;
  }
  return aRet;
3821}

3823// SwXAutoStyle with the family IStyleAccess::AUTO_STYLE_PARA (or
3824// PROPERTY_MAP_PARA_AUTO_STYLE) now uses DrawingLayer FillStyles to allow
3825// unified paragraph background fill, thus the UNO API implementation has to
3826// support the needed slots for these. This seems to be used only for reading
3827// (no setPropertyValue implementation here), so maybe specialized for saving
3828// the Writer Doc to ODF

3830SwXAutoStyle::SwXAutoStyle(
  SwDoc* pDoc,
  std::shared_ptr<SfxItemSet> const & pInitSet,
  IStyleAccess::SwAutoStyleFamily eFam)
  mpSet(pInitSet),
  meFamily(eFam),
  mrDoc(*pDoc)
3837{
  // Register ourselves as a listener to the document (via the page descriptor)
  //StartListening(mrDoc.getIDocumentStylePoolAccess().GetPageDescFromPool(RES_POOLPAGE_STANDARD)->GetNotifier());
3840}

3842SwXAutoStyle::~SwXAutoStyle()
3843{
3844}

3846void SwXAutoStyle::Notify(const SfxHint& rHint)
3847{
  if(rHint.GetId() == SfxHintId::Dying)
      mpSet.reset();
3850}

3852uno::Reference< beans::XPropertySetInfo > SwXAutoStyle::getPropertySetInfo(  )
3853{
  uno::Reference< beans::XPropertySetInfo >  xRet;
  switch( meFamily )
  {
      case IStyleAccess::AUTO_STYLE_CHAR:
      {
          static uno::Reference< beans::XPropertySetInfo >  xCharRef;
          if(!xCharRef.is())
          {
              xCharRef = aSwMapProvider.GetPropertySet(PROPERTY_MAP_CHAR_AUTO_STYLE94)->getPropertySetInfo();
          }
          xRet = xCharRef;
      }
      break;
      case IStyleAccess::AUTO_STYLE_RUBY:
      {
          static uno::Reference< beans::XPropertySetInfo >  xRubyRef;
          if(!xRubyRef.is())
          {
              const sal_uInt16 nMapId = PROPERTY_MAP_RUBY_AUTO_STYLE95;
              xRubyRef = aSwMapProvider.GetPropertySet(nMapId)->getPropertySetInfo();
          }
          xRet = xRubyRef;
      }
      break;
      case IStyleAccess::AUTO_STYLE_PARA:
      {
          static uno::Reference< beans::XPropertySetInfo >  xParaRef;
          if(!xParaRef.is())
          {
              const sal_uInt16 nMapId = PROPERTY_MAP_PARA_AUTO_STYLE96;
              xParaRef = aSwMapProvider.GetPropertySet(nMapId)->getPropertySetInfo();
          }
          xRet = xParaRef;
      }
      break;

      default:
          ;
  }

  return xRet;
3895}

3897void SwXAutoStyle::setPropertyValue( const OUString& /*rPropertyName*/, const uno::Any& /*rValue*/ )
3898{
3899}

3901uno::Any SwXAutoStyle::getPropertyValue( const OUString& rPropertyName )
3902{
  SolarMutexGuard aGuard;
  const uno::Sequence<OUString> aProperties(&rPropertyName, 1);
  return GetPropertyValues_Impl(aProperties).getConstArray()[0];
3906}

3908void SwXAutoStyle::addPropertyChangeListener( const OUString& /*aPropertyName*/,
                                            const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/ )
3910{
3911}

3913void SwXAutoStyle::removePropertyChangeListener( const OUString& /*aPropertyName*/,
                                               const uno::Reference< beans::XPropertyChangeListener >& /*aListener*/ )
3915{
3916}

3918void SwXAutoStyle::addVetoableChangeListener( const OUString& /*PropertyName*/,
                                            const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
3920{
3921}

3923void SwXAutoStyle::removeVetoableChangeListener( const OUString& /*PropertyName*/,
                                               const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
3925{
3926}

3928void SwXAutoStyle::setPropertyValues(
      const uno::Sequence< OUString >& /*aPropertyNames*/,
      const uno::Sequence< uno::Any >& /*aValues*/ )
3931{
3932}

3934uno::Sequence< uno::Any > SwXAutoStyle::GetPropertyValues_Impl(
      const uno::Sequence< OUString > & rPropertyNames )
3936{
  if( !mpSet )
  {
      throw uno::RuntimeException();
  }

  // query_item
  sal_Int8 nPropSetId = PROPERTY_MAP_CHAR_AUTO_STYLE94;
  switch(meFamily)
  {
      case IStyleAccess::AUTO_STYLE_CHAR  : nPropSetId = PROPERTY_MAP_CHAR_AUTO_STYLE94;  break;
      case IStyleAccess::AUTO_STYLE_RUBY  : nPropSetId = PROPERTY_MAP_RUBY_AUTO_STYLE95;  break;
      case IStyleAccess::AUTO_STYLE_PARA  : nPropSetId = PROPERTY_MAP_PARA_AUTO_STYLE96;  break;
      default: ;
  }

  const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(nPropSetId);
  const SfxItemPropertyMap& rMap = pPropSet->getPropertyMap();
  const OUString* pNames = rPropertyNames.getConstArray();

  const sal_Int32 nLen(rPropertyNames.getLength());
  uno::Sequence< uno::Any > aRet( nLen );
  uno::Any* pValues = aRet.getArray();
  const bool bTakeCareOfDrawingLayerFillStyle(IStyleAccess::AUTO_STYLE_PARA == meFamily);

  for( sal_Int32 i = 0; i < nLen; ++i )
  {
      const OUString sPropName = pNames[i];
      const SfxItemPropertySimpleEntry* pEntry = rMap.getByName(sPropName);
      if(!pEntry)
      {
          throw beans::UnknownPropertyException("Unknown property: " + sPropName, static_cast < cppu::OWeakObject * > ( this ) );
      }

      uno::Any aTarget;
      bool bDone(false);

      if ( RES_TXTATR_AUTOFMT == pEntry->nWID || RES_AUTO_STYLE == pEntry->nWID )
      {
          OUString sName(StylePool::nameOf( mpSet ));
          aTarget <<= sName;
          bDone = true;
      }
      else if(bTakeCareOfDrawingLayerFillStyle)
      {
          // add support for DrawingLayer FillStyle slots
          switch(pEntry->nWID)
          {
              case RES_BACKGROUND:
              {
                  const std::unique_ptr<SvxBrushItem> aOriginalBrushItem(getSvxBrushItemFromSourceSet(*mpSet, RES_BACKGROUND));

                  if(!aOriginalBrushItem->QueryValue(aTarget, pEntry->nMemberId))
                  {
                      OSL_ENSURE(false, "Error getting attribute from RES_BACKGROUND (!)")do { if (true && (!(false))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "3990" ": "), "%s", "Error getting attribute from RES_BACKGROUND (!)"
); } } while (false);
                  }

                  bDone = true;
                  break;
              }
              case OWN_ATTR_FILLBMP_MODE(3900 +45):
              {
                  if (mpSet->Get(XATTR_FILLBMP_TILE).GetValue())
                  {
                      aTarget <<= drawing::BitmapMode_REPEAT;
                  }
                  else if (mpSet->Get(XATTR_FILLBMP_STRETCH).GetValue())
                  {
                      aTarget <<= drawing::BitmapMode_STRETCH;
                  }
                  else
                  {
                      aTarget <<= drawing::BitmapMode_NO_REPEAT;
                  }

                  bDone = true;
                  break;
              }
          }
      }

      if(!bDone)
      {
          pPropSet->getPropertyValue( *pEntry, *mpSet, aTarget );
      }

      if(bTakeCareOfDrawingLayerFillStyle)
      {
          if(pEntry->aType == cppu::UnoType<sal_Int16>::get() && pEntry->aType != aTarget.getValueType())
          {
              // since the sfx uint16 item now exports a sal_Int32, we may have to fix this here
              sal_Int32 nValue = 0;
              if (aTarget >>= nValue)
              {
                  aTarget <<= static_cast<sal_Int16>(nValue);
              }
          }

          // check for needed metric translation
          if(pEntry->nMoreFlags & PropertyMoreFlags::METRIC_ITEM)
          {
              bool bDoIt(true);

              if(XATTR_FILLBMP_SIZEX == pEntry->nWID || XATTR_FILLBMP_SIZEY == pEntry->nWID)
              {
                  // exception: If these ItemTypes are used, do not convert when these are negative
                  // since this means they are intended as percent values
                  sal_Int32 nValue = 0;

                  if(aTarget >>= nValue)
                  {
                      bDoIt = nValue > 0;
                  }
              }

              if(bDoIt)
              {
                  const SfxItemPool& rPool = mrDoc.GetAttrPool();
                  const MapUnit eMapUnit(rPool.GetMetric(pEntry->nWID));

                  if(eMapUnit != MapUnit::Map100thMM)
                  {
                      SvxUnoConvertToMM(eMapUnit, aTarget);
                  }
              }
          }
      }

      // add value
      pValues[i] = aTarget;
  }

  return aRet;
4069}

4071uno::Sequence< uno::Any > SwXAutoStyle::getPropertyValues (
      const uno::Sequence< OUString >& rPropertyNames )
4073{
  SolarMutexGuard aGuard;
  uno::Sequence< uno::Any > aValues;

  // workaround for bad designed API
  try
  {
      aValues = GetPropertyValues_Impl( rPropertyNames );
  }
  catch (beans::UnknownPropertyException &)
  {
      css::uno::Any exc = cppu::getCaughtException();
      throw lang::WrappedTargetRuntimeException("Unknown property exception caught", static_cast < cppu::OWeakObject * > ( this ), exc );
  }
  catch (lang::WrappedTargetException &)
  {
      css::uno::Any exc = cppu::getCaughtException();
      throw lang::WrappedTargetRuntimeException("WrappedTargetException caught", static_cast < cppu::OWeakObject * > ( this ), exc );
  }

  return aValues;
4094}

4096void SwXAutoStyle::addPropertiesChangeListener(
      const uno::Sequence< OUString >& /*aPropertyNames*/,
      const uno::Reference< beans::XPropertiesChangeListener >& /*xListener*/ )
4099{
4100}

4102void SwXAutoStyle::removePropertiesChangeListener(
      const uno::Reference< beans::XPropertiesChangeListener >& /*xListener*/ )
4104{
4105}

4107void SwXAutoStyle::firePropertiesChangeEvent(
      const uno::Sequence< OUString >& /*aPropertyNames*/,
      const uno::Reference< beans::XPropertiesChangeListener >& /*xListener*/ )
4110{
4111}

4113beans::PropertyState SwXAutoStyle::getPropertyState( const OUString& rPropertyName )
4114{
  SolarMutexGuard aGuard;

  uno::Sequence< OUString > aNames { rPropertyName };
  uno::Sequence< beans::PropertyState > aStates = getPropertyStates(aNames);
  return aStates.getConstArray()[0];
4120}

4122void SwXAutoStyle::setPropertyToDefault( const OUString& /*PropertyName*/ )
4123{
4124}

4126uno::Any SwXAutoStyle::getPropertyDefault( const OUString& rPropertyName )
4127{
  const uno::Sequence < OUString > aSequence ( &rPropertyName, 1 );
  return getPropertyDefaults ( aSequence ).getConstArray()[0];
4130}

4132uno::Sequence< beans::PropertyState > SwXAutoStyle::getPropertyStates(
      const uno::Sequence< OUString >& rPropertyNames )
4134{
  if (!mpSet)
  {
      throw uno::RuntimeException();
  }

  SolarMutexGuard aGuard;
  uno::Sequence< beans::PropertyState > aRet(rPropertyNames.getLength());
  beans::PropertyState* pStates = aRet.getArray();
  const OUString* pNames = rPropertyNames.getConstArray();

  sal_Int8 nPropSetId = PROPERTY_MAP_CHAR_AUTO_STYLE94;
  switch(meFamily)
  {
      case IStyleAccess::AUTO_STYLE_CHAR  : nPropSetId = PROPERTY_MAP_CHAR_AUTO_STYLE94;  break;
      case IStyleAccess::AUTO_STYLE_RUBY  : nPropSetId = PROPERTY_MAP_RUBY_AUTO_STYLE95;  break;
      case IStyleAccess::AUTO_STYLE_PARA  : nPropSetId = PROPERTY_MAP_PARA_AUTO_STYLE96;  break;
      default: ;
  }

  const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(nPropSetId);
  const SfxItemPropertyMap& rMap = pPropSet->getPropertyMap();
  const bool bTakeCareOfDrawingLayerFillStyle(IStyleAccess::AUTO_STYLE_PARA == meFamily);

  for(sal_Int32 i = 0; i < rPropertyNames.getLength(); i++)
  {
      const OUString sPropName = pNames[i];
      const SfxItemPropertySimpleEntry* pEntry = rMap.getByName(sPropName);
      if(!pEntry)
      {
          throw beans::UnknownPropertyException("Unknown property: " + sPropName, static_cast < cppu::OWeakObject * > ( this ) );
      }

      bool bDone(false);

      if(bTakeCareOfDrawingLayerFillStyle)
      {
          // DrawingLayer PropertyStyle support
          switch(pEntry->nWID)
          {
              case OWN_ATTR_FILLBMP_MODE(3900 +45):
              {
                  if(SfxItemState::SET == mpSet->GetItemState(XATTR_FILLBMP_STRETCH, false)
                      || SfxItemState::SET == mpSet->GetItemState(XATTR_FILLBMP_TILE, false))
                  {
                      pStates[i] = beans::PropertyState_DIRECT_VALUE;
                  }
                  else
                  {
                      pStates[i] = beans::PropertyState_AMBIGUOUS_VALUE;
                  }

                  bDone = true;
                  break;
              }
              case RES_BACKGROUND:
              {
                  if (SWUnoHelper::needToMapFillItemsToSvxBrushItemTypes(*mpSet,
                          pEntry->nMemberId))
                  {
                      pStates[i] = beans::PropertyState_DIRECT_VALUE;
                  }
                  else
                  {
                      pStates[i] = beans::PropertyState_DEFAULT_VALUE;
                  }
                  bDone = true;

                  break;
              }
          }
      }

      if(!bDone)
      {
          pStates[i] = pPropSet->getPropertyState(*pEntry, *mpSet );
      }
  }

  return aRet;
4214}

4216void SwXAutoStyle::setAllPropertiesToDefault(  )
4217{
4218}

4220void SwXAutoStyle::setPropertiesToDefault(
      const uno::Sequence< OUString >& /*rPropertyNames*/ )
4222{
4223}

4225uno::Sequence< uno::Any > SwXAutoStyle::getPropertyDefaults(
      const uno::Sequence< OUString >& /*aPropertyNames*/ )
4227{
  uno::Sequence< uno::Any > aRet(0);
  return aRet;
4230}

4232uno::Sequence< beans::PropertyValue > SwXAutoStyle::getProperties()
4233{
  if( !mpSet )
      throw uno::RuntimeException();
  SolarMutexGuard aGuard;
  std::vector< beans::PropertyValue > aPropertyVector;

  sal_Int8 nPropSetId = 0;
  switch(meFamily)
  {
      case IStyleAccess::AUTO_STYLE_CHAR  : nPropSetId = PROPERTY_MAP_CHAR_AUTO_STYLE94;  break;
      case IStyleAccess::AUTO_STYLE_RUBY  : nPropSetId = PROPERTY_MAP_RUBY_AUTO_STYLE95;  break;
      case IStyleAccess::AUTO_STYLE_PARA  : nPropSetId = PROPERTY_MAP_PARA_AUTO_STYLE96;  break;
      default: ;
  }

  const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(nPropSetId);
  const SfxItemPropertyMap &rMap = pPropSet->getPropertyMap();
  PropertyEntryVector_t aPropVector = rMap.getPropertyEntries();

  SfxItemSet& rSet = *mpSet;
  SfxItemIter aIter(rSet);

  for (const SfxPoolItem* pItem = aIter.GetCurItem(); pItem; pItem = aIter.NextItem())
  {
      const sal_uInt16 nWID = pItem->Which();

      // TODO: Optimize - and fix! the old iteration filled each WhichId
      // only once but there are more properties than WhichIds
      for( const auto& rProp : aPropVector )
      {
          if ( rProp.nWID == nWID )
          {
              beans::PropertyValue aPropertyValue;
              aPropertyValue.Name = rProp.sName;
              pItem->QueryValue( aPropertyValue.Value, rProp.nMemberId );
              aPropertyVector.push_back( aPropertyValue );
          }
      }
  }

  const sal_Int32 nCount = aPropertyVector.size();
  uno::Sequence< beans::PropertyValue > aRet( nCount );
  beans::PropertyValue* pProps = aRet.getArray();

  for ( int i = 0; i < nCount; ++i, pProps++ )
  {
      *pProps = aPropertyVector[i];
  }

  return aRet;
4283}

4285SwXTextTableStyle::SwXTextTableStyle(SwDocShell* pDocShell, SwTableAutoFormat* pTableAutoFormat) :
  m_pDocShell(pDocShell), m_pTableAutoFormat(pTableAutoFormat), m_bPhysical(true)
4287{
  UpdateCellStylesMapping();
4289}

4291SwXTextTableStyle::SwXTextTableStyle(SwDocShell* pDocShell, const OUString& rTableAutoFormatName) :
  m_pDocShell(pDocShell), m_pTableAutoFormat_Impl(new SwTableAutoFormat(rTableAutoFormatName)), m_bPhysical(false)
4293{
  m_pTableAutoFormat = m_pTableAutoFormat_Impl.get();
  UpdateCellStylesMapping();
4296}

4298uno::Reference<style::XStyle> SwXTextTableStyle::CreateXTextTableStyle(SwDocShell* pDocShell, const OUString& rTableAutoFormatName)
4299{
  SolarMutexGuard aGuard;
  uno::Reference<style::XStyle> xTextTableStyle;
  SwTableAutoFormat* pAutoFormat = GetTableAutoFormat(pDocShell, rTableAutoFormatName);
  if (pAutoFormat && pAutoFormat->GetName() == rTableAutoFormatName)
  {
      xTextTableStyle.set(pAutoFormat->GetXObject(), uno::UNO_QUERY);
      if (!xTextTableStyle.is())
      {
          xTextTableStyle.set(new SwXTextTableStyle(pDocShell, pAutoFormat));
          pAutoFormat->SetXObject(xTextTableStyle);
      }
  }

  // If corresponding AutoFormat doesn't exist create a non physical style.
  if (!xTextTableStyle.is())
  {
      xTextTableStyle.set(new SwXTextTableStyle(pDocShell, rTableAutoFormatName));
      SAL_INFO("sw.uno", "creating SwXTextTableStyle for non existing SwTableAutoFormat")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "creating SwXTextTableStyle for non existing SwTableAutoFormat"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4317" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "creating SwXTextTableStyle for non existing SwTableAutoFormat"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "creating SwXTextTableStyle for non existing SwTableAutoFormat"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4317" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "creating SwXTextTableStyle for non existing SwTableAutoFormat"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4317" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "creating SwXTextTableStyle for non existing SwTableAutoFormat"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "creating SwXTextTableStyle for non existing SwTableAutoFormat"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4317" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  }

  return xTextTableStyle;
4321}

4323void SwXTextTableStyle::UpdateCellStylesMapping()
4324{
  const std::vector<sal_Int32> aTableTemplateMap = SwTableAutoFormat::GetTableTemplateMap();
  assert(aTableTemplateMap.size() == STYLE_COUNT && "can not map SwTableAutoFormat to a SwXTextTableStyle")(static_cast <bool> (aTableTemplateMap.size() == STYLE_COUNT
 && "can not map SwTableAutoFormat to a SwXTextTableStyle"
) ? void (0) : __assert_fail ("aTableTemplateMap.size() == STYLE_COUNT && \"can not map SwTableAutoFormat to a SwXTextTableStyle\""
, "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
, 4326, __extension__ __PRETTY_FUNCTION__));
  for (sal_Int32 i=0; i<STYLE_COUNT; ++i)
  {
      SwBoxAutoFormat* pBoxFormat = &m_pTableAutoFormat->GetBoxFormat(aTableTemplateMap[i]);
      uno::Reference<style::XStyle> xCellStyle(pBoxFormat->GetXObject(), uno::UNO_QUERY);
      if (!xCellStyle.is())
      {
          xCellStyle.set(new SwXTextCellStyle(m_pDocShell, pBoxFormat, m_pTableAutoFormat->GetName()));
          pBoxFormat->SetXObject(xCellStyle);
      }
      m_aCellStyles[i] = xCellStyle;
  }
4338}

4340const CellStyleNameMap& SwXTextTableStyle::GetCellStyleNameMap()
4341{
  static CellStyleNameMap const aMap
  {
      { "first-row"     , FIRST_ROW_STYLE },
      { "last-row"      , LAST_ROW_STYLE },
      { "first-column"  , FIRST_COLUMN_STYLE },
      { "last-column"   , LAST_COLUMN_STYLE },
      { "body"          , BODY_STYLE },
      { "even-rows"     , EVEN_ROWS_STYLE },
      { "odd-rows"      , ODD_ROWS_STYLE },
      { "even-columns"  , EVEN_COLUMNS_STYLE },
      { "odd-columns"   , ODD_COLUMNS_STYLE },
      { "background"    , BACKGROUND_STYLE },
      // loext namespace
      { "first-row-start-column"  , FIRST_ROW_START_COLUMN_STYLE },
      { "first-row-end-column"    , FIRST_ROW_END_COLUMN_STYLE },
      { "last-row-start-column"   , LAST_ROW_START_COLUMN_STYLE },
      { "last-row-end-column"     , LAST_ROW_END_COLUMN_STYLE },
      { "first-row-even-column"   , FIRST_ROW_EVEN_COLUMN_STYLE },
      { "last-row-even-column"    , LAST_ROW_EVEN_COLUMN_STYLE },
  };
  return aMap;
4363}

4365SwTableAutoFormat* SwXTextTableStyle::GetTableFormat()
4366{
  return m_pTableAutoFormat;
4368}

4370SwTableAutoFormat* SwXTextTableStyle::GetTableAutoFormat(SwDocShell* pDocShell, const OUString& sName)
4371{
  const size_t nStyles = pDocShell->GetDoc()->GetTableStyles().size();
  for(size_t i=0; i < nStyles; ++i)
  {
      SwTableAutoFormat* pAutoFormat = &pDocShell->GetDoc()->GetTableStyles()[i];
      if (pAutoFormat->GetName() == sName)
      {
          return pAutoFormat;
      }
  }
  // not found
  return nullptr;
4383}

4385void SwXTextTableStyle::SetPhysical()
4386{
  if (!m_bPhysical)
  {
      // find table format in doc
      SwTableAutoFormat* pTableAutoFormat = GetTableAutoFormat(m_pDocShell, m_pTableAutoFormat->GetName());
      if (pTableAutoFormat)
      {
          m_bPhysical = true;
          /// take care of children, make SwXTextCellStyles use new core SwBoxAutoFormats
          const std::vector<sal_Int32> aTableTemplateMap = SwTableAutoFormat::GetTableTemplateMap();
          for (size_t i=0; i<aTableTemplateMap.size(); ++i)
          {
              SwBoxAutoFormat* pOldBoxFormat = &m_pTableAutoFormat->GetBoxFormat(aTableTemplateMap[i]);
              uno::Reference<style::XStyle> xCellStyle(pOldBoxFormat->GetXObject(), uno::UNO_QUERY);
              if (!xCellStyle.is())
                  continue;
              SwXTextCellStyle& rStyle = dynamic_cast<SwXTextCellStyle&>(*xCellStyle);
              SwBoxAutoFormat& rNewBoxFormat = pTableAutoFormat->GetBoxFormat(aTableTemplateMap[i]);
              rStyle.SetBoxFormat(&rNewBoxFormat);
              rNewBoxFormat.SetXObject(xCellStyle);
          }
          m_pTableAutoFormat_Impl = nullptr;
          m_pTableAutoFormat = pTableAutoFormat;
          m_pTableAutoFormat->SetXObject(uno::Reference<style::XStyle>(this));
      }
      else
          SAL_WARN("sw.uno", "setting style physical, but SwTableAutoFormat in document not found")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "setting style physical, but SwTableAutoFormat in document not found"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4412" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "setting style physical, but SwTableAutoFormat in document not found"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "setting style physical, but SwTableAutoFormat in document not found"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4412" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "setting style physical, but SwTableAutoFormat in document not found"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4412" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "setting style physical, but SwTableAutoFormat in document not found"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "setting style physical, but SwTableAutoFormat in document not found"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4412" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  }
  else
      SAL_WARN("sw.uno", "calling SetPhysical on a physical SwXTextTableStyle")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "calling SetPhysical on a physical SwXTextTableStyle"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4415" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "calling SetPhysical on a physical SwXTextTableStyle"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "calling SetPhysical on a physical SwXTextTableStyle"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4415" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "calling SetPhysical on a physical SwXTextTableStyle"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4415" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "calling SetPhysical on a physical SwXTextTableStyle"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "calling SetPhysical on a physical SwXTextTableStyle"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4415" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
4416}

4418// XStyle
4419sal_Bool SAL_CALL SwXTextTableStyle::isUserDefined()
4420{
  SolarMutexGuard aGuard;
  // only first style is not user defined
  if (m_pDocShell->GetDoc()->GetTableStyles()[0].GetName() == m_pTableAutoFormat->GetName())
      return false;

  return true;
4427}

4429sal_Bool SAL_CALL SwXTextTableStyle::isInUse()
4430{
  SolarMutexGuard aGuard;
  if (!m_bPhysical)
      return false;

  SwAutoFormatGetDocNode aGetHt( &m_pDocShell->GetDoc()->GetNodes() );

  for (SwFrameFormat* const & pFormat : *m_pDocShell->GetDoc()->GetTableFrameFormats())
  {
      if (!pFormat->GetInfo(aGetHt))
      {
          SwTable* pTable = SwTable::FindTable(pFormat);
          if (pTable->GetTableStyleName() == m_pTableAutoFormat->GetName())
              return true;
      }
  }

  return false;
4448}

4450OUString SAL_CALL SwXTextTableStyle::getParentStyle()
4451{
  return OUString();
4453}

4455void SAL_CALL SwXTextTableStyle::setParentStyle(const OUString& /*aParentStyle*/)
4456{ }

4458//XNamed
4459OUString SAL_CALL SwXTextTableStyle::getName()
4460{
  SolarMutexGuard aGuard;
  OUString sProgName;
  SwStyleNameMapper::FillProgName(m_pTableAutoFormat->GetName(), sProgName, SwGetPoolIdFromName::TabStyle);
  return sProgName;
4465}

4467void SAL_CALL SwXTextTableStyle::setName(const OUString& rName)
4468{
  SolarMutexGuard aGuard;
  m_pTableAutoFormat->SetName(rName);
4471}

4473//XPropertySet
4474css::uno::Reference<css::beans::XPropertySetInfo> SAL_CALL SwXTextTableStyle::getPropertySetInfo()
4475{
  static uno::Reference<beans::XPropertySetInfo> xRef(aSwMapProvider.GetPropertySet(PROPERTY_MAP_TABLE_STYLE100)->getPropertySetInfo());
  return xRef;
4478}

4480void SAL_CALL SwXTextTableStyle::setPropertyValue(const OUString& /*rPropertyName*/, const css::uno::Any& /*aValue*/)
4481{
  SAL_WARN("sw.uno", "not implemented")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "not implemented") ==
 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4482" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4482" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "not implemented") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4482" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4482" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
4483}

4485css::uno::Any SAL_CALL SwXTextTableStyle::getPropertyValue(const OUString& rPropertyName)
4486{
  SolarMutexGuard aGuard;
  bool bIsRow = false;

  if (rPropertyName == UNO_NAME_TABLE_FIRST_ROW_END_COLUMN"FirstRowEndColumn")
      bIsRow = m_pTableAutoFormat->FirstRowEndColumnIsRow();
  else if (rPropertyName == UNO_NAME_TABLE_FIRST_ROW_START_COLUMN"FirstRowStartColumn")
      bIsRow = m_pTableAutoFormat->FirstRowStartColumnIsRow();
  else if (rPropertyName == UNO_NAME_TABLE_LAST_ROW_END_COLUMN"LastRowEndColumn")
      bIsRow = m_pTableAutoFormat->LastRowEndColumnIsRow();
  else if (rPropertyName == UNO_NAME_TABLE_LAST_ROW_START_COLUMN"LastRowStartColumn")
      bIsRow = m_pTableAutoFormat->LastRowStartColumnIsRow();
  else if (rPropertyName == UNO_NAME_DISPLAY_NAME"DisplayName")
      return uno::makeAny(m_pTableAutoFormat->GetName());
  else
      throw css::beans::UnknownPropertyException(rPropertyName);

  return uno::makeAny(bIsRow ? OUString("row") : OUString("column"));
4504}

4506void SAL_CALL SwXTextTableStyle::addPropertyChangeListener( const OUString& /*aPropertyName*/, const css::uno::Reference< css::beans::XPropertyChangeListener >& /*xListener*/ )
4507{
  SAL_WARN("sw.uno", "not implemented")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "not implemented") ==
 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4508" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4508" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "not implemented") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4508" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4508" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
4509}

4511void SAL_CALL SwXTextTableStyle::removePropertyChangeListener( const OUString& /*aPropertyName*/, const css::uno::Reference< css::beans::XPropertyChangeListener >& /*aListener*/ )
4512{
  SAL_WARN("sw.uno", "not implemented")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "not implemented") ==
 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4513" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4513" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "not implemented") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4513" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4513" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
4514}

4516void SAL_CALL SwXTextTableStyle::addVetoableChangeListener( const OUString& /*PropertyName*/, const css::uno::Reference< css::beans::XVetoableChangeListener >& /*aListener*/ )
4517{
  SAL_WARN("sw.uno", "not implemented")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "not implemented") ==
 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4518" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4518" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "not implemented") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4518" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4518" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
4519}

4521void SAL_CALL SwXTextTableStyle::removeVetoableChangeListener( const OUString& /*PropertyName*/, const css::uno::Reference< css::beans::XVetoableChangeListener >& /*aListener*/ )
4522{
  SAL_WARN("sw.uno", "not implemented")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "not implemented") ==
 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4523" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4523" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "not implemented") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4523" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4523" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
4524}

4526//XNameAccess
4527uno::Any SAL_CALL SwXTextTableStyle::getByName(const OUString& rName)
4528{
  SolarMutexGuard aGuard;
  const CellStyleNameMap& rMap = GetCellStyleNameMap();
  CellStyleNameMap::const_iterator iter = rMap.find(rName);
  if(iter == rMap.end())
      throw css::container::NoSuchElementException();

  return css::uno::Any(m_aCellStyles[(*iter).second]);
4536}

4538css::uno::Sequence<OUString> SAL_CALL SwXTextTableStyle::getElementNames()
4539{
  SolarMutexGuard aGuard;
  return comphelper::mapKeysToSequence(GetCellStyleNameMap());
4542}

4544sal_Bool SAL_CALL SwXTextTableStyle::hasByName(const OUString& rName)
4545{
  SolarMutexGuard aGuard;
  const CellStyleNameMap& rMap = GetCellStyleNameMap();
  CellStyleNameMap::const_iterator iter = rMap.find(rName);
  return iter != rMap.end();
4550}

4552//XNameContainer
4553void SAL_CALL SwXTextTableStyle::insertByName(const OUString& /*Name*/, const uno::Any& /*Element*/)
4554{
  SAL_WARN("sw.uno", "not implemented")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "not implemented") ==
 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4555" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4555" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "not implemented") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4555" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4555" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
4556}

4558void SAL_CALL SwXTextTableStyle::replaceByName(const OUString& rName, const uno::Any& rElement)
4559{
  SolarMutexGuard aGuard;
  const CellStyleNameMap& rMap = GetCellStyleNameMap();
  CellStyleNameMap::const_iterator iter = rMap.find(rName);
  if(iter == rMap.end())
      throw container::NoSuchElementException();
  const sal_Int32 nCellStyle = iter->second;

  uno::Reference<style::XStyle> xStyle = rElement.get<uno::Reference<style::XStyle>>();
  if (!xStyle.is())
      throw lang::IllegalArgumentException();

  SwXTextCellStyle* pStyleToReplaceWith = dynamic_cast<SwXTextCellStyle*>(xStyle.get());
  if (!pStyleToReplaceWith)
       throw lang::IllegalArgumentException();

  // replace only with physical ...
  if (!pStyleToReplaceWith->IsPhysical())
      throw lang::IllegalArgumentException();

  const auto& rTableTemplateMap = SwTableAutoFormat::GetTableTemplateMap();
  const sal_Int32 nBoxFormat = rTableTemplateMap[nCellStyle];

  // move SwBoxAutoFormat to dest. SwTableAutoFormat
  m_pTableAutoFormat->SetBoxFormat(*pStyleToReplaceWith->GetBoxFormat(), nBoxFormat);
  // remove unassigned SwBoxAutoFormat, which is not anymore in use anyways
  m_pDocShell->GetDoc()->GetCellStyles().RemoveBoxFormat(xStyle->getName());
  // make SwXTextCellStyle use new, moved SwBoxAutoFormat
  pStyleToReplaceWith->SetBoxFormat(&m_pTableAutoFormat->GetBoxFormat(nBoxFormat));
  m_pTableAutoFormat->GetBoxFormat(nBoxFormat).SetXObject(xStyle);
  // make this SwXTextTableStyle use new SwXTextCellStyle
  m_aCellStyles[nCellStyle] = xStyle;
4591}

4593void SAL_CALL SwXTextTableStyle::removeByName(const OUString& /*Name*/)
4594{
  SAL_WARN("sw.uno", "not implemented")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "not implemented") ==
 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4595" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4595" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "not implemented") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4595" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4595" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
4596}

4598//XElementAccess
4599uno::Type SAL_CALL SAL_CALL SwXTextTableStyle::getElementType()
4600{
  return cppu::UnoType<style::XStyle>::get();
4602}

4604sal_Bool SAL_CALL SAL_CALL SwXTextTableStyle::hasElements()
4605{
  return true;
4607}

4609//XServiceInfo
4610OUString SAL_CALL SwXTextTableStyle::getImplementationName()
4611{
  return {"SwXTextTableStyle"};
4613}

4615sal_Bool SAL_CALL SwXTextTableStyle::supportsService(const OUString& rServiceName)
4616{
  return cppu::supportsService(this, rServiceName);
4618}

4620css::uno::Sequence<OUString> SAL_CALL SwXTextTableStyle::getSupportedServiceNames()
4621{
  return {"com.sun.star.style.Style"};
4623}

4625// SwXTextCellStyle
4626SwXTextCellStyle::SwXTextCellStyle(SwDocShell* pDocShell, SwBoxAutoFormat* pBoxAutoFormat, const OUString& sParentStyle) :
  m_pDocShell(pDocShell),
  m_pBoxAutoFormat(pBoxAutoFormat),
  m_sParentStyle(sParentStyle),
  m_bPhysical(true)
4631{ }

4633SwXTextCellStyle::SwXTextCellStyle(SwDocShell* pDocShell, const OUString& sName) :
  m_pDocShell(pDocShell),
  m_pBoxAutoFormat_Impl(std::make_shared<SwBoxAutoFormat>()),
  m_sName(sName),
  m_bPhysical(false)
4638{
  m_pBoxAutoFormat = m_pBoxAutoFormat_Impl.get();
4640}

4642SwBoxAutoFormat* SwXTextCellStyle::GetBoxFormat()
4643{
  return m_pBoxAutoFormat;
4645}

4647void SwXTextCellStyle::SetBoxFormat(SwBoxAutoFormat* pBoxFormat)
4648{
  if (m_bPhysical)
      m_pBoxAutoFormat = pBoxFormat;
  else
      SAL_INFO("sw.uno", "trying to call SwXTextCellStyle::SetBoxFormat on non physical style")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "trying to call SwXTextCellStyle::SetBoxFormat on non physical style"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4652" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "trying to call SwXTextCellStyle::SetBoxFormat on non physical style"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "trying to call SwXTextCellStyle::SetBoxFormat on non physical style"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4652" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "trying to call SwXTextCellStyle::SetBoxFormat on non physical style"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4652" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "trying to call SwXTextCellStyle::SetBoxFormat on non physical style"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "trying to call SwXTextCellStyle::SetBoxFormat on non physical style"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4652" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
4653}

4655void SwXTextCellStyle::SetPhysical()
4656{
  if (!m_bPhysical)
  {
      SwBoxAutoFormat* pBoxAutoFormat = GetBoxAutoFormat(m_pDocShell, m_sName, &m_sParentStyle);
      if (pBoxAutoFormat)
      {
          m_bPhysical = true;
          m_pBoxAutoFormat_Impl = nullptr;
          m_pBoxAutoFormat = pBoxAutoFormat;
          m_pBoxAutoFormat->SetXObject(uno::Reference<style::XStyle>(this));
      }
      else
          SAL_WARN("sw.uno", "setting style physical, but SwBoxAutoFormat in document not found")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "setting style physical, but SwBoxAutoFormat in document not found"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4668" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "setting style physical, but SwBoxAutoFormat in document not found"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "setting style physical, but SwBoxAutoFormat in document not found"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4668" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "setting style physical, but SwBoxAutoFormat in document not found"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4668" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "setting style physical, but SwBoxAutoFormat in document not found"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "setting style physical, but SwBoxAutoFormat in document not found"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4668" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  }
  else
      SAL_WARN("sw.uno", "calling SetPhysical on a physical SwXTextCellStyle")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "calling SetPhysical on a physical SwXTextCellStyle"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4671" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "calling SetPhysical on a physical SwXTextCellStyle"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "calling SetPhysical on a physical SwXTextCellStyle"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4671" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "calling SetPhysical on a physical SwXTextCellStyle"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4671" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "calling SetPhysical on a physical SwXTextCellStyle"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "calling SetPhysical on a physical SwXTextCellStyle"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4671" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
4672}

4674bool SwXTextCellStyle::IsPhysical() const
4675{
  return m_bPhysical;
4677}

4679SwBoxAutoFormat* SwXTextCellStyle::GetBoxAutoFormat(SwDocShell* pDocShell, const OUString& sName, OUString* pParentName)
4680{
  if (sName.isEmpty())
      return nullptr;

  SwBoxAutoFormat* pBoxAutoFormat = pDocShell->GetDoc()->GetCellStyles().GetBoxFormat(sName);
  if (!pBoxAutoFormat)
  {
      sal_Int32 nSeparatorIndex, nTemplateIndex;
      OUString sParentName, sCellSubName;

      nSeparatorIndex = sName.lastIndexOf('.');
      if (0 >= nSeparatorIndex)
          return nullptr;

      sParentName = sName.copy(0, nSeparatorIndex);
      sCellSubName = sName.copy(nSeparatorIndex+1);
      nTemplateIndex = sCellSubName.toInt32()-1; // -1 because cell styles names start from 1, but internally are indexed from 0
      if (0 > nTemplateIndex)
          return nullptr;

      const auto& rTableTemplateMap = SwTableAutoFormat::GetTableTemplateMap();
      if (rTableTemplateMap.size() <= o3tl::make_unsigned(nTemplateIndex))
          return nullptr;

      SwStyleNameMapper::FillUIName(sParentName, sParentName, SwGetPoolIdFromName::TabStyle);
      SwTableAutoFormat* pTableAutoFormat = pDocShell->GetDoc()->GetTableStyles().FindAutoFormat(sParentName);
      if (!pTableAutoFormat)
          return nullptr;

      if (pParentName)
          *pParentName = sParentName;
      sal_uInt32 nBoxIndex = rTableTemplateMap[nTemplateIndex];
      pBoxAutoFormat = &pTableAutoFormat->GetBoxFormat(nBoxIndex);
  }

  return pBoxAutoFormat;
4716}

4718css::uno::Reference<css::style::XStyle> SwXTextCellStyle::CreateXTextCellStyle(SwDocShell* pDocShell, const OUString& sName)
4719{
  uno::Reference<style::XStyle> xTextCellStyle;

  if (!sName.isEmpty()) // create a cell style for a physical box
  {
      OUString sParentName;
      SwBoxAutoFormat* pBoxFormat = GetBoxAutoFormat(pDocShell, sName, &sParentName);

      // something went wrong but we don't want a crash
      if (!pBoxFormat)
      {
          // return a default-dummy style to prevent crash
          static SwBoxAutoFormat aDefaultBoxFormat;
          pBoxFormat = &aDefaultBoxFormat;
      }

      xTextCellStyle.set(pBoxFormat->GetXObject(), uno::UNO_QUERY);
      if (!xTextCellStyle.is())
      {
          xTextCellStyle.set(new SwXTextCellStyle(pDocShell, pBoxFormat, sParentName));
          pBoxFormat->SetXObject(xTextCellStyle);
      }
  }
  else // create a non physical style
      xTextCellStyle.set(new SwXTextCellStyle(pDocShell, sName));

  return xTextCellStyle;
4746}

4748// XStyle
4749sal_Bool SAL_CALL SwXTextCellStyle::isUserDefined()
4750{
  SolarMutexGuard aGuard;
  // if this cell belong to first table style then its default style
  if (&m_pDocShell->GetDoc()->GetTableStyles()[0] == m_pDocShell->GetDoc()->GetTableStyles().FindAutoFormat(m_sParentStyle))
      return false;

  return true;
4757}

4759sal_Bool SAL_CALL SwXTextCellStyle::isInUse()
4760{
  SolarMutexGuard aGuard;
  uno::Reference<style::XStyleFamiliesSupplier> xFamiliesSupplier(m_pDocShell->GetModel(), uno::UNO_QUERY);
  if (!xFamiliesSupplier.is())
      return false;

  uno::Reference<container::XNameAccess> xFamilies = xFamiliesSupplier->getStyleFamilies();
  if (!xFamilies.is())
      return false;

  uno::Reference<container::XNameAccess> xTableStyles;
  xFamilies->getByName("TableStyles") >>= xTableStyles;
  if (!xTableStyles.is())
      return false;

  uno::Reference<style::XStyle> xStyle;
  xTableStyles->getByName(m_sParentStyle) >>= xStyle;
  if (!xStyle.is())
      return false;

  return xStyle->isInUse();
4781}

4783OUString SAL_CALL SwXTextCellStyle::getParentStyle()
4784{
  // Do not return name of the parent (which is a table style) because the parent should be a cell style.
  return OUString();
4787}

4789void SAL_CALL SwXTextCellStyle::setParentStyle(const OUString& /*sParentStyle*/)
4790{
  SolarMutexGuard aGuard;
  // Changing parent to one which is unaware of it will lead to a something unexpected. getName() rely on a parent.
  SAL_INFO("sw.uno", "Changing SwXTextCellStyle parent")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "Changing SwXTextCellStyle parent"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4793" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Changing SwXTextCellStyle parent"),
 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Changing SwXTextCellStyle parent"; ::sal::detail::
log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4793" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Changing SwXTextCellStyle parent") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4793" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Changing SwXTextCellStyle parent"),
 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Changing SwXTextCellStyle parent"; ::sal::detail::
log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "4793" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
4794}

4796//XNamed
4797OUString SAL_CALL SwXTextCellStyle::getName()
4798{
  SolarMutexGuard aGuard;
  OUString sName;

  // if style is physical then we request a name from doc
  if (m_bPhysical)
  {
      SwTableAutoFormat* pTableFormat = m_pDocShell->GetDoc()->GetTableStyles().FindAutoFormat(m_sParentStyle);
      if (!pTableFormat)
      {
          // if auto format is not found as a child of table formats, look in SwDoc cellstyles
          sName = m_pDocShell->GetDoc()->GetCellStyles().GetBoxFormatName(*m_pBoxAutoFormat);
      }
      else
      {
          OUString sParentStyle;
          SwStyleNameMapper::FillProgName(m_sParentStyle, sParentStyle, SwGetPoolIdFromName::TabStyle);
          sName = sParentStyle + pTableFormat->GetTableTemplateCellSubName(*m_pBoxAutoFormat);
      }
  }
  else
      sName = m_sName;

  return sName;
4822}

4824void SAL_CALL SwXTextCellStyle::setName(const OUString& sName)
4825{
  SolarMutexGuard aGuard;
  // if style is physical then we can not rename it.
  if (!m_bPhysical)
      m_sName = sName;
  // change name if style is unassigned (name is not generated automatically)
  m_pDocShell->GetDoc()->GetCellStyles().ChangeBoxFormatName(getName(), sName);
4832}

4834//XPropertySet
4835css::uno::Reference<css::beans::XPropertySetInfo> SAL_CALL SwXTextCellStyle::getPropertySetInfo()
4836{
  static uno::Reference<beans::XPropertySetInfo> xRef(aSwMapProvider.GetPropertySet(PROPERTY_MAP_CELL_STYLE101)->getPropertySetInfo());
  return xRef;
4839}

4841void SAL_CALL SwXTextCellStyle::setPropertyValue(const OUString& rPropertyName, const css::uno::Any& aValue)
4842{
  SolarMutexGuard aGuard;
  const SfxItemPropertySimpleEntry *const pEntry = aSwMapProvider.GetPropertySet(PROPERTY_MAP_CELL_STYLE101)->getPropertyMap().getByName(rPropertyName);
  if(pEntry)
  {
      switch(pEntry->nWID)
      {
          case RES_BACKGROUND:
          {
              SvxBrushItem rBrush = m_pBoxAutoFormat->GetBackground();
              rBrush.PutValue(aValue, 0);
              m_pBoxAutoFormat->SetBackground(rBrush);
              return;
          }
          case RES_BOX:
          {
              SvxBoxItem rBox = m_pBoxAutoFormat->GetBox();
              rBox.PutValue(aValue, pEntry->nMemberId);
              m_pBoxAutoFormat->SetBox(rBox);
              return;
          }
          case RES_VERT_ORIENT:
          {
              SwFormatVertOrient rVertOrient = m_pBoxAutoFormat->GetVerticalAlignment();
              rVertOrient.PutValue(aValue, pEntry->nMemberId);
              m_pBoxAutoFormat->SetVerticalAlignment(rVertOrient);
              return;
          }
          case RES_FRAMEDIR:
          {
              SvxFrameDirectionItem rDirItem = m_pBoxAutoFormat->GetTextOrientation();
              rDirItem.PutValue(aValue, pEntry->nMemberId);
              m_pBoxAutoFormat->SetTextOrientation(rDirItem);
              return;
          }
          case RES_BOXATR_FORMAT:
          {
              sal_uInt32 nKey;
              if (aValue >>= nKey)
              {
                  // FIXME: It's not working for old "automatic" currency formats, which are still in use by autotbl.fmt.
                  // Scenario:
                  // 1) Mark all styles present by default in autotbl.fmt as default.
                  // 2) convert all currencies present in autotbl.fmt before calling this code
                  const SvNumberformat* pNumFormat = m_pDocShell->GetDoc()->GetNumberFormatter()->GetEntry(nKey);
                  if (pNumFormat)
                      m_pBoxAutoFormat->SetValueFormat(pNumFormat->GetFormatstring(), pNumFormat->GetLanguage(), GetAppLanguage());
              }
              return;
          }
          // Paragraph attributes
          case RES_PARATR_ADJUST:
          {
              SvxAdjustItem rAdjustItem = m_pBoxAutoFormat->GetAdjust();
              rAdjustItem.PutValue(aValue, pEntry->nMemberId);
              m_pBoxAutoFormat->SetAdjust(rAdjustItem);
              return;
          }
          case RES_CHRATR_COLOR:
          {
              SvxColorItem rColorItem = m_pBoxAutoFormat->GetColor();
              rColorItem.PutValue(aValue, pEntry->nMemberId);
              m_pBoxAutoFormat->SetColor(rColorItem);
              return;
          }
          case RES_CHRATR_SHADOWED:
          {
              SvxShadowedItem rShadowedItem = m_pBoxAutoFormat->GetShadowed();
              bool bValue = false; aValue >>= bValue;
              rShadowedItem.SetValue(bValue);
              m_pBoxAutoFormat->SetShadowed(rShadowedItem);
              return;
          }
          case RES_CHRATR_CONTOUR:
          {
              SvxContourItem rContourItem = m_pBoxAutoFormat->GetContour();
              bool bValue = false; aValue >>= bValue;
              rContourItem.SetValue(bValue);
              m_pBoxAutoFormat->SetContour(rContourItem);
              return;
          }
          case RES_CHRATR_CROSSEDOUT:
          {
              SvxCrossedOutItem rCrossedOutItem = m_pBoxAutoFormat->GetCrossedOut();
              rCrossedOutItem.PutValue(aValue, pEntry->nMemberId);
              m_pBoxAutoFormat->SetCrossedOut(rCrossedOutItem);
              return;
          }
          case RES_CHRATR_UNDERLINE:
          {
              SvxUnderlineItem rUnderlineItem = m_pBoxAutoFormat->GetUnderline();
              rUnderlineItem.PutValue(aValue, pEntry->nMemberId);
              m_pBoxAutoFormat->SetUnderline(rUnderlineItem);
              return;
          }
          case RES_CHRATR_FONTSIZE:
          {
              SvxFontHeightItem rFontHeightItem = m_pBoxAutoFormat->GetHeight();
              rFontHeightItem.PutValue(aValue, pEntry->nMemberId);
              m_pBoxAutoFormat->SetHeight(rFontHeightItem);
              return;
          }
          case RES_CHRATR_WEIGHT:
          {
              SvxWeightItem rWeightItem = m_pBoxAutoFormat->GetWeight();
              rWeightItem.PutValue(aValue, pEntry->nMemberId);
              m_pBoxAutoFormat->SetWeight(rWeightItem);
              return;
          }
          case RES_CHRATR_POSTURE:
          {
              SvxPostureItem rPostureItem = m_pBoxAutoFormat->GetPosture();
              rPostureItem.PutValue(aValue, pEntry->nMemberId);
              m_pBoxAutoFormat->SetPosture(rPostureItem);
              return;
          }
          case RES_CHRATR_FONT:
          {
              SvxFontItem rFontItem = m_pBoxAutoFormat->GetFont();
              rFontItem.PutValue(aValue, pEntry->nMemberId);
              m_pBoxAutoFormat->SetFont(rFontItem);
              return;
          }
          case RES_CHRATR_CJK_FONTSIZE:
          {
              SvxFontHeightItem rFontHeightItem = m_pBoxAutoFormat->GetCJKHeight();
              rFontHeightItem.PutValue(aValue, pEntry->nMemberId);
              m_pBoxAutoFormat->SetCJKHeight(rFontHeightItem);
              return;
          }
          case RES_CHRATR_CJK_WEIGHT:
          {
              SvxWeightItem rWeightItem = m_pBoxAutoFormat->GetCJKWeight();
              rWeightItem.PutValue(aValue, pEntry->nMemberId);
              m_pBoxAutoFormat->SetCJKWeight(rWeightItem);
              return;
          }
          case RES_CHRATR_CJK_POSTURE:
          {
              SvxPostureItem rPostureItem = m_pBoxAutoFormat->GetCJKPosture();
              rPostureItem.PutValue(aValue, pEntry->nMemberId);
              m_pBoxAutoFormat->SetCJKPosture(rPostureItem);
              return;
          }
          case RES_CHRATR_CJK_FONT:
          {
              SvxFontItem rFontItem = m_pBoxAutoFormat->GetCJKFont();
              rFontItem.PutValue(aValue, pEntry->nMemberId);
              m_pBoxAutoFormat->SetCJKFont(rFontItem);
              return;
          }
          case RES_CHRATR_CTL_FONTSIZE:
          {
              SvxFontHeightItem rFontHeightItem = m_pBoxAutoFormat->GetCTLHeight();
              rFontHeightItem.PutValue(aValue, pEntry->nMemberId);
              m_pBoxAutoFormat->SetCTLHeight(rFontHeightItem);
              return;
          }
          case RES_CHRATR_CTL_WEIGHT:
          {
              SvxWeightItem rWeightItem = m_pBoxAutoFormat->GetCTLWeight();
              rWeightItem.PutValue(aValue, pEntry->nMemberId);
              m_pBoxAutoFormat->SetCTLWeight(rWeightItem);
              return;
          }
          case RES_CHRATR_CTL_POSTURE:
          {
              SvxPostureItem rPostureItem = m_pBoxAutoFormat->GetCTLPosture();
              rPostureItem.PutValue(aValue, pEntry->nMemberId);
              m_pBoxAutoFormat->SetCTLPosture(rPostureItem);
              return;
          }
          case RES_CHRATR_CTL_FONT:
          {
              SvxFontItem rFontItem = m_pBoxAutoFormat->GetCTLFont();
              rFontItem.PutValue(aValue, pEntry->nMemberId);
              m_pBoxAutoFormat->SetCTLFont(rFontItem);
              return;
          }
          default:
              SAL_WARN("sw.uno", "SwXTextCellStyle unknown nWID")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "SwXTextCellStyle unknown nWID"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5022" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "SwXTextCellStyle unknown nWID"), 0)
; } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "SwXTextCellStyle unknown nWID"; ::sal::detail::log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5022" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "SwXTextCellStyle unknown nWID") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5022" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "SwXTextCellStyle unknown nWID"), 0)
; } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "SwXTextCellStyle unknown nWID"; ::sal::detail::log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5022" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
              throw css::uno::RuntimeException();
      }
  }

  throw css::beans::UnknownPropertyException(rPropertyName);
5028}

5030css::uno::Any SAL_CALL SwXTextCellStyle::getPropertyValue(const OUString& rPropertyName)
5031{
  SolarMutexGuard aGuard;
  uno::Any aRet;
  const SfxItemPropertySimpleEntry *const pEntry = aSwMapProvider.GetPropertySet(PROPERTY_MAP_CELL_STYLE101)->getPropertyMap().getByName(rPropertyName);
  if(pEntry)
  {
      switch(pEntry->nWID)
      {
          case RES_BACKGROUND:
          {
              const SvxBrushItem& rBrush = m_pBoxAutoFormat->GetBackground();
              rBrush.QueryValue(aRet);
              return aRet;
          }
          case RES_BOX:
          {
              const SvxBoxItem& rBox = m_pBoxAutoFormat->GetBox();
              rBox.QueryValue(aRet, pEntry->nMemberId);
              return aRet;
          }
          case RES_VERT_ORIENT:
          {
              const SwFormatVertOrient& rVertOrient = m_pBoxAutoFormat->GetVerticalAlignment();
              rVertOrient.QueryValue(aRet, pEntry->nMemberId);
              return aRet;
          }
          case RES_FRAMEDIR:
          {
              const SvxFrameDirectionItem& rDirItem = m_pBoxAutoFormat->GetTextOrientation();
              rDirItem.QueryValue(aRet, pEntry->nMemberId);
              return aRet;
          }
          case RES_BOXATR_FORMAT:
          {
              OUString sFormat;
              LanguageType eLng, eSys;
              m_pBoxAutoFormat->GetValueFormat(sFormat, eLng, eSys);
              if(!sFormat.isEmpty())
              {
                  SvNumFormatType nType; bool bNew; sal_Int32 nCheckPos;
                  sal_uInt32 nKey = m_pDocShell->GetDoc()->GetNumberFormatter()->GetIndexPuttingAndConverting(sFormat, eLng, eSys, nType, bNew, nCheckPos);
                  aRet <<= nKey;
              }
              return aRet;
          }
          // Paragraph attributes
          case RES_PARATR_ADJUST:
          {
              const SvxAdjustItem& rAdjustItem = m_pBoxAutoFormat->GetAdjust();
              rAdjustItem.QueryValue(aRet, pEntry->nMemberId);
              return aRet;
          }
          case RES_CHRATR_COLOR:
          {
              const SvxColorItem& rColorItem = m_pBoxAutoFormat->GetColor();
              rColorItem.QueryValue(aRet, pEntry->nMemberId);
              return aRet;
          }
          case RES_CHRATR_SHADOWED:
          {
              const SvxShadowedItem& rShadowedItem = m_pBoxAutoFormat->GetShadowed();
              aRet <<= rShadowedItem.GetValue();
              return aRet;
          }
          case RES_CHRATR_CONTOUR:
          {
              const SvxContourItem& rContourItem = m_pBoxAutoFormat->GetContour();
              aRet <<= rContourItem.GetValue();
              return aRet;
          }
          case RES_CHRATR_CROSSEDOUT:
          {
              const SvxCrossedOutItem& rCrossedOutItem = m_pBoxAutoFormat->GetCrossedOut();
              rCrossedOutItem.QueryValue(aRet, pEntry->nMemberId);
              return aRet;
          }
          case RES_CHRATR_UNDERLINE:
          {
              const SvxUnderlineItem& rUnderlineItem = m_pBoxAutoFormat->GetUnderline();
              rUnderlineItem.QueryValue(aRet, pEntry->nMemberId);
              return aRet;
          }
          case RES_CHRATR_FONTSIZE:
          {
              const SvxFontHeightItem& rFontHeightItem = m_pBoxAutoFormat->GetHeight();
              rFontHeightItem.QueryValue(aRet, pEntry->nMemberId);
              return aRet;
          }
          case RES_CHRATR_WEIGHT:
          {
              const SvxWeightItem& rWeightItem = m_pBoxAutoFormat->GetWeight();
              rWeightItem.QueryValue(aRet, pEntry->nMemberId);
              return aRet;
          }
          case RES_CHRATR_POSTURE:
          {
              const SvxPostureItem& rPostureItem = m_pBoxAutoFormat->GetPosture();
              rPostureItem.QueryValue(aRet, pEntry->nMemberId);
              return aRet;
          }
          case RES_CHRATR_FONT:
          {
              const SvxFontItem rFontItem = m_pBoxAutoFormat->GetFont();
              rFontItem.QueryValue(aRet, pEntry->nMemberId);
              return aRet;
          }
          case RES_CHRATR_CJK_FONTSIZE:
          {
              const SvxFontHeightItem rFontHeightItem = m_pBoxAutoFormat->GetCJKHeight();
              rFontHeightItem.QueryValue(aRet, pEntry->nMemberId);
              return aRet;
          }
          case RES_CHRATR_CJK_WEIGHT:
          {
              const SvxWeightItem& rWeightItem = m_pBoxAutoFormat->GetCJKWeight();
              rWeightItem.QueryValue(aRet, pEntry->nMemberId);
              return aRet;
          }
          case RES_CHRATR_CJK_POSTURE:
          {
              const SvxPostureItem& rPostureItem = m_pBoxAutoFormat->GetCJKPosture();
              rPostureItem.QueryValue(aRet, pEntry->nMemberId);
              return aRet;
          }
          case RES_CHRATR_CJK_FONT:
          {
              const SvxFontItem rFontItem = m_pBoxAutoFormat->GetCJKFont();
              rFontItem.QueryValue(aRet, pEntry->nMemberId);
              return aRet;
          }
          case RES_CHRATR_CTL_FONTSIZE:
          {
              const SvxFontHeightItem rFontHeightItem = m_pBoxAutoFormat->GetCTLHeight();
              rFontHeightItem.QueryValue(aRet, pEntry->nMemberId);
              return aRet;
          }
          case RES_CHRATR_CTL_WEIGHT:
          {
              const SvxWeightItem& rWeightItem = m_pBoxAutoFormat->GetCTLWeight();
              rWeightItem.QueryValue(aRet, pEntry->nMemberId);
              return aRet;
          }
          case RES_CHRATR_CTL_POSTURE:
          {
              const SvxPostureItem& rPostureItem = m_pBoxAutoFormat->GetCTLPosture();
              rPostureItem.QueryValue(aRet, pEntry->nMemberId);
              return aRet;
          }
          case RES_CHRATR_CTL_FONT:
          {
              const SvxFontItem rFontItem = m_pBoxAutoFormat->GetCTLFont();
              rFontItem.QueryValue(aRet, pEntry->nMemberId);
              return aRet;
          }
          default:
              SAL_WARN("sw.uno", "SwXTextCellStyle unknown nWID")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "SwXTextCellStyle unknown nWID"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5186" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "SwXTextCellStyle unknown nWID"), 0)
; } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "SwXTextCellStyle unknown nWID"; ::sal::detail::log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5186" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "SwXTextCellStyle unknown nWID") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5186" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "SwXTextCellStyle unknown nWID"), 0)
; } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "SwXTextCellStyle unknown nWID"; ::sal::detail::log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5186" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
              throw css::uno::RuntimeException();
      }
  }

  throw css::beans::UnknownPropertyException(rPropertyName);
5192}

5194void SAL_CALL SwXTextCellStyle::addPropertyChangeListener( const OUString& /*aPropertyName*/, const css::uno::Reference< css::beans::XPropertyChangeListener >& /*xListener*/ )
5195{
  SAL_WARN("sw.uno", "not implemented")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "not implemented") ==
 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5196" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5196" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "not implemented") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5196" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5196" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
5197}

5199void SAL_CALL SwXTextCellStyle::removePropertyChangeListener( const OUString& /*aPropertyName*/, const css::uno::Reference< css::beans::XPropertyChangeListener >& /*aListener*/ )
5200{
  SAL_WARN("sw.uno", "not implemented")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "not implemented") ==
 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5201" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5201" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "not implemented") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5201" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5201" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
5202}

5204void SAL_CALL SwXTextCellStyle::addVetoableChangeListener( const OUString& /*PropertyName*/, const css::uno::Reference< css::beans::XVetoableChangeListener >& /*aListener*/ )
5205{
  SAL_WARN("sw.uno", "not implemented")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "not implemented") ==
 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5206" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5206" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "not implemented") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5206" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5206" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
5207}

5209void SAL_CALL SwXTextCellStyle::removeVetoableChangeListener( const OUString& /*PropertyName*/, const css::uno::Reference< css::beans::XVetoableChangeListener >& /*aListener*/ )
5210{
  SAL_WARN("sw.uno", "not implemented")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "not implemented") ==
 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5211" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5211" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "not implemented") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5211" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5211" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
5212}

5214//XPropertyState
5215css::beans::PropertyState SAL_CALL SwXTextCellStyle::getPropertyState(const OUString& rPropertyName)
5216{
  SolarMutexGuard aGuard;
  uno::Sequence<OUString> aNames { rPropertyName };
  uno::Sequence<beans::PropertyState> aStates = getPropertyStates(aNames);
  return aStates.getConstArray()[0];
5221}

5223css::uno::Sequence<css::beans::PropertyState> SAL_CALL SwXTextCellStyle::getPropertyStates(const css::uno::Sequence<OUString>& aPropertyNames)
5224{
  SolarMutexGuard aGuard;
  uno::Sequence<beans::PropertyState> aRet(aPropertyNames.getLength());
  beans::PropertyState* pStates = aRet.getArray();
  const SwBoxAutoFormat& rDefaultBoxFormat = SwTableAutoFormat::GetDefaultBoxFormat();
  const SfxItemPropertyMap& rMap = aSwMapProvider.GetPropertySet(PROPERTY_MAP_CELL_STYLE101)->getPropertyMap();
  const OUString* pNames = aPropertyNames.getConstArray();
  for(sal_Int32 i=0; i < aPropertyNames.getLength(); ++i)
  {
      const OUString sPropName = pNames[i];
      const SfxItemPropertySimpleEntry* pEntry = rMap.getByName(sPropName);
      if(pEntry)
      {
          uno::Any aAny1, aAny2;
          switch(pEntry->nWID)
          {
              case RES_BACKGROUND:
                  m_pBoxAutoFormat->GetBackground().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetBackground().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              case RES_BOX:
                  m_pBoxAutoFormat->GetBox().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetBox().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              case RES_VERT_ORIENT:
                  m_pBoxAutoFormat->GetVerticalAlignment().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetVerticalAlignment().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              case RES_FRAMEDIR:
                  m_pBoxAutoFormat->GetTextOrientation().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetTextOrientation().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              case RES_BOXATR_FORMAT:
              {
                  OUString sFormat;
                  LanguageType eLng, eSys;
                  m_pBoxAutoFormat->GetValueFormat(sFormat, eLng, eSys);
                  pStates[i] = sFormat.isEmpty() ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              }
              case RES_PARATR_ADJUST:
                  m_pBoxAutoFormat->GetAdjust().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetAdjust().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              case RES_CHRATR_COLOR:
                  m_pBoxAutoFormat->GetColor().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetColor().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              case RES_CHRATR_SHADOWED:
                  m_pBoxAutoFormat->GetShadowed().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetShadowed().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              case RES_CHRATR_CONTOUR:
                  m_pBoxAutoFormat->GetContour().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetContour().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              case RES_CHRATR_CROSSEDOUT:
                  m_pBoxAutoFormat->GetCrossedOut().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetCrossedOut().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              case RES_CHRATR_UNDERLINE:
                  m_pBoxAutoFormat->GetUnderline().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetUnderline().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              case RES_CHRATR_FONTSIZE:
                  m_pBoxAutoFormat->GetHeight().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetHeight().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              case RES_CHRATR_WEIGHT:
                  m_pBoxAutoFormat->GetWeight().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetWeight().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              case RES_CHRATR_POSTURE:
                  m_pBoxAutoFormat->GetPosture().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetPosture().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              case RES_CHRATR_FONT:
                  m_pBoxAutoFormat->GetFont().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetFont().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              case RES_CHRATR_CJK_FONTSIZE:
                  m_pBoxAutoFormat->GetCJKHeight().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetCJKHeight().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              case RES_CHRATR_CJK_WEIGHT:
                  m_pBoxAutoFormat->GetCJKWeight().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetCJKWeight().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              case RES_CHRATR_CJK_POSTURE:
                  m_pBoxAutoFormat->GetCJKPosture().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetCJKPosture().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              case RES_CHRATR_CJK_FONT:
                  m_pBoxAutoFormat->GetCJKFont().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetCJKFont().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              case RES_CHRATR_CTL_FONTSIZE:
                  m_pBoxAutoFormat->GetCTLHeight().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetCTLHeight().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              case RES_CHRATR_CTL_WEIGHT:
                  m_pBoxAutoFormat->GetCTLWeight().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetCTLWeight().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              case RES_CHRATR_CTL_POSTURE:
                  m_pBoxAutoFormat->GetCTLPosture().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetCTLPosture().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              case RES_CHRATR_CTL_FONT:
                  m_pBoxAutoFormat->GetCTLFont().QueryValue(aAny1, pEntry->nMemberId);
                  rDefaultBoxFormat.GetCTLFont().QueryValue(aAny2, pEntry->nMemberId);
                  pStates[i] = aAny1 == aAny2 ? beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
                  break;
              default:
                  // fallthrough to DIRECT_VALUE, to export properties for which getPropertyStates is not implemented
                  pStates[i] = beans::PropertyState_DIRECT_VALUE;
                  SAL_WARN("sw.uno", "SwXTextCellStyle getPropertyStates unknown nWID")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "SwXTextCellStyle getPropertyStates unknown nWID"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5361" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "SwXTextCellStyle getPropertyStates unknown nWID"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "SwXTextCellStyle getPropertyStates unknown nWID"; ::
sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"), (
"/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5361" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "SwXTextCellStyle getPropertyStates unknown nWID"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5361" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "SwXTextCellStyle getPropertyStates unknown nWID"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "SwXTextCellStyle getPropertyStates unknown nWID"; ::
sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"), (
"/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5361" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
          }
      }
      else
      {
          SAL_WARN("sw.uno", "SwXTextCellStyle unknown property:" + sPropName)do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "SwXTextCellStyle unknown property:"
 + sPropName) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5366" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "SwXTextCellStyle unknown property:"
 + sPropName), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "SwXTextCellStyle unknown property:"
 + sPropName; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5366" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "SwXTextCellStyle unknown property:" + sPropName)
 == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5366" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "SwXTextCellStyle unknown property:"
 + sPropName), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "SwXTextCellStyle unknown property:"
 + sPropName; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5366" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
          throw css::beans::UnknownPropertyException(sPropName);
      }
  }
  return aRet;
5371}

5373void SAL_CALL SwXTextCellStyle::setPropertyToDefault(const OUString& rPropertyName)
5374{
  SolarMutexGuard aGuard;
  const SwBoxAutoFormat& rDefaultBoxFormat = SwTableAutoFormat::GetDefaultBoxFormat();
  const SfxItemPropertyMap& rMap = aSwMapProvider.GetPropertySet(PROPERTY_MAP_CELL_STYLE101)->getPropertyMap();
  const SfxItemPropertySimpleEntry* pEntry = rMap.getByName(rPropertyName);
  if(!pEntry)
      return;

  uno::Any aAny;
  switch(pEntry->nWID)
  {
      case RES_BACKGROUND:
      {
          SvxBrushItem rBrush = m_pBoxAutoFormat->GetBackground();
          rDefaultBoxFormat.GetBackground().QueryValue(aAny, pEntry->nMemberId);
          rBrush.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetBackground(rBrush);
          break;
      }
      case RES_BOX:
      {
          SvxBoxItem rBox = m_pBoxAutoFormat->GetBox();
          rDefaultBoxFormat.GetBox().QueryValue(aAny, pEntry->nMemberId);
          rBox.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetBox(rBox);
          break;
      }
      case RES_VERT_ORIENT:
      {
          SwFormatVertOrient rVertOrient = m_pBoxAutoFormat->GetVerticalAlignment();
          rDefaultBoxFormat.GetVerticalAlignment().QueryValue(aAny, pEntry->nMemberId);
          rVertOrient.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetVerticalAlignment(rVertOrient);
          break;
      }
      case RES_FRAMEDIR:
      {
          SvxFrameDirectionItem rFrameDirectionItem = m_pBoxAutoFormat->GetTextOrientation();
          rDefaultBoxFormat.GetTextOrientation().QueryValue(aAny, pEntry->nMemberId);
          rFrameDirectionItem.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetTextOrientation(rFrameDirectionItem);
          break;
      }
      case RES_BOXATR_FORMAT:
      {
          OUString sFormat;
          LanguageType eLng, eSys;
          rDefaultBoxFormat.GetValueFormat(sFormat, eLng, eSys);
          m_pBoxAutoFormat->SetValueFormat(sFormat, eLng, eSys);
          break;
      }
      case RES_PARATR_ADJUST:
      {
          SvxAdjustItem rAdjustItem = m_pBoxAutoFormat->GetAdjust();
          rDefaultBoxFormat.GetAdjust().QueryValue(aAny, pEntry->nMemberId);
          rAdjustItem.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetAdjust(rAdjustItem);
          break;
      }
      case RES_CHRATR_COLOR:
      {
          SvxColorItem rColorItem = m_pBoxAutoFormat->GetColor();
          rDefaultBoxFormat.GetColor().QueryValue(aAny, pEntry->nMemberId);
          rColorItem.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetColor(rColorItem);
          break;
      }
      case RES_CHRATR_SHADOWED:
      {
          SvxShadowedItem rShadowedItem = m_pBoxAutoFormat->GetShadowed();
          rDefaultBoxFormat.GetShadowed().QueryValue(aAny, pEntry->nMemberId);
          rShadowedItem.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetShadowed(rShadowedItem);
          break;
      }
      case RES_CHRATR_CONTOUR:
      {
          SvxContourItem rContourItem = m_pBoxAutoFormat->GetContour();
          rDefaultBoxFormat.GetContour().QueryValue(aAny, pEntry->nMemberId);
          rContourItem.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetContour(rContourItem);
          break;
      }
      case RES_CHRATR_CROSSEDOUT:
      {
          SvxCrossedOutItem rCrossedOutItem = m_pBoxAutoFormat->GetCrossedOut();
          rDefaultBoxFormat.GetCrossedOut().QueryValue(aAny, pEntry->nMemberId);
          rCrossedOutItem.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetCrossedOut(rCrossedOutItem);
          break;
      }
      case RES_CHRATR_UNDERLINE:
      {
          SvxUnderlineItem rUnderlineItem = m_pBoxAutoFormat->GetUnderline();
          rDefaultBoxFormat.GetUnderline().QueryValue(aAny, pEntry->nMemberId);
          rUnderlineItem.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetUnderline(rUnderlineItem);
          break;
      }
      case RES_CHRATR_FONTSIZE:
      {
          SvxFontHeightItem rFontHeightItem = m_pBoxAutoFormat->GetHeight();
          rDefaultBoxFormat.GetHeight().QueryValue(aAny, pEntry->nMemberId);
          rFontHeightItem.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetHeight(rFontHeightItem);
          break;
      }
      case RES_CHRATR_WEIGHT:
      {
          SvxWeightItem rWeightItem = m_pBoxAutoFormat->GetWeight();
          rDefaultBoxFormat.GetWeight().QueryValue(aAny, pEntry->nMemberId);
          rWeightItem.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetWeight(rWeightItem);
          break;
      }
      case RES_CHRATR_POSTURE:
      {
          SvxPostureItem rPostureItem = m_pBoxAutoFormat->GetPosture();
          rDefaultBoxFormat.GetPosture().QueryValue(aAny, pEntry->nMemberId);
          rPostureItem.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetPosture(rPostureItem);
          break;
      }
      case RES_CHRATR_FONT:
      {
          SvxFontItem rFontItem = m_pBoxAutoFormat->GetFont();
          rDefaultBoxFormat.GetFont().QueryValue(aAny, pEntry->nMemberId);
          rFontItem.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetFont(rFontItem);
          break;
      }
      case RES_CHRATR_CJK_FONTSIZE:
      {
          SvxFontHeightItem rFontHeightItem = m_pBoxAutoFormat->GetCJKHeight();
          rDefaultBoxFormat.GetCJKHeight().QueryValue(aAny, pEntry->nMemberId);
          rFontHeightItem.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetCJKHeight(rFontHeightItem);
          break;
      }
      case RES_CHRATR_CJK_WEIGHT:
      {
          SvxWeightItem rWeightItem = m_pBoxAutoFormat->GetCJKWeight();
          rDefaultBoxFormat.GetCJKWeight().QueryValue(aAny, pEntry->nMemberId);
          rWeightItem.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetCJKWeight(rWeightItem);
          break;
      }
      case RES_CHRATR_CJK_POSTURE:
      {
          SvxPostureItem rPostureItem = m_pBoxAutoFormat->GetCJKPosture();
          rDefaultBoxFormat.GetCJKPosture().QueryValue(aAny, pEntry->nMemberId);
          rPostureItem.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetCJKPosture(rPostureItem);
          break;
      }
      case RES_CHRATR_CJK_FONT:
      {
          SvxFontItem rFontItem = m_pBoxAutoFormat->GetCJKFont();
          rDefaultBoxFormat.GetCJKFont().QueryValue(aAny, pEntry->nMemberId);
          rFontItem.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetCJKFont(rFontItem);
          break;
      }
      case RES_CHRATR_CTL_FONTSIZE:
      {
          SvxFontHeightItem rFontHeightItem = m_pBoxAutoFormat->GetCTLHeight();
          rDefaultBoxFormat.GetCTLHeight().QueryValue(aAny, pEntry->nMemberId);
          rFontHeightItem.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetCTLHeight(rFontHeightItem);
          break;
      }
      case RES_CHRATR_CTL_WEIGHT:
      {
          SvxWeightItem rWeightItem = m_pBoxAutoFormat->GetCTLWeight();
          rDefaultBoxFormat.GetCTLWeight().QueryValue(aAny, pEntry->nMemberId);
          rWeightItem.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetCTLWeight(rWeightItem);
          break;
      }
      case RES_CHRATR_CTL_POSTURE:
      {
          SvxPostureItem rPostureItem = m_pBoxAutoFormat->GetCTLPosture();
          rDefaultBoxFormat.GetCTLPosture().QueryValue(aAny, pEntry->nMemberId);
          rPostureItem.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetCTLPosture(rPostureItem);
          break;
      }
      case RES_CHRATR_CTL_FONT:
      {
          SvxFontItem rFontItem = m_pBoxAutoFormat->GetCTLFont();
          rDefaultBoxFormat.GetCTLFont().QueryValue(aAny, pEntry->nMemberId);
          rFontItem.PutValue(aAny, pEntry->nMemberId);
          m_pBoxAutoFormat->SetCTLFont(rFontItem);
          break;
      }
      default:
          SAL_WARN("sw.uno", "SwXTextCellStyle setPropertyToDefault unknown nWID")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "SwXTextCellStyle setPropertyToDefault unknown nWID"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5570" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "SwXTextCellStyle setPropertyToDefault unknown nWID"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "SwXTextCellStyle setPropertyToDefault unknown nWID"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5570" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "SwXTextCellStyle setPropertyToDefault unknown nWID"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5570" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "SwXTextCellStyle setPropertyToDefault unknown nWID"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "SwXTextCellStyle setPropertyToDefault unknown nWID"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5570" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  }
5572}

5574css::uno::Any SAL_CALL SwXTextCellStyle::getPropertyDefault(const OUString& /*aPropertyName*/)
5575{
  SAL_WARN("sw.uno", "not implemented")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "not implemented") ==
 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.uno"
), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5576" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5576" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "not implemented") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5576" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "not implemented"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "not implemented"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.uno"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx"
 ":" "5576" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  uno::Any aRet;
  return aRet;
5579}

5581//XServiceInfo
5582OUString SAL_CALL SwXTextCellStyle::getImplementationName()
5583{
  return {"SwXTextCellStyle"};
5585}

5587sal_Bool SAL_CALL SwXTextCellStyle::supportsService(const OUString& rServiceName)
5588{
  return cppu::supportsService(this, rServiceName);
5590}

5592css::uno::Sequence<OUString> SAL_CALL SwXTextCellStyle::getSupportedServiceNames()
5593{
  return {"com.sun.star.style.Style"};
5595}

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

←

/usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/bits/stl_algo.h

→

1// Algorithm implementation -*- C++ -*-

3// Copyright (C) 2001-2020 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*/

51/** @file bits/stl_algo.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{algorithm}
*/

56#ifndef _STL_ALGO_H1
57#define _STL_ALGO_H1 1

59#include <cstdlib>	     // for rand
60#include <bits/algorithmfwd.h>
61#include <bits/stl_heap.h>
62#include <bits/stl_tempbuf.h>  // for _Temporary_buffer
63#include <bits/predefined_ops.h>

65#if __cplusplus201703L >= 201103L
66#include <bits/uniform_int_dist.h>
67#endif

69// See concept_check.h for the __glibcxx_*_requires macros.

71namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
72{
73_GLIBCXX_BEGIN_NAMESPACE_VERSION

/// Swaps the median value of *__a, *__b and *__c under __comp to *__result
template<typename _Iterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b,
	   _Iterator __c, _Compare __comp)
  {
    if (__comp(__a, __b))
{
 if (__comp(__b, __c))
   std::iter_swap(__result, __b);
 else if (__comp(__a, __c))
   std::iter_swap(__result, __c);
 else
   std::iter_swap(__result, __a);
}
    else if (__comp(__a, __c))
std::iter_swap(__result, __a);
    else if (__comp(__b, __c))
std::iter_swap(__result, __c);
    else
std::iter_swap(__result, __b);
  }

/// Provided for stable_partition to use.
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline _InputIterator
  __find_if_not(_InputIterator __first, _InputIterator __last,
  _Predicate __pred)
  {
    return std::__find_if(__first, __last,
	    __gnu_cxx::__ops::__negate(__pred),
	    std::__iterator_category(__first));
  }

/// Like find_if_not(), but uses and updates a count of the
/// remaining range length instead of comparing against an end
/// iterator.
template<typename _InputIterator, typename _Predicate, typename _Distance>
  _GLIBCXX20_CONSTEXPR
  _InputIterator
  __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
  {
    for (; __len; --__len,  (void) ++__first)
if (!__pred(__first))
 break;
    return __first;
  }

// set_difference
// set_intersection
// set_symmetric_difference
// set_union
// for_each
// find
// find_if
// find_first_of
// adjacent_find
// count
// count_if
// search

template<typename _ForwardIterator1, typename _ForwardIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator1
  __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    _ForwardIterator2 __first2, _ForwardIterator2 __last2,
    _BinaryPredicate  __predicate)
  {
    // Test for empty ranges
    if (__first1 == __last1 || __first2 == __last2)
return __first1;

    // Test for a pattern of length 1.
    _ForwardIterator2 __p1(__first2);
    if (++__p1 == __last2)
return std::__find_if(__first1, __last1,
__gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));

    // General case.
    _ForwardIterator1 __current = __first1;

    for (;;)
{
 __first1 =
   std::__find_if(__first1, __last1,
__gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));

 if (__first1 == __last1)
   return __last1;

 _ForwardIterator2 __p = __p1;
 __current = __first1;
 if (++__current == __last1)
   return __last1;

 while (__predicate(__current, __p))
   {
     if (++__p == __last2)
return __first1;
     if (++__current == __last1)
return __last1;
   }
 ++__first1;
}
    return __first1;
  }

// search_n

/**
 *  This is an helper function for search_n overloaded for forward iterators.
*/
template<typename _ForwardIterator, typename _Integer,
  typename _UnaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __search_n_aux(_ForwardIterator __first, _ForwardIterator __last,
   _Integer __count, _UnaryPredicate __unary_pred,
   std::forward_iterator_tag)
  {
    __first = std::__find_if(__first, __last, __unary_pred);
    while (__first != __last)
{
 typename iterator_traits<_ForwardIterator>::difference_type
   __n = __count;
 _ForwardIterator __i = __first;
 ++__i;
 while (__i != __last && __n != 1 && __unary_pred(__i))
   {
     ++__i;
     --__n;
   }
 if (__n == 1)
   return __first;
 if (__i == __last)
   return __last;
 __first = std::__find_if(++__i, __last, __unary_pred);
}
    return __last;
  }

/**
 *  This is an helper function for search_n overloaded for random access
 *  iterators.
*/
template<typename _RandomAccessIter, typename _Integer,
  typename _UnaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _RandomAccessIter
  __search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last,
   _Integer __count, _UnaryPredicate __unary_pred,
   std::random_access_iterator_tag)
  {
    typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
_DistanceType;

    _DistanceType __tailSize = __last - __first;
    _DistanceType __remainder = __count;

    while (__remainder <= __tailSize) // the main loop...
{
 __first += __remainder;
 __tailSize -= __remainder;
 // __first here is always pointing to one past the last element of
 // next possible match.
 _RandomAccessIter __backTrack = __first; 
 while (__unary_pred(--__backTrack))
   {
     if (--__remainder == 0)
return (__first - __count); // Success
   }
 __remainder = __count + 1 - (__first - __backTrack);
}
    return __last; // Failure
  }

template<typename _ForwardIterator, typename _Integer,
  typename _UnaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __search_n(_ForwardIterator __first, _ForwardIterator __last,
      _Integer __count,
      _UnaryPredicate __unary_pred)
  {
    if (__count <= 0)
return __first;

    if (__count == 1)
return std::__find_if(__first, __last, __unary_pred);

    return std::__search_n_aux(__first, __last, __count, __unary_pred,
		 std::__iterator_category(__first));
  }

// find_end for forward iterators.
template<typename _ForwardIterator1, typename _ForwardIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator1
  __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
      forward_iterator_tag, forward_iterator_tag,
      _BinaryPredicate __comp)
  {
    if (__first2 == __last2)
return __last1;

    _ForwardIterator1 __result = __last1;
    while (1)
{
 _ForwardIterator1 __new_result
   = std::__search(__first1, __last1, __first2, __last2, __comp);
 if (__new_result == __last1)
   return __result;
 else
   {
     __result = __new_result;
     __first1 = __new_result;
     ++__first1;
   }
}
  }

// find_end for bidirectional iterators (much faster).
template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _BidirectionalIterator1
  __find_end(_BidirectionalIterator1 __first1,
      _BidirectionalIterator1 __last1,
      _BidirectionalIterator2 __first2,
      _BidirectionalIterator2 __last2,
      bidirectional_iterator_tag, bidirectional_iterator_tag,
      _BinaryPredicate __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_BidirectionalIteratorConcept<
		  _BidirectionalIterator1>)
    __glibcxx_function_requires(_BidirectionalIteratorConcept<
		  _BidirectionalIterator2>)

    typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
    typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;

    _RevIterator1 __rlast1(__first1);
    _RevIterator2 __rlast2(__first2);
    _RevIterator1 __rresult = std::__search(_RevIterator1(__last1), __rlast1,
			      _RevIterator2(__last2), __rlast2,
			      __comp);

    if (__rresult == __rlast1)
return __last1;
    else
{
 _BidirectionalIterator1 __result = __rresult.base();
 std::advance(__result, -std::distance(__first2, __last2));
 return __result;
}
  }

/**
 *  @brief  Find last matching subsequence in a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  Start of range to search.
 *  @param  __last1   End of range to search.
 *  @param  __first2  Start of sequence to match.
 *  @param  __last2   End of sequence to match.
 *  @return   The last iterator @c i in the range
 *  @p [__first1,__last1-(__last2-__first2)) such that @c *(i+N) ==
 *  @p *(__first2+N) for each @c N in the range @p
 *  [0,__last2-__first2), or @p __last1 if no such iterator exists.
 *
 *  Searches the range @p [__first1,__last1) for a sub-sequence that
 *  compares equal value-by-value with the sequence given by @p
 *  [__first2,__last2) and returns an iterator to the __first
 *  element of the sub-sequence, or @p __last1 if the sub-sequence
 *  is not found.  The sub-sequence will be the last such
 *  subsequence contained in [__first1,__last1).
 *
 *  Because the sub-sequence must lie completely within the range @p
 *  [__first1,__last1) it must start at a position less than @p
 *  __last1-(__last2-__first2) where @p __last2-__first2 is the
 *  length of the sub-sequence.  This means that the returned
 *  iterator @c i will be in the range @p
 *  [__first1,__last1-(__last2-__first2))
*/
template<typename _ForwardIterator1, typename _ForwardIterator2>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator1
  find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    _ForwardIterator2 __first2, _ForwardIterator2 __last2)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_ForwardIterator1>::value_type,
   typename iterator_traits<_ForwardIterator2>::value_type>)
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    return std::__find_end(__first1, __last1, __first2, __last2,
	     std::__iterator_category(__first1),
	     std::__iterator_category(__first2),
	     __gnu_cxx::__ops::__iter_equal_to_iter());
  }

/**
 *  @brief  Find last matching subsequence in a sequence using a predicate.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  Start of range to search.
 *  @param  __last1   End of range to search.
 *  @param  __first2  Start of sequence to match.
 *  @param  __last2   End of sequence to match.
 *  @param  __comp    The predicate to use.
 *  @return The last iterator @c i in the range @p
 *  [__first1,__last1-(__last2-__first2)) such that @c
 *  predicate(*(i+N), @p (__first2+N)) is true for each @c N in the
 *  range @p [0,__last2-__first2), or @p __last1 if no such iterator
 *  exists.
 *
 *  Searches the range @p [__first1,__last1) for a sub-sequence that
 *  compares equal value-by-value with the sequence given by @p
 *  [__first2,__last2) using comp as a predicate and returns an
 *  iterator to the first element of the sub-sequence, or @p __last1
 *  if the sub-sequence is not found.  The sub-sequence will be the
 *  last such subsequence contained in [__first,__last1).
 *
 *  Because the sub-sequence must lie completely within the range @p
 *  [__first1,__last1) it must start at a position less than @p
 *  __last1-(__last2-__first2) where @p __last2-__first2 is the
 *  length of the sub-sequence.  This means that the returned
 *  iterator @c i will be in the range @p
 *  [__first1,__last1-(__last2-__first2))
*/
template<typename _ForwardIterator1, typename _ForwardIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator1
  find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    _ForwardIterator2 __first2, _ForwardIterator2 __last2,
    _BinaryPredicate __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
   typename iterator_traits<_ForwardIterator1>::value_type,
   typename iterator_traits<_ForwardIterator2>::value_type>)
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    return std::__find_end(__first1, __last1, __first2, __last2,
	     std::__iterator_category(__first1),
	     std::__iterator_category(__first2),
	     __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

436#if __cplusplus201703L >= 201103L
/**
 *  @brief  Checks that a predicate is true for all the elements
 *          of a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __pred    A predicate.
 *  @return  True if the check is true, false otherwise.
 *
 *  Returns true if @p __pred is true for each element in the range
 *  @p [__first,__last), and false otherwise.
*/
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline bool
  all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
  { return __last == std::find_if_not(__first, __last, __pred); }

/**
 *  @brief  Checks that a predicate is false for all the elements
 *          of a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __pred    A predicate.
 *  @return  True if the check is true, false otherwise.
 *
 *  Returns true if @p __pred is false for each element in the range
 *  @p [__first,__last), and false otherwise.
*/
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline bool
  none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
  { return __last == _GLIBCXX_STD_Astd::find_if(__first, __last, __pred); }
13
←
Calling 'operator==<const SfxItemPropertyNamedEntry *, std::vector<SfxItemPropertyNamedEntry, std::allocator<SfxItemPropertyNamedEntry>>>'→
16
←
Returning from 'operator==<const SfxItemPropertyNamedEntry *, std::vector<SfxItemPropertyNamedEntry, std::allocator<SfxItemPropertyNamedEntry>>>'→
17
←
Returning the value 1, which participates in a condition later→

/**
 *  @brief  Checks that a predicate is false for at least an element
 *          of a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __pred    A predicate.
 *  @return  True if the check is true, false otherwise.
 *
 *  Returns true if an element exists in the range @p
 *  [__first,__last) such that @p __pred is true, and false
 *  otherwise.
*/
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline bool
  any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
  { return !std::none_of(__first, __last, __pred); }
12
←
Calling 'none_of<__gnu_cxx::__normal_iterator<const SfxItemPropertyNamedEntry *, std::vector<SfxItemPropertyNamedEntry, std::allocator<SfxItemPropertyNamedEntry>>>, (lambda at /home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx:1153:13)>'→
18
←
Returning from 'none_of<__gnu_cxx::__normal_iterator<const SfxItemPropertyNamedEntry *, std::vector<SfxItemPropertyNamedEntry, std::allocator<SfxItemPropertyNamedEntry>>>, (lambda at /home/maarten/src/libreoffice/core/sw/source/core/unocore/unostyle.cxx:1153:13)>'→
19
←
Returning zero, which participates in a condition later→

/**
 *  @brief  Find the first element in a sequence for which a
 *          predicate is false.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __pred   A predicate.
 *  @return   The first iterator @c i in the range @p [__first,__last)
 *  such that @p __pred(*i) is false, or @p __last if no such iterator exists.
*/
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline _InputIterator
  find_if_not(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
     typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    return std::__find_if_not(__first, __last,
		__gnu_cxx::__ops::__pred_iter(__pred));
  }

/**
 *  @brief  Checks whether the sequence is partitioned.
 *  @ingroup mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __pred   A predicate.
 *  @return  True if the range @p [__first,__last) is partioned by @p __pred,
 *  i.e. if all elements that satisfy @p __pred appear before those that
 *  do not.
*/
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline bool
  is_partitioned(_InputIterator __first, _InputIterator __last,
   _Predicate __pred)
  {
    __first = std::find_if_not(__first, __last, __pred);
    if (__first == __last)
return true;
    ++__first;
    return std::none_of(__first, __last, __pred);
  }

/**
 *  @brief  Find the partition point of a partitioned range.
 *  @ingroup mutating_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __pred    A predicate.
 *  @return  An iterator @p mid such that @p all_of(__first, mid, __pred)
 *           and @p none_of(mid, __last, __pred) are both true.
*/
template<typename _ForwardIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  partition_point(_ForwardIterator __first, _ForwardIterator __last,
    _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
     typename iterator_traits<_ForwardIterator>::value_type>)

    // A specific debug-mode test will be necessary...
    __glibcxx_requires_valid_range(__first, __last);

    typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;

    _DistanceType __len = std::distance(__first, __last);

    while (__len > 0)
{
 _DistanceType __half = __len >> 1;
 _ForwardIterator __middle = __first;
 std::advance(__middle, __half);
 if (__pred(*__middle))
   {
     __first = __middle;
     ++__first;
     __len = __len - __half - 1;
   }
 else
   __len = __half;
}
    return __first;
  }
584#endif

template<typename _InputIterator, typename _OutputIterator,
  typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __remove_copy_if(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result, _Predicate __pred)
  {
    for (; __first != __last; ++__first)
if (!__pred(__first))
 {
   *__result = *__first;
   ++__result;
 }
    return __result;
  }

/**
 *  @brief Copy a sequence, removing elements of a given value.
 *  @ingroup mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __result  An output iterator.
 *  @param  __value   The value to be removed.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  Copies each element in the range @p [__first,__last) not equal
 *  to @p __value to the range beginning at @p __result.
 *  remove_copy() is stable, so the relative order of elements that
 *  are copied is unchanged.
*/
template<typename _InputIterator, typename _OutputIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  remove_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, const _Tp& __value)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_InputIterator>::value_type, _Tp>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__remove_copy_if(__first, __last, __result,
__gnu_cxx::__ops::__iter_equals_val(__value));
  }

/**
 *  @brief Copy a sequence, removing elements for which a predicate is true.
 *  @ingroup mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __result  An output iterator.
 *  @param  __pred    A predicate.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  Copies each element in the range @p [__first,__last) for which
 *  @p __pred returns false to the range beginning at @p __result.
 *
 *  remove_copy_if() is stable, so the relative order of elements that are
 *  copied is unchanged.
*/
template<typename _InputIterator, typename _OutputIterator,
  typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  remove_copy_if(_InputIterator __first, _InputIterator __last,
   _OutputIterator __result, _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__remove_copy_if(__first, __last, __result,
		   __gnu_cxx::__ops::__pred_iter(__pred));
  }

668#if __cplusplus201703L >= 201103L
/**
 *  @brief Copy the elements of a sequence for which a predicate is true.
 *  @ingroup mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __result  An output iterator.
 *  @param  __pred    A predicate.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  Copies each element in the range @p [__first,__last) for which
 *  @p __pred returns true to the range beginning at @p __result.
 *
 *  copy_if() is stable, so the relative order of elements that are
 *  copied is unchanged.
*/
template<typename _InputIterator, typename _OutputIterator,
  typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  copy_if(_InputIterator __first, _InputIterator __last,
   _OutputIterator __result, _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    for (; __first != __last; ++__first)
if (__pred(*__first))
 {
   *__result = *__first;
   ++__result;
 }
    return __result;
  }

template<typename _InputIterator, typename _Size, typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result)
  {
    if (__n > 0)
{
 while (true)
   {
     *__result = *__first;
     ++__result;
     if (--__n > 0)
++__first;
     else
break;
   }
}
    return __result;
  }

template<typename _CharT, typename _Size>
  __enable_if_t<__is_char<_CharT>::__value, _CharT*>
  __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT>>,
      _Size, _CharT*);

template<typename _InputIterator, typename _Size, typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __copy_n(_InputIterator __first, _Size __n,
    _OutputIterator __result, input_iterator_tag)
  {
    return std::__niter_wrap(__result,
	       __copy_n_a(__first, __n,
			  std::__niter_base(__result)));
  }

template<typename _RandomAccessIterator, typename _Size,
  typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  __copy_n(_RandomAccessIterator __first, _Size __n,
    _OutputIterator __result, random_access_iterator_tag)
  { return std::copy(__first, __first + __n, __result); }

/**
 *  @brief Copies the range [first,first+n) into [result,result+n).
 *  @ingroup mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __n      The number of elements to copy.
 *  @param  __result An output iterator.
 *  @return  result+n.
 *
 *  This inline function will boil down to a call to @c memmove whenever
 *  possible.  Failing that, if random access iterators are passed, then the
 *  loop count will be known (and therefore a candidate for compiler
 *  optimizations such as unrolling).
*/
template<typename _InputIterator, typename _Size, typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_can_increment(__first, __n);
    __glibcxx_requires_can_increment(__result, __n);

    return std::__copy_n(__first, __n, __result,
	   std::__iterator_category(__first));
  }

/**
 *  @brief Copy the elements of a sequence to separate output sequences
 *         depending on the truth value of a predicate.
 *  @ingroup mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __out_true   An output iterator.
 *  @param  __out_false  An output iterator.
 *  @param  __pred    A predicate.
 *  @return   A pair designating the ends of the resulting sequences.
 *
 *  Copies each element in the range @p [__first,__last) for which
 *  @p __pred returns true to the range beginning at @p out_true
 *  and each element for which @p __pred returns false to @p __out_false.
*/
template<typename _InputIterator, typename _OutputIterator1,
  typename _OutputIterator2, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  pair<_OutputIterator1, _OutputIterator2>
  partition_copy(_InputIterator __first, _InputIterator __last,
   _OutputIterator1 __out_true, _OutputIterator2 __out_false,
   _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator1,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator2,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    
    for (; __first != __last; ++__first)
if (__pred(*__first))
 {
   *__out_true = *__first;
   ++__out_true;
 }
else
 {
   *__out_false = *__first;
   ++__out_false;
 }

    return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
  }
828#endif // C++11

template<typename _ForwardIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __remove_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
  {
    __first = std::__find_if(__first, __last, __pred);
    if (__first == __last)
return __first;
    _ForwardIterator __result = __first;
    ++__first;
    for (; __first != __last; ++__first)
if (!__pred(__first))
 {
   *__result = _GLIBCXX_MOVE(*__first)std::move(*__first);
   ++__result;
 }
    return __result;
  }

/**
 *  @brief Remove elements from a sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __value  The value to be removed.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  All elements equal to @p __value are removed from the range
 *  @p [__first,__last).
 *
 *  remove() is stable, so the relative order of elements that are
 *  not removed is unchanged.
 *
 *  Elements between the end of the resulting sequence and @p __last
 *  are still present, but their value is unspecified.
*/
template<typename _ForwardIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  remove(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __value)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__remove_if(__first, __last,
__gnu_cxx::__ops::__iter_equals_val(__value));
  }

/**
 *  @brief Remove elements from a sequence using a predicate.
 *  @ingroup mutating_algorithms
 *  @param  __first  A forward iterator.
 *  @param  __last   A forward iterator.
 *  @param  __pred   A predicate.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  All elements for which @p __pred returns true are removed from the range
 *  @p [__first,__last).
 *
 *  remove_if() is stable, so the relative order of elements that are
 *  not removed is unchanged.
 *
 *  Elements between the end of the resulting sequence and @p __last
 *  are still present, but their value is unspecified.
*/
template<typename _ForwardIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  remove_if(_ForwardIterator __first, _ForwardIterator __last,
     _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__remove_if(__first, __last,
	      __gnu_cxx::__ops::__pred_iter(__pred));
  }

template<typename _ForwardIterator, typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
    _BinaryPredicate __binary_pred)
  {
    if (__first == __last)
return __last;
    _ForwardIterator __next = __first;
    while (++__next != __last)
{
 if (__binary_pred(__first, __next))
   return __first;
 __first = __next;
}
    return __last;
  }

template<typename _ForwardIterator, typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __unique(_ForwardIterator __first, _ForwardIterator __last,
    _BinaryPredicate __binary_pred)
  {
    // Skip the beginning, if already unique.
    __first = std::__adjacent_find(__first, __last, __binary_pred);
    if (__first == __last)
return __last;

    // Do the real copy work.
    _ForwardIterator __dest = __first;
    ++__first;
    while (++__first != __last)
if (!__binary_pred(__dest, __first))
 *++__dest = _GLIBCXX_MOVE(*__first)std::move(*__first);
    return ++__dest;
  }

/**
 *  @brief Remove consecutive duplicate values from a sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first  A forward iterator.
 *  @param  __last   A forward iterator.
 *  @return  An iterator designating the end of the resulting sequence.
 *
 *  Removes all but the first element from each group of consecutive
 *  values that compare equal.
 *  unique() is stable, so the relative order of elements that are
 *  not removed is unchanged.
 *  Elements between the end of the resulting sequence and @p __last
 *  are still present, but their value is unspecified.
*/
template<typename _ForwardIterator>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  unique(_ForwardIterator __first, _ForwardIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_EqualityComparableConcept<
     typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__unique(__first, __last,
	   __gnu_cxx::__ops::__iter_equal_to_iter());
  }

/**
 *  @brief Remove consecutive values from a sequence using a predicate.
 *  @ingroup mutating_algorithms
 *  @param  __first        A forward iterator.
 *  @param  __last         A forward iterator.
 *  @param  __binary_pred  A binary predicate.
 *  @return  An iterator designating the end of the resulting sequence.
 *
 *  Removes all but the first element from each group of consecutive
 *  values for which @p __binary_pred returns true.
 *  unique() is stable, so the relative order of elements that are
 *  not removed is unchanged.
 *  Elements between the end of the resulting sequence and @p __last
 *  are still present, but their value is unspecified.
*/
template<typename _ForwardIterator, typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  unique(_ForwardIterator __first, _ForwardIterator __last,
  _BinaryPredicate __binary_pred)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
typename iterator_traits<_ForwardIterator>::value_type,
typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__unique(__first, __last,
	   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
  }

/**
 *  This is an uglified
 *  unique_copy(_InputIterator, _InputIterator, _OutputIterator,
 *              _BinaryPredicate)
 *  overloaded for forward iterators and output iterator as result.
*/
template<typename _ForwardIterator, typename _OutputIterator,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
  _OutputIterator __result, _BinaryPredicate __binary_pred,
  forward_iterator_tag, output_iterator_tag)
  {
    // concept requirements -- iterators already checked
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
 typename iterator_traits<_ForwardIterator>::value_type,
 typename iterator_traits<_ForwardIterator>::value_type>)

    _ForwardIterator __next = __first;
    *__result = *__first;
    while (++__next != __last)
if (!__binary_pred(__first, __next))
 {
   __first = __next;
   *++__result = *__first;
 }
    return ++__result;
  }

/**
 *  This is an uglified
 *  unique_copy(_InputIterator, _InputIterator, _OutputIterator,
 *              _BinaryPredicate)
 *  overloaded for input iterators and output iterator as result.
*/
template<typename _InputIterator, typename _OutputIterator,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __unique_copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result, _BinaryPredicate __binary_pred,
  input_iterator_tag, output_iterator_tag)
  {
    // concept requirements -- iterators already checked
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
 typename iterator_traits<_InputIterator>::value_type,
 typename iterator_traits<_InputIterator>::value_type>)

    typename iterator_traits<_InputIterator>::value_type __value = *__first;
    __decltype(__gnu_cxx::__ops::__iter_comp_val(__binary_pred))
__rebound_pred
= __gnu_cxx::__ops::__iter_comp_val(__binary_pred);
    *__result = __value;
    while (++__first != __last)
if (!__rebound_pred(__first, __value))
 {
   __value = *__first;
   *++__result = __value;
 }
    return ++__result;
  }

/**
 *  This is an uglified
 *  unique_copy(_InputIterator, _InputIterator, _OutputIterator,
 *              _BinaryPredicate)
 *  overloaded for input iterators and forward iterator as result.
*/
template<typename _InputIterator, typename _ForwardIterator,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __unique_copy(_InputIterator __first, _InputIterator __last,
  _ForwardIterator __result, _BinaryPredicate __binary_pred,
  input_iterator_tag, forward_iterator_tag)
  {
    // concept requirements -- iterators already checked
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
 typename iterator_traits<_ForwardIterator>::value_type,
 typename iterator_traits<_InputIterator>::value_type>)
    *__result = *__first;
    while (++__first != __last)
if (!__binary_pred(__result, __first))
 *++__result = *__first;
    return ++__result;
  }

/**
 *  This is an uglified reverse(_BidirectionalIterator,
 *                              _BidirectionalIterator)
 *  overloaded for bidirectional iterators.
*/
template<typename _BidirectionalIterator>
  _GLIBCXX20_CONSTEXPR
  void
  __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
     bidirectional_iterator_tag)
  {
    while (true)
if (__first == __last || __first == --__last)
 return;
else
 {
   std::iter_swap(__first, __last);
   ++__first;
 }
  }

/**
 *  This is an uglified reverse(_BidirectionalIterator,
 *                              _BidirectionalIterator)
 *  overloaded for random access iterators.
*/
template<typename _RandomAccessIterator>
  _GLIBCXX20_CONSTEXPR
  void
  __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
     random_access_iterator_tag)
  {
    if (__first == __last)
return;
    --__last;
    while (__first < __last)
{
 std::iter_swap(__first, __last);
 ++__first;
 --__last;
}
  }

/**
 *  @brief Reverse a sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first  A bidirectional iterator.
 *  @param  __last   A bidirectional iterator.
 *  @return   reverse() returns no value.
 *
 *  Reverses the order of the elements in the range @p [__first,__last),
 *  so that the first element becomes the last etc.
 *  For every @c i such that @p 0<=i<=(__last-__first)/2), @p reverse()
 *  swaps @p *(__first+i) and @p *(__last-(i+1))
*/
template<typename _BidirectionalIterator>
  _GLIBCXX20_CONSTEXPR
  inline void
  reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
		  _BidirectionalIterator>)
    __glibcxx_requires_valid_range(__first, __last);
    std::__reverse(__first, __last, std::__iterator_category(__first));
  }

/**
 *  @brief Copy a sequence, reversing its elements.
 *  @ingroup mutating_algorithms
 *  @param  __first   A bidirectional iterator.
 *  @param  __last    A bidirectional iterator.
 *  @param  __result  An output iterator.
 *  @return  An iterator designating the end of the resulting sequence.
 *
 *  Copies the elements in the range @p [__first,__last) to the
 *  range @p [__result,__result+(__last-__first)) such that the
 *  order of the elements is reversed.  For every @c i such that @p
 *  0<=i<=(__last-__first), @p reverse_copy() performs the
 *  assignment @p *(__result+(__last-__first)-1-i) = *(__first+i).
 *  The ranges @p [__first,__last) and @p
 *  [__result,__result+(__last-__first)) must not overlap.
*/
template<typename _BidirectionalIterator, typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
 _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_BidirectionalIteratorConcept<
		  _BidirectionalIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
typename iterator_traits<_BidirectionalIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    while (__first != __last)
{
 --__last;
 *__result = *__last;
 ++__result;
}
    return __result;
  }

/**
 *  This is a helper function for the rotate algorithm specialized on RAIs.
 *  It returns the greatest common divisor of two integer values.
*/
template<typename _EuclideanRingElement>
  _GLIBCXX20_CONSTEXPR
  _EuclideanRingElement
  __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
  {
    while (__n != 0)
{
 _EuclideanRingElement __t = __m % __n;
 __m = __n;
 __n = __t;
}
    return __m;
  }

inline namespace _V2
{

/// This is a helper function for the rotate algorithm.
template<typename _ForwardIterator>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __rotate(_ForwardIterator __first,
    _ForwardIterator __middle,
    _ForwardIterator __last,
    forward_iterator_tag)
  {
    if (__first == __middle)
return __last;
    else if (__last == __middle)
return __first;

    _ForwardIterator __first2 = __middle;
    do
{
 std::iter_swap(__first, __first2);
 ++__first;
 ++__first2;
 if (__first == __middle)
   __middle = __first2;
}
    while (__first2 != __last);

    _ForwardIterator __ret = __first;

    __first2 = __middle;

    while (__first2 != __last)
{
 std::iter_swap(__first, __first2);
 ++__first;
 ++__first2;
 if (__first == __middle)
   __middle = __first2;
 else if (__first2 == __last)
   __first2 = __middle;
}
    return __ret;
  }

 /// This is a helper function for the rotate algorithm.
template<typename _BidirectionalIterator>
  _GLIBCXX20_CONSTEXPR
  _BidirectionalIterator
  __rotate(_BidirectionalIterator __first,
    _BidirectionalIterator __middle,
    _BidirectionalIterator __last,
     bidirectional_iterator_tag)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
		  _BidirectionalIterator>)

    if (__first == __middle)
return __last;
    else if (__last == __middle)
return __first;

    std::__reverse(__first,  __middle, bidirectional_iterator_tag());
    std::__reverse(__middle, __last,   bidirectional_iterator_tag());

    while (__first != __middle && __middle != __last)
{
 std::iter_swap(__first, --__last);
 ++__first;
}

    if (__first == __middle)
{
 std::__reverse(__middle, __last,   bidirectional_iterator_tag());
 return __last;
}
    else
{
 std::__reverse(__first,  __middle, bidirectional_iterator_tag());
 return __first;
}
  }

/// This is a helper function for the rotate algorithm.
template<typename _RandomAccessIterator>
  _GLIBCXX20_CONSTEXPR
  _RandomAccessIterator
  __rotate(_RandomAccessIterator __first,
    _RandomAccessIterator __middle,
    _RandomAccessIterator __last,
    random_access_iterator_tag)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
		  _RandomAccessIterator>)

    if (__first == __middle)
return __last;
    else if (__last == __middle)
return __first;

    typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_Distance;
    typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;

    _Distance __n = __last   - __first;
    _Distance __k = __middle - __first;

    if (__k == __n - __k)
{
 std::swap_ranges(__first, __middle, __middle);
 return __middle;
}

    _RandomAccessIterator __p = __first;
    _RandomAccessIterator __ret = __first + (__last - __middle);

    for (;;)
{
 if (__k < __n - __k)
   {
     if (__is_pod(_ValueType) && __k == 1)
{
  _ValueType __t = _GLIBCXX_MOVE(*__p)std::move(*__p);
  _GLIBCXX_MOVE3(__p + 1, __p + __n, __p)std::move(__p + 1, __p + __n, __p);
  *(__p + __n - 1) = _GLIBCXX_MOVE(__t)std::move(__t);
  return __ret;
}
     _RandomAccessIterator __q = __p + __k;
     for (_Distance __i = 0; __i < __n - __k; ++ __i)
{
  std::iter_swap(__p, __q);
  ++__p;
  ++__q;
}
     __n %= __k;
     if (__n == 0)
return __ret;
     std::swap(__n, __k);
     __k = __n - __k;
   }
 else
   {
     __k = __n - __k;
     if (__is_pod(_ValueType) && __k == 1)
{
  _ValueType __t = _GLIBCXX_MOVE(*(__p + __n - 1))std::move(*(__p + __n - 1));
  _GLIBCXX_MOVE_BACKWARD3(__p, __p + __n - 1, __p + __n)std::move_backward(__p, __p + __n - 1, __p + __n);
  *__p = _GLIBCXX_MOVE(__t)std::move(__t);
  return __ret;
}
     _RandomAccessIterator __q = __p + __n;
     __p = __q - __k;
     for (_Distance __i = 0; __i < __n - __k; ++ __i)
{
  --__p;
  --__q;
  std::iter_swap(__p, __q);
}
     __n %= __k;
     if (__n == 0)
return __ret;
     std::swap(__n, __k);
   }
}
  }

 // _GLIBCXX_RESOLVE_LIB_DEFECTS
 // DR 488. rotate throws away useful information
/**
 *  @brief Rotate the elements of a sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first   A forward iterator.
 *  @param  __middle  A forward iterator.
 *  @param  __last    A forward iterator.
 *  @return  first + (last - middle).
 *
 *  Rotates the elements of the range @p [__first,__last) by 
 *  @p (__middle - __first) positions so that the element at @p __middle
 *  is moved to @p __first, the element at @p __middle+1 is moved to
 *  @p __first+1 and so on for each element in the range
 *  @p [__first,__last).
 *
 *  This effectively swaps the ranges @p [__first,__middle) and
 *  @p [__middle,__last).
 *
 *  Performs
 *   @p *(__first+(n+(__last-__middle))%(__last-__first))=*(__first+n)
 *  for each @p n in the range @p [0,__last-__first).
*/
template<typename _ForwardIterator>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  rotate(_ForwardIterator __first, _ForwardIterator __middle,
  _ForwardIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_requires_valid_range(__first, __middle);
    __glibcxx_requires_valid_range(__middle, __last);

    return std::__rotate(__first, __middle, __last,
	   std::__iterator_category(__first));
  }

} // namespace _V2

/**
 *  @brief Copy a sequence, rotating its elements.
 *  @ingroup mutating_algorithms
 *  @param  __first   A forward iterator.
 *  @param  __middle  A forward iterator.
 *  @param  __last    A forward iterator.
 *  @param  __result  An output iterator.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  Copies the elements of the range @p [__first,__last) to the
 *  range beginning at @result, rotating the copied elements by 
 *  @p (__middle-__first) positions so that the element at @p __middle
 *  is moved to @p __result, the element at @p __middle+1 is moved
 *  to @p __result+1 and so on for each element in the range @p
 *  [__first,__last).
 *
 *  Performs 
 *  @p *(__result+(n+(__last-__middle))%(__last-__first))=*(__first+n)
 *  for each @p n in the range @p [0,__last-__first).
*/
template<typename _ForwardIterator, typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
_ForwardIterator __last, _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __middle);
    __glibcxx_requires_valid_range(__middle, __last);

    return std::copy(__first, __middle,
       std::copy(__middle, __last, __result));
  }

/// This is a helper function...
template<typename _ForwardIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred, forward_iterator_tag)
  {
    if (__first == __last)
return __first;

    while (__pred(*__first))
if (++__first == __last)
 return __first;

    _ForwardIterator __next = __first;

    while (++__next != __last)
if (__pred(*__next))
 {
   std::iter_swap(__first, __next);
   ++__first;
 }

    return __first;
  }

/// This is a helper function...
template<typename _BidirectionalIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  _BidirectionalIterator
  __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
_Predicate __pred, bidirectional_iterator_tag)
  {
    while (true)
{
 while (true)
   if (__first == __last)
     return __first;
   else if (__pred(*__first))
     ++__first;
   else
     break;
 --__last;
 while (true)
   if (__first == __last)
     return __first;
   else if (!bool(__pred(*__last)))
     --__last;
   else
     break;
 std::iter_swap(__first, __last);
 ++__first;
}
  }

// partition

/// This is a helper function...
/// Requires __first != __last and !__pred(__first)
/// and __len == distance(__first, __last).
///
/// !__pred(__first) allows us to guarantee that we don't
/// move-assign an element onto itself.
template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
  typename _Distance>
  _ForwardIterator
  __stable_partition_adaptive(_ForwardIterator __first,
		_ForwardIterator __last,
		_Predicate __pred, _Distance __len,
		_Pointer __buffer,
		_Distance __buffer_size)
  {
    if (__len == 1)
return __first;

    if (__len <= __buffer_size)
{
 _ForwardIterator __result1 = __first;
 _Pointer __result2 = __buffer;

 // The precondition guarantees that !__pred(__first), so
 // move that element to the buffer before starting the loop.
 // This ensures that we only call __pred once per element.
 *__result2 = _GLIBCXX_MOVE(*__first)std::move(*__first);
 ++__result2;
 ++__first;
 for (; __first != __last; ++__first)
   if (__pred(__first))
     {
*__result1 = _GLIBCXX_MOVE(*__first)std::move(*__first);
++__result1;
     }
   else
     {
*__result2 = _GLIBCXX_MOVE(*__first)std::move(*__first);
++__result2;
     }

 _GLIBCXX_MOVE3(__buffer, __result2, __result1)std::move(__buffer, __result2, __result1);
 return __result1;
}

    _ForwardIterator __middle = __first;
    std::advance(__middle, __len / 2);
    _ForwardIterator __left_split =
std::__stable_partition_adaptive(__first, __middle, __pred,
			 __len / 2, __buffer,
			 __buffer_size);

    // Advance past true-predicate values to satisfy this
    // function's preconditions.
    _Distance __right_len = __len - __len / 2;
    _ForwardIterator __right_split =
std::__find_if_not_n(__middle, __right_len, __pred);

    if (__right_len)
__right_split =
 std::__stable_partition_adaptive(__right_split, __last, __pred,
			   __right_len,
			   __buffer, __buffer_size);

    return std::rotate(__left_split, __middle, __right_split);
  }

template<typename _ForwardIterator, typename _Predicate>
  _ForwardIterator
  __stable_partition(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
  {
    __first = std::__find_if_not(__first, __last, __pred);

    if (__first == __last)
return __first;

    typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType;
    typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;

    _Temporary_buffer<_ForwardIterator, _ValueType>
__buf(__first, std::distance(__first, __last));
    return
std::__stable_partition_adaptive(__first, __last, __pred,
			 _DistanceType(__buf.requested_size()),
			 __buf.begin(),
			 _DistanceType(__buf.size()));
  }

/**
 *  @brief Move elements for which a predicate is true to the beginning
 *         of a sequence, preserving relative ordering.
 *  @ingroup mutating_algorithms
 *  @param  __first   A forward iterator.
 *  @param  __last    A forward iterator.
 *  @param  __pred    A predicate functor.
 *  @return  An iterator @p middle such that @p __pred(i) is true for each
 *  iterator @p i in the range @p [first,middle) and false for each @p i
 *  in the range @p [middle,last).
 *
 *  Performs the same function as @p partition() with the additional
 *  guarantee that the relative ordering of elements in each group is
 *  preserved, so any two elements @p x and @p y in the range
 *  @p [__first,__last) such that @p __pred(x)==__pred(y) will have the same
 *  relative ordering after calling @p stable_partition().
*/
template<typename _ForwardIterator, typename _Predicate>
  inline _ForwardIterator
  stable_partition(_ForwardIterator __first, _ForwardIterator __last,
     _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__stable_partition(__first, __last,
		     __gnu_cxx::__ops::__pred_iter(__pred));
  }

/// This is a helper function for the sort routines.
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __heap_select(_RandomAccessIterator __first,
  _RandomAccessIterator __middle,
  _RandomAccessIterator __last, _Compare __comp)
  {
    std::__make_heap(__first, __middle, __comp);
    for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
if (__comp(__i, __first))
 std::__pop_heap(__first, __middle, __i, __comp);
  }

// partial_sort

template<typename _InputIterator, typename _RandomAccessIterator,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _RandomAccessIterator
  __partial_sort_copy(_InputIterator __first, _InputIterator __last,
	_RandomAccessIterator __result_first,
	_RandomAccessIterator __result_last,
	_Compare __comp)
  {
    typedef typename iterator_traits<_InputIterator>::value_type
_InputValueType;
    typedef iterator_traits<_RandomAccessIterator> _RItTraits;
    typedef typename _RItTraits::difference_type _DistanceType;

    if (__result_first == __result_last)
return __result_last;
    _RandomAccessIterator __result_real_last = __result_first;
    while (__first != __last && __result_real_last != __result_last)
{
 *__result_real_last = *__first;
 ++__result_real_last;
 ++__first;
}
    
    std::__make_heap(__result_first, __result_real_last, __comp);
    while (__first != __last)
{
 if (__comp(__first, __result_first))
   std::__adjust_heap(__result_first, _DistanceType(0),
	       _DistanceType(__result_real_last
			     - __result_first),
	       _InputValueType(*__first), __comp);
 ++__first;
}
    std::__sort_heap(__result_first, __result_real_last, __comp);
    return __result_real_last;
  }

/**
 *  @brief Copy the smallest elements of a sequence.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __result_first   A random-access iterator.
 *  @param  __result_last    Another random-access iterator.
 *  @return   An iterator indicating the end of the resulting sequence.
 *
 *  Copies and sorts the smallest N values from the range @p [__first,__last)
 *  to the range beginning at @p __result_first, where the number of
 *  elements to be copied, @p N, is the smaller of @p (__last-__first) and
 *  @p (__result_last-__result_first).
 *  After the sort if @e i and @e j are iterators in the range
 *  @p [__result_first,__result_first+N) such that i precedes j then
 *  *j<*i is false.
 *  The value returned is @p __result_first+N.
*/
template<typename _InputIterator, typename _RandomAccessIterator>
  _GLIBCXX20_CONSTEXPR
  inline _RandomAccessIterator
  partial_sort_copy(_InputIterator __first, _InputIterator __last,
      _RandomAccessIterator __result_first,
      _RandomAccessIterator __result_last)
  {
1737#ifdef _GLIBCXX_CONCEPT_CHECKS
    typedef typename iterator_traits<_InputIterator>::value_type
_InputValueType;
    typedef typename iterator_traits<_RandomAccessIterator>::value_type
_OutputValueType;
1742#endif

    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_ConvertibleConcept<_InputValueType,
		  _OutputValueType>)
    __glibcxx_function_requires(_LessThanOpConcept<_InputValueType,
				     _OutputValueType>)
    __glibcxx_function_requires(_LessThanComparableConcept<_OutputValueType>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);
    __glibcxx_requires_valid_range(__result_first, __result_last);

    return std::__partial_sort_copy(__first, __last,
		      __result_first, __result_last,
		      __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Copy the smallest elements of a sequence using a predicate for
 *         comparison.
 *  @ingroup sorting_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    Another input iterator.
 *  @param  __result_first   A random-access iterator.
 *  @param  __result_last    Another random-access iterator.
 *  @param  __comp    A comparison functor.
 *  @return   An iterator indicating the end of the resulting sequence.
 *
 *  Copies and sorts the smallest N values from the range @p [__first,__last)
 *  to the range beginning at @p result_first, where the number of
 *  elements to be copied, @p N, is the smaller of @p (__last-__first) and
 *  @p (__result_last-__result_first).
 *  After the sort if @e i and @e j are iterators in the range
 *  @p [__result_first,__result_first+N) such that i precedes j then
 *  @p __comp(*j,*i) is false.
 *  The value returned is @p __result_first+N.
*/
template<typename _InputIterator, typename _RandomAccessIterator,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _RandomAccessIterator
  partial_sort_copy(_InputIterator __first, _InputIterator __last,
      _RandomAccessIterator __result_first,
      _RandomAccessIterator __result_last,
      _Compare __comp)
  {
1789#ifdef _GLIBCXX_CONCEPT_CHECKS
    typedef typename iterator_traits<_InputIterator>::value_type
_InputValueType;
    typedef typename iterator_traits<_RandomAccessIterator>::value_type
_OutputValueType;
1794#endif

    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
		  _RandomAccessIterator>)
    __glibcxx_function_requires(_ConvertibleConcept<_InputValueType,
		  _OutputValueType>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
		  _InputValueType, _OutputValueType>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
		  _OutputValueType, _OutputValueType>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);
    __glibcxx_requires_valid_range(__result_first, __result_last);

    return std::__partial_sort_copy(__first, __last,
		      __result_first, __result_last,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

/// This is a helper function for the sort routine.
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __unguarded_linear_insert(_RandomAccessIterator __last,
	      _Compare __comp)
  {
    typename iterator_traits<_RandomAccessIterator>::value_type
__val = _GLIBCXX_MOVE(*__last)std::move(*__last);
    _RandomAccessIterator __next = __last;
    --__next;
    while (__comp(__val, __next))
{
 *__last = _GLIBCXX_MOVE(*__next)std::move(*__next);
 __last = __next;
 --__next;
}
    *__last = _GLIBCXX_MOVE(__val)std::move(__val);
  }

/// This is a helper function for the sort routine.
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __insertion_sort(_RandomAccessIterator __first,
     _RandomAccessIterator __last, _Compare __comp)
  {
    if (__first == __last) return;

    for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
{
 if (__comp(__i, __first))
   {
     typename iterator_traits<_RandomAccessIterator>::value_type
__val = _GLIBCXX_MOVE(*__i)std::move(*__i);
     _GLIBCXX_MOVE_BACKWARD3(__first, __i, __i + 1)std::move_backward(__first, __i, __i + 1);
     *__first = _GLIBCXX_MOVE(__val)std::move(__val);
   }
 else
   std::__unguarded_linear_insert(__i,
		__gnu_cxx::__ops::__val_comp_iter(__comp));
}
  }

/// This is a helper function for the sort routine.
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline void
  __unguarded_insertion_sort(_RandomAccessIterator __first,
	       _RandomAccessIterator __last, _Compare __comp)
  {
    for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
std::__unguarded_linear_insert(__i,
		__gnu_cxx::__ops::__val_comp_iter(__comp));
  }

/**
 *  @doctodo
 *  This controls some aspect of the sort routines.
*/
enum { _S_threshold = 16 };

/// This is a helper function for the sort routine.
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __final_insertion_sort(_RandomAccessIterator __first,
	   _RandomAccessIterator __last, _Compare __comp)
  {
    if (__last - __first > int(_S_threshold))
{
 std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
 std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
			  __comp);
}
    else
std::__insertion_sort(__first, __last, __comp);
  }

/// This is a helper function...
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _RandomAccessIterator
  __unguarded_partition(_RandomAccessIterator __first,
	  _RandomAccessIterator __last,
	  _RandomAccessIterator __pivot, _Compare __comp)
  {
    while (true)
{
 while (__comp(__first, __pivot))
   ++__first;
 --__last;
 while (__comp(__pivot, __last))
   --__last;
 if (!(__first < __last))
   return __first;
 std::iter_swap(__first, __last);
 ++__first;
}
  }

/// This is a helper function...
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _RandomAccessIterator
  __unguarded_partition_pivot(_RandomAccessIterator __first,
		_RandomAccessIterator __last, _Compare __comp)
  {
    _RandomAccessIterator __mid = __first + (__last - __first) / 2;
    std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,
		  __comp);
    return std::__unguarded_partition(__first + 1, __last, __first, __comp);
  }

template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline void
  __partial_sort(_RandomAccessIterator __first,
   _RandomAccessIterator __middle,
   _RandomAccessIterator __last,
   _Compare __comp)
  {
    std::__heap_select(__first, __middle, __last, __comp);
    std::__sort_heap(__first, __middle, __comp);
  }

/// This is a helper function for the sort routine.
template<typename _RandomAccessIterator, typename _Size, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __introsort_loop(_RandomAccessIterator __first,
     _RandomAccessIterator __last,
     _Size __depth_limit, _Compare __comp)
  {
    while (__last - __first > int(_S_threshold))
{
 if (__depth_limit == 0)
   {
     std::__partial_sort(__first, __last, __last, __comp);
     return;
   }
 --__depth_limit;
 _RandomAccessIterator __cut =
   std::__unguarded_partition_pivot(__first, __last, __comp);
 std::__introsort_loop(__cut, __last, __depth_limit, __comp);
 __last = __cut;
}
  }

// sort

template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline void
  __sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare __comp)
  {
    if (__first != __last)
{
 std::__introsort_loop(__first, __last,
		std::__lg(__last - __first) * 2,
		__comp);
 std::__final_insertion_sort(__first, __last, __comp);
}
  }

template<typename _RandomAccessIterator, typename _Size, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
  _RandomAccessIterator __last, _Size __depth_limit,
  _Compare __comp)
  {
    while (__last - __first > 3)
{
 if (__depth_limit == 0)
   {
     std::__heap_select(__first, __nth + 1, __last, __comp);
     // Place the nth largest element in its final position.
     std::iter_swap(__first, __nth);
     return;
   }
 --__depth_limit;
 _RandomAccessIterator __cut =
   std::__unguarded_partition_pivot(__first, __last, __comp);
 if (__cut <= __nth)
   __first = __cut;
 else
   __last = __cut;
}
    std::__insertion_sort(__first, __last, __comp);
  }

// nth_element

// lower_bound moved to stl_algobase.h

/**
 *  @brief Finds the first position in which @p __val could be inserted
 *         without changing the ordering.
 *  @ingroup binary_search_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __val     The search term.
 *  @param  __comp    A functor to use for comparisons.
 *  @return An iterator pointing to the first element <em>not less
 *           than</em> @p __val, or end() if every element is less
 *           than @p __val.
 *  @ingroup binary_search_algorithms
 *
 *  The comparison function should have the same effects on ordering as
 *  the function used for the initial sort.
*/
template<typename _ForwardIterator, typename _Tp, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    __glibcxx_requires_partitioned_lower_pred(__first, __last,
				__val, __comp);

    return std::__lower_bound(__first, __last, __val,
		__gnu_cxx::__ops::__iter_comp_val(__comp));
  }

template<typename _ForwardIterator, typename _Tp, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __upper_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val, _Compare __comp)
  {
    typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;

    _DistanceType __len = std::distance(__first, __last);

    while (__len > 0)
{
 _DistanceType __half = __len >> 1;
 _ForwardIterator __middle = __first;
 std::advance(__middle, __half);
 if (__comp(__val, __middle))
   __len = __half;
 else
   {
     __first = __middle;
     ++__first;
     __len = __len - __half - 1;
   }
}
    return __first;
  }

/**
 *  @brief Finds the last position in which @p __val could be inserted
 *         without changing the ordering.
 *  @ingroup binary_search_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __val     The search term.
 *  @return  An iterator pointing to the first element greater than @p __val,
 *           or end() if no elements are greater than @p __val.
 *  @ingroup binary_search_algorithms
*/
template<typename _ForwardIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_LessThanOpConcept<
_Tp, typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_partitioned_upper(__first, __last, __val);

    return std::__upper_bound(__first, __last, __val,
		__gnu_cxx::__ops::__val_less_iter());
  }

/**
 *  @brief Finds the last position in which @p __val could be inserted
 *         without changing the ordering.
 *  @ingroup binary_search_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __val     The search term.
 *  @param  __comp    A functor to use for comparisons.
 *  @return  An iterator pointing to the first element greater than @p __val,
 *           or end() if no elements are greater than @p __val.
 *  @ingroup binary_search_algorithms
 *
 *  The comparison function should have the same effects on ordering as
 *  the function used for the initial sort.
*/
template<typename _ForwardIterator, typename _Tp, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
_Tp, typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_partitioned_upper_pred(__first, __last,
				__val, __comp);

    return std::__upper_bound(__first, __last, __val,
		__gnu_cxx::__ops::__val_comp_iter(__comp));
  }

template<typename _ForwardIterator, typename _Tp,
  typename _CompareItTp, typename _CompareTpIt>
  _GLIBCXX20_CONSTEXPR
  pair<_ForwardIterator, _ForwardIterator>
  __equal_range(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val,
  _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it)
  {
    typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;

    _DistanceType __len = std::distance(__first, __last);

    while (__len > 0)
{
 _DistanceType __half = __len >> 1;
 _ForwardIterator __middle = __first;
 std::advance(__middle, __half);
 if (__comp_it_val(__middle, __val))
   {
     __first = __middle;
     ++__first;
     __len = __len - __half - 1;
   }
 else if (__comp_val_it(__val, __middle))
   __len = __half;
 else
   {
     _ForwardIterator __left
= std::__lower_bound(__first, __middle, __val, __comp_it_val);
     std::advance(__first, __len);
     _ForwardIterator __right
= std::__upper_bound(++__middle, __first, __val, __comp_val_it);
     return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
   }
}
    return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
  }

/**
 *  @brief Finds the largest subrange in which @p __val could be inserted
 *         at any place in it without changing the ordering.
 *  @ingroup binary_search_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __val     The search term.
 *  @return  An pair of iterators defining the subrange.
 *  @ingroup binary_search_algorithms
 *
 *  This is equivalent to
 *  @code
 *    std::make_pair(lower_bound(__first, __last, __val),
 *                   upper_bound(__first, __last, __val))
 *  @endcode
 *  but does not actually call those functions.
*/
template<typename _ForwardIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline pair<_ForwardIterator, _ForwardIterator>
  equal_range(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_LessThanOpConcept<
typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    __glibcxx_function_requires(_LessThanOpConcept<
_Tp, typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_partitioned_lower(__first, __last, __val);
    __glibcxx_requires_partitioned_upper(__first, __last, __val);

    return std::__equal_range(__first, __last, __val,
		__gnu_cxx::__ops::__iter_less_val(),
		__gnu_cxx::__ops::__val_less_iter());
  }

/**
 *  @brief Finds the largest subrange in which @p __val could be inserted
 *         at any place in it without changing the ordering.
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __val     The search term.
 *  @param  __comp    A functor to use for comparisons.
 *  @return  An pair of iterators defining the subrange.
 *  @ingroup binary_search_algorithms
 *
 *  This is equivalent to
 *  @code
 *    std::make_pair(lower_bound(__first, __last, __val, __comp),
 *                   upper_bound(__first, __last, __val, __comp))
 *  @endcode
 *  but does not actually call those functions.
*/
template<typename _ForwardIterator, typename _Tp, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline pair<_ForwardIterator, _ForwardIterator>
  equal_range(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
_Tp, typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_partitioned_lower_pred(__first, __last,
				__val, __comp);
    __glibcxx_requires_partitioned_upper_pred(__first, __last,
				__val, __comp);

    return std::__equal_range(__first, __last, __val,
		__gnu_cxx::__ops::__iter_comp_val(__comp),
		__gnu_cxx::__ops::__val_comp_iter(__comp));
  }

/**
 *  @brief Determines whether an element exists in a range.
 *  @ingroup binary_search_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __val     The search term.
 *  @return True if @p __val (or its equivalent) is in [@p
 *  __first,@p __last ].
 *
 *  Note that this does not actually return an iterator to @p __val.  For
 *  that, use std::find or a container's specialized find member functions.
*/
template<typename _ForwardIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  bool
  binary_search(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_LessThanOpConcept<
_Tp, typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_partitioned_lower(__first, __last, __val);
    __glibcxx_requires_partitioned_upper(__first, __last, __val);

    _ForwardIterator __i
= std::__lower_bound(__first, __last, __val,
	     __gnu_cxx::__ops::__iter_less_val());
    return __i != __last && !(__val < *__i);
  }

/**
 *  @brief Determines whether an element exists in a range.
 *  @ingroup binary_search_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __val     The search term.
 *  @param  __comp    A functor to use for comparisons.
 *  @return  True if @p __val (or its equivalent) is in @p [__first,__last].
 *
 *  Note that this does not actually return an iterator to @p __val.  For
 *  that, use std::find or a container's specialized find member functions.
 *
 *  The comparison function should have the same effects on ordering as
 *  the function used for the initial sort.
*/
template<typename _ForwardIterator, typename _Tp, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  bool
  binary_search(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
_Tp, typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_partitioned_lower_pred(__first, __last,
				__val, __comp);
    __glibcxx_requires_partitioned_upper_pred(__first, __last,
				__val, __comp);

    _ForwardIterator __i
= std::__lower_bound(__first, __last, __val,
	     __gnu_cxx::__ops::__iter_comp_val(__comp));
    return __i != __last && !bool(__comp(__val, *__i));
  }

// merge

/// This is a helper function for the __merge_adaptive routines.
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _Compare>
  void
  __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
	  _InputIterator2 __first2, _InputIterator2 __last2,
	  _OutputIterator __result, _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
{
 if (__comp(__first2, __first1))
   {
     *__result = _GLIBCXX_MOVE(*__first2)std::move(*__first2);
     ++__first2;
   }
 else
   {
     *__result = _GLIBCXX_MOVE(*__first1)std::move(*__first1);
     ++__first1;
   }
 ++__result;
}
    if (__first1 != __last1)
_GLIBCXX_MOVE3(__first1, __last1, __result)std::move(__first1, __last1, __result);
  }

/// This is a helper function for the __merge_adaptive routines.
template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
  typename _BidirectionalIterator3, typename _Compare>
  void
  __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
		   _BidirectionalIterator1 __last1,
		   _BidirectionalIterator2 __first2,
		   _BidirectionalIterator2 __last2,
		   _BidirectionalIterator3 __result,
		   _Compare __comp)
  {
    if (__first1 == __last1)
{
 _GLIBCXX_MOVE_BACKWARD3(__first2, __last2, __result)std::move_backward(__first2, __last2, __result);
 return;
}
    else if (__first2 == __last2)
return;

    --__last1;
    --__last2;
    while (true)
{
 if (__comp(__last2, __last1))
   {
     *--__result = _GLIBCXX_MOVE(*__last1)std::move(*__last1);
     if (__first1 == __last1)
{
  _GLIBCXX_MOVE_BACKWARD3(__first2, ++__last2, __result)std::move_backward(__first2, ++__last2, __result);
  return;
}
     --__last1;
   }
 else
   {
     *--__result = _GLIBCXX_MOVE(*__last2)std::move(*__last2);
     if (__first2 == __last2)
return;
     --__last2;
   }
}
  }

/// This is a helper function for the merge routines.
template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
  typename _Distance>
  _BidirectionalIterator1
  __rotate_adaptive(_BidirectionalIterator1 __first,
      _BidirectionalIterator1 __middle,
      _BidirectionalIterator1 __last,
      _Distance __len1, _Distance __len2,
      _BidirectionalIterator2 __buffer,
      _Distance __buffer_size)
  {
    _BidirectionalIterator2 __buffer_end;
    if (__len1 > __len2 && __len2 <= __buffer_size)
{
 if (__len2)
   {
     __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer)std::move(__middle, __last, __buffer);
     _GLIBCXX_MOVE_BACKWARD3(__first, __middle, __last)std::move_backward(__first, __middle, __last);
     return _GLIBCXX_MOVE3(__buffer, __buffer_end, __first)std::move(__buffer, __buffer_end, __first);
   }
 else
   return __first;
}
    else if (__len1 <= __buffer_size)
{
 if (__len1)
   {
     __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer)std::move(__first, __middle, __buffer);
     _GLIBCXX_MOVE3(__middle, __last, __first)std::move(__middle, __last, __first);
     return _GLIBCXX_MOVE_BACKWARD3(__buffer, __buffer_end, __last)std::move_backward(__buffer, __buffer_end, __last);
   }
 else
   return __last;
}
    else
return std::rotate(__first, __middle, __last);
  }

/// This is a helper function for the merge routines.
template<typename _BidirectionalIterator, typename _Distance, 
  typename _Pointer, typename _Compare>
  void
  __merge_adaptive(_BidirectionalIterator __first,
     _BidirectionalIterator __middle,
     _BidirectionalIterator __last,
     _Distance __len1, _Distance __len2,
     _Pointer __buffer, _Distance __buffer_size,
     _Compare __comp)
  {
    if (__len1 <= __len2 && __len1 <= __buffer_size)
{
 _Pointer __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer)std::move(__first, __middle, __buffer);
 std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
		     __first, __comp);
}
    else if (__len2 <= __buffer_size)
{
 _Pointer __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer)std::move(__middle, __last, __buffer);
 std::__move_merge_adaptive_backward(__first, __middle, __buffer,
			      __buffer_end, __last, __comp);
}
    else
{
 _BidirectionalIterator __first_cut = __first;
 _BidirectionalIterator __second_cut = __middle;
 _Distance __len11 = 0;
 _Distance __len22 = 0;
 if (__len1 > __len2)
   {
     __len11 = __len1 / 2;
     std::advance(__first_cut, __len11);
     __second_cut
= std::__lower_bound(__middle, __last, *__first_cut,
		     __gnu_cxx::__ops::__iter_comp_val(__comp));
     __len22 = std::distance(__middle, __second_cut);
   }
 else
   {
     __len22 = __len2 / 2;
     std::advance(__second_cut, __len22);
     __first_cut
= std::__upper_bound(__first, __middle, *__second_cut,
		     __gnu_cxx::__ops::__val_comp_iter(__comp));
     __len11 = std::distance(__first, __first_cut);
   }

 _BidirectionalIterator __new_middle
   = std::__rotate_adaptive(__first_cut, __middle, __second_cut,
		     __len1 - __len11, __len22, __buffer,
		     __buffer_size);
 std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
		__len22, __buffer, __buffer_size, __comp);
 std::__merge_adaptive(__new_middle, __second_cut, __last,
		__len1 - __len11,
		__len2 - __len22, __buffer,
		__buffer_size, __comp);
}
  }

/// This is a helper function for the merge routines.
template<typename _BidirectionalIterator, typename _Distance,
  typename _Compare>
  void
  __merge_without_buffer(_BidirectionalIterator __first,
	   _BidirectionalIterator __middle,
	   _BidirectionalIterator __last,
	   _Distance __len1, _Distance __len2,
	   _Compare __comp)
  {
    if (__len1 == 0 || __len2 == 0)
return;

    if (__len1 + __len2 == 2)
{
 if (__comp(__middle, __first))
   std::iter_swap(__first, __middle);
 return;
}

    _BidirectionalIterator __first_cut = __first;
    _BidirectionalIterator __second_cut = __middle;
    _Distance __len11 = 0;
    _Distance __len22 = 0;
    if (__len1 > __len2)
{
 __len11 = __len1 / 2;
 std::advance(__first_cut, __len11);
 __second_cut
   = std::__lower_bound(__middle, __last, *__first_cut,
		 __gnu_cxx::__ops::__iter_comp_val(__comp));
 __len22 = std::distance(__middle, __second_cut);
}
    else
{
 __len22 = __len2 / 2;
 std::advance(__second_cut, __len22);
 __first_cut
   = std::__upper_bound(__first, __middle, *__second_cut,
		 __gnu_cxx::__ops::__val_comp_iter(__comp));
 __len11 = std::distance(__first, __first_cut);
}

    _BidirectionalIterator __new_middle
= std::rotate(__first_cut, __middle, __second_cut);
    std::__merge_without_buffer(__first, __first_cut, __new_middle,
		  __len11, __len22, __comp);
    std::__merge_without_buffer(__new_middle, __second_cut, __last,
		  __len1 - __len11, __len2 - __len22, __comp);
  }

template<typename _BidirectionalIterator, typename _Compare>
  void
  __inplace_merge(_BidirectionalIterator __first,
    _BidirectionalIterator __middle,
    _BidirectionalIterator __last,
    _Compare __comp)
  {
    typedef typename iterator_traits<_BidirectionalIterator>::value_type
 _ValueType;
    typedef typename iterator_traits<_BidirectionalIterator>::difference_type
 _DistanceType;

    if (__first == __middle || __middle == __last)
return;

    const _DistanceType __len1 = std::distance(__first, __middle);
    const _DistanceType __len2 = std::distance(__middle, __last);

    typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf;
    _TmpBuf __buf(__first, __len1 + __len2);

    if (__buf.begin() == 0)
std::__merge_without_buffer
 (__first, __middle, __last, __len1, __len2, __comp);
    else
std::__merge_adaptive
 (__first, __middle, __last, __len1, __len2, __buf.begin(),
  _DistanceType(__buf.size()), __comp);
  }

/**
 *  @brief Merges two sorted ranges in place.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __middle  Another iterator.
 *  @param  __last    Another iterator.
 *  @return  Nothing.
 *
 *  Merges two sorted and consecutive ranges, [__first,__middle) and
 *  [__middle,__last), and puts the result in [__first,__last).  The
 *  output will be sorted.  The sort is @e stable, that is, for
 *  equivalent elements in the two ranges, elements from the first
 *  range will always come before elements from the second.
 *
 *  If enough additional memory is available, this takes (__last-__first)-1
 *  comparisons.  Otherwise an NlogN algorithm is used, where N is
 *  distance(__first,__last).
*/
template<typename _BidirectionalIterator>
  inline void
  inplace_merge(_BidirectionalIterator __first,
  _BidirectionalIterator __middle,
  _BidirectionalIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
   _BidirectionalIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_BidirectionalIterator>::value_type>)
    __glibcxx_requires_sorted(__first, __middle);
    __glibcxx_requires_sorted(__middle, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    std::__inplace_merge(__first, __middle, __last,
	   __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Merges two sorted ranges in place.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __middle  Another iterator.
 *  @param  __last    Another iterator.
 *  @param  __comp    A functor to use for comparisons.
 *  @return  Nothing.
 *
 *  Merges two sorted and consecutive ranges, [__first,__middle) and
 *  [middle,last), and puts the result in [__first,__last).  The output will
 *  be sorted.  The sort is @e stable, that is, for equivalent
 *  elements in the two ranges, elements from the first range will always
 *  come before elements from the second.
 *
 *  If enough additional memory is available, this takes (__last-__first)-1
 *  comparisons.  Otherwise an NlogN algorithm is used, where N is
 *  distance(__first,__last).
 *
 *  The comparison function should have the same effects on ordering as
 *  the function used for the initial sort.
*/
template<typename _BidirectionalIterator, typename _Compare>
  inline void
  inplace_merge(_BidirectionalIterator __first,
  _BidirectionalIterator __middle,
  _BidirectionalIterator __last,
  _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
   _BidirectionalIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_BidirectionalIterator>::value_type,
   typename iterator_traits<_BidirectionalIterator>::value_type>)
    __glibcxx_requires_sorted_pred(__first, __middle, __comp);
    __glibcxx_requires_sorted_pred(__middle, __last, __comp);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    std::__inplace_merge(__first, __middle, __last,
	   __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }


/// This is a helper function for the __merge_sort_loop routines.
template<typename _InputIterator, typename _OutputIterator,
  typename _Compare>
  _OutputIterator
  __move_merge(_InputIterator __first1, _InputIterator __last1,
 _InputIterator __first2, _InputIterator __last2,
 _OutputIterator __result, _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
{
 if (__comp(__first2, __first1))
   {
     *__result = _GLIBCXX_MOVE(*__first2)std::move(*__first2);
     ++__first2;
   }
 else
   {
     *__result = _GLIBCXX_MOVE(*__first1)std::move(*__first1);
     ++__first1;
   }
 ++__result;
}
    return _GLIBCXX_MOVE3(__first2, __last2,std::move(__first2, __last2, std::move(__first1, __last1, __result
))
	    _GLIBCXX_MOVE3(__first1, __last1,std::move(__first2, __last2, std::move(__first1, __last1, __result
))
			   __result))std::move(__first2, __last2, std::move(__first1, __last1, __result
));
  }

template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
  typename _Distance, typename _Compare>
  void
  __merge_sort_loop(_RandomAccessIterator1 __first,
      _RandomAccessIterator1 __last,
      _RandomAccessIterator2 __result, _Distance __step_size,
      _Compare __comp)
  {
    const _Distance __two_step = 2 * __step_size;

    while (__last - __first >= __two_step)
{
 __result = std::__move_merge(__first, __first + __step_size,
		       __first + __step_size,
		       __first + __two_step,
		       __result, __comp);
 __first += __two_step;
}
    __step_size = std::min(_Distance(__last - __first), __step_size);

    std::__move_merge(__first, __first + __step_size,
	__first + __step_size, __last, __result, __comp);
  }

template<typename _RandomAccessIterator, typename _Distance,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  void
  __chunk_insertion_sort(_RandomAccessIterator __first,
	   _RandomAccessIterator __last,
	   _Distance __chunk_size, _Compare __comp)
  {
    while (__last - __first >= __chunk_size)
{
 std::__insertion_sort(__first, __first + __chunk_size, __comp);
 __first += __chunk_size;
}
    std::__insertion_sort(__first, __last, __comp);
  }

enum { _S_chunk_size = 7 };

template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
  void
  __merge_sort_with_buffer(_RandomAccessIterator __first,
	     _RandomAccessIterator __last,
	     _Pointer __buffer, _Compare __comp)
  {
    typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_Distance;

    const _Distance __len = __last - __first;
    const _Pointer __buffer_last = __buffer + __len;

    _Distance __step_size = _S_chunk_size;
    std::__chunk_insertion_sort(__first, __last, __step_size, __comp);

    while (__step_size < __len)
{
 std::__merge_sort_loop(__first, __last, __buffer,
		 __step_size, __comp);
 __step_size *= 2;
 std::__merge_sort_loop(__buffer, __buffer_last, __first,
		 __step_size, __comp);
 __step_size *= 2;
}
  }

template<typename _RandomAccessIterator, typename _Pointer,
  typename _Distance, typename _Compare>
  void
  __stable_sort_adaptive(_RandomAccessIterator __first,
	   _RandomAccessIterator __last,
	   _Pointer __buffer, _Distance __buffer_size,
	   _Compare __comp)
  {
    const _Distance __len = (__last - __first + 1) / 2;
    const _RandomAccessIterator __middle = __first + __len;
    if (__len > __buffer_size)
{
 std::__stable_sort_adaptive(__first, __middle, __buffer,
		      __buffer_size, __comp);
 std::__stable_sort_adaptive(__middle, __last, __buffer,
		      __buffer_size, __comp);
}
    else
{
 std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
 std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
}
    std::__merge_adaptive(__first, __middle, __last,
	    _Distance(__middle - __first),
	    _Distance(__last - __middle),
	    __buffer, __buffer_size,
	    __comp);
  }

/// This is a helper function for the stable sorting routines.
template<typename _RandomAccessIterator, typename _Compare>
  void
  __inplace_stable_sort(_RandomAccessIterator __first,
	  _RandomAccessIterator __last, _Compare __comp)
  {
    if (__last - __first < 15)
{
 std::__insertion_sort(__first, __last, __comp);
 return;
}
    _RandomAccessIterator __middle = __first + (__last - __first) / 2;
    std::__inplace_stable_sort(__first, __middle, __comp);
    std::__inplace_stable_sort(__middle, __last, __comp);
    std::__merge_without_buffer(__first, __middle, __last,
		  __middle - __first,
		  __last - __middle,
		  __comp);
  }

// stable_sort

// Set algorithms: includes, set_union, set_intersection, set_difference,
// set_symmetric_difference.  All of these algorithms have the precondition
// that their input ranges are sorted and the postcondition that their output
// ranges are sorted.

template<typename _InputIterator1, typename _InputIterator2,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  bool
  __includes(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2,
      _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
if (__comp(__first2, __first1))
 return false;
else if (__comp(__first1, __first2))
 ++__first1;
else
 {
   ++__first1;
   ++__first2;
 }

    return __first2 == __last2;
  }

/**
 *  @brief Determines whether all elements of a sequence exists in a range.
 *  @param  __first1  Start of search range.
 *  @param  __last1   End of search range.
 *  @param  __first2  Start of sequence
 *  @param  __last2   End of sequence.
 *  @return  True if each element in [__first2,__last2) is contained in order
 *  within [__first1,__last1).  False otherwise.
 *  @ingroup set_algorithms
 *
 *  This operation expects both [__first1,__last1) and
 *  [__first2,__last2) to be sorted.  Searches for the presence of
 *  each element in [__first2,__last2) within [__first1,__last1).
 *  The iterators over each range only move forward, so this is a
 *  linear algorithm.  If an element in [__first2,__last2) is not
 *  found before the search iterator reaches @p __last2, false is
 *  returned.
*/
template<typename _InputIterator1, typename _InputIterator2>
  _GLIBCXX20_CONSTEXPR
  inline bool
  includes(_InputIterator1 __first1, _InputIterator1 __last1,
    _InputIterator2 __first2, _InputIterator2 __last2)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    __glibcxx_requires_irreflexive2(__first1, __last1);
    __glibcxx_requires_irreflexive2(__first2, __last2);

    return std::__includes(__first1, __last1, __first2, __last2,
	     __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Determines whether all elements of a sequence exists in a range
 *  using comparison.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of search range.
 *  @param  __last1   End of search range.
 *  @param  __first2  Start of sequence
 *  @param  __last2   End of sequence.
 *  @param  __comp    Comparison function to use.
 *  @return True if each element in [__first2,__last2) is contained
 *  in order within [__first1,__last1) according to comp.  False
 *  otherwise.  @ingroup set_algorithms
 *
 *  This operation expects both [__first1,__last1) and
 *  [__first2,__last2) to be sorted.  Searches for the presence of
 *  each element in [__first2,__last2) within [__first1,__last1),
 *  using comp to decide.  The iterators over each range only move
 *  forward, so this is a linear algorithm.  If an element in
 *  [__first2,__last2) is not found before the search iterator
 *  reaches @p __last2, false is returned.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline bool
  includes(_InputIterator1 __first1, _InputIterator1 __last1,
    _InputIterator2 __first2, _InputIterator2 __last2,
    _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);

    return std::__includes(__first1, __last1, __first2, __last2,
	     __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

// nth_element
// merge
// set_difference
// set_intersection
// set_union
// stable_sort
// set_symmetric_difference
// min_element
// max_element

template<typename _BidirectionalIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  bool
  __next_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last, _Compare __comp)
  {
    if (__first == __last)
return false;
    _BidirectionalIterator __i = __first;
    ++__i;
    if (__i == __last)
return false;
    __i = __last;
    --__i;

    for(;;)
{
 _BidirectionalIterator __ii = __i;
 --__i;
 if (__comp(__i, __ii))
   {
     _BidirectionalIterator __j = __last;
     while (!__comp(__i, --__j))
{}
     std::iter_swap(__i, __j);
     std::__reverse(__ii, __last,
	     std::__iterator_category(__first));
     return true;
   }
 if (__i == __first)
   {
     std::__reverse(__first, __last,
	     std::__iterator_category(__first));
     return false;
   }
}
  }

/**
 *  @brief  Permute range into the next @e dictionary ordering.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @return  False if wrapped to first permutation, true otherwise.
 *
 *  Treats all permutations of the range as a set of @e dictionary sorted
 *  sequences.  Permutes the current sequence into the next one of this set.
 *  Returns true if there are more sequences to generate.  If the sequence
 *  is the largest of the set, the smallest is generated and false returned.
*/
template<typename _BidirectionalIterator>
  _GLIBCXX20_CONSTEXPR
  inline bool
  next_permutation(_BidirectionalIterator __first,
     _BidirectionalIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_BidirectionalIteratorConcept<
		  _BidirectionalIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_BidirectionalIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    return std::__next_permutation
(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Permute range into the next @e dictionary ordering using
 *          comparison functor.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @param  __comp   A comparison functor.
 *  @return  False if wrapped to first permutation, true otherwise.
 *
 *  Treats all permutations of the range [__first,__last) as a set of
 *  @e dictionary sorted sequences ordered by @p __comp.  Permutes the current
 *  sequence into the next one of this set.  Returns true if there are more
 *  sequences to generate.  If the sequence is the largest of the set, the
 *  smallest is generated and false returned.
*/
template<typename _BidirectionalIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline bool
  next_permutation(_BidirectionalIterator __first,
     _BidirectionalIterator __last, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_BidirectionalIteratorConcept<
		  _BidirectionalIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_BidirectionalIterator>::value_type,
   typename iterator_traits<_BidirectionalIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    return std::__next_permutation
(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _BidirectionalIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  bool
  __prev_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last, _Compare __comp)
  {
    if (__first == __last)
return false;
    _BidirectionalIterator __i = __first;
    ++__i;
    if (__i == __last)
return false;
    __i = __last;
    --__i;

    for(;;)
{
 _BidirectionalIterator __ii = __i;
 --__i;
 if (__comp(__ii, __i))
   {
     _BidirectionalIterator __j = __last;
     while (!__comp(--__j, __i))
{}
     std::iter_swap(__i, __j);
     std::__reverse(__ii, __last,
	     std::__iterator_category(__first));
     return true;
   }
 if (__i == __first)
   {
     std::__reverse(__first, __last,
	     std::__iterator_category(__first));
     return false;
   }
}
  }

/**
 *  @brief  Permute range into the previous @e dictionary ordering.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @return  False if wrapped to last permutation, true otherwise.
 *
 *  Treats all permutations of the range as a set of @e dictionary sorted
 *  sequences.  Permutes the current sequence into the previous one of this
 *  set.  Returns true if there are more sequences to generate.  If the
 *  sequence is the smallest of the set, the largest is generated and false
 *  returned.
*/
template<typename _BidirectionalIterator>
  _GLIBCXX20_CONSTEXPR
  inline bool
  prev_permutation(_BidirectionalIterator __first,
     _BidirectionalIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_BidirectionalIteratorConcept<
		  _BidirectionalIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_BidirectionalIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    return std::__prev_permutation(__first, __last,
		     __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Permute range into the previous @e dictionary ordering using
 *          comparison functor.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @param  __comp   A comparison functor.
 *  @return  False if wrapped to last permutation, true otherwise.
 *
 *  Treats all permutations of the range [__first,__last) as a set of
 *  @e dictionary sorted sequences ordered by @p __comp.  Permutes the current
 *  sequence into the previous one of this set.  Returns true if there are
 *  more sequences to generate.  If the sequence is the smallest of the set,
 *  the largest is generated and false returned.
*/
template<typename _BidirectionalIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline bool
  prev_permutation(_BidirectionalIterator __first,
     _BidirectionalIterator __last, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_BidirectionalIteratorConcept<
		  _BidirectionalIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_BidirectionalIterator>::value_type,
   typename iterator_traits<_BidirectionalIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    return std::__prev_permutation(__first, __last,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

// replace
// replace_if

template<typename _InputIterator, typename _OutputIterator,
  typename _Predicate, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __replace_copy_if(_InputIterator __first, _InputIterator __last,
      _OutputIterator __result,
      _Predicate __pred, const _Tp& __new_value)
  {
    for (; __first != __last; ++__first, (void)++__result)
if (__pred(__first))
 *__result = __new_value;
else
 *__result = *__first;
    return __result;
  }

/**
 *  @brief Copy a sequence, replacing each element of one value with another
 *         value.
 *  @param  __first      An input iterator.
 *  @param  __last       An input iterator.
 *  @param  __result     An output iterator.
 *  @param  __old_value  The value to be replaced.
 *  @param  __new_value  The replacement value.
 *  @return   The end of the output sequence, @p result+(last-first).
 *
 *  Copies each element in the input range @p [__first,__last) to the
 *  output range @p [__result,__result+(__last-__first)) replacing elements
 *  equal to @p __old_value with @p __new_value.
*/
template<typename _InputIterator, typename _OutputIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  replace_copy(_InputIterator __first, _InputIterator __last,
 _OutputIterator __result,
 const _Tp& __old_value, const _Tp& __new_value)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_InputIterator>::value_type, _Tp>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__replace_copy_if(__first, __last, __result,
	__gnu_cxx::__ops::__iter_equals_val(__old_value),
			      __new_value);
  }

/**
 *  @brief Copy a sequence, replacing each value for which a predicate
 *         returns true with another value.
 *  @ingroup mutating_algorithms
 *  @param  __first      An input iterator.
 *  @param  __last       An input iterator.
 *  @param  __result     An output iterator.
 *  @param  __pred       A predicate.
 *  @param  __new_value  The replacement value.
 *  @return   The end of the output sequence, @p __result+(__last-__first).
 *
 *  Copies each element in the range @p [__first,__last) to the range
 *  @p [__result,__result+(__last-__first)) replacing elements for which
 *  @p __pred returns true with @p __new_value.
*/
template<typename _InputIterator, typename _OutputIterator,
  typename _Predicate, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  replace_copy_if(_InputIterator __first, _InputIterator __last,
    _OutputIterator __result,
    _Predicate __pred, const _Tp& __new_value)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__replace_copy_if(__first, __last, __result,
		__gnu_cxx::__ops::__pred_iter(__pred),
			      __new_value);
  }

3212#if __cplusplus201703L >= 201103L
/**
 *  @brief  Determines whether the elements of a sequence are sorted.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @return  True if the elements are sorted, false otherwise.
*/
template<typename _ForwardIterator>
  _GLIBCXX20_CONSTEXPR
  inline bool
  is_sorted(_ForwardIterator __first, _ForwardIterator __last)
  { return std::is_sorted_until(__first, __last) == __last; }

/**
 *  @brief  Determines whether the elements of a sequence are sorted
 *          according to a comparison functor.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __comp    A comparison functor.
 *  @return  True if the elements are sorted, false otherwise.
*/
template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline bool
  is_sorted(_ForwardIterator __first, _ForwardIterator __last,
     _Compare __comp)
  { return std::is_sorted_until(__first, __last, __comp) == __last; }

template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _ForwardIterator
  __is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
      _Compare __comp)
  {
    if (__first == __last)
return __last;

    _ForwardIterator __next = __first;
    for (++__next; __next != __last; __first = __next, (void)++__next)
if (__comp(__next, __first))
 return __next;
    return __next;
  }

/**
 *  @brief  Determines the end of a sorted sequence.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @return  An iterator pointing to the last iterator i in [__first, __last)
 *           for which the range [__first, i) is sorted.
*/
template<typename _ForwardIterator>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    return std::__is_sorted_until(__first, __last,
		    __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Determines the end of a sorted sequence using comparison functor.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __comp    A comparison functor.
 *  @return  An iterator pointing to the last iterator i in [__first, __last)
 *           for which the range [__first, i) is sorted.
*/
template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
    _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_ForwardIterator>::value_type,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    return std::__is_sorted_until(__first, __last,
		    __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

/**
 *  @brief  Determines min and max at once as an ordered pair.
 *  @ingroup sorting_algorithms
 *  @param  __a  A thing of arbitrary type.
 *  @param  __b  Another thing of arbitrary type.
 *  @return A pair(__b, __a) if __b is smaller than __a, pair(__a,
 *  __b) otherwise.
*/
template<typename _Tp>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline pair<const _Tp&, const _Tp&>
  minmax(const _Tp& __a, const _Tp& __b)
  {
    // concept requirements
    __glibcxx_function_requires(_LessThanComparableConcept<_Tp>)

    return __b < __a ? pair<const _Tp&, const _Tp&>(__b, __a)
       : pair<const _Tp&, const _Tp&>(__a, __b);
  }

/**
 *  @brief  Determines min and max at once as an ordered pair.
 *  @ingroup sorting_algorithms
 *  @param  __a  A thing of arbitrary type.
 *  @param  __b  Another thing of arbitrary type.
 *  @param  __comp  A @link comparison_functors comparison functor @endlink.
 *  @return A pair(__b, __a) if __b is smaller than __a, pair(__a,
 *  __b) otherwise.
*/
template<typename _Tp, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline pair<const _Tp&, const _Tp&>
  minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
  {
    return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a)
	      : pair<const _Tp&, const _Tp&>(__a, __b);
  }

template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  pair<_ForwardIterator, _ForwardIterator>
  __minmax_element(_ForwardIterator __first, _ForwardIterator __last,
     _Compare __comp)
  {
    _ForwardIterator __next = __first;
    if (__first == __last
 || ++__next == __last)
return std::make_pair(__first, __first);

    _ForwardIterator __min{}, __max{};
    if (__comp(__next, __first))
{
 __min = __next;
 __max = __first;
}
    else
{
 __min = __first;
 __max = __next;
}

    __first = __next;
    ++__first;

    while (__first != __last)
{
 __next = __first;
 if (++__next == __last)
   {
     if (__comp(__first, __min))
__min = __first;
     else if (!__comp(__first, __max))
__max = __first;
     break;
   }

 if (__comp(__next, __first))
   {
     if (__comp(__next, __min))
__min = __next;
     if (!__comp(__first, __max))
__max = __first;
   }
 else
   {
     if (__comp(__first, __min))
__min = __first;
     if (!__comp(__next, __max))
__max = __next;
   }

 __first = __next;
 ++__first;
}

    return std::make_pair(__min, __max);
  }

/**
 *  @brief  Return a pair of iterators pointing to the minimum and maximum
 *          elements in a range.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @return  make_pair(m, M), where m is the first iterator i in 
 *           [__first, __last) such that no other element in the range is
 *           smaller, and where M is the last iterator i in [__first, __last)
 *           such that no other element in the range is larger.
*/
template<typename _ForwardIterator>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline pair<_ForwardIterator, _ForwardIterator>
  minmax_element(_ForwardIterator __first, _ForwardIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    return std::__minmax_element(__first, __last,
		   __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Return a pair of iterators pointing to the minimum and maximum
 *          elements in a range.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @param  __comp   Comparison functor.
 *  @return  make_pair(m, M), where m is the first iterator i in 
 *           [__first, __last) such that no other element in the range is
 *           smaller, and where M is the last iterator i in [__first, __last)
 *           such that no other element in the range is larger.
*/
template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline pair<_ForwardIterator, _ForwardIterator>
  minmax_element(_ForwardIterator __first, _ForwardIterator __last,
   _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_ForwardIterator>::value_type,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    return std::__minmax_element(__first, __last,
		   __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

// N2722 + DR 915.
template<typename _Tp>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _Tp
  min(initializer_list<_Tp> __l)
  { return *std::min_element(__l.begin(), __l.end()); }

template<typename _Tp, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _Tp
  min(initializer_list<_Tp> __l, _Compare __comp)
  { return *std::min_element(__l.begin(), __l.end(), __comp); }

template<typename _Tp>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _Tp
  max(initializer_list<_Tp> __l)
  { return *std::max_element(__l.begin(), __l.end()); }

template<typename _Tp, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _Tp
  max(initializer_list<_Tp> __l, _Compare __comp)
  { return *std::max_element(__l.begin(), __l.end(), __comp); }

template<typename _Tp>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline pair<_Tp, _Tp>
  minmax(initializer_list<_Tp> __l)
  {
    pair<const _Tp*, const _Tp*> __p =
std::minmax_element(__l.begin(), __l.end());
    return std::make_pair(*__p.first, *__p.second);
  }

template<typename _Tp, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline pair<_Tp, _Tp>
  minmax(initializer_list<_Tp> __l, _Compare __comp)
  {
    pair<const _Tp*, const _Tp*> __p =
std::minmax_element(__l.begin(), __l.end(), __comp);
    return std::make_pair(*__p.first, *__p.second);
  }

/**
 *  @brief  Checks whether a permutation of the second sequence is equal
 *          to the first sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __pred    A binary predicate.
 *  @return true if there exists a permutation of the elements in
 *          the range [__first2, __first2 + (__last1 - __first1)),
 *          beginning with ForwardIterator2 begin, such that
 *          equal(__first1, __last1, __begin, __pred) returns true;
 *          otherwise, returns false.
*/
template<typename _ForwardIterator1, typename _ForwardIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline bool
  is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
   _ForwardIterator2 __first2, _BinaryPredicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
   typename iterator_traits<_ForwardIterator1>::value_type,
   typename iterator_traits<_ForwardIterator2>::value_type>)
    __glibcxx_requires_valid_range(__first1, __last1);

    return std::__is_permutation(__first1, __last1, __first2,
		   __gnu_cxx::__ops::__iter_comp_iter(__pred));
  }

3542#if __cplusplus201703L > 201103L
template<typename _ForwardIterator1, typename _ForwardIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  bool
  __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
     _ForwardIterator2 __first2, _ForwardIterator2 __last2,
     _BinaryPredicate __pred)
  {
    using _Cat1
= typename iterator_traits<_ForwardIterator1>::iterator_category;
    using _Cat2
= typename iterator_traits<_ForwardIterator2>::iterator_category;
    using _It1_is_RA = is_same<_Cat1, random_access_iterator_tag>;
    using _It2_is_RA = is_same<_Cat2, random_access_iterator_tag>;
    constexpr bool __ra_iters = _It1_is_RA() && _It2_is_RA();
    if (__ra_iters)
{
 auto __d1 = std::distance(__first1, __last1);
 auto __d2 = std::distance(__first2, __last2);
 if (__d1 != __d2)
   return false;
}

    // Efficiently compare identical prefixes:  O(N) if sequences
    // have the same elements in the same order.
    for (; __first1 != __last1 && __first2 != __last2;
 ++__first1, (void)++__first2)
if (!__pred(__first1, __first2))
 break;

    if (__ra_iters)
{
 if (__first1 == __last1)
   return true;
}
    else
{
 auto __d1 = std::distance(__first1, __last1);
 auto __d2 = std::distance(__first2, __last2);
 if (__d1 == 0 && __d2 == 0)
   return true;
 if (__d1 != __d2)
   return false;
}

    for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
{
 if (__scan != std::__find_if(__first1, __scan,
	__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
   continue; // We've seen this one before.

 auto __matches = std::__count_if(__first2, __last2,
__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
 if (0 == __matches
     || std::__count_if(__scan, __last1,
	__gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
     != __matches)
   return false;
}
    return true;
  }

/**
 *  @brief  Checks whether a permutaion of the second sequence is equal
 *          to the first sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of first range.
 *  @return true if there exists a permutation of the elements in the range
 *          [__first2, __last2), beginning with ForwardIterator2 begin,
 *          such that equal(__first1, __last1, begin) returns true;
 *          otherwise, returns false.
*/
template<typename _ForwardIterator1, typename _ForwardIterator2>
  _GLIBCXX20_CONSTEXPR
  inline bool
  is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
   _ForwardIterator2 __first2, _ForwardIterator2 __last2)
  {
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    return
std::__is_permutation(__first1, __last1, __first2, __last2,
	      __gnu_cxx::__ops::__iter_equal_to_iter());
  }

/**
 *  @brief  Checks whether a permutation of the second sequence is equal
 *          to the first sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of first range.
 *  @param  __pred    A binary predicate.
 *  @return true if there exists a permutation of the elements in the range
 *          [__first2, __last2), beginning with ForwardIterator2 begin,
 *          such that equal(__first1, __last1, __begin, __pred) returns true;
 *          otherwise, returns false.
*/
template<typename _ForwardIterator1, typename _ForwardIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline bool
  is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
   _ForwardIterator2 __first2, _ForwardIterator2 __last2,
   _BinaryPredicate __pred)
  {
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    return std::__is_permutation(__first1, __last1, __first2, __last2,
		   __gnu_cxx::__ops::__iter_comp_iter(__pred));
  }

3661#if __cplusplus201703L > 201402L

3663#define __cpp_lib_clamp201603 201603

/**
 *  @brief  Returns the value clamped between lo and hi.
 *  @ingroup sorting_algorithms
 *  @param  __val  A value of arbitrary type.
 *  @param  __lo   A lower limit of arbitrary type.
 *  @param  __hi   An upper limit of arbitrary type.
 *  @return max(__val, __lo) if __val < __hi or min(__val, __hi) otherwise.
 */
template<typename _Tp>
  constexpr const _Tp&
  clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi)
  {
    __glibcxx_assert(!(__hi < __lo));
    return (__val < __lo) ? __lo : (__hi < __val) ? __hi : __val;
  }

/**
 *  @brief  Returns the value clamped between lo and hi.
 *  @ingroup sorting_algorithms
 *  @param  __val   A value of arbitrary type.
 *  @param  __lo    A lower limit of arbitrary type.
 *  @param  __hi    An upper limit of arbitrary type.
 *  @param  __comp  A comparison functor.
 *  @return max(__val, __lo, __comp) if __comp(__val, __hi)
 *	      or min(__val, __hi, __comp) otherwise.
 */
template<typename _Tp, typename _Compare>
  constexpr const _Tp&
  clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi, _Compare __comp)
  {
    __glibcxx_assert(!__comp(__hi, __lo));
    return __comp(__val, __lo) ? __lo : __comp(__hi, __val) ? __hi : __val;
  }
3698#endif // C++17
3699#endif // C++14

3701#ifdef _GLIBCXX_USE_C99_STDINT_TR11
/**
 *  @brief Generate two uniformly distributed integers using a
 *         single distribution invocation.
 *  @param  __b0    The upper bound for the first integer.
 *  @param  __b1    The upper bound for the second integer.
 *  @param  __g     A UniformRandomBitGenerator.
 *  @return  A pair (i, j) with i and j uniformly distributed
 *           over [0, __b0) and [0, __b1), respectively.
 *
 *  Requires: __b0 * __b1 <= __g.max() - __g.min().
 *
 *  Using uniform_int_distribution with a range that is very
 *  small relative to the range of the generator ends up wasting
 *  potentially expensively generated randomness, since
 *  uniform_int_distribution does not store leftover randomness
 *  between invocations.
 *
 *  If we know we want two integers in ranges that are sufficiently
 *  small, we can compose the ranges, use a single distribution
 *  invocation, and significantly reduce the waste.
*/
template<typename _IntType, typename _UniformRandomBitGenerator>
  pair<_IntType, _IntType>
  __gen_two_uniform_ints(_IntType __b0, _IntType __b1,
	   _UniformRandomBitGenerator&& __g)
  {
    _IntType __x
= uniform_int_distribution<_IntType>{0, (__b0 * __b1) - 1}(__g);
    return std::make_pair(__x / __b1, __x % __b1);
  }

/**
 *  @brief Shuffle the elements of a sequence using a uniform random
 *         number generator.
 *  @ingroup mutating_algorithms
 *  @param  __first   A forward iterator.
 *  @param  __last    A forward iterator.
 *  @param  __g       A UniformRandomNumberGenerator (26.5.1.3).
 *  @return  Nothing.
 *
 *  Reorders the elements in the range @p [__first,__last) using @p __g to
 *  provide random numbers.
*/
template<typename _RandomAccessIterator,
  typename _UniformRandomNumberGenerator>
  void
  shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
   _UniformRandomNumberGenerator&& __g)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_requires_valid_range(__first, __last);

    if (__first == __last)
return;

    typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_DistanceType;

    typedef typename std::make_unsigned<_DistanceType>::type __ud_type;
    typedef typename std::uniform_int_distribution<__ud_type> __distr_type;
    typedef typename __distr_type::param_type __p_type;

    typedef typename remove_reference<_UniformRandomNumberGenerator>::type
_Gen;
    typedef typename common_type<typename _Gen::result_type, __ud_type>::type
__uc_type;

    const __uc_type __urngrange = __g.max() - __g.min();
    const __uc_type __urange = __uc_type(__last - __first);

    if (__urngrange / __urange >= __urange)
      // I.e. (__urngrange >= __urange * __urange) but without wrap issues.
    {
_RandomAccessIterator __i = __first + 1;

// Since we know the range isn't empty, an even number of elements
// means an uneven number of elements /to swap/, in which case we
// do the first one up front:

if ((__urange % 2) == 0)
{
 __distr_type __d{0, 1};
 std::iter_swap(__i++, __first + __d(__g));
}

// Now we know that __last - __i is even, so we do the rest in pairs,
// using a single distribution invocation to produce swap positions
// for two successive elements at a time:

while (__i != __last)
{
 const __uc_type __swap_range = __uc_type(__i - __first) + 1;

 const pair<__uc_type, __uc_type> __pospos =
   __gen_two_uniform_ints(__swap_range, __swap_range + 1, __g);

 std::iter_swap(__i++, __first + __pospos.first);
 std::iter_swap(__i++, __first + __pospos.second);
}

return;
    }

    __distr_type __d;

    for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first)));
  }
3812#endif

3814#endif // C++11

3816_GLIBCXX_BEGIN_NAMESPACE_ALGO

/**
 *  @brief Apply a function to every element of a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __f      A unary function object.
 *  @return   @p __f
 *
 *  Applies the function object @p __f to each element in the range
 *  @p [first,last).  @p __f must not modify the order of the sequence.
 *  If @p __f has a return value it is ignored.
*/
template<typename _InputIterator, typename _Function>
  _GLIBCXX20_CONSTEXPR
  _Function
  for_each(_InputIterator __first, _InputIterator __last, _Function __f)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_requires_valid_range(__first, __last);
    for (; __first != __last; ++__first)
__f(*__first);
    return __f; // N.B. [alg.foreach] says std::move(f) but it's redundant.
  }

3843#if __cplusplus201703L >= 201703L
/**
 *  @brief Apply a function to every element of a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __n      A value convertible to an integer.
 *  @param  __f      A unary function object.
 *  @return   `__first+__n`
 *
 *  Applies the function object `__f` to each element in the range
 *  `[first, first+n)`.  `__f` must not modify the order of the sequence.
 *  If `__f` has a return value it is ignored.
*/
template<typename _InputIterator, typename _Size, typename _Function>
  _InputIterator
  for_each_n(_InputIterator __first, _Size __n, _Function __f)
  {
    auto __n2 = std::__size_to_integer(__n);
    using _Cat = typename iterator_traits<_InputIterator>::iterator_category;
    if constexpr (is_base_of_v<random_access_iterator_tag, _Cat>)
{
 if (__n2 <= 0)
   return __first;
 auto __last = __first + __n2;
 std::for_each(__first, __last, std::move(__f));
 return __last;
}
    else
{
 while (__n2-->0)
   {
     __f(*__first);
     ++__first;
   }
 return __first;
}
  }
3880#endif // C++17

/**
 *  @brief Find the first occurrence of a value in a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __val    The value to find.
 *  @return   The first iterator @c i in the range @p [__first,__last)
 *  such that @c *i == @p __val, or @p __last if no such iterator exists.
*/
template<typename _InputIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _InputIterator
  find(_InputIterator __first, _InputIterator __last,
const _Tp& __val)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_EqualOpConcept<
typename iterator_traits<_InputIterator>::value_type, _Tp>)
    __glibcxx_requires_valid_range(__first, __last);
    return std::__find_if(__first, __last,
	    __gnu_cxx::__ops::__iter_equals_val(__val));
  }

/**
 *  @brief Find the first element in a sequence for which a
 *         predicate is true.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __pred   A predicate.
 *  @return   The first iterator @c i in the range @p [__first,__last)
 *  such that @p __pred(*i) is true, or @p __last if no such iterator exists.
*/
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline _InputIterator
  find_if(_InputIterator __first, _InputIterator __last,
   _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
     typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__find_if(__first, __last,
	    __gnu_cxx::__ops::__pred_iter(__pred));
  }

/**
 *  @brief  Find element from a set in a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  Start of range to search.
 *  @param  __last1   End of range to search.
 *  @param  __first2  Start of match candidates.
 *  @param  __last2   End of match candidates.
 *  @return   The first iterator @c i in the range
 *  @p [__first1,__last1) such that @c *i == @p *(i2) such that i2 is an
 *  iterator in [__first2,__last2), or @p __last1 if no such iterator exists.
 *
 *  Searches the range @p [__first1,__last1) for an element that is
 *  equal to some element in the range [__first2,__last2).  If
 *  found, returns an iterator in the range [__first1,__last1),
 *  otherwise returns @p __last1.
*/
template<typename _InputIterator, typename _ForwardIterator>
  _GLIBCXX20_CONSTEXPR
  _InputIterator
  find_first_of(_InputIterator __first1, _InputIterator __last1,
  _ForwardIterator __first2, _ForwardIterator __last2)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_InputIterator>::value_type,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    for (; __first1 != __last1; ++__first1)
for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
 if (*__first1 == *__iter)
   return __first1;
    return __last1;
  }

/**
 *  @brief  Find element from a set in a sequence using a predicate.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  Start of range to search.
 *  @param  __last1   End of range to search.
 *  @param  __first2  Start of match candidates.
 *  @param  __last2   End of match candidates.
 *  @param  __comp    Predicate to use.
 *  @return   The first iterator @c i in the range
 *  @p [__first1,__last1) such that @c comp(*i, @p *(i2)) is true
 *  and i2 is an iterator in [__first2,__last2), or @p __last1 if no
 *  such iterator exists.
 *

 *  Searches the range @p [__first1,__last1) for an element that is
 *  equal to some element in the range [__first2,__last2).  If
 *  found, returns an iterator in the range [__first1,__last1),
 *  otherwise returns @p __last1.
*/
template<typename _InputIterator, typename _ForwardIterator,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  _InputIterator
  find_first_of(_InputIterator __first1, _InputIterator __last1,
  _ForwardIterator __first2, _ForwardIterator __last2,
  _BinaryPredicate __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
   typename iterator_traits<_InputIterator>::value_type,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    for (; __first1 != __last1; ++__first1)
for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
 if (__comp(*__first1, *__iter))
   return __first1;
    return __last1;
  }

/**
 *  @brief Find two adjacent values in a sequence that are equal.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  A forward iterator.
 *  @param  __last   A forward iterator.
 *  @return   The first iterator @c i such that @c i and @c i+1 are both
 *  valid iterators in @p [__first,__last) and such that @c *i == @c *(i+1),
 *  or @p __last if no such iterator exists.
*/
template<typename _ForwardIterator>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_EqualityComparableConcept<
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__adjacent_find(__first, __last,
		  __gnu_cxx::__ops::__iter_equal_to_iter());
  }

/**
 *  @brief Find two adjacent values in a sequence using a predicate.
 *  @ingroup non_mutating_algorithms
 *  @param  __first         A forward iterator.
 *  @param  __last          A forward iterator.
 *  @param  __binary_pred   A binary predicate.
 *  @return   The first iterator @c i such that @c i and @c i+1 are both
 *  valid iterators in @p [__first,__last) and such that
 *  @p __binary_pred(*i,*(i+1)) is true, or @p __last if no such iterator
 *  exists.
*/
template<typename _ForwardIterator, typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
  _BinaryPredicate __binary_pred)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
   typename iterator_traits<_ForwardIterator>::value_type,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__adjacent_find(__first, __last,
	__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
  }

/**
 *  @brief Count the number of copies of a value in a sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __value  The value to be counted.
 *  @return   The number of iterators @c i in the range @p [__first,__last)
 *  for which @c *i == @p __value
*/
template<typename _InputIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline typename iterator_traits<_InputIterator>::difference_type
  count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_InputIterator>::value_type, _Tp>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__count_if(__first, __last,
	     __gnu_cxx::__ops::__iter_equals_val(__value));
  }

/**
 *  @brief Count the elements of a sequence for which a predicate is true.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  An input iterator.
 *  @param  __last   An input iterator.
 *  @param  __pred   A predicate.
 *  @return   The number of iterators @c i in the range @p [__first,__last)
 *  for which @p __pred(*i) is true.
*/
template<typename _InputIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline typename iterator_traits<_InputIterator>::difference_type
  count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__count_if(__first, __last,
	     __gnu_cxx::__ops::__pred_iter(__pred));
  }

/**
 *  @brief Search a sequence for a matching sub-sequence.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1  A forward iterator.
 *  @param  __last1   A forward iterator.
 *  @param  __first2  A forward iterator.
 *  @param  __last2   A forward iterator.
 *  @return The first iterator @c i in the range @p
 *  [__first1,__last1-(__last2-__first2)) such that @c *(i+N) == @p
 *  *(__first2+N) for each @c N in the range @p
 *  [0,__last2-__first2), or @p __last1 if no such iterator exists.
 *
 *  Searches the range @p [__first1,__last1) for a sub-sequence that
 *  compares equal value-by-value with the sequence given by @p
 *  [__first2,__last2) and returns an iterator to the first element
 *  of the sub-sequence, or @p __last1 if the sub-sequence is not
 *  found.
 *
 *  Because the sub-sequence must lie completely within the range @p
 *  [__first1,__last1) it must start at a position less than @p
 *  __last1-(__last2-__first2) where @p __last2-__first2 is the
 *  length of the sub-sequence.
 *
 *  This means that the returned iterator @c i will be in the range
 *  @p [__first1,__last1-(__last2-__first2))
*/
template<typename _ForwardIterator1, typename _ForwardIterator2>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator1
  search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
  _ForwardIterator2 __first2, _ForwardIterator2 __last2)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_ForwardIterator1>::value_type,
   typename iterator_traits<_ForwardIterator2>::value_type>)
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    return std::__search(__first1, __last1, __first2, __last2,
	   __gnu_cxx::__ops::__iter_equal_to_iter());
  }

/**
 *  @brief Search a sequence for a matching sub-sequence using a predicate.
 *  @ingroup non_mutating_algorithms
 *  @param  __first1     A forward iterator.
 *  @param  __last1      A forward iterator.
 *  @param  __first2     A forward iterator.
 *  @param  __last2      A forward iterator.
 *  @param  __predicate  A binary predicate.
 *  @return   The first iterator @c i in the range
 *  @p [__first1,__last1-(__last2-__first2)) such that
 *  @p __predicate(*(i+N),*(__first2+N)) is true for each @c N in the range
 *  @p [0,__last2-__first2), or @p __last1 if no such iterator exists.
 *
 *  Searches the range @p [__first1,__last1) for a sub-sequence that
 *  compares equal value-by-value with the sequence given by @p
 *  [__first2,__last2), using @p __predicate to determine equality,
 *  and returns an iterator to the first element of the
 *  sub-sequence, or @p __last1 if no such iterator exists.
 *
 *  @see search(_ForwardIter1, _ForwardIter1, _ForwardIter2, _ForwardIter2)
*/
template<typename _ForwardIterator1, typename _ForwardIterator2,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator1
  search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
  _ForwardIterator2 __first2, _ForwardIterator2 __last2,
  _BinaryPredicate  __predicate)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
   typename iterator_traits<_ForwardIterator1>::value_type,
   typename iterator_traits<_ForwardIterator2>::value_type>)
    __glibcxx_requires_valid_range(__first1, __last1);
    __glibcxx_requires_valid_range(__first2, __last2);

    return std::__search(__first1, __last1, __first2, __last2,
	   __gnu_cxx::__ops::__iter_comp_iter(__predicate));
  }

/**
 *  @brief Search a sequence for a number of consecutive values.
 *  @ingroup non_mutating_algorithms
 *  @param  __first  A forward iterator.
 *  @param  __last   A forward iterator.
 *  @param  __count  The number of consecutive values.
 *  @param  __val    The value to find.
 *  @return The first iterator @c i in the range @p
 *  [__first,__last-__count) such that @c *(i+N) == @p __val for
 *  each @c N in the range @p [0,__count), or @p __last if no such
 *  iterator exists.
 *
 *  Searches the range @p [__first,__last) for @p count consecutive elements
 *  equal to @p __val.
*/
template<typename _ForwardIterator, typename _Integer, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  search_n(_ForwardIterator __first, _ForwardIterator __last,
    _Integer __count, const _Tp& __val)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__search_n(__first, __last, __count,
	     __gnu_cxx::__ops::__iter_equals_val(__val));
  }


/**
 *  @brief Search a sequence for a number of consecutive values using a
 *         predicate.
 *  @ingroup non_mutating_algorithms
 *  @param  __first        A forward iterator.
 *  @param  __last         A forward iterator.
 *  @param  __count        The number of consecutive values.
 *  @param  __val          The value to find.
 *  @param  __binary_pred  A binary predicate.
 *  @return The first iterator @c i in the range @p
 *  [__first,__last-__count) such that @p
 *  __binary_pred(*(i+N),__val) is true for each @c N in the range
 *  @p [0,__count), or @p __last if no such iterator exists.
 *
 *  Searches the range @p [__first,__last) for @p __count
 *  consecutive elements for which the predicate returns true.
*/
template<typename _ForwardIterator, typename _Integer, typename _Tp,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  search_n(_ForwardIterator __first, _ForwardIterator __last,
    _Integer __count, const _Tp& __val,
    _BinaryPredicate __binary_pred)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
   typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__search_n(__first, __last, __count,
__gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val));
  }

4267#if __cplusplus201703L > 201402L
/** @brief Search a sequence using a Searcher object.
 *
 *  @param  __first        A forward iterator.
 *  @param  __last         A forward iterator.
 *  @param  __searcher     A callable object.
 *  @return @p __searcher(__first,__last).first
*/
template<typename _ForwardIterator, typename _Searcher>
  inline _ForwardIterator
  search(_ForwardIterator __first, _ForwardIterator __last,
  const _Searcher& __searcher)
  { return __searcher(__first, __last).first; }
4280#endif

/**
 *  @brief Perform an operation on a sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first     An input iterator.
 *  @param  __last      An input iterator.
 *  @param  __result    An output iterator.
 *  @param  __unary_op  A unary operator.
 *  @return   An output iterator equal to @p __result+(__last-__first).
 *
 *  Applies the operator to each element in the input range and assigns
 *  the results to successive elements of the output sequence.
 *  Evaluates @p *(__result+N)=unary_op(*(__first+N)) for each @c N in the
 *  range @p [0,__last-__first).
 *
 *  @p unary_op must not alter its argument.
*/
template<typename _InputIterator, typename _OutputIterator,
  typename _UnaryOperation>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  transform(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result, _UnaryOperation __unary_op)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   // "the type returned by a _UnaryOperation"
   __typeof__(__unary_op(*__first))>)
    __glibcxx_requires_valid_range(__first, __last);

    for (; __first != __last; ++__first, (void)++__result)
*__result = __unary_op(*__first);
    return __result;
  }

/**
 *  @brief Perform an operation on corresponding elements of two sequences.
 *  @ingroup mutating_algorithms
 *  @param  __first1     An input iterator.
 *  @param  __last1      An input iterator.
 *  @param  __first2     An input iterator.
 *  @param  __result     An output iterator.
 *  @param  __binary_op  A binary operator.
 *  @return   An output iterator equal to @p result+(last-first).
 *
 *  Applies the operator to the corresponding elements in the two
 *  input ranges and assigns the results to successive elements of the
 *  output sequence.
 *  Evaluates @p
 *  *(__result+N)=__binary_op(*(__first1+N),*(__first2+N)) for each
 *  @c N in the range @p [0,__last1-__first1).
 *
 *  @p binary_op must not alter either of its arguments.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _BinaryOperation>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  transform(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _OutputIterator __result,
     _BinaryOperation __binary_op)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   // "the type returned by a _BinaryOperation"
   __typeof__(__binary_op(*__first1,*__first2))>)
    __glibcxx_requires_valid_range(__first1, __last1);

    for (; __first1 != __last1; ++__first1, (void)++__first2, ++__result)
*__result = __binary_op(*__first1, *__first2);
    return __result;
  }

/**
 *  @brief Replace each occurrence of one value in a sequence with another
 *         value.
 *  @ingroup mutating_algorithms
 *  @param  __first      A forward iterator.
 *  @param  __last       A forward iterator.
 *  @param  __old_value  The value to be replaced.
 *  @param  __new_value  The replacement value.
 *  @return   replace() returns no value.
 *
 *  For each iterator @c i in the range @p [__first,__last) if @c *i ==
 *  @p __old_value then the assignment @c *i = @p __new_value is performed.
*/
template<typename _ForwardIterator, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  void
  replace(_ForwardIterator __first, _ForwardIterator __last,
   const _Tp& __old_value, const _Tp& __new_value)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_EqualOpConcept<
   typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    __glibcxx_function_requires(_ConvertibleConcept<_Tp,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    for (; __first != __last; ++__first)
if (*__first == __old_value)
 *__first = __new_value;
  }

/**
 *  @brief Replace each value in a sequence for which a predicate returns
 *         true with another value.
 *  @ingroup mutating_algorithms
 *  @param  __first      A forward iterator.
 *  @param  __last       A forward iterator.
 *  @param  __pred       A predicate.
 *  @param  __new_value  The replacement value.
 *  @return   replace_if() returns no value.
 *
 *  For each iterator @c i in the range @p [__first,__last) if @p __pred(*i)
 *  is true then the assignment @c *i = @p __new_value is performed.
*/
template<typename _ForwardIterator, typename _Predicate, typename _Tp>
  _GLIBCXX20_CONSTEXPR
  void
  replace_if(_ForwardIterator __first, _ForwardIterator __last,
      _Predicate __pred, const _Tp& __new_value)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_ConvertibleConcept<_Tp,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    for (; __first != __last; ++__first)
if (__pred(*__first))
 *__first = __new_value;
  }

/**
 *  @brief Assign the result of a function object to each value in a
 *         sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first  A forward iterator.
 *  @param  __last   A forward iterator.
 *  @param  __gen    A function object taking no arguments and returning
 *                 std::iterator_traits<_ForwardIterator>::value_type
 *  @return   generate() returns no value.
 *
 *  Performs the assignment @c *i = @p __gen() for each @c i in the range
 *  @p [__first,__last).
*/
template<typename _ForwardIterator, typename _Generator>
  _GLIBCXX20_CONSTEXPR
  void
  generate(_ForwardIterator __first, _ForwardIterator __last,
    _Generator __gen)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_GeneratorConcept<_Generator,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    for (; __first != __last; ++__first)
*__first = __gen();
  }

/**
 *  @brief Assign the result of a function object to each value in a
 *         sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first  A forward iterator.
 *  @param  __n      The length of the sequence.
 *  @param  __gen    A function object taking no arguments and returning
 *                 std::iterator_traits<_ForwardIterator>::value_type
 *  @return   The end of the sequence, @p __first+__n
 *
 *  Performs the assignment @c *i = @p __gen() for each @c i in the range
 *  @p [__first,__first+__n).
 *
 * If @p __n is negative, the function does nothing and returns @p __first.
*/
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 865. More algorithms that throw away information
// DR 426. search_n(), fill_n(), and generate_n() with negative n
template<typename _OutputIterator, typename _Size, typename _Generator>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
  {
    // concept requirements
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   // "the type returned by a _Generator"
   __typeof__(__gen())>)

    typedef __decltype(std::__size_to_integer(__n)) _IntSize;
    for (_IntSize __niter = std::__size_to_integer(__n);
  __niter > 0; --__niter, (void) ++__first)
*__first = __gen();
    return __first;
  }

/**
 *  @brief Copy a sequence, removing consecutive duplicate values.
 *  @ingroup mutating_algorithms
 *  @param  __first   An input iterator.
 *  @param  __last    An input iterator.
 *  @param  __result  An output iterator.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  Copies each element in the range @p [__first,__last) to the range
 *  beginning at @p __result, except that only the first element is copied
 *  from groups of consecutive elements that compare equal.
 *  unique_copy() is stable, so the relative order of elements that are
 *  copied is unchanged.
 *
 *  _GLIBCXX_RESOLVE_LIB_DEFECTS
 *  DR 241. Does unique_copy() require CopyConstructible and Assignable?
 *  
 *  _GLIBCXX_RESOLVE_LIB_DEFECTS
 *  DR 538. 241 again: Does unique_copy() require CopyConstructible and 
 *  Assignable?
*/
template<typename _InputIterator, typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  unique_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_function_requires(_EqualityComparableConcept<
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    if (__first == __last)
return __result;
    return std::__unique_copy(__first, __last, __result,
		__gnu_cxx::__ops::__iter_equal_to_iter(),
		std::__iterator_category(__first),
		std::__iterator_category(__result));
  }

/**
 *  @brief Copy a sequence, removing consecutive values using a predicate.
 *  @ingroup mutating_algorithms
 *  @param  __first        An input iterator.
 *  @param  __last         An input iterator.
 *  @param  __result       An output iterator.
 *  @param  __binary_pred  A binary predicate.
 *  @return   An iterator designating the end of the resulting sequence.
 *
 *  Copies each element in the range @p [__first,__last) to the range
 *  beginning at @p __result, except that only the first element is copied
 *  from groups of consecutive elements for which @p __binary_pred returns
 *  true.
 *  unique_copy() is stable, so the relative order of elements that are
 *  copied is unchanged.
 *
 *  _GLIBCXX_RESOLVE_LIB_DEFECTS
 *  DR 241. Does unique_copy() require CopyConstructible and Assignable?
*/
template<typename _InputIterator, typename _OutputIterator,
  typename _BinaryPredicate>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  unique_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result,
_BinaryPredicate __binary_pred)
  {
    // concept requirements -- predicates checked later
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    if (__first == __last)
return __result;
    return std::__unique_copy(__first, __last, __result,
	__gnu_cxx::__ops::__iter_comp_iter(__binary_pred),
		std::__iterator_category(__first),
		std::__iterator_category(__result));
  }

4571#if _GLIBCXX_HOSTED1
/**
 *  @brief Randomly shuffle the elements of a sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first   A forward iterator.
 *  @param  __last    A forward iterator.
 *  @return  Nothing.
 *
 *  Reorder the elements in the range @p [__first,__last) using a random
 *  distribution, so that every possible ordering of the sequence is
 *  equally likely.
*/
template<typename _RandomAccessIterator>
  inline void
  random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_requires_valid_range(__first, __last);

    if (__first != __last)
for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
 {
   // XXX rand() % N is not uniformly distributed
   _RandomAccessIterator __j = __first
			+ std::rand() % ((__i - __first) + 1);
   if (__i != __j)
     std::iter_swap(__i, __j);
 }
  }
4602#endif

/**
 *  @brief Shuffle the elements of a sequence using a random number
 *         generator.
 *  @ingroup mutating_algorithms
 *  @param  __first   A forward iterator.
 *  @param  __last    A forward iterator.
 *  @param  __rand    The RNG functor or function.
 *  @return  Nothing.
 *
 *  Reorders the elements in the range @p [__first,__last) using @p __rand to
 *  provide a random distribution. Calling @p __rand(N) for a positive
 *  integer @p N should return a randomly chosen integer from the
 *  range [0,N).
*/
template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
  void
  random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
4621#if __cplusplus201703L >= 201103L
   _RandomNumberGenerator&& __rand)
4623#else
   _RandomNumberGenerator& __rand)
4625#endif
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_requires_valid_range(__first, __last);

    if (__first == __last)
return;
    for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
{
 _RandomAccessIterator __j = __first + __rand((__i - __first) + 1);
 if (__i != __j)
   std::iter_swap(__i, __j);
}
  }


/**
 *  @brief Move elements for which a predicate is true to the beginning
 *         of a sequence.
 *  @ingroup mutating_algorithms
 *  @param  __first   A forward iterator.
 *  @param  __last    A forward iterator.
 *  @param  __pred    A predicate functor.
 *  @return  An iterator @p middle such that @p __pred(i) is true for each
 *  iterator @p i in the range @p [__first,middle) and false for each @p i
 *  in the range @p [middle,__last).
 *
 *  @p __pred must not modify its operand. @p partition() does not preserve
 *  the relative ordering of elements in each group, use
 *  @p stable_partition() if this is needed.
*/
template<typename _ForwardIterator, typename _Predicate>
  _GLIBCXX20_CONSTEXPR
  inline _ForwardIterator
  partition(_ForwardIterator __first, _ForwardIterator __last,
     _Predicate   __pred)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
		  _ForwardIterator>)
    __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);

    return std::__partition(__first, __last, __pred,
	      std::__iterator_category(__first));
  }


/**
 *  @brief Sort the smallest elements of a sequence.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __middle  Another iterator.
 *  @param  __last    Another iterator.
 *  @return  Nothing.
 *
 *  Sorts the smallest @p (__middle-__first) elements in the range
 *  @p [first,last) and moves them to the range @p [__first,__middle). The
 *  order of the remaining elements in the range @p [__middle,__last) is
 *  undefined.
 *  After the sort if @e i and @e j are iterators in the range
 *  @p [__first,__middle) such that i precedes j and @e k is an iterator in
 *  the range @p [__middle,__last) then *j<*i and *k<*i are both false.
*/
template<typename _RandomAccessIterator>
  _GLIBCXX20_CONSTEXPR
  inline void
  partial_sort(_RandomAccessIterator __first,
 _RandomAccessIterator __middle,
 _RandomAccessIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __middle);
    __glibcxx_requires_valid_range(__middle, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    std::__partial_sort(__first, __middle, __last,
	  __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Sort the smallest elements of a sequence using a predicate
 *         for comparison.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __middle  Another iterator.
 *  @param  __last    Another iterator.
 *  @param  __comp    A comparison functor.
 *  @return  Nothing.
 *
 *  Sorts the smallest @p (__middle-__first) elements in the range
 *  @p [__first,__last) and moves them to the range @p [__first,__middle). The
 *  order of the remaining elements in the range @p [__middle,__last) is
 *  undefined.
 *  After the sort if @e i and @e j are iterators in the range
 *  @p [__first,__middle) such that i precedes j and @e k is an iterator in
 *  the range @p [__middle,__last) then @p *__comp(j,*i) and @p __comp(*k,*i)
 *  are both false.
*/
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline void
  partial_sort(_RandomAccessIterator __first,
 _RandomAccessIterator __middle,
 _RandomAccessIterator __last,
 _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_RandomAccessIterator>::value_type,
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __middle);
    __glibcxx_requires_valid_range(__middle, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    std::__partial_sort(__first, __middle, __last,
	  __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

/**
 *  @brief Sort a sequence just enough to find a particular position.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __nth     Another iterator.
 *  @param  __last    Another iterator.
 *  @return  Nothing.
 *
 *  Rearranges the elements in the range @p [__first,__last) so that @p *__nth
 *  is the same element that would have been in that position had the
 *  whole sequence been sorted. The elements either side of @p *__nth are
 *  not completely sorted, but for any iterator @e i in the range
 *  @p [__first,__nth) and any iterator @e j in the range @p [__nth,__last) it
 *  holds that *j < *i is false.
*/
template<typename _RandomAccessIterator>
  _GLIBCXX20_CONSTEXPR
  inline void
  nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
		  _RandomAccessIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __nth);
    __glibcxx_requires_valid_range(__nth, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    if (__first == __last || __nth == __last)
return;

    std::__introselect(__first, __nth, __last,
	 std::__lg(__last - __first) * 2,
	 __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Sort a sequence just enough to find a particular position
 *         using a predicate for comparison.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __nth     Another iterator.
 *  @param  __last    Another iterator.
 *  @param  __comp    A comparison functor.
 *  @return  Nothing.
 *
 *  Rearranges the elements in the range @p [__first,__last) so that @p *__nth
 *  is the same element that would have been in that position had the
 *  whole sequence been sorted. The elements either side of @p *__nth are
 *  not completely sorted, but for any iterator @e i in the range
 *  @p [__first,__nth) and any iterator @e j in the range @p [__nth,__last) it
 *  holds that @p __comp(*j,*i) is false.
*/
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline void
  nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
		  _RandomAccessIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_RandomAccessIterator>::value_type,
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __nth);
    __glibcxx_requires_valid_range(__nth, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    if (__first == __last || __nth == __last)
return;

    std::__introselect(__first, __nth, __last,
	 std::__lg(__last - __first) * 2,
	 __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

/**
 *  @brief Sort the elements of a sequence.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @return  Nothing.
 *
 *  Sorts the elements in the range @p [__first,__last) in ascending order,
 *  such that for each iterator @e i in the range @p [__first,__last-1),  
 *  *(i+1)<*i is false.
 *
 *  The relative ordering of equivalent elements is not preserved, use
 *  @p stable_sort() if this is needed.
*/
template<typename _RandomAccessIterator>
  _GLIBCXX20_CONSTEXPR
  inline void
  sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Sort the elements of a sequence using a predicate for comparison.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __comp    A comparison functor.
 *  @return  Nothing.
 *
 *  Sorts the elements in the range @p [__first,__last) in ascending order,
 *  such that @p __comp(*(i+1),*i) is false for every iterator @e i in the
 *  range @p [__first,__last-1).
 *
 *  The relative ordering of equivalent elements is not preserved, use
 *  @p stable_sort() if this is needed.
*/
template<typename _RandomAccessIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline void
  sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_RandomAccessIterator>::value_type,
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __merge(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2, _InputIterator2 __last2,
   _OutputIterator __result, _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
{
 if (__comp(__first2, __first1))
   {
     *__result = *__first2;
     ++__first2;
   }
 else
   {
     *__result = *__first1;
     ++__first1;
   }
 ++__result;
}
    return std::copy(__first2, __last2,
       std::copy(__first1, __last1, __result));
  }

/**
 *  @brief Merges two sorted ranges.
 *  @ingroup sorting_algorithms
 *  @param  __first1  An iterator.
 *  @param  __first2  Another iterator.
 *  @param  __last1   Another iterator.
 *  @param  __last2   Another iterator.
 *  @param  __result  An iterator pointing to the end of the merged range.
 *  @return   An output iterator equal to @p __result + (__last1 - __first1)
 *            + (__last2 - __first2).
 *
 *  Merges the ranges @p [__first1,__last1) and @p [__first2,__last2) into
 *  the sorted range @p [__result, __result + (__last1-__first1) +
 *  (__last2-__first2)).  Both input ranges must be sorted, and the
 *  output range must not overlap with either of the input ranges.
 *  The sort is @e stable, that is, for equivalent elements in the
 *  two ranges, elements from the first range will always come
 *  before elements from the second.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  merge(_InputIterator1 __first1, _InputIterator1 __last1,
 _InputIterator2 __first2, _InputIterator2 __last2,
 _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)	
    __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    __glibcxx_requires_irreflexive2(__first1, __last1);
    __glibcxx_requires_irreflexive2(__first2, __last2);

    return _GLIBCXX_STD_Astd::__merge(__first1, __last1,
		     __first2, __last2, __result,
		     __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Merges two sorted ranges.
 *  @ingroup sorting_algorithms
 *  @param  __first1  An iterator.
 *  @param  __first2  Another iterator.
 *  @param  __last1   Another iterator.
 *  @param  __last2   Another iterator.
 *  @param  __result  An iterator pointing to the end of the merged range.
 *  @param  __comp    A functor to use for comparisons.
 *  @return   An output iterator equal to @p __result + (__last1 - __first1)
 *            + (__last2 - __first2).
 *
 *  Merges the ranges @p [__first1,__last1) and @p [__first2,__last2) into
 *  the sorted range @p [__result, __result + (__last1-__first1) +
 *  (__last2-__first2)).  Both input ranges must be sorted, and the
 *  output range must not overlap with either of the input ranges.
 *  The sort is @e stable, that is, for equivalent elements in the
 *  two ranges, elements from the first range will always come
 *  before elements from the second.
 *
 *  The comparison function should have the same effects on ordering as
 *  the function used for the initial sort.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  merge(_InputIterator1 __first1, _InputIterator1 __last1,
 _InputIterator2 __first2, _InputIterator2 __last2,
 _OutputIterator __result, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);

    return _GLIBCXX_STD_Astd::__merge(__first1, __last1,
		__first2, __last2, __result,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _RandomAccessIterator, typename _Compare>
  inline void
  __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare __comp)
  {
    typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;
    typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_DistanceType;

    typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf;
    _TmpBuf __buf(__first, std::distance(__first, __last));

    if (__buf.begin() == 0)
std::__inplace_stable_sort(__first, __last, __comp);
    else
std::__stable_sort_adaptive(__first, __last, __buf.begin(),
		    _DistanceType(__buf.size()), __comp);
  }

/**
 *  @brief Sort the elements of a sequence, preserving the relative order
 *         of equivalent elements.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @return  Nothing.
 *
 *  Sorts the elements in the range @p [__first,__last) in ascending order,
 *  such that for each iterator @p i in the range @p [__first,__last-1),
 *  @p *(i+1)<*i is false.
 *
 *  The relative ordering of equivalent elements is preserved, so any two
 *  elements @p x and @p y in the range @p [__first,__last) such that
 *  @p x<y is false and @p y<x is false will have the same relative
 *  ordering after calling @p stable_sort().
*/
template<typename _RandomAccessIterator>
  inline void
  stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    _GLIBCXX_STD_Astd::__stable_sort(__first, __last,
		    __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Sort the elements of a sequence using a predicate for comparison,
 *         preserving the relative order of equivalent elements.
 *  @ingroup sorting_algorithms
 *  @param  __first   An iterator.
 *  @param  __last    Another iterator.
 *  @param  __comp    A comparison functor.
 *  @return  Nothing.
 *
 *  Sorts the elements in the range @p [__first,__last) in ascending order,
 *  such that for each iterator @p i in the range @p [__first,__last-1),
 *  @p __comp(*(i+1),*i) is false.
 *
 *  The relative ordering of equivalent elements is preserved, so any two
 *  elements @p x and @p y in the range @p [__first,__last) such that
 *  @p __comp(x,y) is false and @p __comp(y,x) is false will have the same
 *  relative ordering after calling @p stable_sort().
*/
template<typename _RandomAccessIterator, typename _Compare>
  inline void
  stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
   _RandomAccessIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_RandomAccessIterator>::value_type,
   typename iterator_traits<_RandomAccessIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    _GLIBCXX_STD_Astd::__stable_sort(__first, __last,
		    __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __set_union(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
{
 if (__comp(__first1, __first2))
   {
     *__result = *__first1;
     ++__first1;
   }
 else if (__comp(__first2, __first1))
   {
     *__result = *__first2;
     ++__first2;
   }
 else
   {
     *__result = *__first1;
     ++__first1;
     ++__first2;
   }
 ++__result;
}
    return std::copy(__first2, __last2,
       std::copy(__first1, __last1, __result));
  }

/**
 *  @brief Return the union of two sorted ranges.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  each range in order to the output range.  Iterators increment for each
 *  range.  When the current element of one range is less than the other,
 *  that element is copied and the iterator advanced.  If an element is
 *  contained in both ranges, the element from the first range is copied and
 *  both ranges advance.  The output range may not overlap either input
 *  range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_union(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    __glibcxx_requires_irreflexive2(__first1, __last1);
    __glibcxx_requires_irreflexive2(__first2, __last2);

    return _GLIBCXX_STD_Astd::__set_union(__first1, __last1,
		__first2, __last2, __result,
		__gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Return the union of two sorted ranges using a comparison functor.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @param  __comp    The comparison functor.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  each range in order to the output range.  Iterators increment for each
 *  range.  When the current element of one range is less than the other
 *  according to @p __comp, that element is copied and the iterator advanced.
 *  If an equivalent element according to @p __comp is contained in both
 *  ranges, the element from the first range is copied and both ranges
 *  advance.  The output range may not overlap either input range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_union(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);

    return _GLIBCXX_STD_Astd::__set_union(__first1, __last1,
		__first2, __last2, __result,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result, _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
if (__comp(__first1, __first2))
 ++__first1;
else if (__comp(__first2, __first1))
 ++__first2;
else
 {
   *__result = *__first1;
   ++__first1;
   ++__first2;
   ++__result;
 }
    return __result;
  }

/**
 *  @brief Return the intersection of two sorted ranges.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  both ranges in order to the output range.  Iterators increment for each
 *  range.  When the current element of one range is less than the other,
 *  that iterator advances.  If an element is contained in both ranges, the
 *  element from the first range is copied and both ranges advance.  The
 *  output range may not overlap either input range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    __glibcxx_requires_irreflexive2(__first1, __last1);
    __glibcxx_requires_irreflexive2(__first2, __last2);

    return _GLIBCXX_STD_Astd::__set_intersection(__first1, __last1,
		     __first2, __last2, __result,
		     __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief Return the intersection of two sorted ranges using comparison
 *  functor.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @param  __comp    The comparison functor.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  both ranges in order to the output range.  Iterators increment for each
 *  range.  When the current element of one range is less than the other
 *  according to @p __comp, that iterator advances.  If an element is
 *  contained in both ranges according to @p __comp, the element from the
 *  first range is copied and both ranges advance.  The output range may not
 *  overlap either input range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);

    return _GLIBCXX_STD_Astd::__set_intersection(__first1, __last1,
		__first2, __last2, __result,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result, _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
if (__comp(__first1, __first2))
 {
   *__result = *__first1;
   ++__first1;
   ++__result;
 }
else if (__comp(__first2, __first1))
 ++__first2;
else
 {
   ++__first1;
   ++__first2;
 }
    return std::copy(__first1, __last1, __result);
  }

/**
 *  @brief Return the difference of two sorted ranges.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  the first range but not the second in order to the output range.
 *  Iterators increment for each range.  When the current element of the
 *  first range is less than the second, that element is copied and the
 *  iterator advances.  If the current element of the second range is less,
 *  the iterator advances, but no element is copied.  If an element is
 *  contained in both ranges, no elements are copied and both ranges
 *  advance.  The output range may not overlap either input range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2, _InputIterator2 __last2,
   _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)	
    __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    __glibcxx_requires_irreflexive2(__first1, __last1);
    __glibcxx_requires_irreflexive2(__first2, __last2);

    return _GLIBCXX_STD_Astd::__set_difference(__first1, __last1,
		   __first2, __last2, __result,
		   __gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Return the difference of two sorted ranges using comparison
 *  functor.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @param  __comp    The comparison functor.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  the first range but not the second in order to the output range.
 *  Iterators increment for each range.  When the current element of the
 *  first range is less than the second according to @p __comp, that element
 *  is copied and the iterator advances.  If the current element of the
 *  second range is less, no element is copied and the iterator advances.
 *  If an element is contained in both ranges according to @p __comp, no
 *  elements are copied and both ranges advance.  The output range may not
 *  overlap either input range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2, _InputIterator2 __last2,
   _OutputIterator __result, _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);

    return _GLIBCXX_STD_Astd::__set_difference(__first1, __last1,
		   __first2, __last2, __result,
		   __gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator,
  typename _Compare>
  _GLIBCXX20_CONSTEXPR
  _OutputIterator
  __set_symmetric_difference(_InputIterator1 __first1,
	       _InputIterator1 __last1,
	       _InputIterator2 __first2,
	       _InputIterator2 __last2,
	       _OutputIterator __result,
	       _Compare __comp)
  {
    while (__first1 != __last1 && __first2 != __last2)
if (__comp(__first1, __first2))
 {
   *__result = *__first1;
   ++__first1;
   ++__result;
 }
else if (__comp(__first2, __first1))
 {
   *__result = *__first2;
   ++__first2;
   ++__result;
 }
else
 {
   ++__first1;
   ++__first2;
 }
    return std::copy(__first2, __last2, 
       std::copy(__first1, __last1, __result));
  }

/**
 *  @brief  Return the symmetric difference of two sorted ranges.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  one range but not the other in order to the output range.  Iterators
 *  increment for each range.  When the current element of one range is less
 *  than the other, that element is copied and the iterator advances.  If an
 *  element is contained in both ranges, no elements are copied and both
 *  ranges advance.  The output range may not overlap either input range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
	     _InputIterator2 __first2, _InputIterator2 __last2,
	     _OutputIterator __result)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_LessThanOpConcept<
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)	
    __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    __glibcxx_requires_irreflexive2(__first1, __last1);
    __glibcxx_requires_irreflexive2(__first2, __last2);

    return _GLIBCXX_STD_Astd::__set_symmetric_difference(__first1, __last1,
			__first2, __last2, __result,
			__gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Return the symmetric difference of two sorted ranges using
 *  comparison functor.
 *  @ingroup set_algorithms
 *  @param  __first1  Start of first range.
 *  @param  __last1   End of first range.
 *  @param  __first2  Start of second range.
 *  @param  __last2   End of second range.
 *  @param  __result  Start of output range.
 *  @param  __comp    The comparison functor.
 *  @return  End of the output range.
 *  @ingroup set_algorithms
 *
 *  This operation iterates over both ranges, copying elements present in
 *  one range but not the other in order to the output range.  Iterators
 *  increment for each range.  When the current element of one range is less
 *  than the other according to @p comp, that element is copied and the
 *  iterator advances.  If an element is contained in both ranges according
 *  to @p __comp, no elements are copied and both ranges advance.  The output
 *  range may not overlap either input range.
*/
template<typename _InputIterator1, typename _InputIterator2,
  typename _OutputIterator, typename _Compare>
  _GLIBCXX20_CONSTEXPR
  inline _OutputIterator
  set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
	     _InputIterator2 __first2, _InputIterator2 __last2,
	     _OutputIterator __result,
	     _Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator1>::value_type,
   typename iterator_traits<_InputIterator2>::value_type>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_InputIterator2>::value_type,
   typename iterator_traits<_InputIterator1>::value_type>)
    __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first1, __last1, __comp);
    __glibcxx_requires_irreflexive_pred2(__first2, __last2, __comp);

    return _GLIBCXX_STD_Astd::__set_symmetric_difference(__first1, __last1,
		__first2, __last2, __result,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  _ForwardIterator
  __min_element(_ForwardIterator __first, _ForwardIterator __last,
  _Compare __comp)
  {
    if (__first == __last)
return __first;
    _ForwardIterator __result = __first;
    while (++__first != __last)
if (__comp(__first, __result))
 __result = __first;
    return __result;
  }

/**
 *  @brief  Return the minimum element in a range.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @return  Iterator referencing the first instance of the smallest value.
*/
template<typename _ForwardIterator>
  _GLIBCXX14_CONSTEXPRconstexpr
  _ForwardIterator
  inline min_element(_ForwardIterator __first, _ForwardIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    return _GLIBCXX_STD_Astd::__min_element(__first, __last,
		__gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Return the minimum element in a range using comparison functor.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @param  __comp   Comparison functor.
 *  @return  Iterator referencing the first instance of the smallest value
 *  according to __comp.
*/
template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _ForwardIterator
  min_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_ForwardIterator>::value_type,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    return _GLIBCXX_STD_Astd::__min_element(__first, __last,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  _ForwardIterator
  __max_element(_ForwardIterator __first, _ForwardIterator __last,
  _Compare __comp)
  {
    if (__first == __last) return __first;
    _ForwardIterator __result = __first;
    while (++__first != __last)
if (__comp(__result, __first))
 __result = __first;
    return __result;
  }

/**
 *  @brief  Return the maximum element in a range.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @return  Iterator referencing the first instance of the largest value.
*/
template<typename _ForwardIterator>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _ForwardIterator
  max_element(_ForwardIterator __first, _ForwardIterator __last)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_LessThanComparableConcept<
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive(__first, __last);

    return _GLIBCXX_STD_Astd::__max_element(__first, __last,
		__gnu_cxx::__ops::__iter_less_iter());
  }

/**
 *  @brief  Return the maximum element in a range using comparison functor.
 *  @ingroup sorting_algorithms
 *  @param  __first  Start of range.
 *  @param  __last   End of range.
 *  @param  __comp   Comparison functor.
 *  @return  Iterator referencing the first instance of the largest value
 *  according to __comp.
*/
template<typename _ForwardIterator, typename _Compare>
  _GLIBCXX14_CONSTEXPRconstexpr
  inline _ForwardIterator
  max_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
  {
    // concept requirements
    __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
   typename iterator_traits<_ForwardIterator>::value_type,
   typename iterator_traits<_ForwardIterator>::value_type>)
    __glibcxx_requires_valid_range(__first, __last);
    __glibcxx_requires_irreflexive_pred(__first, __last, __comp);

    return _GLIBCXX_STD_Astd::__max_element(__first, __last,
		__gnu_cxx::__ops::__iter_comp_iter(__comp));
  }

5755#if __cplusplus201703L >= 201402L
/// Reservoir sampling algorithm.
template<typename _InputIterator, typename _RandomAccessIterator,
         typename _Size, typename _UniformRandomBitGenerator>
  _RandomAccessIterator
  __sample(_InputIterator __first, _InputIterator __last, input_iterator_tag,
    _RandomAccessIterator __out, random_access_iterator_tag,
    _Size __n, _UniformRandomBitGenerator&& __g)
  {
    using __distrib_type = uniform_int_distribution<_Size>;
    using __param_type = typename __distrib_type::param_type;
    __distrib_type __d{};
    _Size __sample_sz = 0;
    while (__first != __last && __sample_sz != __n)
{
 __out[__sample_sz++] = *__first;
 ++__first;
}
    for (auto __pop_sz = __sample_sz; __first != __last;
 ++__first, (void) ++__pop_sz)
{
 const auto __k = __d(__g, __param_type{0, __pop_sz});
 if (__k < __n)
   __out[__k] = *__first;
}
    return __out + __sample_sz;
  }

/// Selection sampling algorithm.
template<typename _ForwardIterator, typename _OutputIterator, typename _Cat,
         typename _Size, typename _UniformRandomBitGenerator>
  _OutputIterator
  __sample(_ForwardIterator __first, _ForwardIterator __last,
    forward_iterator_tag,
    _OutputIterator __out, _Cat,
    _Size __n, _UniformRandomBitGenerator&& __g)
  {
    using __distrib_type = uniform_int_distribution<_Size>;
    using __param_type = typename __distrib_type::param_type;
    using _USize = make_unsigned_t<_Size>;
    using _Gen = remove_reference_t<_UniformRandomBitGenerator>;
    using __uc_type = common_type_t<typename _Gen::result_type, _USize>;

    __distrib_type __d{};
    _Size __unsampled_sz = std::distance(__first, __last);
    __n = std::min(__n, __unsampled_sz);

    // If possible, we use __gen_two_uniform_ints to efficiently produce
    // two random numbers using a single distribution invocation:

    const __uc_type __urngrange = __g.max() - __g.min();
    if (__urngrange / __uc_type(__unsampled_sz) >= __uc_type(__unsampled_sz))
      // I.e. (__urngrange >= __unsampled_sz * __unsampled_sz) but without
// wrapping issues.
      {
 while (__n != 0 && __unsampled_sz >= 2)
   {
     const pair<_Size, _Size> __p =
__gen_two_uniform_ints(__unsampled_sz, __unsampled_sz - 1, __g);

     --__unsampled_sz;
     if (__p.first < __n)
{
  *__out++ = *__first;
  --__n;
}

     ++__first;

     if (__n == 0) break;

     --__unsampled_sz;
     if (__p.second < __n)
{
  *__out++ = *__first;
  --__n;
}

     ++__first;
   }
      }

    // The loop above is otherwise equivalent to this one-at-a-time version:

    for (; __n != 0; ++__first)
if (__d(__g, __param_type{0, --__unsampled_sz}) < __n)
 {
   *__out++ = *__first;
   --__n;
 }
    return __out;
  }

5848#if __cplusplus201703L > 201402L
5849#define __cpp_lib_sample201603 201603
/// Take a random sample from a population.
template<typename _PopulationIterator, typename _SampleIterator,
         typename _Distance, typename _UniformRandomBitGenerator>
  _SampleIterator
  sample(_PopulationIterator __first, _PopulationIterator __last,
  _SampleIterator __out, _Distance __n,
  _UniformRandomBitGenerator&& __g)
  {
    using __pop_cat = typename
std::iterator_traits<_PopulationIterator>::iterator_category;
    using __samp_cat = typename
std::iterator_traits<_SampleIterator>::iterator_category;

    static_assert(
 __or_<is_convertible<__pop_cat, forward_iterator_tag>,
is_convertible<__samp_cat, random_access_iterator_tag>>::value,
 "output range must use a RandomAccessIterator when input range"
 " does not meet the ForwardIterator requirements");

    static_assert(is_integral<_Distance>::value,
    "sample size must be an integer type");

    typename iterator_traits<_PopulationIterator>::difference_type __d = __n;
    return _GLIBCXX_STD_Astd::
__sample(__first, __last, __pop_cat{}, __out, __samp_cat{}, __d,
 std::forward<_UniformRandomBitGenerator>(__g));
  }
5877#endif // C++17
5878#endif // C++14

5880_GLIBCXX_END_NAMESPACE_ALGO
5881_GLIBCXX_END_NAMESPACE_VERSION
5882} // namespace std

5884#endif /* _STL_ALGO_H */

←

/usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/bits/stl_iterator.h

1// Iterators -*- C++ -*-

3// Copyright (C) 2001-2020 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996-1998
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*/

51/** @file bits/stl_iterator.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{iterator}
*
*  This file implements reverse_iterator, back_insert_iterator,
*  front_insert_iterator, insert_iterator, __normal_iterator, and their
*  supporting functions and overloaded operators.
*/

60#ifndef _STL_ITERATOR_H1
61#define _STL_ITERATOR_H1 1

63#include <bits/cpp_type_traits.h>
64#include <ext/type_traits.h>
65#include <bits/move.h>
66#include <bits/ptr_traits.h>

68#if __cplusplus201703L >= 201103L
69# include <type_traits>
70#endif

72#if __cplusplus201703L > 201703L
73# define __cpp_lib_array_constexpr201803L 201811L
74# define __cpp_lib_constexpr_iterator 201811L
75#elif __cplusplus201703L == 201703L
76# define __cpp_lib_array_constexpr201803L 201803L
77#endif

79#if __cplusplus201703L > 201703L
80# include <compare>
81# include <new>
82# include <bits/iterator_concepts.h>
83#endif

85namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
86{
87_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup iterators
 * @{
 */

94#if __cplusplus201703L > 201703L && __cpp_lib_concepts
namespace __detail
{
  // Weaken iterator_category _Cat to _Limit if it is derived from that,
  // otherwise use _Otherwise.
  template<typename _Cat, typename _Limit, typename _Otherwise = _Cat>
    using __clamp_iter_cat
= conditional_t<derived_from<_Cat, _Limit>, _Limit, _Otherwise>;
}
103#endif

// 24.4.1 Reverse iterators
/**
 *  Bidirectional and random access iterators have corresponding reverse
 *  %iterator adaptors that iterate through the data structure in the
 *  opposite direction.  They have the same signatures as the corresponding
 *  iterators.  The fundamental relation between a reverse %iterator and its
 *  corresponding %iterator @c i is established by the identity:
 *  @code
 *      &*(reverse_iterator(i)) == &*(i - 1)
 *  @endcode
 *
 *  <em>This mapping is dictated by the fact that while there is always a
 *  pointer past the end of an array, there might not be a valid pointer
 *  before the beginning of an array.</em> [24.4.1]/1,2
 *
 *  Reverse iterators can be tricky and surprising at first.  Their
 *  semantics make sense, however, and the trickiness is a side effect of
 *  the requirement that the iterators must be safe.
*/
template<typename _Iterator>
  class reverse_iterator
  : public iterator<typename iterator_traits<_Iterator>::iterator_category,
      typename iterator_traits<_Iterator>::value_type,
      typename iterator_traits<_Iterator>::difference_type,
      typename iterator_traits<_Iterator>::pointer,
                    typename iterator_traits<_Iterator>::reference>
  {
  protected:
    _Iterator current;

    typedef iterator_traits<_Iterator>		__traits_type;

  public:
    typedef _Iterator					iterator_type;
    typedef typename __traits_type::difference_type	difference_type;
    typedef typename __traits_type::pointer		pointer;
    typedef typename __traits_type::reference		reference;

143#if __cplusplus201703L > 201703L && __cpp_lib_concepts
    using iterator_concept
= conditional_t<random_access_iterator<_Iterator>,
	random_access_iterator_tag,
	bidirectional_iterator_tag>;
    using iterator_category
= __detail::__clamp_iter_cat<typename __traits_type::iterator_category,
		     random_access_iterator_tag>;
151#endif

    /**
     *  The default constructor value-initializes member @p current.
     *  If it is a pointer, that means it is zero-initialized.
    */
    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 235 No specification of default ctor for reverse_iterator
    // 1012. reverse_iterator default ctor should value initialize
    _GLIBCXX17_CONSTEXPRconstexpr
    reverse_iterator() : current() { }

    /**
     *  This %iterator will move in the opposite direction that @p x does.
    */
    explicit _GLIBCXX17_CONSTEXPRconstexpr
    reverse_iterator(iterator_type __x) : current(__x) { }

    /**
     *  The copy constructor is normal.
    */
    _GLIBCXX17_CONSTEXPRconstexpr
    reverse_iterator(const reverse_iterator& __x)
    : current(__x.current) { }

176#if __cplusplus201703L >= 201103L
    reverse_iterator& operator=(const reverse_iterator&) = default;
178#endif

    /**
     *  A %reverse_iterator across other types can be copied if the
     *  underlying %iterator can be converted to the type of @c current.
    */
    template<typename _Iter>
_GLIBCXX17_CONSTEXPRconstexpr
      reverse_iterator(const reverse_iterator<_Iter>& __x)
: current(__x.base()) { }

    /**
     *  @return  @c current, the %iterator used for underlying work.
    */
    _GLIBCXX17_CONSTEXPRconstexpr iterator_type
    base() const
    { return current; }

    /**
     *  @return  A reference to the value at @c --current
     *
     *  This requires that @c --current is dereferenceable.
     *
     *  @warning This implementation requires that for an iterator of the
     *           underlying iterator type, @c x, a reference obtained by
     *           @c *x remains valid after @c x has been modified or
     *           destroyed. This is a bug: http://gcc.gnu.org/PR51823
    */
    _GLIBCXX17_CONSTEXPRconstexpr reference
    operator*() const
    {
_Iterator __tmp = current;
return *--__tmp;
    }

    /**
     *  @return  A pointer to the value at @c --current
     *
     *  This requires that @c --current is dereferenceable.
    */
    _GLIBCXX17_CONSTEXPRconstexpr pointer
    operator->() const
220#if __cplusplus201703L > 201703L && __cpp_concepts >= 201907L
    requires is_pointer_v<_Iterator>
|| requires(const _Iterator __i) { __i.operator->(); }
223#endif
    {
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 1052. operator-> should also support smart pointers
_Iterator __tmp = current;
--__tmp;
return _S_to_pointer(__tmp);
    }

    /**
     *  @return  @c *this
     *
     *  Decrements the underlying iterator.
    */
    _GLIBCXX17_CONSTEXPRconstexpr reverse_iterator&
    operator++()
    {
--current;
return *this;
    }

    /**
     *  @return  The original value of @c *this
     *
     *  Decrements the underlying iterator.
    */
    _GLIBCXX17_CONSTEXPRconstexpr reverse_iterator
    operator++(int)
    {
reverse_iterator __tmp = *this;
--current;
return __tmp;
    }

    /**
     *  @return  @c *this
     *
     *  Increments the underlying iterator.
    */
    _GLIBCXX17_CONSTEXPRconstexpr reverse_iterator&
    operator--()
    {
++current;
return *this;
    }

    /**
     *  @return  A reverse_iterator with the previous value of @c *this
     *
     *  Increments the underlying iterator.
    */
    _GLIBCXX17_CONSTEXPRconstexpr reverse_iterator
    operator--(int)
    {
reverse_iterator __tmp = *this;
++current;
return __tmp;
    }

    /**
     *  @return  A reverse_iterator that refers to @c current - @a __n
     *
     *  The underlying iterator must be a Random Access Iterator.
    */
    _GLIBCXX17_CONSTEXPRconstexpr reverse_iterator
    operator+(difference_type __n) const
    { return reverse_iterator(current - __n); }

    /**
     *  @return  *this
     *
     *  Moves the underlying iterator backwards @a __n steps.
     *  The underlying iterator must be a Random Access Iterator.
    */
    _GLIBCXX17_CONSTEXPRconstexpr reverse_iterator&
    operator+=(difference_type __n)
    {
current -= __n;
return *this;
    }

    /**
     *  @return  A reverse_iterator that refers to @c current - @a __n
     *
     *  The underlying iterator must be a Random Access Iterator.
    */
    _GLIBCXX17_CONSTEXPRconstexpr reverse_iterator
    operator-(difference_type __n) const
    { return reverse_iterator(current + __n); }

    /**
     *  @return  *this
     *
     *  Moves the underlying iterator forwards @a __n steps.
     *  The underlying iterator must be a Random Access Iterator.
    */
    _GLIBCXX17_CONSTEXPRconstexpr reverse_iterator&
    operator-=(difference_type __n)
    {
current += __n;
return *this;
    }

    /**
     *  @return  The value at @c current - @a __n - 1
     *
     *  The underlying iterator must be a Random Access Iterator.
    */
    _GLIBCXX17_CONSTEXPRconstexpr reference
    operator[](difference_type __n) const
    { return *(*this + __n); }

  private:
    template<typename _Tp>
static _GLIBCXX17_CONSTEXPRconstexpr _Tp*
_S_to_pointer(_Tp* __p)
      { return __p; }

    template<typename _Tp>
static _GLIBCXX17_CONSTEXPRconstexpr pointer
_S_to_pointer(_Tp __t)
      { return __t.operator->(); }
  };

//@{
/**
 *  @param  __x  A %reverse_iterator.
 *  @param  __y  A %reverse_iterator.
 *  @return  A simple bool.
 *
 *  Reverse iterators forward comparisons to their underlying base()
 *  iterators.
 *
*/
357#if __cplusplus201703L <= 201703L || ! defined __cpp_lib_concepts
template<typename _Iterator>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator==(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return __x.base() == __y.base(); }

template<typename _Iterator>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator<(const reverse_iterator<_Iterator>& __x,
     const reverse_iterator<_Iterator>& __y)
  { return __y.base() < __x.base(); }

template<typename _Iterator>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator!=(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return !(__x == __y); }

template<typename _Iterator>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator>(const reverse_iterator<_Iterator>& __x,
     const reverse_iterator<_Iterator>& __y)
  { return __y < __x; }

template<typename _Iterator>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator<=(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return !(__y < __x); }

template<typename _Iterator>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator>=(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return !(__x < __y); }

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 280. Comparison of reverse_iterator to const reverse_iterator.
template<typename _IteratorL, typename _IteratorR>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator==(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return __x.base() == __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator<(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
  { return __y.base() < __x.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator!=(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return !(__x == __y); }

template<typename _IteratorL, typename _IteratorR>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator>(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
  { return __y < __x; }

template<typename _IteratorL, typename _IteratorR>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator<=(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return !(__y < __x); }

template<typename _IteratorL, typename _IteratorR>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator>=(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return !(__x < __y); }
431#else // C++20
template<typename _IteratorL, typename _IteratorR>
  constexpr bool
  operator==(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
  { return __x.base() == __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  constexpr bool
  operator!=(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  requires requires { { __x.base() != __y.base() } -> convertible_to<bool>; }
  { return __x.base() != __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  constexpr bool
  operator<(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
  requires requires { { __x.base() > __y.base() } -> convertible_to<bool>; }
  { return __x.base() > __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  constexpr bool
  operator>(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
  requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
  { return __x.base() < __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  constexpr bool
  operator<=(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  requires requires { { __x.base() >= __y.base() } -> convertible_to<bool>; }
  { return __x.base() >= __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  constexpr bool
  operator>=(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  requires requires { { __x.base() <= __y.base() } -> convertible_to<bool>; }
  { return __x.base() <= __y.base(); }

template<typename _IteratorL,
  three_way_comparable_with<_IteratorL> _IteratorR>
  constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
  operator<=>(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
  { return __y.base() <=> __x.base(); }
480#endif // C++20
//@}

483#if __cplusplus201703L < 201103L
template<typename _Iterator>
  inline typename reverse_iterator<_Iterator>::difference_type
  operator-(const reverse_iterator<_Iterator>& __x,
     const reverse_iterator<_Iterator>& __y)
  { return __y.base() - __x.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline typename reverse_iterator<_IteratorL>::difference_type
  operator-(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
  { return __y.base() - __x.base(); }
495#else
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 685. reverse_iterator/move_iterator difference has invalid signatures
template<typename _IteratorL, typename _IteratorR>
  inline _GLIBCXX17_CONSTEXPRconstexpr auto
  operator-(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
  -> decltype(__y.base() - __x.base())
  { return __y.base() - __x.base(); }
504#endif

template<typename _Iterator>
  inline _GLIBCXX17_CONSTEXPRconstexpr reverse_iterator<_Iterator>
  operator+(typename reverse_iterator<_Iterator>::difference_type __n,
     const reverse_iterator<_Iterator>& __x)
  { return reverse_iterator<_Iterator>(__x.base() - __n); }

512#if __cplusplus201703L >= 201103L
// Same as C++14 make_reverse_iterator but used in C++11 mode too.
template<typename _Iterator>
  inline _GLIBCXX17_CONSTEXPRconstexpr reverse_iterator<_Iterator>
  __make_reverse_iterator(_Iterator __i)
  { return reverse_iterator<_Iterator>(__i); }

519# if __cplusplus201703L >= 201402L
520#  define __cpp_lib_make_reverse_iterator201402 201402

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 2285. make_reverse_iterator
/// Generator function for reverse_iterator.
template<typename _Iterator>
  inline _GLIBCXX17_CONSTEXPRconstexpr reverse_iterator<_Iterator>
  make_reverse_iterator(_Iterator __i)
  { return reverse_iterator<_Iterator>(__i); }

530#  if __cplusplus201703L > 201703L && defined __cpp_lib_concepts
template<typename _Iterator1, typename _Iterator2>
  requires (!sized_sentinel_for<_Iterator1, _Iterator2>)
  inline constexpr bool
  disable_sized_sentinel_for<reverse_iterator<_Iterator1>,
	       reverse_iterator<_Iterator2>> = true;
536#  endif // C++20
537# endif // C++14

template<typename _Iterator>
  _GLIBCXX20_CONSTEXPR
  auto
  __niter_base(reverse_iterator<_Iterator> __it)
  -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
  { return __make_reverse_iterator(__niter_base(__it.base())); }

template<typename _Iterator>
  struct __is_move_iterator<reverse_iterator<_Iterator> >
    : __is_move_iterator<_Iterator>
  { };

template<typename _Iterator>
  _GLIBCXX20_CONSTEXPR
  auto
  __miter_base(reverse_iterator<_Iterator> __it)
  -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
  { return __make_reverse_iterator(__miter_base(__it.base())); }
557#endif // C++11

// 24.4.2.2.1 back_insert_iterator
/**
 *  @brief  Turns assignment into insertion.
 *
 *  These are output iterators, constructed from a container-of-T.
 *  Assigning a T to the iterator appends it to the container using
 *  push_back.
 *
 *  Tip:  Using the back_inserter function to create these iterators can
 *  save typing.
*/
template<typename _Container>
  class back_insert_iterator
  : public iterator<output_iterator_tag, void, void, void, void>
  {
  protected:
    _Container* container;

  public:
    /// A nested typedef for the type of whatever container you used.
    typedef _Container          container_type;
580#if __cplusplus201703L > 201703L
    using difference_type = ptrdiff_t;

    constexpr back_insert_iterator() noexcept : container(nullptr) { }
584#endif

    /// The only way to create this %iterator is with a container.
    explicit _GLIBCXX20_CONSTEXPR
    back_insert_iterator(_Container& __x)
    : container(std::__addressof(__x)) { }

    /**
     *  @param  __value  An instance of whatever type
     *                 container_type::const_reference is; presumably a
     *                 reference-to-const T for container<T>.
     *  @return  This %iterator, for chained operations.
     *
     *  This kind of %iterator doesn't really have a @a position in the
     *  container (you can think of the position as being permanently at
     *  the end, if you like).  Assigning a value to the %iterator will
     *  always append the value to the end of the container.
    */
602#if __cplusplus201703L < 201103L
    back_insert_iterator&
    operator=(typename _Container::const_reference __value)
    {
container->push_back(__value);
return *this;
    }
609#else
    _GLIBCXX20_CONSTEXPR
    back_insert_iterator&
    operator=(const typename _Container::value_type& __value)
    {
container->push_back(__value);
return *this;
    }

    _GLIBCXX20_CONSTEXPR
    back_insert_iterator&
    operator=(typename _Container::value_type&& __value)
    {
container->push_back(std::move(__value));
return *this;
    }
625#endif

    /// Simply returns *this.
    _GLIBCXX20_CONSTEXPR
    back_insert_iterator&
    operator*()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    _GLIBCXX20_CONSTEXPR
    back_insert_iterator&
    operator++()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    _GLIBCXX20_CONSTEXPR
    back_insert_iterator
    operator++(int)
    { return *this; }
  };

/**
 *  @param  __x  A container of arbitrary type.
 *  @return  An instance of back_insert_iterator working on @p __x.
 *
 *  This wrapper function helps in creating back_insert_iterator instances.
 *  Typing the name of the %iterator requires knowing the precise full
 *  type of the container, which can be tedious and impedes generic
 *  programming.  Using this function lets you take advantage of automatic
 *  template parameter deduction, making the compiler match the correct
 *  types for you.
*/
template<typename _Container>
  _GLIBCXX20_CONSTEXPR
  inline back_insert_iterator<_Container>
  back_inserter(_Container& __x)
  { return back_insert_iterator<_Container>(__x); }

/**
 *  @brief  Turns assignment into insertion.
 *
 *  These are output iterators, constructed from a container-of-T.
 *  Assigning a T to the iterator prepends it to the container using
 *  push_front.
 *
 *  Tip:  Using the front_inserter function to create these iterators can
 *  save typing.
*/
template<typename _Container>
  class front_insert_iterator
  : public iterator<output_iterator_tag, void, void, void, void>
  {
  protected:
    _Container* container;

  public:
    /// A nested typedef for the type of whatever container you used.
    typedef _Container          container_type;
683#if __cplusplus201703L > 201703L
    using difference_type = ptrdiff_t;

    constexpr front_insert_iterator() noexcept : container(nullptr) { }
687#endif

    /// The only way to create this %iterator is with a container.
    explicit _GLIBCXX20_CONSTEXPR
    front_insert_iterator(_Container& __x)
    : container(std::__addressof(__x)) { }

    /**
     *  @param  __value  An instance of whatever type
     *                 container_type::const_reference is; presumably a
     *                 reference-to-const T for container<T>.
     *  @return  This %iterator, for chained operations.
     *
     *  This kind of %iterator doesn't really have a @a position in the
     *  container (you can think of the position as being permanently at
     *  the front, if you like).  Assigning a value to the %iterator will
     *  always prepend the value to the front of the container.
    */
705#if __cplusplus201703L < 201103L
    front_insert_iterator&
    operator=(typename _Container::const_reference __value)
    {
container->push_front(__value);
return *this;
    }
712#else
    _GLIBCXX20_CONSTEXPR
    front_insert_iterator&
    operator=(const typename _Container::value_type& __value)
    {
container->push_front(__value);
return *this;
    }

    _GLIBCXX20_CONSTEXPR
    front_insert_iterator&
    operator=(typename _Container::value_type&& __value)
    {
container->push_front(std::move(__value));
return *this;
    }
728#endif

    /// Simply returns *this.
    _GLIBCXX20_CONSTEXPR
    front_insert_iterator&
    operator*()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    _GLIBCXX20_CONSTEXPR
    front_insert_iterator&
    operator++()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    _GLIBCXX20_CONSTEXPR
    front_insert_iterator
    operator++(int)
    { return *this; }
  };

/**
 *  @param  __x  A container of arbitrary type.
 *  @return  An instance of front_insert_iterator working on @p x.
 *
 *  This wrapper function helps in creating front_insert_iterator instances.
 *  Typing the name of the %iterator requires knowing the precise full
 *  type of the container, which can be tedious and impedes generic
 *  programming.  Using this function lets you take advantage of automatic
 *  template parameter deduction, making the compiler match the correct
 *  types for you.
*/
template<typename _Container>
  _GLIBCXX20_CONSTEXPR
  inline front_insert_iterator<_Container>
  front_inserter(_Container& __x)
  { return front_insert_iterator<_Container>(__x); }

/**
 *  @brief  Turns assignment into insertion.
 *
 *  These are output iterators, constructed from a container-of-T.
 *  Assigning a T to the iterator inserts it in the container at the
 *  %iterator's position, rather than overwriting the value at that
 *  position.
 *
 *  (Sequences will actually insert a @e copy of the value before the
 *  %iterator's position.)
 *
 *  Tip:  Using the inserter function to create these iterators can
 *  save typing.
*/
template<typename _Container>
  class insert_iterator
  : public iterator<output_iterator_tag, void, void, void, void>
  {
784#if __cplusplus201703L > 201703L && defined __cpp_lib_concepts
    using _Iter = std::__detail::__range_iter_t<_Container>;

  protected:
    _Container* container = nullptr;
    _Iter iter = _Iter();
790#else
    typedef typename _Container::iterator		_Iter;

  protected:
    _Container* container;
    _Iter iter;
796#endif

  public:
    /// A nested typedef for the type of whatever container you used.
    typedef _Container          container_type;

802#if __cplusplus201703L > 201703L && defined __cpp_lib_concepts
    using difference_type = ptrdiff_t;

    insert_iterator() = default;
806#endif

    /**
     *  The only way to create this %iterator is with a container and an
     *  initial position (a normal %iterator into the container).
    */
    _GLIBCXX20_CONSTEXPR
    insert_iterator(_Container& __x, _Iter __i)
    : container(std::__addressof(__x)), iter(__i) {}

    /**
     *  @param  __value  An instance of whatever type
     *                 container_type::const_reference is; presumably a
     *                 reference-to-const T for container<T>.
     *  @return  This %iterator, for chained operations.
     *
     *  This kind of %iterator maintains its own position in the
     *  container.  Assigning a value to the %iterator will insert the
     *  value into the container at the place before the %iterator.
     *
     *  The position is maintained such that subsequent assignments will
     *  insert values immediately after one another.  For example,
     *  @code
     *     // vector v contains A and Z
     *
     *     insert_iterator i (v, ++v.begin());
     *     i = 1;
     *     i = 2;
     *     i = 3;
     *
     *     // vector v contains A, 1, 2, 3, and Z
     *  @endcode
    */
839#if __cplusplus201703L < 201103L
    insert_iterator&
    operator=(typename _Container::const_reference __value)
    {
iter = container->insert(iter, __value);
++iter;
return *this;
    }
847#else
    _GLIBCXX20_CONSTEXPR
    insert_iterator&
    operator=(const typename _Container::value_type& __value)
    {
iter = container->insert(iter, __value);
++iter;
return *this;
    }

    _GLIBCXX20_CONSTEXPR
    insert_iterator&
    operator=(typename _Container::value_type&& __value)
    {
iter = container->insert(iter, std::move(__value));
++iter;
return *this;
    }
865#endif

    /// Simply returns *this.
    _GLIBCXX20_CONSTEXPR
    insert_iterator&
    operator*()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    _GLIBCXX20_CONSTEXPR
    insert_iterator&
    operator++()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    _GLIBCXX20_CONSTEXPR
    insert_iterator&
    operator++(int)
    { return *this; }
  };

/**
 *  @param __x  A container of arbitrary type.
 *  @param __i  An iterator into the container.
 *  @return  An instance of insert_iterator working on @p __x.
 *
 *  This wrapper function helps in creating insert_iterator instances.
 *  Typing the name of the %iterator requires knowing the precise full
 *  type of the container, which can be tedious and impedes generic
 *  programming.  Using this function lets you take advantage of automatic
 *  template parameter deduction, making the compiler match the correct
 *  types for you.
*/
898#if __cplusplus201703L > 201703L && defined __cpp_lib_concepts
template<typename _Container>
  constexpr insert_iterator<_Container>
  inserter(_Container& __x, std::__detail::__range_iter_t<_Container> __i)
  { return insert_iterator<_Container>(__x, __i); }
903#else
template<typename _Container, typename _Iterator>
  inline insert_iterator<_Container>
  inserter(_Container& __x, _Iterator __i)
  {
    return insert_iterator<_Container>(__x,
			 typename _Container::iterator(__i));
  }
911#endif

// @} group iterators

915_GLIBCXX_END_NAMESPACE_VERSION
916} // namespace

918namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
919{
920_GLIBCXX_BEGIN_NAMESPACE_VERSION

// This iterator adapter is @a normal in the sense that it does not
// change the semantics of any of the operators of its iterator
// parameter.  Its primary purpose is to convert an iterator that is
// not a class, e.g. a pointer, into an iterator that is a class.
// The _Container parameter exists solely so that different containers
// using this template can instantiate different types, even if the
// _Iterator parameter is the same.
template<typename _Iterator, typename _Container>
  class __normal_iterator
  {
  protected:
    _Iterator _M_current;

    typedef std::iterator_traits<_Iterator>		__traits_type;

  public:
    typedef _Iterator					iterator_type;
    typedef typename __traits_type::iterator_category iterator_category;
    typedef typename __traits_type::value_type  	value_type;
    typedef typename __traits_type::difference_type 	difference_type;
    typedef typename __traits_type::reference 	reference;
    typedef typename __traits_type::pointer   	pointer;

945#if __cplusplus201703L > 201703L && __cpp_lib_concepts
    using iterator_concept = std::__detail::__iter_concept<_Iterator>;
947#endif

    _GLIBCXX_CONSTEXPRconstexpr __normal_iterator() _GLIBCXX_NOEXCEPTnoexcept
    : _M_current(_Iterator()) { }

    explicit _GLIBCXX20_CONSTEXPR
    __normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPTnoexcept
    : _M_current(__i) { }

    // Allow iterator to const_iterator conversion
    template<typename _Iter>
      _GLIBCXX20_CONSTEXPR
      __normal_iterator(const __normal_iterator<_Iter,
	  typename __enable_if<
    	       (std::__are_same<_Iter, typename _Container::pointer>::__value),
      _Container>::__type>& __i) _GLIBCXX_NOEXCEPTnoexcept
      : _M_current(__i.base()) { }

    // Forward iterator requirements
    _GLIBCXX20_CONSTEXPR
    reference
    operator*() const _GLIBCXX_NOEXCEPTnoexcept
    { return *_M_current; }

    _GLIBCXX20_CONSTEXPR
    pointer
    operator->() const _GLIBCXX_NOEXCEPTnoexcept
    { return _M_current; }

    _GLIBCXX20_CONSTEXPR
    __normal_iterator&
    operator++() _GLIBCXX_NOEXCEPTnoexcept
    {
++_M_current;
return *this;
    }

    _GLIBCXX20_CONSTEXPR
    __normal_iterator
    operator++(int) _GLIBCXX_NOEXCEPTnoexcept
    { return __normal_iterator(_M_current++); }

    // Bidirectional iterator requirements
    _GLIBCXX20_CONSTEXPR
    __normal_iterator&
    operator--() _GLIBCXX_NOEXCEPTnoexcept
    {
--_M_current;
return *this;
    }

    _GLIBCXX20_CONSTEXPR
    __normal_iterator
    operator--(int) _GLIBCXX_NOEXCEPTnoexcept
    { return __normal_iterator(_M_current--); }

    // Random access iterator requirements
    _GLIBCXX20_CONSTEXPR
    reference
    operator[](difference_type __n) const _GLIBCXX_NOEXCEPTnoexcept
    { return _M_current[__n]; }

    _GLIBCXX20_CONSTEXPR
    __normal_iterator&
    operator+=(difference_type __n) _GLIBCXX_NOEXCEPTnoexcept
    { _M_current += __n; return *this; }

    _GLIBCXX20_CONSTEXPR
    __normal_iterator
    operator+(difference_type __n) const _GLIBCXX_NOEXCEPTnoexcept
    { return __normal_iterator(_M_current + __n); }

    _GLIBCXX20_CONSTEXPR
    __normal_iterator&
    operator-=(difference_type __n) _GLIBCXX_NOEXCEPTnoexcept
    { _M_current -= __n; return *this; }

    _GLIBCXX20_CONSTEXPR
    __normal_iterator
    operator-(difference_type __n) const _GLIBCXX_NOEXCEPTnoexcept
    { return __normal_iterator(_M_current - __n); }

    _GLIBCXX20_CONSTEXPR
    const _Iterator&
    base() const _GLIBCXX_NOEXCEPTnoexcept
    { return _M_current; }
  };

// Note: In what follows, the left- and right-hand-side iterators are
// allowed to vary in types (conceptually in cv-qualification) so that
// comparison between cv-qualified and non-cv-qualified iterators be
// valid.  However, the greedy and unfriendly operators in std::rel_ops
// will make overload resolution ambiguous (when in scope) if we don't
// provide overloads whose operands are of the same type.  Can someone
// remind me what generic programming is about? -- Gaby

1043#if __cpp_lib_three_way_comparison
template<typename _IteratorL, typename _IteratorR, typename _Container>
  requires requires (_IteratorL __lhs, _IteratorR __rhs)
  { { __lhs == __rhs } -> std::convertible_to<bool>; }
  constexpr bool
  operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  noexcept(noexcept(__lhs.base() == __rhs.base()))
  { return __lhs.base() == __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  constexpr std::__detail::__synth3way_t<_IteratorR, _IteratorL>
  operator<=>(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
  noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
  { return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
1059#else
 // Forward iterator requirements
template<typename _IteratorL, typename _IteratorR, typename _Container>
  _GLIBCXX20_CONSTEXPR
  inline bool
  operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() == __rhs.base(); }

template<typename _Iterator, typename _Container>
  _GLIBCXX20_CONSTEXPR
  inline bool
  operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() == __rhs.base(); }
14
←
Assuming the condition is true→
15
←
Returning the value 1, which participates in a condition later→

template<typename _IteratorL, typename _IteratorR, typename _Container>
  _GLIBCXX20_CONSTEXPR
  inline bool
  operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() != __rhs.base(); }

template<typename _Iterator, typename _Container>
  _GLIBCXX20_CONSTEXPR
  inline bool
  operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() != __rhs.base(); }

// Random access iterator requirements
template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() < __rhs.base(); }

template<typename _Iterator, typename _Container>
  _GLIBCXX20_CONSTEXPR
  inline bool
  operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() < __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() > __rhs.base(); }

template<typename _Iterator, typename _Container>
  _GLIBCXX20_CONSTEXPR
  inline bool
  operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() > __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() <= __rhs.base(); }

template<typename _Iterator, typename _Container>
  _GLIBCXX20_CONSTEXPR
  inline bool
  operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() <= __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() >= __rhs.base(); }

template<typename _Iterator, typename _Container>
  _GLIBCXX20_CONSTEXPR
  inline bool
  operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() >= __rhs.base(); }
1153#endif // three-way comparison

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// According to the resolution of DR179 not only the various comparison
// operators but also operator- must accept mixed iterator/const_iterator
// parameters.
template<typename _IteratorL, typename _IteratorR, typename _Container>
1160#if __cplusplus201703L >= 201103L
  // DR 685.
  _GLIBCXX20_CONSTEXPR
  inline auto
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
  -> decltype(__lhs.base() - __rhs.base())
1167#else
  inline typename __normal_iterator<_IteratorL, _Container>::difference_type
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
1171#endif
  { return __lhs.base() - __rhs.base(); }

template<typename _Iterator, typename _Container>
  _GLIBCXX20_CONSTEXPR
  inline typename __normal_iterator<_Iterator, _Container>::difference_type
  operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() - __rhs.base(); }

template<typename _Iterator, typename _Container>
  _GLIBCXX20_CONSTEXPR
  inline __normal_iterator<_Iterator, _Container>
  operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
     __n, const __normal_iterator<_Iterator, _Container>& __i)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }

1190_GLIBCXX_END_NAMESPACE_VERSION
1191} // namespace

1193namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
1194{
1195_GLIBCXX_BEGIN_NAMESPACE_VERSION

template<typename _Iterator, typename _Container>
  _GLIBCXX20_CONSTEXPR
  _Iterator
  __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
  _GLIBCXX_NOEXCEPT_IF(std::is_nothrow_copy_constructible<_Iterator>::value)noexcept(std::is_nothrow_copy_constructible<_Iterator>::
value)
  { return __it.base(); }

1204#if __cplusplus201703L >= 201103L
/**
 * @addtogroup iterators
 * @{
 */

1210#if __cplusplus201703L > 201703L && __cpp_lib_concepts
template<semiregular _Sent>
  class move_sentinel
  {
  public:
    constexpr
    move_sentinel()
    noexcept(is_nothrow_default_constructible_v<_Sent>)
    : _M_last() { }

    constexpr explicit
    move_sentinel(_Sent __s)
    noexcept(is_nothrow_move_constructible_v<_Sent>)
    : _M_last(std::move(__s)) { }

    template<typename _S2> requires convertible_to<const _S2&, _Sent>
constexpr
move_sentinel(const move_sentinel<_S2>& __s)
noexcept(is_nothrow_constructible_v<_Sent, const _S2&>)
: _M_last(__s.base())
{ }

    template<typename _S2> requires assignable_from<_Sent&, const _S2&>
constexpr move_sentinel&
operator=(const move_sentinel<_S2>& __s)
noexcept(is_nothrow_assignable_v<_Sent, const _S2&>)
{
 _M_last = __s.base();
 return *this;
}

    constexpr _Sent
    base() const
    noexcept(is_nothrow_copy_constructible_v<_Sent>)
    { return _M_last; }

  private:
    _Sent _M_last;
  };
1249#endif // C++20

// 24.4.3  Move iterators
/**
 *  Class template move_iterator is an iterator adapter with the same
 *  behavior as the underlying iterator except that its dereference
 *  operator implicitly converts the value returned by the underlying
 *  iterator's dereference operator to an rvalue reference.  Some
 *  generic algorithms can be called with move iterators to replace
 *  copying with moving.
 */
template<typename _Iterator>
  class move_iterator
  {
    _Iterator _M_current;

    using __traits_type = iterator_traits<_Iterator>;
1266#if __cplusplus201703L > 201703L && __cpp_lib_concepts
    using __base_cat = typename __traits_type::iterator_category;
1268#else
    using __base_ref = typename __traits_type::reference;
1270#endif

  public:
    using iterator_type = _Iterator;

1275#if __cplusplus201703L > 201703L && __cpp_lib_concepts
    using iterator_concept = input_iterator_tag;
    using iterator_category
= __detail::__clamp_iter_cat<__base_cat, random_access_iterator_tag>;
    using value_type = iter_value_t<_Iterator>;
    using difference_type = iter_difference_t<_Iterator>;
    using pointer = _Iterator;
    using reference = iter_rvalue_reference_t<_Iterator>;
1283#else
    typedef typename __traits_type::iterator_category iterator_category;
    typedef typename __traits_type::value_type  	value_type;
    typedef typename __traits_type::difference_type	difference_type;
    // NB: DR 680.
    typedef _Iterator					pointer;
    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 2106. move_iterator wrapping iterators returning prvalues
    typedef typename conditional<is_reference<__base_ref>::value,
	 typename remove_reference<__base_ref>::type&&,
	 __base_ref>::type		reference;
1294#endif

    _GLIBCXX17_CONSTEXPRconstexpr
    move_iterator()
    : _M_current() { }

    explicit _GLIBCXX17_CONSTEXPRconstexpr
    move_iterator(iterator_type __i)
    : _M_current(std::move(__i)) { }

    template<typename _Iter>
_GLIBCXX17_CONSTEXPRconstexpr
move_iterator(const move_iterator<_Iter>& __i)
: _M_current(__i.base()) { }

1309#if __cplusplus201703L <= 201703L
    _GLIBCXX17_CONSTEXPRconstexpr iterator_type
    base() const
    { return _M_current; }
1313#else
    constexpr iterator_type
    base() const &
1316#if __cpp_lib_concepts
requires copy_constructible<iterator_type>
1318#endif
    { return _M_current; }

    constexpr iterator_type
    base() &&
    { return std::move(_M_current); }
1324#endif

    _GLIBCXX17_CONSTEXPRconstexpr reference
    operator*() const
    { return static_cast<reference>(*_M_current); }

    _GLIBCXX17_CONSTEXPRconstexpr pointer
    operator->() const
    { return _M_current; }

    _GLIBCXX17_CONSTEXPRconstexpr move_iterator&
    operator++()
    {
++_M_current;
return *this;
    }

    _GLIBCXX17_CONSTEXPRconstexpr move_iterator
    operator++(int)
    {
move_iterator __tmp = *this;
++_M_current;
return __tmp;
    }

1349#if __cpp_lib_concepts
    constexpr void
    operator++(int) requires (!forward_iterator<_Iterator>)
    { ++_M_current; }
1353#endif

    _GLIBCXX17_CONSTEXPRconstexpr move_iterator&
    operator--()
    {
--_M_current;
return *this;
    }

    _GLIBCXX17_CONSTEXPRconstexpr move_iterator
    operator--(int)
    {
move_iterator __tmp = *this;
--_M_current;
return __tmp;
    }

    _GLIBCXX17_CONSTEXPRconstexpr move_iterator
    operator+(difference_type __n) const
    { return move_iterator(_M_current + __n); }

    _GLIBCXX17_CONSTEXPRconstexpr move_iterator&
    operator+=(difference_type __n)
    {
_M_current += __n;
return *this;
    }

    _GLIBCXX17_CONSTEXPRconstexpr move_iterator
    operator-(difference_type __n) const
    { return move_iterator(_M_current - __n); }
  
    _GLIBCXX17_CONSTEXPRconstexpr move_iterator&
    operator-=(difference_type __n)
    { 
_M_current -= __n;
return *this;
    }

    _GLIBCXX17_CONSTEXPRconstexpr reference
    operator[](difference_type __n) const
    { return std::move(_M_current[__n]); }

1396#if __cplusplus201703L > 201703L && __cpp_lib_concepts
    template<sentinel_for<_Iterator> _Sent>
friend constexpr bool
operator==(const move_iterator& __x, const move_sentinel<_Sent>& __y)
{ return __x.base() == __y.base(); }

    template<sized_sentinel_for<_Iterator> _Sent>
friend constexpr iter_difference_t<_Iterator>
operator-(const move_sentinel<_Sent>& __x, const move_iterator& __y)
{ return __x.base() - __y.base(); }

    template<sized_sentinel_for<_Iterator> _Sent>
friend constexpr iter_difference_t<_Iterator>
operator-(const move_iterator& __x, const move_sentinel<_Sent>& __y)
{ return __x.base() - __y.base(); }

    friend constexpr iter_rvalue_reference_t<_Iterator>
    iter_move(const move_iterator& __i)
    noexcept(noexcept(ranges::iter_move(__i._M_current)))
    { return ranges::iter_move(__i._M_current); }

    template<indirectly_swappable<_Iterator> _Iter2>
friend constexpr void
iter_swap(const move_iterator& __x, const move_iterator<_Iter2>& __y)
noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
{ return ranges::iter_swap(__x._M_current, __y._M_current); }
1422#endif // C++20
  };

template<typename _IteratorL, typename _IteratorR>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator==(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
1429#if __cplusplus201703L > 201703L && __cpp_lib_concepts
  requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
1431#endif
  { return __x.base() == __y.base(); }

1434#if __cpp_lib_three_way_comparison
template<typename _IteratorL,
  three_way_comparable_with<_IteratorL> _IteratorR>
  constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
  operator<=>(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
  { return __x.base() <=> __y.base(); }
1441#else
template<typename _IteratorL, typename _IteratorR>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator!=(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
  { return !(__x == __y); }
1447#endif

template<typename _IteratorL, typename _IteratorR>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator<(const move_iterator<_IteratorL>& __x,
     const move_iterator<_IteratorR>& __y)
1453#if __cplusplus201703L > 201703L && __cpp_lib_concepts
  requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1455#endif
  { return __x.base() < __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator<=(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
1462#if __cplusplus201703L > 201703L && __cpp_lib_concepts
  requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1464#endif
  { return !(__y < __x); }

template<typename _IteratorL, typename _IteratorR>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator>(const move_iterator<_IteratorL>& __x,
     const move_iterator<_IteratorR>& __y)
1471#if __cplusplus201703L > 201703L && __cpp_lib_concepts
  requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1473#endif
  { return __y < __x; }

template<typename _IteratorL, typename _IteratorR>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator>=(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
1480#if __cplusplus201703L > 201703L && __cpp_lib_concepts
  requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1482#endif
  { return !(__x < __y); }

1485#if ! (__cplusplus201703L > 201703L && __cpp_lib_concepts)
// Note: See __normal_iterator operators note from Gaby to understand
// why we have these extra overloads for some move_iterator operators.

// These extra overloads are not needed in C++20, because the ones above
// are constrained with a requires-clause and so overload resolution will
// prefer them to greedy unconstrained function templates.

template<typename _Iterator>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator==(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return __x.base() == __y.base(); }

template<typename _Iterator>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator!=(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return !(__x == __y); }

template<typename _Iterator>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator<(const move_iterator<_Iterator>& __x,
     const move_iterator<_Iterator>& __y)
  { return __x.base() < __y.base(); }

template<typename _Iterator>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator<=(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return !(__y < __x); }

template<typename _Iterator>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator>(const move_iterator<_Iterator>& __x,
     const move_iterator<_Iterator>& __y)
  { return __y < __x; }

template<typename _Iterator>
  inline _GLIBCXX17_CONSTEXPRconstexpr bool
  operator>=(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return !(__x < __y); }
1528#endif // ! C++20

// DR 685.
template<typename _IteratorL, typename _IteratorR>
  inline _GLIBCXX17_CONSTEXPRconstexpr auto
  operator-(const move_iterator<_IteratorL>& __x,
     const move_iterator<_IteratorR>& __y)
  -> decltype(__x.base() - __y.base())
  { return __x.base() - __y.base(); }

template<typename _Iterator>
  inline _GLIBCXX17_CONSTEXPRconstexpr move_iterator<_Iterator>
  operator+(typename move_iterator<_Iterator>::difference_type __n,
     const move_iterator<_Iterator>& __x)
  { return __x + __n; }

template<typename _Iterator>
  inline _GLIBCXX17_CONSTEXPRconstexpr move_iterator<_Iterator>
  make_move_iterator(_Iterator __i)
  { return move_iterator<_Iterator>(std::move(__i)); }

template<typename _Iterator, typename _ReturnType
  = typename conditional<__move_if_noexcept_cond
    <typename iterator_traits<_Iterator>::value_type>::value,
              _Iterator, move_iterator<_Iterator>>::type>
  inline _GLIBCXX17_CONSTEXPRconstexpr _ReturnType
  __make_move_if_noexcept_iterator(_Iterator __i)
  { return _ReturnType(__i); }

// Overload for pointers that matches std::move_if_noexcept more closely,
// returning a constant iterator when we don't want to move.
template<typename _Tp, typename _ReturnType
  = typename conditional<__move_if_noexcept_cond<_Tp>::value,
	   const _Tp*, move_iterator<_Tp*>>::type>
  inline _GLIBCXX17_CONSTEXPRconstexpr _ReturnType
  __make_move_if_noexcept_iterator(_Tp* __i)
  { return _ReturnType(__i); }

1566#if __cplusplus201703L > 201703L && __cpp_lib_concepts
// [iterators.common] Common iterators

namespace __detail
{
  template<typename _It>
    concept __common_iter_has_arrow = indirectly_readable<const _It>
&& (requires(const _It& __it) { __it.operator->(); }
   || is_reference_v<iter_reference_t<_It>>
   || constructible_from<iter_value_t<_It>, iter_reference_t<_It>>);

} // namespace __detail

/// An iterator/sentinel adaptor for representing a non-common range.
template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
  requires (!same_as<_It, _Sent>) && copyable<_It>
class common_iterator
{
  template<typename _Tp, typename _Up>
    static constexpr bool
    _S_noexcept1()
    {
if constexpr (is_trivially_default_constructible_v<_Tp>)
 return is_nothrow_assignable_v<_Tp, _Up>;
else
 return is_nothrow_constructible_v<_Tp, _Up>;
    }

  template<typename _It2, typename _Sent2>
    static constexpr bool
    _S_noexcept()
    { return _S_noexcept1<_It, _It2>() && _S_noexcept1<_Sent, _Sent2>(); }

  class _Proxy
  {
    iter_value_t<_It> _M_keep;

    _Proxy(iter_reference_t<_It>&& __x)
    : _M_keep(std::move(__x)) { }

    friend class common_iterator;

  public:
    const iter_value_t<_It>*
    operator->() const
    { return std::__addressof(_M_keep); }
  };

public:
  constexpr
  common_iterator()
  noexcept(is_nothrow_default_constructible_v<_It>)
  : _M_it(), _M_index(0)
  { }

  constexpr
  common_iterator(_It __i)
  noexcept(is_nothrow_move_constructible_v<_It>)
  : _M_it(std::move(__i)), _M_index(0)
  { }

  constexpr
  common_iterator(_Sent __s)
  noexcept(is_nothrow_move_constructible_v<_Sent>)
  : _M_sent(std::move(__s)), _M_index(1)
  { }

  template<typename _It2, typename _Sent2>
    requires convertible_to<const _It2&, _It>
&& convertible_to<const _Sent2&, _Sent>
    constexpr
    common_iterator(const common_iterator<_It2, _Sent2>& __x)
    noexcept(_S_noexcept<const _It2&, const _Sent2&>())
    : _M_valueless(), _M_index(__x._M_index)
    {
if (_M_index == 0)
 {
   if constexpr (is_trivially_default_constructible_v<_It>)
     _M_it = std::move(__x._M_it);
   else
     ::new((void*)std::__addressof(_M_it)) _It(__x._M_it);
 }
else if (_M_index == 1)
 {
   if constexpr (is_trivially_default_constructible_v<_Sent>)
     _M_sent = std::move(__x._M_sent);
   else
     ::new((void*)std::__addressof(_M_sent)) _Sent(__x._M_sent);
 }
    }

  constexpr
  common_iterator(const common_iterator& __x)
  noexcept(_S_noexcept<const _It&, const _Sent&>())
  : _M_valueless(), _M_index(__x._M_index)
  {
    if (_M_index == 0)
{
 if constexpr (is_trivially_default_constructible_v<_It>)
   _M_it = std::move(__x._M_it);
 else
   ::new((void*)std::__addressof(_M_it)) _It(__x._M_it);
}
    else if (_M_index == 1)
{
 if constexpr (is_trivially_default_constructible_v<_Sent>)
   _M_sent = std::move(__x._M_sent);
 else
   ::new((void*)std::__addressof(_M_sent)) _Sent(__x._M_sent);
}
  }

  common_iterator&
  operator=(const common_iterator& __x)
  noexcept(is_nothrow_copy_assignable_v<_It>
    && is_nothrow_copy_assignable_v<_Sent>
    && is_nothrow_copy_constructible_v<_It>
    && is_nothrow_copy_constructible_v<_Sent>)
  {
    return this->operator=<_It, _Sent>(__x);
  }

  template<typename _It2, typename _Sent2>
    requires convertible_to<const _It2&, _It>
&& convertible_to<const _Sent2&, _Sent>
&& assignable_from<_It&, const _It2&>
&& assignable_from<_Sent&, const _Sent2&>
    common_iterator&
    operator=(const common_iterator<_It2, _Sent2>& __x)
    noexcept(is_nothrow_constructible_v<_It, const _It2&>
      && is_nothrow_constructible_v<_Sent, const _Sent2&>
      && is_nothrow_assignable_v<_It, const _It2&>
      && is_nothrow_assignable_v<_Sent, const _Sent2&>)
    {
switch(_M_index << 2 | __x._M_index)
 {
 case 0b0000:
   _M_it = __x._M_it;
   break;
 case 0b0101:
   _M_sent = __x._M_sent;
   break;
 case 0b0001:
   _M_it.~_It();
   _M_index = -1;
   [[fallthrough]];
 case 0b1001:
   ::new((void*)std::__addressof(_M_sent)) _Sent(__x._M_sent);
   _M_index = 1;
   break;
 case 0b0100:
   _M_sent.~_Sent();
   _M_index = -1;
   [[fallthrough]];
 case 0b1000:
   ::new((void*)std::__addressof(_M_it)) _It(__x._M_it);
   _M_index = 0;
   break;
 default:
   __glibcxx_assert(__x._M_has_value());
   __builtin_unreachable();
 }
return *this;
    }

  ~common_iterator()
  {
    switch (_M_index)
{
case 0:
 _M_it.~_It();
 break;
case 1:
 _M_sent.~_Sent();
 break;
}
  }

  decltype(auto)
  operator*()
  {
    __glibcxx_assert(_M_index == 0);
    return *_M_it;
  }

  decltype(auto)
  operator*() const requires __detail::__dereferenceable<const _It>
  {
    __glibcxx_assert(_M_index == 0);
    return *_M_it;
  }

  decltype(auto)
  operator->() const requires __detail::__common_iter_has_arrow<_It>
  {
    __glibcxx_assert(_M_index == 0);
    if constexpr (is_pointer_v<_It> || requires { _M_it.operator->(); })
return _M_it;
    else if constexpr (is_reference_v<iter_reference_t<_It>>)
{
 auto&& __tmp = *_M_it;
 return std::__addressof(__tmp);
}
    else
return _Proxy{*_M_it};
  }

  common_iterator&
  operator++()
  {
    __glibcxx_assert(_M_index == 0);
    ++_M_it;
    return *this;
  }

  decltype(auto)
  operator++(int)
  {
    __glibcxx_assert(_M_index == 0);
    if constexpr (forward_iterator<_It>)
{
 common_iterator __tmp = *this;
 ++*this;
 return __tmp;
}
    else
return _M_it++;
  }

  template<typename _It2, sentinel_for<_It> _Sent2>
    requires sentinel_for<_Sent, _It2>
    friend bool
    operator==(const common_iterator& __x,
 const common_iterator<_It2, _Sent2>& __y)
    {
switch(__x._M_index << 2 | __y._M_index)
 {
 case 0b0000:
 case 0b0101:
   return true;
 case 0b0001:
   return __x._M_it == __y._M_sent;
 case 0b0100:
   return __x._M_sent == __y._M_it;
 default:
   __glibcxx_assert(__x._M_has_value());
   __glibcxx_assert(__y._M_has_value());
   __builtin_unreachable();
 }
    }

  template<typename _It2, sentinel_for<_It> _Sent2>
    requires sentinel_for<_Sent, _It2> && equality_comparable_with<_It, _It2>
    friend bool
    operator==(const common_iterator& __x,
 const common_iterator<_It2, _Sent2>& __y)
    {
switch(__x._M_index << 2 | __y._M_index)
 {
 case 0b0101:
   return true;
 case 0b0000:
   return __x._M_it == __y._M_it;
 case 0b0001:
   return __x._M_it == __y._M_sent;
 case 0b0100:
   return __x._M_sent == __y._M_it;
 default:
   __glibcxx_assert(__x._M_has_value());
   __glibcxx_assert(__y._M_has_value());
   __builtin_unreachable();
 }
    }

  template<sized_sentinel_for<_It> _It2, sized_sentinel_for<_It> _Sent2>
    requires sized_sentinel_for<_Sent, _It2>
    friend iter_difference_t<_It2>
    operator-(const common_iterator& __x,
const common_iterator<_It2, _Sent2>& __y)
    {
switch(__x._M_index << 2 | __y._M_index)
 {
 case 0b0101:
   return 0;
 case 0b0000:
   return __x._M_it - __y._M_it;
 case 0b0001:
   return __x._M_it - __y._M_sent;
 case 0b0100:
   return __x._M_sent - __y._M_it;
 default:
   __glibcxx_assert(__x._M_has_value());
   __glibcxx_assert(__y._M_has_value());
   __builtin_unreachable();
 }
    }

  friend iter_rvalue_reference_t<_It>
  iter_move(const common_iterator& __i)
  noexcept(noexcept(ranges::iter_move(std::declval<const _It&>())))
  requires input_iterator<_It>
  {
    __glibcxx_assert(__i._M_index == 0);
    return ranges::iter_move(__i._M_it);
  }

  template<indirectly_swappable<_It> _It2, typename _Sent2>
    friend void
    iter_swap(const common_iterator& __x,
const common_iterator<_It2, _Sent2>& __y)
    noexcept(noexcept(ranges::iter_swap(std::declval<const _It&>(),
			  std::declval<const _It2&>())))
    {
__glibcxx_assert(__x._M_index == 0);
__glibcxx_assert(__y._M_index == 0);
return ranges::iter_swap(__x._M_it, __y._M_it);
    }

private:
  template<input_or_output_iterator _It2, sentinel_for<_It2> _Sent2>
    friend class common_iterator;

  bool _M_has_value() const noexcept { return _M_index < 2; }

  union
  {
    _It _M_it;
    _Sent _M_sent;
    unsigned char _M_valueless;
  };
  unsigned char _M_index; // 0==_M_it, 1==_M_sent, 2==valueless
};

template<typename _It, typename _Sent>
  struct incrementable_traits<common_iterator<_It, _Sent>>
  {
    using difference_type = iter_difference_t<_It>;
  };

namespace __detail
{
  // FIXME: This has to be at namespace-scope because of PR 92103.
  template<typename _It, typename _Sent>
    struct __common_iter_ptr
    {
using type = void;
    };

  template<typename _It, typename _Sent>
    requires __detail::__common_iter_has_arrow<_It>
    struct __common_iter_ptr<_It, _Sent>
    {
using common_iterator = std::common_iterator<_It, _Sent>;

using type
 = decltype(std::declval<const common_iterator&>().operator->());
    };
} // namespace __detail

template<input_iterator _It, typename _Sent>
  struct iterator_traits<common_iterator<_It, _Sent>>
  {
    using iterator_concept = conditional_t<forward_iterator<_It>,
   forward_iterator_tag, input_iterator_tag>;
    using iterator_category = __detail::__clamp_iter_cat<
typename iterator_traits<_It>::iterator_category,
forward_iterator_tag, input_iterator_tag>;
    using value_type = iter_value_t<_It>;
    using difference_type = iter_difference_t<_It>;
    using pointer = typename __detail::__common_iter_ptr<_It, _Sent>::type;
    using reference = iter_reference_t<_It>;
  };

// [iterators.counted] Counted iterators

/// An iterator adaptor that keeps track of the distance to the end.
template<input_or_output_iterator _It>
  class counted_iterator
  {
  public:
    using iterator_type = _It;

    constexpr counted_iterator() = default;

    constexpr
    counted_iterator(_It __i, iter_difference_t<_It> __n)
    : _M_current(std::move(__i)), _M_length(__n)
    { __glibcxx_assert(__n >= 0); }

    template<typename _It2>
requires convertible_to<const _It2&, _It>
constexpr
counted_iterator(const counted_iterator<_It2>& __x)
: _M_current(__x._M_current), _M_length(__x._M_length)
{ }

    template<typename _It2>
requires assignable_from<_It&, const _It2&>
constexpr counted_iterator&
operator=(const counted_iterator<_It2>& __x)
{
 _M_current = __x._M_current;
 _M_length = __x._M_length;
 return *this;
}

    constexpr _It
    base() const &
    noexcept(is_nothrow_copy_constructible_v<_It>)
    requires copy_constructible<_It>
    { return _M_current; }

    constexpr _It
    base() &&
    noexcept(is_nothrow_move_constructible_v<_It>)
    { return std::move(_M_current); }

    constexpr iter_difference_t<_It>
    count() const noexcept { return _M_length; }

    constexpr decltype(auto)
    operator*()
    noexcept(noexcept(*_M_current))
    { return *_M_current; }

    constexpr decltype(auto)
    operator*() const
    noexcept(noexcept(*_M_current))
    requires __detail::__dereferenceable<const _It>
    { return *_M_current; }

    constexpr counted_iterator&
    operator++()
    {
__glibcxx_assert(_M_length > 0);
++_M_current;
--_M_length;
return *this;
    }

    decltype(auto)
    operator++(int)
    {
__glibcxx_assert(_M_length > 0);
--_M_length;
__trytry
 {
   return _M_current++;
 } __catch(...)catch(...) {
   ++_M_length;
   throw;
 }

    }

    constexpr counted_iterator
    operator++(int) requires forward_iterator<_It>
    {
auto __tmp = *this;
++*this;
return __tmp;
    }

    constexpr counted_iterator&
    operator--() requires bidirectional_iterator<_It>
    {
--_M_current;
++_M_length;
return *this;
    }

    constexpr counted_iterator
    operator--(int) requires bidirectional_iterator<_It>
    {
auto __tmp = *this;
--*this;
return __tmp;
    }

    constexpr counted_iterator
    operator+(iter_difference_t<_It> __n) const
requires random_access_iterator<_It>
    { return counted_iterator(_M_current + __n, _M_length - __n); }

    friend constexpr counted_iterator
    operator+(iter_difference_t<_It> __n, const counted_iterator& __x)
    requires random_access_iterator<_It>
    { return __x + __n; }

    constexpr counted_iterator&
    operator+=(iter_difference_t<_It> __n)
    requires random_access_iterator<_It>
    {
__glibcxx_assert(__n <= _M_length);
_M_current += __n;
_M_length -= __n;
return *this;
    }

    constexpr counted_iterator
    operator-(iter_difference_t<_It> __n) const
    requires random_access_iterator<_It>
    { return counted_iterator(_M_current - __n, _M_length + __n); }

    template<common_with<_It> _It2>
friend constexpr iter_difference_t<_It2>
operator-(const counted_iterator& __x,
  const counted_iterator<_It2>& __y)
{ return __y._M_length - __x._M_length; }

    friend constexpr iter_difference_t<_It>
    operator-(const counted_iterator& __x, default_sentinel_t)
    { return -__x._M_length; }

    friend constexpr iter_difference_t<_It>
    operator-(default_sentinel_t, const counted_iterator& __y)
    { return __y._M_length; }

    constexpr counted_iterator&
    operator-=(iter_difference_t<_It> __n)
    requires random_access_iterator<_It>
    {
__glibcxx_assert(-__n <= _M_length);
_M_current -= __n;
_M_length += __n;
return *this;
    }

    constexpr decltype(auto)
    operator[](iter_difference_t<_It> __n) const
    noexcept(noexcept(_M_current[__n]))
    requires random_access_iterator<_It>
    {
__glibcxx_assert(__n < _M_length);
return _M_current[__n];
    }

    template<common_with<_It> _It2>
friend constexpr bool
operator==(const counted_iterator& __x,
   const counted_iterator<_It2>& __y)
{ return __x._M_length == __y._M_length; }

    friend constexpr bool
    operator==(const counted_iterator& __x, default_sentinel_t)
    { return __x._M_length == 0; }

    template<common_with<_It> _It2>
friend constexpr strong_ordering
operator<=>(const counted_iterator& __x,
    const counted_iterator<_It2>& __y)
{ return __y._M_length <=> __x._M_length; }

    friend constexpr iter_rvalue_reference_t<_It>
    iter_move(const counted_iterator& __i)
    noexcept(noexcept(ranges::iter_move(__i._M_current)))
    requires input_iterator<_It>
    { return ranges::iter_move(__i._M_current); }

    template<indirectly_swappable<_It> _It2>
friend constexpr void
iter_swap(const counted_iterator& __x,
  const counted_iterator<_It2>& __y)
noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
{ ranges::iter_swap(__x._M_current, __y._M_current); }

  private:
    template<input_or_output_iterator _It2> friend class counted_iterator;

    _It _M_current = _It();
    iter_difference_t<_It> _M_length = 0;
  };

template<typename _It>
  struct incrementable_traits<counted_iterator<_It>>
  {
    using difference_type = iter_difference_t<_It>;
  };

template<input_iterator _It>
  struct iterator_traits<counted_iterator<_It>> : iterator_traits<_It>
  {
    using pointer = void;
  };
2150#endif // C++20

// @} group iterators

template<typename _Iterator>
  auto
  __niter_base(move_iterator<_Iterator> __it)
  -> decltype(make_move_iterator(__niter_base(__it.base())))
  { return make_move_iterator(__niter_base(__it.base())); }

template<typename _Iterator>
  struct __is_move_iterator<move_iterator<_Iterator> >
  {
    enum { __value = 1 };
    typedef __true_type __type;
  };

template<typename _Iterator>
  auto
  __miter_base(move_iterator<_Iterator> __it)
  -> decltype(__miter_base(__it.base()))
  { return __miter_base(__it.base()); }

2173#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter)std::make_move_iterator(_Iter) std::make_move_iterator(_Iter)
2174#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter)std::__make_move_if_noexcept_iterator(_Iter) \
std::__make_move_if_noexcept_iterator(_Iter)
2176#else
2177#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter)std::make_move_iterator(_Iter) (_Iter)
2178#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter)std::__make_move_if_noexcept_iterator(_Iter) (_Iter)
2179#endif // C++11

2181#if __cpp_deduction_guides201703L >= 201606
// These helper traits are used for deduction guides
// of associative containers.
template<typename _InputIterator>
  using __iter_key_t = remove_const_t<
  typename iterator_traits<_InputIterator>::value_type::first_type>;

template<typename _InputIterator>
  using __iter_val_t =
  typename iterator_traits<_InputIterator>::value_type::second_type;

template<typename _T1, typename _T2>
  struct pair;

template<typename _InputIterator>
  using __iter_to_alloc_t =
  pair<add_const_t<__iter_key_t<_InputIterator>>,
__iter_val_t<_InputIterator>>;
2199#endif // __cpp_deduction_guides

2201_GLIBCXX_END_NAMESPACE_VERSION
2202} // namespace

2204#ifdef _GLIBCXX_DEBUG
2205# include <debug/stl_iterator.h>
2206#endif

2208#endif