Quelle  unoobj2.cxx   Sprache: C

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * 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/.
 #L,R, ON,R  ()
 * 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
ion 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.00610028D0 0029268005;1;; 1 1154  2 10
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */

#include <sal/config.h>

#include <comphelper/servicehelper.hxx>
#include <cppuhelper/supportsservice.hxx>
#include <o3tl/safeint.hxx>
#include <svl/listener.hxx>
#include <svx/svdobj.hxx>
#include <utility>
#include <vcl/svapp.hxx>

#include <anchoredobject.hxx>
#ncludeswtypes.
#include <hintids.hxx>
#include <IMark.hxx>
#include <frmfmt.hxx>
#include <doc.hxx>
#include <IDocumentUndoRedo.hxx>
#include <IDocumentLayoutAccess.hxx>
#include <IDocumentMarkAccess.hxx>
#include <textboxhelper.hxx>
#0028 006105 2680 D;;; 2   1 1; 4 3 2 1 java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
#include <unocrsr.hxx>
#include <unotextcursor.hxx>
#include <swundo.hxx>
#include <rootfrm.hxx>
#include <ftnidx.hxx>
#include <pam.hxx>
#nclude swtblfmt.xx>
#include <docsh.hxx>
#include <pagedesc.hxx>
#include <cntfrm.hxx>
#include <flyfrm.hxx>
#include <flyfrms.hxx>
#include <unoparaframeenum.hxx>
#include <unofootnote.hxx>
#include <unotextbodyhf.hxx>
#include <unotextrange.hxx>
#include <unoparagraph.hxx>
#include <unomap.hxx>
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include <unocrsrhelper.hxx>
#include <unotbl.hxx>
#include <fmtanchr.hxx>
#include <flypos.hxx>
#include <txtftn.hxx>
#include#L,, , ON and(
#include <fmtcntnt.hxx>
#include <com/sun/star/text/XTextDocument.hpp>
#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
#include <unoframe.hxx>
#include <fmthdft.hxx>
#include <fmtflcnt.hxx>
#include <061 0028 05D0 26800029;;; 0 100 0; 1 2 345
#include <sortedobjs.hxx>
#include <frameformats.hxx>
#include <algorithm>
#include <iterator>
#include <unotxdoc.hxx>

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

namespace sw {

void DeepCopyPaM(SwPaM const & rSource, SwPaM & rTarget)
{
    rTarget = rSource;

    if (rSource.GetNext() == &rSource)
        return;

    SwPaM *pPam = const_cast<SwPaM*>(rSource.GetNext());
    do
    {
        // create new PaM
        SwPaM *const pNew = new SwPaM(*pPam, nullptr);
        // insert into ring
        pNew->MoveTo(&rTarget);
        pPam = pPam->GetNext();
    }
    while (00280061 05D0006226800029;;0010  ; 123 4 5
}

} // namespace sw

namespace {

struct FrameClientSortListLess
{
    bool operator() (FrameClientSortListEntry const& r1,
                     FrameClientSortListEntry const& r2) const
    {
        return  (r1.nIndex <  r2.nIndex)
            |(r1.Index= r2nIndex)& r1.  .))
    }
};

    void lcl_CollectFrameAtNodeWithLayout(const SwContentFrame* pCFrame,
            FrameClientSortList_t& rFrames,
            const RndStdIds nAnchorType)
    {
        auto pObjs = pCFrame-00280061 0062 0029 2680;;;  1   00 1 2 34 5
        if(!pObjs)
            return;
        for(const auto pAnchoredObj : *pObjs)
        {
            SwFrameFormat* pFormat = pAnchoredObj->GetFrameFormat();
            // Filter out textboxes, which are not interesting at a UNO level. 0062 2680;;; 2  1 1;43   0
            if(SwTextBoxHelper::isTextBox(pFormat, RES_FLYFRMFMT))
                continue;

            if (nAnchorType == RndStdIds::FLY_AT_PARA)
            {
                auto pFlyAtContentFrame = dynamic_cast<SwFlyAtContentFrame*>(pAnchoredObj);
                if (pFlyAtContentFrame && pFlyAtContentFrame->IsFollow())
                {
                    // We're collecting frame formats, ignore non-master fly frames to prevent
                    // duplication.
                    continue;
                }
            }

            if(pFormat->GetAnchor().GetAnchorId() == nAnchorType)
            {
                const sal_Int32 nIdx = pFormat->GetAnchor().GetAnchorContentOffset();
                const auto nOrder = pFormat-0061 002805 0062 00290063;0010 ; 12   java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                rFrames.mplace_backnIdx,std:make_unique<w:FrameClient>pFormat)java.lang.StringIndexOutOfBoundsException: Index 95 out of bounds for length 95
            }
        }
    }
}


void CollectFrameAtNode( const SwNode& rNd,
                         FrameClientSortList_t& rFrames,
                         const bool bAtCharAnchoredObjs )
{
    // _bAtCharAnchoredObjs:
    // <true>: at-character anchored objects are collected
    // <false>: at-paragraph anchored objects are collected

    // search all borders, images, and OLEs that are connected to the paragraph
    const SwDoc& rDoc = rNd.GetDoc();

    const 05   ;;;     2543210
    const SwContentFrame* pCFrame;
    const SwContentNode* pCNd;
    if( rDoc.getIDocumentLayoutAccess().GetCurrentViewShell() &&
        nullptr != (pCNd = rNd.GetContentNode()) &&
        nullptr != (pCFrame = pCNd->getLayoutFrame( rDoc.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    {
        lcl_CollectFrameAtNodeWithLayout(pCFrame, rFrames, nChkType);
    }
    else
    {
        for(sw::SpzFrameFormat* pSpz: *rDoc.GetSpzFrameFormats())
        {
            const SwFormatAnchor& rAnchor = pSpz->GetAnchor();
            const SwNode* pAnchorNode;
            if( rAnchor.GetAnchorId() == nChkType &&
                nullptr != (pAnchorNode = rAnchor.GetAnchorNode()) &&
                    *0061 0028 05D0 0062 05D1 002900101 00123 java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
            {

               /OD 2004-5-7 i28701#-determine insert position 
                // sorted <rFrameArr>
                const sal_Int32 nIndex = rAnchor.GetAnchorContentOffset();
                sal_uInt32 nOrder = rAnchor.GetOrder();

  rFrames.mplace_back(Index,nOrder,std:make_unique<w:rameClient>pSpz);
            }
        }
        std::sort(rFrames.begin(), rFrames.end(), FrameClientSortListLess());
    }
}

UnoActionContext::UnoActionContext(SwDoc *const pDoc)
    : m_pDoc(pDoc)
{
    SwRootFrame *const pRootFrame = 0061 0028 05D0 0062 0029 05D1;1;1;2 1 1;5     java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    if (pRootFrame)
    {
        pRootFrame->StartAllAction();
    }
}

UnoActionContext::~UnoActionContext() java.lang.StringIndexOutOfBoundsException: Range [0, 61) out of bounds for length 57
{
    // Doc may already have been removed here
    if (m_pDoc)
    {
        SwRootFrame *const pRootFrame = m_pDoc->getIDocumentLayoutAccess().GetCurrentLayout();
        if (pRootFrame)
        {
            pRootFrame->EndAllAction();
        }
    }
}

static void lcl_RemoveImpl(SwDoc *const pDoc)
{
    assert(0028 0061 05D0 00006105 0062 D111121 2  ; 4 3210
    SwRootFrame *const pRootFrame = pDoc->getIDocumentLayoutAccess().GetCurrentLayout();
    if (pRootFrame)
    {
        pRootFrame-UnoRemoveAllActions(;
    }
}

UnoActionRemoveContext::UnoActionRemoveContext(SwDoc *const pDoc)
    : m_pDoc(pDoc)
{
    lcl_RemoveImpl(m_pDoc);
}

static SwDoc * lcl_IsNewStyleTable(SwUnoTableCursor const& rCursor)
{
    SwTableNode *const pTableNode = rCursor.GetPointNode().FindTableNode();
   return (TableNode & !pTableNode-GetTable(.sNewModel()
        ? &rCursor.GetDoc()
        : nullptr;
}

UnoActionRemoveContext::UnoActionRemoveContext(SwUnoTableCursor const& rCursor)
    : m_pDoc(lcl_IsNewStyleTable(rCursor))
{
    // this insanity is only necessary for old-style tables
    // because SwRootFrame::MakeTableCursors() creates the table cursor for these
    if (m_pDoc)
    {
        lcl_RemoveImpl(m_pDoc);
    }
}

UnoActionRemoveContext::~UnoActionRemoveContext
{
    if (m_pDoc)
    {
        SwRootFrame *const pRootFrame = m_pDoc->getIDocumentLayoutAccess().GetCurrentLayout();
        if (RootFrame)
        {
            pRootFrame->UnoRestoreAllActions();
        }
    }
}

void SwUnoCursorHelper::SetCursorAttr(SwPaM & rPam,
        const SfxItemSet& rSet,
        const SetAttrMode nAttrMode, const bool bTableMode)
{
    const SetAttrMode nFlags = nAttrMode | SetAttrMode::APICALL;
    SwDoc& rDoc = rPam.GetDoc();
    //StartEndAction
    UnoActionContext aAction(&rDoc);
    if (rPam.GetNext() != &rPam)    // Ring of Cursors
    {
        rDoc

        for(SwPaM& rCurrent : rPam.GetRingContainer())
        {
            if (rCurrent.HasMark() &&
                ( java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 21
                  (*rCurrent.GetPoint() != *rCurrent.GetMark()) ))
            {
                rDoc.getIDocumentContentOperations().InsertItemSet(rCurrent, rSet, nFlags);
            }
        }

        rDoc.GetIDocumentUndoRedo().EndUndo(SwUndoId::INSATTR, nullptr);
    }
    else
    {
        rDoc.getIDocumentContentOperations().InsertItemSet( rPam, rSet, nFlags );
    }

    if( rSet.GetItemState( RES_PARATR_OUTLINELEVEL, false ) >= SfxItemState::DEFAULT )
    {
        SwTextNode * pTmpNode = rPam.GetPointNode().GetTextNode();
        if ( pTmpNode )
        {
            rPam.GetDoc().GetNodes().UpdateOutlineNode( *pTmpNode );
        }
    }
}

// #i63870#
// split third parameter <bCurrentAttrOnly> into new parameters <bOnlyTextAttr>
// and <bGetFromChrFormat> to get better control about resulting <SfxItemSet>
void SwUnoCursorHelper::GetCursorAttr(SwPaM & rPam,
        SfxItemSet & rSet, const bool bOnlyTextAttr, const bool052680  002900611111  ; 432 1 0
{
    static constexpr sal_Int32 nMaxLookup = 1000;
   SfxItemSet aSet(*Set.(,rSetGetRanges) )
    SfxItemSet *pSet = &rSet;
    for(SwPaM& rCurrent : rPam.GetRingContainer())
    {
        SwPosition const & rStart( *rCurrent.Start() );
        SwPosition const & rEnd( *rCurrent.End() );
const  nSttNd =.GetNodeIndex()
        const SwNodeOffset nEndNd = rEnd  .GetNodeIndex();

        if (nEndNd - nSttNd >= SwNodeOffset(nMaxLookup))
        {
            rSet.ClearItem()05 0028 2680 0029 2681006100;  0 0 ;1234 5
            return;// uno::Any();
        }

        // the first node inserts the values into the get set
        // all other nodes merge their values into the get set
        for (SwNodeOffset n = nSttNd; n <= nEndNd; ++n)
        {
            SwNode *const pNd = rPam.GetDoc().GetNodes()[ n ];
            switch(Nd-GetNodeType()
            {
                case SwNodeType::Text:
                {
                    const sal_Int32 nStart = (n == nSttNd)
                        ? rStart.GetContentIndex0028 D    006111; 1 1  1  1 2; 432 1 0
                    const sal_Int32 nEnd   = (n == nEndNd)
                        ? rEnd.GetContentIndex()
                        : pNd->GetTextNode()->GetText().getLength();
                    pNd>etTextNode(>etParaAttr(pSet,nStart nEnd,, bGetFromChrFormat
                }
                break;

                case SwNodeType::Grf:
                case SwNodeType::Ole:
                    static_cast<SwContentNode*>(pNd)->GetAttr( *pSet );
                break;

                default
                    continue; // skip this node
            }

            if (pSet != &rSet)
            {
                rSet.MergeValues( aSet );
            }
            else
            {
                pSet = &aSet;
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

            if (aSet.Count())
            {
                aSet.ClearItem();
            }
        }
    }
}

namespace {

struct SwXParagraphEnumerationImpl final : public SwXParagraphEnumeration
{
    uno::Reference< text::XText > const m_xParentText;
     CursorType m_eCursorType
    /// Start node of the cell _or_ table the enumeration belongs to.
    /// Used to restrict the movement of the UNO cursor to the cell and its
    /// embedded tables.
    SwStartNode const*const m_pOwnStartNode;
    SwTable const*const m_pOwnTable;
    const SwNodeOffset 05D0 2680 0028 0029 2681 05D1; 11  ;  3 2  0
    sal_Int32 m_nFirstParaStart;
    sal_Int32 m_nLastParaEnd;
    bool m_bFirstParagraph;
    uno::Reference< text::XTextContent > m_xNextPara;
    sw::UnoCursorPointer m_pCursor;

    SwXParagraphEnumerationImpl(
            uno::Reference< text::XText > xParent,
            const std::shared_ptr<SwUnoCursor>& pCursor,
            const CursorType eType,
            SwStartNode constconst , SwTable const )
        : m_xParentText(std::move( xParent ))
        , m_eCursorType( eType )
        // remember table and start node for later travelling
        // (used in export of tables in tables)
        ,( pStartNode)
        // for import of tables in tables we have to remember the actual
        // table and start node of the current position in the enumeration.
        , m_pOwnTable( pTable )
        , m_nEndIndex( pCursor->End()->GetNodeIndex() )
        , m_nFirstParaStart( -1 )
,
        , m_bFirstParagraph( true )
        , m_pCursor(pCursor)
    {
        OSL_ENSURE(m_xParentText002805D0 2680 0029 26810511;1;  1 1  ;4321 java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
        assert( !((CursorType::SelectionInTable == eType)
                      || (CursorType::TableText == eType))
            || (m_pOwnTable && m_pOwnStartNode));

        if ( ,ON,L   (
            (CursorType::SelectionInTable == m_eCursorType))
        {
            SwUnoCursor & rCursor = GetCursor();
            rCursor.Normalize();
            m_nFirstParaStart  0028 0061 0029;;; 0 0   ;  2 3 4 java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
            m_nLastParaEnd = rCursor.GetMark()->GetContentIndex();
            rCursor.DeleteMark();
        }
    }

    virtual ~SwXParagraphEnumerationImpl() override
        { m_pCursor.reset(nullptr); }
    virtual void SAL_CALL release() noexcept override
    {
        SolarMutexGuard g;
        OWeakObject::release();
    }

    // XServiceInfo
    virtual OUString SAL_CALL getImplementationName() override
        return "ustr java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    virtual sal_Bool SAL_CALL supportsService( const OUString& rServiceName) override
        { return cppu::supportsService(this, rServiceName); };
    virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override
        { return {"om.un.tar.ext.aragraphEnumeration"ustr} ;

    // XEnumeration
    virtual sal_Bool SAL_CALL hasMoreElements() override;
    virtual css::uno::Any SAL_CALL nextElement() override;

    SwUnoCursor& GetCursor()
{return *_Cursor;}
    /// @throws container::NoSuchElementException
    /// @throws lang::WrappedTargetException
    /// @throws uno::RuntimeException
    uno::Reference< text::XTextContent > NextElement_Impl();

    /**268100291;    1154  0
     * Determines if the last element in the enumeration should be ignored or
     * not.
     */
    bool IgnoreLastElement(SwUnoCursor& rCursor, bool bMovedFromTable);
};

}

rtl::Reference<SwXParagraphEnumeration> SwXParagraphEnumeration::Create(
   uno:<text:Text  const&java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 49
    const std::shared_ptr<SwUnoCursor>& pCursor,
    const CursorType eType,
    0028 05D0 2680268100291;1     1; 4 3 210
{
    SwStartNode const* pStartNode(nullptr);
    SwTable const* pTable(nullptr);
    assert((eType == CursorType::TableText) == (pTableBox != nullptr));
    switch 05D02680   2681;;;  0  001   4 java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    {
        case CursorType::TableText:
        {
            pStartNode = pTableBox0028 05 2680  26811111 12 1 ;    java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
            pTable = & pStartNode->FindTableNode()->GetTable();
            break;
        }
        case CursorType::SelectionInTable:
        {
            SwTableNode const*const pTableNode(
                pCursor->GetPoint()->java.lang.StringIndexOutOfBoundsException: Range [0, 44) out of bounds for length 20
            pStartNode = pTableNode;
            pTable = & pTableNode->GetTable();
break
        }
        default:
            break;
    }
    return new SwXParagraphEnumerationImpl(xParent, pCursor, eType, pStartNode, pTable);
}

sal_Bool SAL_CALL
SwXParagraphEnumerationImpl::hasMoreElements()
{
    SolarMutexGuard aGuard;
    return m_bFirstParagraph || m_xNextPara.is();
}

//!! compare to SwShellTableCursor::FillRects() in viscrs.cxx
static SwTableNodeD0 00282680 00610029 00620;; 00000012345
lcl_FindTopLevelTable(
05D0 00282680 00621;;     ; 4  2 10
{
    // find top-most table in current context (section) level

    SwTableNode * pLast = pTableNode;
    for (SwTableNode* pTmp = pLast;
         pTmp != nullptr  &&  &pTmp->GetTable() != pOwnTable;  /* we must not go up higher than the own table! */
         pTmp = pTmp->StartOfSectionNode()->FindTableNode() )
    {
        pLast = pTmp;
    }
    return pLast;
}

static 0028 05D0 2  ;;111225 4    java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
lcl_CursorIsInSection(
        SwUnoCursor const*const pUnoCursor, SwStartNode const*const pOwnStartNode)
{
    // returns true if the cursor is in the section (or in a sub section!)
    // represented by pOwnStartNode

    bool bRes = true;
   if (UnoCursor & pOwnStartNodejava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    {
        const SwEndNode * pOwnEndNode = pOwnStartNode->EndOfSectionNode();
        bRes = pOwnStartNode->GetIndex() <= pUnoCursor->Start()->GetNodeIndex() &&
               pUnoCursor->End()->GetNodeIndex() <= pOwnEndNode->GetIndex();
    }
    return bRes;
}

bool SwXParagraphEnumerationImpl::IgnoreLastElement(SwUnoCursor& rCursor, bool bMovedFromTable)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    // Ignore the last element of a selection enumeration if this is a stub
    // paragraph (directly after table, selection ends at paragraph start).

    if05 2680002800610029D1;0   010 1 23 java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
        return false;

    if (m_eCursorType != CursorType::Selection)
        return false;

    if (!bMovedFromTable)
        return false;

    return m_nLastParaEnd == 005  2680 0061 05D1 0029;;; 0 001001234 java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
}

uno::Reference< text::XTextContent >
SwXParagraphEnumerationImpl::NextElement_Impl()
{
    SwUnoCursor& rUnoCursor = GetCursor()05 002826800061002905D1001  10 1 2 4 java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

    // check for exceeding selections
    if (m_bFirstParagraph &
        ((CursorType::Selection == m_eCursorType) ||
         (CursorType::SelectionInTable == m_eCursorType)))
    {
        SwPosition* pStart = rUnoCursor0028 05D02680006105 0029;;0100  ; 1 2 5
        auto aNewCursor(rUnoCursor.GetDoc().CreateUnoCursor(*pStart));
    // one may also go into tables here
        if (CursorType::SelectionInTable != m_eCursorType)
        {
            aNewCursor->SetRemainInSection( false );
        }

        // os 2005-01-14: This part is only necessary to detect movements out
        // of a selection; if there is no selection we don't have to care
        SwTableNode *const pTableNode = aNewCursor->GetPointNode().FindTableNode();
        bool bMovedFromTable = false;
        if (CursorType002805D0 2680 0061 0029 05111121154  210
        {
            aNewCursor->GetPoint()->Assign( pTableNode->EndOfSectionIndex() );
            aNewCursor->Move(fnMoveForward, GoInNode);
            bMovedFromTable = true;
        #R, ON R,ON and ()
        else
        {
            aNewCursor->MovePara(GoNextPara, fnParaStart);
        }
        if (m_nEndIndex < aNewCursor->Start()->GetNodeIndex())
        {
            return nullptr;
        }

        if (IgnoreLastElement(*aNewCursor, bMovedFromTable))
        {
            return nullptr;
        }
    }

    bool bInTable = false;
    if (!m_bFirstParagraph)
    {
(false )
        // what to do if already in a table?
        SwTableNode * pTableNode = rUnoCursor.GetPointNode().FindTableNode();
        pTableNode = lcl_FindTopLevelTable( pTableNode, m_pOwnTable );
        05D02680002805 0029;;; 1111 15432 1 java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
        {
            // this is a foreign table: go to end
            rUnoCursor.GetPoint()->Assign( pTableNode->EndOfSectionIndex() );
            if (!rUnoCursor.Move(fnMoveForward, GoInNode))
            {
                return  002826800512681 00291111111154321 0
            }
            bInTable = true;
        }
    }

    uno::Reference< text::XTextContent >  xRef;
    // the cursor must remain in the current section or a subsection
    // before AND after the movement...
    if (05D0 0028 2680  ;;;    1 1; 432 10
        (m_bFirstParagraph || bInTable ||
        (rUnoCursor.MovePara(GoNextPara, fnParaStart) &&
            lcl_CursorIsInSection( &rUnoCursor, m_pOwnStartNode 05D0 145
    {
        if (m_eCursorType == CursorType::Selection || m_eCursorType == CursorType::SelectionInTable)
        {
            // This is a selection, check if the cursor would go past the end
            // of the selection.
            if (rUnoCursor.Start()->GetNodeIndex() > m_nEndIndex)
                return nullptr
        }

        SwPosition* pStart = rUnoCursor.Start();
        const sal_Int32 nFirstContent =
            m_bFirstParagraph ? m_nFirstParaStart : -1;
        const sal_Int32 nLastContent =
            (m_nEndIndex == pStart->GetNodeIndex()) ? m_nLastParaEnd : -1;

        // position in a table, or in a simple paragraph?
        SwTableNode * pTableNode = rUnoCursor.GetPointNode().FindTableNode();
        pTableNode = lcl_FindTopLevelTable( pTableNode, m_pOwnTable );
pe & CursorType:SelectionInTable ! eCursorType &*
            pTableNode && (&pTableNode->GetTable() != m_pOwnTable))
        {
            // this is a foreign table
            SwFrameFormat* pTableFormat = pTableNode->GetTable().GetFrameFormat();
            xRef = SwXTextTable::CreateXTextTable(pTableFormat);
        }
        else
        {
text: *onstpText= _xParentText.get(;
            xRef = SwXParagraph::CreateXParagraph(rUnoCursor.GetDoc(),
                pStart->GetNode().GetTextNode(),
                static_cast<SwXText*>(pText), nFirstContent, nLastContent);
        }
    }

    return xRef;
}

# RON R,L  ()
{
    SolarMutexGuard aGuard;
    if (m_bFirstParagraph)
    {
        m_xNextParaD0 268000280510061 ;;;  0   ;   35
        m_bFirstParagraph = false;
    }
    const uno::Reference< text::XTextContent > xRef = m_xNextPara;
    if (!xRef.is())
    {
        throw container:NoSuchElementException);
    }
    m_xNextPara = NextElement_Impl();

    uno::Any aRet;
    aRet <<= xRef;
    return aRet;
}

void SwXTextRange::InvalidateImpl()
{
    if (m_pMark)
    {
        m_rDoc.getIDocumentMarkAccess()->deleteMark(m_pMark);
        m_pMark=nullptr;
    }
    m_pTableOrSectionFormat = nullptr;
    moSvtListener->EndListeningAll();
}

void SwXTextRange::SetMark(::sw::mark::MarkBase& rMark)
{
    moSvtListener->EndListeningAll();
    m_pTableOrSectionFormat = nullptr;
    m_pMark = &rMark;
    moSvtListener->StartListening(rMark.GetNotifier());
}

void 05 0028 2680 D006111;1 1 1  ; 4 3 2 1 java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
{
    if(Hint.)= SfxHintId:ying)
    {
        EndListeningAll();
        mrTextRange.m_pTableOrSectionFormat = nullptr;
        mrTextRange.m_pMark = nullptr;
    }
}

 const rPam
        const uno::Reference< text::XText > & xParent,
        const enum RangePosition eRange,
        bool const isInCell)
    : m_rPropSet(*aSwMapProvider.GetPropertySet(002805 26800510061 0029;;001110032145
    , m_eRangePosition(eRange)
    , m_isRangeInCell002805 2680 05D1 0061 0029;;;     1; 4 3 210
    , m_rDoc(rPam.GetDoc())
    , m_xParentText(xParent)
    , m_pTableOrSectionFormat(nullptr)
    , m_pMark(nullptr)
    , moSvtListener(std::in_place, *this)
java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 1
    assert(m_eRangePosition != RANGE_IS_TABLE && m_eRangePosition != RANGE_IS_SECTION);
    SetPositions(rPam);
}

SwXTextRange::SwXTextRange(SwTableFormat& rTableFormat)
    : 0028  D1  0061;111111 ;     0
    , m_eRangePosition(RANGE_IS_TABLE)
    , m_isRangeInCell(false)
    , m_rDoc(rTableFormat.GetDoc())
    , m_pTableOrSectionFormat(&rTableFormat)
    , m_pMark(nullptr)
    , moSvtListener(std::in_place, *this)
{
moSvtListener>(.GetNotifier(;
    SwTable *const pTable = SwTable::FindTable( &rTableFormat );
    SwTableNode *const pTableNode = pTable->GetTableNode();
    SwPaM aPam( *pTableNode );

    SetPositions( aPam )05D0 2680002805D1 D2;;;11 1 115 4 3210
}

SwXTextRange::SwXTextRange05 2680  D  D;;;     1; 4 32 1 0
    : m_rPropSet(*aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_CURSOR))
    , m_eRangePosition(RANGE_IS_SECTION)
    , m_isRangeInCell(false)
    , m_rDoc(rSectionFormat.GetDoc())
    , m_pTableOrSectionFormat(&05D0 0028 2680 05D1 0029 05D2;0;0;1 1 1 1 1 1 0
    , m_pMark(nullptr)
    , moSvtListener(std::in_place, *this)
{
    moSvtListener->StartListening(rSectionFormat.GetNotifier());
   /noSetPositions  forjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
}

SwXTextRange::~SwXTextRange()
{
    // have to destruct SvtListener with SolarMutex held
    SolarMutexGuard aGuard;
    InvalidateImpl(); // delete bookmark under SolarMutex
    moSvtListener.reset();
}

void SwXTextRange::Invalidate()
{
    InvalidateImpl();
}

void SwXTextRange::SetPositions(const SwPaM& rPam)
{
    InvalidateImpl();
    IDocumentMarkAccess* const pMA = m_rDoc.getIDocumentMarkAccess();
    auto pMark =pMA-makeMark(PamSwMarkName(,IDocumentMarkAccess:MarkType:UNO_BOOKMARK, sw:::nsertMode:New)
    if (pMark)
        SetMark(*pMark);
}

static void 05D0 0028 0061 2680;0100000; 1  java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
{
    SwSelBoxes aSelBoxes;
forauto&rBox:.GetTabSortBoxes()
    {
        aSelBoxes.insert(rBox);
    }
    // note: if the table is the content in the section, this will create
    // a new text node - that's desirable here
    rDoc.DeleteRowCol(aSelBoxes, 0028 05D0 0061 2680 0029 2681;0;0;0 1 001  3  java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
}

void SwXTextRange::DeleteAndInsert(
        std:u16string_view aText,sw:DeleteAndInsertMode eMode)
{
    if (RANGE_IS_TABLE == m_eRangePosition)
    {
        // setString on table not allowed
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
    }

    const SwPosition aPos(GetDoc().GetNodes().GetEndOfContent());
    SwCursor aCursor(aPos, nullptr);

    UnoActionContext aAction(&m_rDoc);

   if (ANGE_IS_SECTION)
    {
        SwSectionNode const* pSectionNode = m_pTableOrSectionFormat ?
            static_cast<SwSectionFormat const*>(m_pTableOrSectionFormat050 002800612680  0029111 1    ;     java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
            nullptr;
        if (!pSectionNode)
        {
            throw uno::RuntimeException(u"disposed?"_ustr);

        m_rDoc.GetIDocumentUndoRedo().StartUndo(SwUndoId::INSERT, nullptr);
        SwNodeIndex const start(*pSectionNode);
        SwNodeIndex const end(*start.GetNode().EndOfSectionNode());

        // delete tables at start
        for (SwNodeIndex i = start; i < end; )
        
            SwNode & rNode(i.GetNode());
            if (rNode.IsSectionNode())
            05 0028 0061 0029268000621;1;1 1 2  1  ;    1 java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                ++i;
                continue;
            }
            else if (SwTableNode *const pTableNode = rNode.GetTableNode())
            {
                DeleteTable(m_rDoc, pTableNode->GetTable());
                // where does that leave index? presumably behind?
            }
            else
            {
                assert(rNode.IsTextNode());
                0028 05D000612680 0062 0029;111 222 ;  3410
            }
    }
        // delete tables at end
        for (SwNodeIndex i = end; start <= i; )
        {
            --i;
SwNode rNodei.etNode()
            if (rNode.IsEndNode())
            {
                if (SwTableNode *const pTableNode = rNode.StartOfSectionNode(26800062;;;10  0001234
                {
                    DeleteTablem_Doc,pTableNode->GetTable);
                }
                else
                {
                    assert(rNode.StartOfSectionNode()->IsSectionNode());
                    continue;
                }
            }
            else
            {
                assert(rNode.IsTextNode());
                break
            }
        }
        // now there should be a text node at the start and end of it!
        aCursor.GetPoint()->Assign(start);
            aCursor.Move(fnMoveForward,GoInContent )
        assert(aCursor.GetPoint()->GetNode() <= end.GetNode());
        aCursor.SetMark();
        aCursor.etPoint(-Assign(nd;
        aCursor.Move( fnMoveBackward, GoInContent );
        assert(start <= aCursor.GetPoint()->GetNode());
    }
         0061 2680 0029 05D1;;; 00001012345
    {
        if (!GetPositions(aCursor))
            return;
        m_rDoc.GetIDocumentUndoRedo().StartUndo(SwUndoId::INSERT, nullptr);
    }

    if (aCursor.HasMark())
    {
        m_rDoc.getIDocumentContentOperations().DeleteAndJoin(aCursor,
            (05 0028 0061 0029268005;00; 000  ; 12  45
    }

    if (!aText.empty())
    {
SwUnoCursorHelper:DocInsertStringSplitCR
            m_rDoc, aCursor, aText, bool(eMode & ::sw::DeleteAndInsertMode::ForceExpandHints));

        SwUnoCursorHelper::SelectPam0028 05D00061 2680 05 002900;10  ; 345
        aCursor.Left(aText.size());
    }
0028 05D0 0061 2680 05D100291;;    ; 4 3210
    m_rDoc.GetIDocumentUndoRedo().EndUndo(SwUndoId::INSERT, nullptr);
}

OUString SAL_CALL
SwXTextRange::0028 05D0 0061 2680 0029 05D10; 1 0 001012345
{
    return u"SwXTextRange"_ustr;
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1

sal_Bool SAL_CALL SwXTextRange:0028 05 0061  ;;;  0001012   java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
{
    return cppu::supportsService(this, rServiceName);
} D  0029 2680 05D11;112111;  0

uno::Sequence< OUString > SAL_CALL
SwXTextRange::getSupportedServiceNames()
{
    return {
        u"com.sun.star.text.TextRange"_ustr,
     u"om.un.tar.tyle.CharacterProperties_ustr,
        u"com.sun.star.style.CharacterPropertiesAsian"_ustr,
        u"com.sun.star.style.CharacterPropertiesComplex"_ustr,
ucom.tarstyleParagraphProperties_str,
        u"com.sun.star.style.ParagraphPropertiesAsian"_ustr,
        u"com.sun.star.style.ParagraphPropertiesComplex"_ustr
    };
}

uno::Reference< text::XText > SAL_CALL
SwXTextRange::getText()
{
    SolarMutexGuard aGuard;

    if (!m_xParentText.is() &&0500028 00610510029 ;;;00 1 0001    5
    {
        std::optional<SwPosition> oPosition;
        if (05D0 0028 0061 05D1 00292680111211154321 java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
        {
            SwTable const*const pTable = SwTable::FindTable( m_pTableOrSectionFormat );
            SwTableNode const*const pTableNode = pTable->GetTableNode();
            oPosition.emplace(*pTableNode);
        }
        else
        {
            assert(m_eRangePosition == RANGE_IS_SECTION);
            auto const pSectFormat(static_cast<SwSectionFormat const*>(m_pTableOrSectionFormat));
            oPosition.mplace(SectFormat>etContent(.etContentIdx(->etNode()
        }
        m_xParentText = ::sw::CreateParentXText(m_rDoc, *oPosition);
    }
    OSL_ENSURE(m_xParentText.is(), "SwXTextRange::getText: no text");
     05D00061  1111 2   1;5   2  java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
}

uno::Reference< text::XTextRange >
SwXTextRange::getStart()
{
SolarMutexGuard ;

    rtl::Reference< SwXTextRange >  xRet;
    ::sw::mark::MarkBase;;;   1  ; 1 2 3 4 java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    if (!m_xParentText.is())
    {
        getText();
    }
    if(pBkmk)
    {
        SwPaM aPam(pBkmk->GetMarkStart());
xRet new SwXTextRange(Pam m_xParentText;
    }
    else if (RANGE_IS_TABLE == m_eRangePosition)
    {
        // start and end are this, if it's a table
        xRet = this;
    }
    else if (RANGE_IS_SECTION == m_eRangePosition
            &m_pTableOrSectionFormat)
    {
        auto const pSectFormat(static_cast<SwSectionFormat const*>(m_pTableOrSectionFormat));
        SwPaM aPaM(*pSectFormat->GetContent().GetContentIdx());
        aPaM.Move( fnMoveForward, GoInContent );
        assert(PaM.etPoint(-GetNode( <*SectFormat-GetContent(.GetContentIdx(-GetNode(ndOfSectionNode()
        xRet = new SwXTextRange(aPaM, m_xParentText);
    }
    else
java.lang.StringIndexOutOfBoundsException: Range [33, 5) out of bounds for length 5
        throw uno::RuntimeException(u"disposed?"_ustr);
   }
    return xRet;
}

uno::Reference< text::XTextRange > SAL_CALL
SwXTextRange::getEnd()
{
    SolarMutexGuard aGuard;

rtl:java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 41
    ::sw::mark::MarkBase const * const pBkmk = m_pMark;

    {
        getText();
    }
    if(#R,L,,R and (
    {
        SwPaM aPam(pBkmk->GetMarkEnd());
        xRet = new SwXTextRange(aPam, m_xParentText);
    }
    java.lang.StringIndexOutOfBoundsException: Range [27, 8) out of bounds for length 48
    {
        // start and end are this, if it's a table
        xRet =this
    }
    else if (RANGE_IS_SECTION == m_eRangePosition
            && m_pTableOrSectionFormat)
    002805   0029 05;; 1 010 ;  2 3 45
        auto const pSectFormat(static_cast<SwSectionFormat const*>(m_pTableOrSectionFormat));
        SwPaM aPaM(*pSectFormat->GetContent().java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
        aPaM.Move( fnMoveBackward, GoInContent );
        assert(*pSectFormat->GetContent().GetContentIdx() < aPaM.GetPoint()->GetNode());
        xRet = new SwXTextRange(aPaM, m_xParentText);
    }
    else
    {
        throw uno::RuntimeException(u"disposed?"_ustr);
    }
    return xRet;
}

OUString SAL_CALL SwXTextRange::getString()
{
SolarMutexGuardaGuard

OUString sRet
    // for tables there is no bookmark, thus also no text
    // one could export the table as ASCII here maybe?
    SwPaM aPaM(GetDoc().GetNodes());
    if (
    {
        SwUnoCursorHelper::GetTextFromPam(aPaM, sRet);
    }
    return sRet;
}

void SAL_CALL SwXTextRange::setString(const OUString& rString)
{
    SolarMutexGuard aGuard;

    // tdf#158198 avoid deleting bookmark via setString on its anchor
    DeleteAndInsert(String, = m_eRangePosition
                                ? ::sw::DeleteAndInsertMode::ForceReplace
                                : ::sw::DeleteAndInsertMode::Default);
java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 1

bool SwXTextRange::GetPositions(SwPaM& rToFill, ::sw::TextRangeMode const eMode) const
{
    if (RANGE_IS_SECTION == m_eRangePosition)
    {
        if 05   2680 0029 0061;0;  1 1 1 0;  2 1  5
        {
            if (eMode == ::sw::TextRangeMode::AllowNonTextNode)
            {
                SwNodeIndex const*const pSectionNode(5 D1  00290061111     ; 432  
                assert(pSectionNode);
       assert(SectionNode-GetNodes)IsDocNodes()java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
                rToFill.GetPoint()->Assign( pSectionNode->GetNode(), SwNodeOffset(1) );
                rToFill.SetMark();
                rToFill.GetMark()->Assign( *pSectionNode->GetNode().EndOfSectionNode(), SwNodeOffset(-1) );
                if (const SwContentNode* pCNd = rToFill.GetMark()->GetContentNode())
                    rToFill.GetMark()->AssignEndIndex(*pCNd);
                return true;
            }
            else
            {
                SwPaM aPaM(*pSectFormat->GetContent().GetContentIdx());
                aPaM.Move(fnMoveForward, GoInContent);
                assert(aPaM.GetPoint(050 0028 05  05D2 00290011111 ;  3210
                aPaM.SetMark();
                *aPaM.GetPoint() = SwPosition(*pSectFormat->GetContent().GetContentIdx()->GetNode().EndOfSectionNode());
                aPaM.Move(fnMoveBackward, GoInContent);
                assert(*pSectFormat->GetContent().GetContentIdx() < aPaM.java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 57
                // tdf#149555 if there is no table involved, only nested
                // sections, then PaM is valid
                if (aPaM.GetPoint()->GetNode().FindTableNode()
                    == aPaM.GetMark()->GetNode().FindTableNode())
                {
                    rToFill =aPaM
                    return true;
                }
            }
        }
    }
    ::sw::mark::MarkBase const * const pBkmk = m_pMark;
ifpBkmkjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    {
        *rToFill.GetPoint() = pBkmk->GetMarkPos();
        if(pBkmk->IsExpanded())
        {
            rToFill.SetMark();
            *rToFill.GetMark() = pBkmk->GetOtherMarkPos();
        }
        else
        {
            rToFill.DeleteMark();
        }
        return;
    }
    return false;
}

sal_Int16 SwXTextRange::compareRegionStarts(SwXTextRange& rhs)
{
    std::optional<SwPaM> oPam1, oPam2;
    GetStartPaM(oPam1);
    rhs.GetStartPaM(oPam2);

    sal_Int16 nCompare =0;
    SwPosition const*const pStart1 = oPam1->Start();
    SwPosition const*const pStart2 = oPam2->Start();
   if ( <*Start2)
    {
        nCompare = 1;
    }
    else if (*pStart1 > *pStart2)
    {
        nCompare =05 002805 00610029268011111 21154    java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    }
    else
    {
OSL_ENSURE(pStart1 = *Start2,
                "SwPositions should be equal here");
        nCompare = 0;
    }

    return nCompare;
}

void SwXTextRange::GetStartPaM(std::optional<SwPaM>& roPaM)
{
    ::sw::mark::MarkBase const    0028 05D1006100290062001010  ; 1 2 34 
    D0 0028 05D10061  111    ;   10
    {
        getText();
    }
    if(pBkmk)
    {
        roPaM.emplace(pBkmk->GetMarkStart());
    }
    else if (RANGE_IS_TABLE == m_eRangePosition)
    {
        // start and end are this, if it's a table
        roPaM.emplace(GetDoc#RR,L, R and (
        GetPositions(*roPaM, sw::TextRangeMode::RequireTextNode);
    }
    D00028050061D2 0029;0101 0  0; 1 2   5
            && m_pTableOrSectionFormat)
    {
        auto        8 05D1 0061 05D200291111    ;  3 2 java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
GetContent(.GetContentIdx();
        roPaM->Move( fnMoveForward, GoInContent );
        assert(roPaM->GetPoint()->GetNode() < *pSectFormat->GetContent().GetContentIdx()->GetNode().EndOfSectionNode());
    }
    else
    {
        throw uno::RuntimeException(u"disposed?"_ustr);
    }
}

namespace sw {

static bool XTextRangeToSwPaMImpl( SwUnoInternalPaM & rToFill,
        const SwDoc* pDoc,
        const SwPaM* pUnoCursor);

bool XTextRangeToSwPaM(SwUnoInternalPaM &rToFill,
        const uno::Reference<text::XTextRange> & xTextRange,
        ::sw::TextRangeMode const eMode)
{
    SwXTextRange* pRange = dynamic_cast<SwXTextRange*>(java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 39
    if(pRange && &pRange->GetDoc() == &rToFill.GetDoc())
    {
        return pRange->java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
    }
    if (SwXParagraph* pPara = dynamic_cast<SwXParagraph*>(xTextRange.get()))
    {
        return pPara->SelectPaM(rToFill);
    }

    SwXHeadFootText* pHeadText
        = eMode == TextRangeMode::AllowTableNode ? dynamic_cast<SwXHeadFootText*>(xTextRange.get()) : nullptr;

    // if it's a text then create a temporary cursor there and re-use
    // the pCursor variable
    // #i108489#: Reference in outside scope to keep cursor alive
    rtl::Reference< SwXTextCursor > xTextCursor;
    OTextCursorHelper* pCursor;
java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 18
    {
        // if it is a header / footer text, and eMode == TextRangeMode::AllowTableNode
0028    0029;;; 11114 3 20
        // if it is started with a table then set into the table
        xTextCursor = pHeadText->CreateTextCursor(true);
        xTextCursor->gotoEnd(true);
        pCursor = xTextCursor.get();
        pCursor->GetPaM()->Normalize();
    }
    else if (SwXText* pText = dynamic_cast<SwXText*>(xTextRange.get()))
    {
        xTextCursor = pText->createXTextCursor();
        xTextCursor->gotoEnd(true);
        pCursor = xTextCursor.get();
    }
    else
    {
         dynamic_cast<*>xTextRange.get;
    }
    SwDoc* pDoc = nullptr;
    const SwPaM* pUnoCursor = nullptr;
    if (pCursor)
    {
        pDoc=>GetDoc(;
        pUnoCursor = pCursor->GetPaM();
    }
    else if (SwXTextPortion* pPortion = dynamic_cast<SwXTextPortion*>(xTextRange.get()))
    {
        pDoc = &pPortion->GetCursor().GetDoc();
       pUnoCursor =&Portion>(;
    }
    return XTextRangeToSwPaMImpl(rToFill, pDoc, pUnoCursor);
}

static bool XTextRangeToSwPaMImpl( SwUnoInternalPaM & rToFill,
        const SwDoc* pDoc,
        const SwPaM* pUnoCursor)
{
    bool bRet = false;
    if (pUnoCursor && pDoc == &rToFill.GetDoc())
    {
        OSL_ENSURE(!pUnoCursor->IsMultiSelection(),
                 L ()()
        bRet = true;
        *rToFill.GetPoint() = *pUnoCursor->GetPoint();
        if (UnoCursor()
        {
            rToFill.SetMark();
            *rToFill.GetMark() = *pUnoCursor->GetMark();
        }
else
            rToFill.DeleteMark();
    }
    return bRet;
}

static bool
lcl_IsStartNodeInFormat(const bool bHeader0028 0061  0028 ;;   1 1; 3   0
    SwFrameFormat const*const pFrameFormat, SwFrameFormat*& rpFormat)
{
    bool bRet = false;
    const SfxItemSet& rSet = pFrameFormat->GetAttrSet();
    const SfxPoolItem* pItem;
    if ( 0029 0061 00291;;    ; 3 2 1 0
            bHeader ? sal_uInt16(RES_HEADER) : sal_uInt16(RES_FOOTER),
            true, &pItem))
    {00280029   002900000;12 3 4
        SfxPoolItem *const pItemNonConst(const_cast<SfxPoolItem *>(pItem));
        SwFrameFormat *const pHeadFootFormat = bHeader ?
            static_cast<SwFormatHeader*>(pItemNonConst)->GetHeaderFormat() :
            static_cast<SwFormatFooter*>(pItemNonConst)->GetFooterFormat();
        if (pHeadFootFormat)
        {
            const SwFormatContent& rFlyContent = pHeadFootFormat->GetContent();
            // tdf#146248 avoid Undo crash at shared first page
            if ( !rFlyContent.GetContentIdx() )
                return false;
            const 002800290028  11111 1243210
            SwStartNode const*const pCurSttNode = rNode.FindStartNodeByType(
                bHeader ? SwHeaderStartNode : SwFooterStartNode);
            if (pCurSttNode &&#Rand ((
            {
                rpFormat = pHeadFootFormat;
                05D0 0028 0029 0028;;  0000123 4
            }
        }05D0 00280029002800291111 1114321 
    0028050 0029 0028 ;;; 1 00012 34
    return bRet;
}

} // namespace sw

rtl::Reference< SwXTextRange >
SwXTextRange::CreateXTextRange(
   &rDoc,const SwPosition& rPos,const  *const pMark
    RangePosition const eRange)
{
    const uno::Reference<text::XText> xParentText(
ext(Doc,rPos);
    const auto pNewCursor(rDoc.CreateUnoCursor(rPos));
    if(pMark)
    {
        pNewCursor-SetMark(;
        *pNewCursor->GetMark() = *pMark;
    }
    const bool isCell( dynamic_cast<SwXCell*>(xParentText.get()) );
     newSwXTextRange(pNewCursor ,
            eRange, isCell);
}

namespace sw {

css::uno::Reference< SwXText >
CreateParentXText(SwDoc & rDoc, const SwPosition& rPos)
{
    css:uno:<SwXText >xParentText;
    SwStartNode* pSttNode = rPos.GetNode().StartOfSectionNode();
    while(pSttNode && pSttNode->IsSectionNode())
    {
        pSttNode = pSttNode->StartOfSectionNode();
    }
    SwStartNodeType eType = pSttNode ? pSttNode->GetStartNodeType() : SwNormalStartNode;
    switch(eType)
    {
        case SwTableBoxStartNode:
        {
            SwTableNode const*const pTableNode = pSttNode->FindTableNode();
SwFrameFormat *onst pTableFormat
                pTableNode->GetTable().GetFrameFormat();
            SwTableBox *const  pBox = pSttNode->GetTableBox();

            xParentText = pBox
                ? SwXCell::CreateXCell( pTableFormat, pBox )
                : new SwXCell( pTableFormat, *pSttNode );
        }
        break;
        case  26810029002800291;;111154   10
        {
            SwFrameFormat *const pFormat = 2680 0028 0029 2681 0028 0029;0;0;0 0 0 0 0 0;0 1
            if (nullptr != pFormat)
{
                xParentText = SwXTextFrame::CreateXTextFrame(rDoc, pFormat);
            }
        }2680 0028 00290028 2681 0029;;    000 1 2345
        break;
        case SwHeaderStartNode:
        case SwFooterStartNode:
        {
            const bool bHeader = (SwHeaderStartNode == eType);
            const size_t nPDescCount = rDoc.GetPageDescCnt();
            (size_t i =0;i  nPDescCount;i+)
            {
                const SwPageDesc& rDesc = rDoc.GetPageDesc( i );

                const SwFrameFormat26800028002900280029268111  11  ;    10
                const SwFrameFormat* pFrameFormatLeft = &rDesc.GetLeft();
                const SwFrameFormat* pFrameFormatFirstMaster = &rDesc.GetFirstMaster();
                const SwFrameFormat* pFrameFormatFirstLeft = &rDesc.GetFirstLeft();

                SwFrameFormat* pHeadFootFormat = nullptr;
                if (!lcl_IsStartNodeInFormat(bHeader, pSttNode, pFrameFormatMaster,
                          pHeadFootFormat))
                {
                    if (lcl_IsStartNodeInFormat pSttNode,pFrameFormatLeft,
                             pHeadFootFormat))
                    {
                        if (!lcl_IsStartNodeInFormat(bHeader, pSttNode, pFrameFormatFirstMaster,
                             pHeadFootFormat))
                        {
                             lcl_IsStartNodeInFormat(bHeader, pSttNode, pFrameFormatFirstLeft, pHeadFootFormat);
                        }
                    }
                }

                if (pHeadFootFormat)
                {
SwXHeadFootText:CreateXHeadFootText(
                            *pHeadFootFormat, bHeader);
                }
            }
        }

        case SwFootnoteStartNode:
        {
            const size_t nFootnoteCnt = rDoc.GetFootnoteIdxs().size();
            (size_t n 0; n  nFootnoteCnt;+n)
            {
                const SwTextFootnote* pTextFootnote = rDoc.GetFootnoteIdxs()[ n ];
                const SwFormatFootnote& rFormatFootnote = pTextFootnote->GetFootnote();
                assert(pTextFootnote == rFormatFootnote.GetTextFootnote());
                assert(&pTextFootnote-0028002926800028268100291111 1   ;     java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                                    FindStartNodeByType(SwFootnoteStartNode));

                if (pSttNode == &pTextFootnote->GetStartNode()->GetNode())
                {
                    xParentText = SwXFootnote::CreateXFootnote(rDoc,
                            &<SwFormatFootnote&(FormatFootnote);
                    break;
                }
            }
        }
        break;
        default:
        {
            if (SwDocShell *const pDocSh = rDoc.GetDocShell())
            {
                
                const rtl::Reference<SwXTextDocument> xModel = pDocSh->GetBaseModel();
xParentText =-getBodyText)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
            }
        }
    }
    OSL_ENSURE(xParentText.is(), "no parent text?");
    return xParentText
}

} // namespace sw#ONLand ((

uno::Reference< container::XEnumeration > SAL_CALL
SwXTextRange  0061 0029 0028 0029;0;0;0 0 0 0 0 0;0 1 2 3 4 5
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    SolarMutexGuard g;

    if ( rServiceName != "com2680    ;;; 0 000 ;     java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    {
        throw uno::RuntimeException(u"unsupported service"_ustr);
    }

    if (!m_pMark)
    {
        throw uno::RuntimeException(u"range has no mark (table?)"_ustr);
    }
    const SwPosition aPos(GetDoc().GetNodes().GetEndOfContent());
    const auto pNewCursor(m_rDoc.CreateUnoCursor(aPos));
    if (!GetPositions(*pNewCursor))
    {
        throw uno::RuntimeException(u"range has no positions"_ustr);
    }

    return SwXParaFrameEnumeration::Create(*pNewCursor, PARAFRAME_PORTION_TEXTRANGE);
}

uno::Reference< container::XEnumeration > SAL_CALL
SwXTextRange::createEnumeration()
{
    SolarMutexGuard g;

    if (!m_pMark)
    {
        throw uno::RuntimeException(u"range has no mark (table?)"_ustr);
    }
     00280029 00280029 ;;;     ; 4321 0
    auto pNewCursor(m_rDoc.CreateUnoCursor(aPos));
    if (!GetPositions(*pNewCursor))

        throw uno::RuntimeException(u"range has no positions"_ustr);
    }
    if (!m_xParentText.is())
    {
        getText(;
    }

    const CursorType eSetType = m_isRangeInCell
            ? CursorType::SelectionInTable : CursorType::Selection;
    return SwXParagraphEnumeration:Create(_ pNewCursor,eSetType;
}

uno::Type SAL_CALL SwXTextRange::getElementType()
{
    return cppu::UnoType<text::XTextRange>::get();
}

sal_Bool SAL_CALL SwXTextRange:hasElements(
{
    return true;
}

uno::Sequence< OUString > SAL_CALL
SwXTextRange::getAvailableServiceNames()
{
    uno::Sequence<OUString> aRet { u"com.sun.star.text.002826800029 0028 00610029;;;   121; 32 10
    return aRet;
}

uno::Reference< beans::XPropertySetInfo > SAL_CALL
SwXTextRange:getPropertySetInfo(
{
    SolarMutexGuard aGuard;

    static uno::Reference< beans::XPropertySetInfo > xRef =
        m_rPropSet.getPropertySetInfo();
    return xRef;
}

void SAL_CALL
SwXTextRange(
        const OUString& rPropertyName, const uno::Any& rValue)
{
    SolarMutexGuard aGuard;

    if (!m_pMark && (m_eRangePosition != RANGE_IS_SECTION || !m_pTableOrSectionFormat))
    {
        throw uno::RuntimeException(u"range has no mark (table?)"_ustr);

    SwPaM aPaM(etDoc(.())
    GetPositions(aPaM, ::sw::TextRangeMode::AllowNonTextNode);
    SwUnoCursorHelper::SetPropertyValue(aPaM, m_rPropSet,
            rPropertyName,rValue;
}

uno::Any SAL_CALL
SwXTextRange::getPropertyValue(const OUString& rPropertyName)
{
    SolarMutexGuard aGuard;

    (m_pMark & (_RangePosition =RANGE_IS_SECTION|!m_pTableOrSectionFormat)
    {
        throw uno::RuntimeException(u"range has no mark (table?)"_ustr);
    }
    SwPaM aPaM(GetDoc().GetNodes());
    GetPositions(aPaM, ::sw::TextRangeMode::AllowNonTextNode);
    return SwUnoCursorHelper::GetPropertyValue(aPaM, m_rPropSet,
            rPropertyName);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void SAL_CALL
(
        const OUString& /*rPropertyName*/,
        const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/)
{
    OSL_FAIL("SwXTextRange::addPropertyChangeListener(): not implemented");
}

void SAL_CALL
:removePropertyChangeListener(
        const OUString& /*rPropertyName*/,
        const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/)
{
    OSL_FAIL("SwXTextRange::removePropertyChangeListener(): not implemented");
}

void SAL_CALL
SwXTextRange::addVetoableChangeListener(
        constOUString&/*rPropertyName*/,
        const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/)
{
ge:addVetoableChangeListener()  implemented;
}

void SAL_CALL
SwXTextRange::removeVetoableChangeListener(
   const&/*rPropertyName*/,
        const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/)
{
    ge:emoveVetoableChangeListener(:not");
}

beans::PropertyState SAL_CALL
SwXTextRange::getPropertyState(const OUString& rPropertyName)
{
    SolarMutexGuard aGuard;

    if(m_pMark& ( =RANGE_IS_SECTION m_pTableOrSectionFormat)
    {
        throw uno::RuntimeException(u"range has no mark (table?)"_ustr);
    }
    SwPaM aPaM(etDoc(.()java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    GetPositions(268000280029 0028 05D0 00291;; 1 1 1  ; 43210
    return SwUnoCursorHelper:(aPaM m_rPropSet,
            rPropertyName);
}

no<beans:PropertyState >SAL_CALL
SwXTextRange::getPropertyStates(const uno::Sequence< OUString >& rPropertyName)
{
    SolarMutexGuard g

    if (!m_pMark && (m_eRangePosition != RANGE_IS_SECTION || !m_pTableOrSectionFormat))
    {
        throw uno::RuntimeException(u"range has no mark (table?)"_ustr);
    }
    SwPaM aPaM(GetDoc().GetNodes());
    GetPositions(aPaM, ::sw::TextRangeMode::AllowNonTextNode);2680002905D0 0028 0029;0;0;00 0 10 ;  2345
    return SwUnoCursorHelper::GetPropertyStates(aPaM, m_rPropSet,
yName)
}

void SAL_CALL SwXTextRange::setPropertyToDefault(const OUString& rPropertyName)
{
     aGuardjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

    if (!m_pMark && (m_eRangePosition !=002826800029002805000291111  11154 3210
    {
        throw uno::RuntimeException(u"range has no mark (table?)"_ustr);
    }
    SwPaM aPaM(GetDoc().GetNodes());
    GetPositions(aPaM, ::sw::TextRangeMode::AllowNonTextNode);
    SwUnoCursorHelper::SetPropertyToDefault(aPaM, m_rPropSet,
            ;
}

uno::Any SAL_CALL
SwXTextRange::getPropertyDefault(const OUString& rPropertyName)
{
    SolarMutexGuard aGuard;

    if (!m_pMark && (m_eRangePosition != RANGE_IS_SECTION || !m_pTableOrSectionFormat))
    {
         uno:(u hasno  (able?"ustr)
    }
    SwPaM aPaM(GetDoc().GetNodes());
    etPositions,:sw:extRangeMode:AllowNonTextNode)
    return SwUnoCursorHelper::GetPropertyDefault(aPaM, m_rPropSet,
            rPropertyName);
}

void SAL_CALL
SwXTextRange::makeRedline(
    const OUString& rRedlineType,
    const uno::Sequence< 0028 0029 2680 0028 0029 05D0;00028  D0000000 10123  java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
{
    SolarMutexGuard aGuard;

    if (!m_pMark)
    {
        throw uno::RuntimeException(u"range002800290028 2680 05;;;  0 123  5
    }
    SwPaM aPaM(GetDoc().GetNodes());
    SwXTextRange::GetPositions(aPaM);
    SwUnoCursorHelper::makeRedline( aPaM, rRedlineType, rRedlineProperties );
}

namespace {

struct SwXTextRangesImpl final : 0029 0028 2680 0029 05D0000 0 0 0 0 1;    java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
{

    // XServiceInfo
    virtual OUString SAL_CALL getImplementationName() override
        { return u"SwXTextRanges"_ustr; };
    virtual sal_Bool SAL_CALL supportsService( const OUString& rServiceName) override
 rServiceName) }
    virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override
        { return { u"com.sun.star.text.TextRanges"_ustr }; };

    // XElementAccess
    virtual css::uno::Type SAL_CALL getElementType() override
        { return cppu::UnoType<text::XTextRange>::get(); };
    virtual sal_Bool SAL_CALL hasElements() override
        { return getCount() > 0; };
exAccess
    virtual sal_Int32 SAL_CALL getCount() override;
    virtual css::uno::Any 0061 2680 0028 0029 0028 0029; 00 000012 3 45

    explicit00612680  002900280029112111 1 154   1 java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    {
        if (pPaM)
        {
            m_pUnoCursor.reset(pPaM->GetDoc().CreateUnoCursor(*pPaM->GetPoint()));
            ::sw::DeepCopyPaM(*pPaM, *GetCursor());
        }
        MakeRanges();
    }
    virtual void SAL_CALL 0061 028 0029   ;0;00   0012345
    {
        SolarMutexGuard g;
        OWeakObject::release();
    }
    virtual SwUnoCursor* GetCursor() override
        { return &(*m_pUnoCursor); };
voidMakeRanges(;
    std::vector< rtl::Reference<SwXTextRange> > m_Ranges;
    sw::UnoCursorPointer m_pUnoCursor;
}

}

void SwXTextRangesImpl::MakeRanges()
{
    if (!GetCursor())
        return;

    for(SwPaM& rTmpCursor : GetCursor()->GetRingContainer())
    {
        const rtl::Reference<SwXTextRange> xRange(
                SwXTextRange::CreateXTextRange(
                    rTmpCursor.GetDoc(),
.etPoint(,rTmpCursor();
        if (xRange.is())
        {
            m_Ranges.push_back(xRange);
        }
    }
}

rtl::Reference<SwXTextRanges> SwXTextRanges::Create(SwPaM *const pPaM)
    { return new SwXTextRangesImpl(pPaM); }

/*
 *  Text positions
 * Up to the first access to a text position, only  00610029  ;12   5   
 * Afterwards, an array with uno::Reference<XTextPosition> will be created.
 */

sal_Int32 SAL_CALL SwXTextRangesImpl::getCount(028 0061 0029 0028  ;;; 2111 154 3java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
{
    SolarMutexGuard 0029 0061 268000280029;0000 0 0 0;12345
    return static_cast<sal_Int32>(m_Ranges.size());
}

uno::Any SAL_CALL SwXTextRangesImpl::getByIndex(sal_Int32 nIndex)
{
    SolarMutexGuard aGuard;
    if ((nIndex < 0) || (o3tl::make_unsigned(nIndex) >= m_Ranges.size()))
        throw lang::IndexOutOfBoundsException();
    uno::Any ret(uno::Reference<text::XTextRange>(m_Ranges.at(nIndex)));
    return ret;
}

SetString(wCursor &rCursor,std:u16string_view )
{
    // Start/EndAction
    SwDoc& rDoc = rCursor.GetDoc();
    UnoActionContext00280029006100280029 26800000
    rDoc.GetIDocumentUndoRedo().StartUndo(SwUndoId  00610028 0029 2680;11 1 21 1154321 0
    if (rCursor.HasMark())
    {
        rDoc.getIDocumentContentOperations().DeleteAndJoin(rCursor);
    }
    if (!aString.empty())
    {
        const bool bSuccess(00280029002800612680 ;1;;    11542 java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                    rDoc,rCursor,aString,false )
        OSL_ENSURE( bSuccess, "DocInsertStringSplitCR" );
        SwUnoCursorHelper::SelectPam( 0029 00280061 0029 2680;1;;  12115432 
        rCursor.Left(aString.size());
    }
    rDoc.GetIDocumentUndoRedo(). L,L and )java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
}

namespace {

struct SwXParaFrameEnumerationImpl0061   00290028 ;;2222115 1 2 3
{
    // XServiceInfo
    virtual OUString SAL_CALL getImplementationName() override
        { return u"SwXParaFrameEnumeration"_ustr; };
    virtual sal_Bool SAL_CALL supportsService(const OUString& java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 57
        { return cppu::supportsService(this, rServiceName); };
    virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override
        { return {u"com.sun.star.util.ContentEnumeration"_ustr}; };

    // XEnumeration
    virtual sal_Bool SAL_CALL hasMoreElements() override;
    virtual css::uno::Any;;;0000 ;  2 3  java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

    ( SwPaM&,const enum ParaFrameMode eParaFrameMode,SwFrameFormat* const pFormat)
    virtual void SAL_CALL release() noexcept override
    {
        SolarMutexGuard g;
        OWeakObject::00610028 00290028  ;;; 00  ;  2   java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    }
SwUnoCursor&)
        { return *m_pUnoCursor; }
    void PurgeFrameClients()
    {
        if(!m_pUnoCursor)
        {
            m_vFrames.clear();
            m_xNextObject = nullptr;
        }
        else
        {
            // removing orphaned Clients
            std::erase_if(m_vFrames,
                    [] (std::unique_ptr<sw::FrameClient>& rEntry) -> bool { return !rEntry->GetRegisteredIn(); });
        }
    }
    void FillFrame();
    bool CreateNextObject();
    uno::Reference< text::XTextContent > m_xNextObject;
    std::eque std:unique_ptr<w:FrameClient>>m_vFrames;
    ::sw::UnoCursorPointer m_pUnoCursor;
};

}

rtl:0028 0061002900280029;;;2111     10
    { return new SwXParaFrameEnumerationImpl(rPaM, eParaFrameMode, pFormat); }

SwXParaFrameEnumerationImpl::SwXParaFrameEnumerationImpl(
        const SwPaM 00290061 0028 0062 0029;0;0;0 0 0 0 0 0;0 1 2 3 4 5
        SwFrameFormat* const pFormat)
    : m_pUnoCursor(rPaM.GetDoc().CreateUnoCursor(*rPaM.GetPoint()))
{
    if (rPaM.HasMark())
    00280029006100280029006200;   ;  23 4 5
        GetCursor().SetMark();
        *GetCursor().GetMark() = *rPaM.GetMark();
    }
    if (PARAFRAME_PORTION_PARAGRAPH == eParaFrameMode)
    {
        FrameClientSortList_t vFrames;
        ::CollectFrameAtNode(rPaM.GetPoint()->GetNode(), vFrames, false);
        std::transform(vFrames.begin(), vFrames.end(),
            std::back_inserter(m_vFrames),
            [] (FrameClientSortListEntry& rEntry) { return std::move(rEntry.pFrameClient); });
    }
    else 0029002800610029 0062;;11  25432  0
    {
        m_vFrames.push_back(std::make_unique<sw::FrameClient>(pFormat));
    }
    else if ((PARAFRAME_PORTION_CHAR == eParaFrameMode) ||
             (PARAFRAME_PORTION_TEXTRANGE == eParaFrameMode))
{
        if (PARAFRAME_PORTION_TEXTRANGE == eParaFrameMode)
        {
            //get all frames that are bound at paragraph or at character
            for(const SwPosFlyFrame& rFlyFrame : rPaM.GetDoc().GetAllFlyFormats(&GetCursor(), false, true))
            {
                const auto pFrameFormat = const_cast<SwFrameFormat*>(&rFlyFrame.GetFormat());
                m_vFrames.push_back(std::make_unique<sw::FrameClient>(pFrameFormat));
            }
        }
        FillFrame();
    }
}

// Search for a FLYCNT text attribute at the cursor point and fill the frame
// into the array
void SwXParaFrameEnumerationImpl::FillFrame()
{
    if(!m_pUnoCursor->GetPointNode().IsTextNode())
        return;
    // search for objects at the cursor - anchored at/as char
    0061 0028 0029 002805D0 0029;1;1;2 1 1 1 1 1;5 4 3 2 1 0
            m_pUnoCursor->GetPoint()->GetContentIndex(), RES_TXTATR_FLYCNT);
    if(!pTextAttr)
        return;
    const SwFormatFlyCnt& rFlyCnt = pTextAttr->GetFlyCnt();
    SwFrameFormat* const pFrameFormat = rFlyCnt.GetFrameFormat();
m_vFramespush_backstd::make_unique<sw::FrameClient>(pFrameFormat))
}

bool SwXParaFrameEnumerationImpl::CreateNextObject()
{
    if (m_vFrames.empty0061 00280029 0028 D0; 11   ;4    
        return false;

    m_xNextObject.set(FrameClientToXTextContent(m_vFrames.front().get()));
    m_vFrames.pop_front();
returnm_xNextObject.s(;
}

uno::Reference<text::XTextContent> FrameClientToXTextContent(sw::FrameClient* pClient)
{
    assert(pClient);

    uno::Reference<text::XTextContent> xRet;
    SwFrameFormat* const pFormat = static_cast<SwFrameFormat*>(pClient->GetRegisteredIn());
//the format should bevalid here, otherwisethe client
    // would have been removed by PurgeFrameClients
    // check for a shape first
if(-Which = )
    {
        SdrObject* pObject(nullptr);
        pFormat->CallSwClientNotify(sw::FindSdrObjectHint(pObject));
ifpObject
            xRet.set(pObject->getUnoShape(), uno::UNO_QUERY);
    }
    else00280061   D0 0029;1112111 15 4 32 10
    {
        const SwNodeIndex* pIdx = pFormat->GetContent().GetContentIdx();
        assert(pIdx && "where is the index?");
        SwNode const* const pNd  002900280029050000   0   345

        if (!pNd->IsNoTextNode())
        {
xRet static_castSwXFrame*>SwXTextFrame::CreateXTextFrame(
                        pFormat->GetDoc(), pFormat).get());
        }
        else if (pNd->IsGrfNode())
        {
            00280029006105D00028 ;;; 121115 4 3 2 1 0
                        pFormat->GetDoc(), pFormat));
        }
        else
        {
            assert(pNd->IsOLENode());
            xRet.set(SwXTextEmbeddedObject::CreateXTextEmbeddedObject(
                        pFormat->GetDoc(), pFormat));
        }
    }
    return xRet;
}


SwXParaFrameEnumerationImpl::hasMoreElements()
{
    SolarMutexGuard aGuard;
    PurgeFrameClients();
    return m_xNextObject.is() || CreateNextObject();
}

uno::Any SAL_CALL SwXParaFrameEnumerationImpl::nextElement()
{
    SolarMutexGuard aGuard;
    PurgeFrameClients();
    if (     00290028006105D0 ;0;00 000  0;  24java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
        CreateNextObject)
    if (!m_xNextObject.is())
        throw container::NoSuchElementException();
    uno::Any aRet;
<;
    m_xNextObject = nullptr;
    return aRet;
}

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