sw/inc/docary.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19 #ifndef INCLUDED_SW_INC_DOCARY_HXX
  20 #define INCLUDED_SW_INC_DOCARY_HXX
  21
  22 #include <vector>
  23 #include <type_traits>
  24 #include <o3tl/sorted_vector.hxx>
  25
  26 #include "fmtcol.hxx"
  27 #include "frmfmt.hxx"
  28 #include "section.hxx"
  29 #include "tox.hxx"
  30 #include "numrule.hxx"
  31 #include "fldbas.hxx"
  32
  33 class SwRangeRedline;
  34 class SwExtraRedline;
  35 class SwOLENode;
  36 class SwTable;
  37 class SwTableLine;
  38 class SwTableBox;
  39 struct SwPosition;
  40 enum class RedlineType : sal_uInt16;
  41
  42 /** provides some methods for generic operations on lists that contain SwFormat* subclasses. */
  43 class SW_DLLPUBLIC SwFormatsBase
  44 {
  45 public:
  46     virtual size_t GetFormatCount() const = 0;
  47     virtual SwFormat* GetFormat(size_t idx) const = 0;
  48     virtual ~SwFormatsBase();
  49
  50     // default linear search implementation, some subclasses will override with a more efficient search
  51     virtual SwFormat* FindFormatByName(const OUString& rName) const;
  52     virtual void Rename(const SwFrameFormat&, const OUString&) {};
  53
  54     SwFormatsBase() = default;
  55     SwFormatsBase(SwFormatsBase const &) = default;
  56     SwFormatsBase(SwFormatsBase &&) = default;
  57     SwFormatsBase & operator =(SwFormatsBase const &) = default;
  58     SwFormatsBase & operator =(SwFormatsBase &&) = default;
  59 };
  60
  61 template<typename Value>
  62 class SwVectorModifyBase
  63 {
  64 public:
  65     typedef typename std::vector<Value>::iterator iterator;
  66     typedef typename std::vector<Value>::const_iterator const_iterator;
  67     typedef typename std::vector<Value>::size_type size_type;
  68     typedef typename std::vector<Value>::value_type value_type;
  69
  70 protected:
  71     enum class DestructorPolicy {
  72         KeepElements,
  73         FreeElements,
  74     };
  75
  76 private:
  77     typename std::vector<Value> mvVals;
  78     const DestructorPolicy mPolicy;
  79
  80 protected:
  81     // default destructor deletes all contained elements
  82     SwVectorModifyBase(DestructorPolicy policy = DestructorPolicy::FreeElements)
  83         : mPolicy(policy) {}
  84
  85 public:
  86     bool empty() const { return mvVals.empty(); }
  87     Value const& front() const { return mvVals.front(); }
  88     size_t size() const { return mvVals.size(); }
  89     iterator begin() { return mvVals.begin(); }
  90     const_iterator begin() const { return mvVals.begin(); }
  91     iterator end() { return mvVals.end(); }
  92     const_iterator end() const { return mvVals.end(); }
  93     void clear() { mvVals.clear(); }
  94     iterator erase(iterator aIt) { return mvVals.erase(aIt); }
  95     iterator erase(iterator aFirst, iterator aLast) { return mvVals.erase(aFirst, aLast); }
  96     iterator insert(iterator aIt, Value const& rVal) { return mvVals.insert(aIt, rVal); }
  97     template<typename TInputIterator>
  98     void insert(iterator aIt, TInputIterator aFirst, TInputIterator aLast)
  99     {
 100         mvVals.insert(aIt, aFirst, aLast);
 101     }
 102     void push_back(Value const& rVal) { mvVals.push_back(rVal); }
 103     void reserve(size_type nSize) { mvVals.reserve(nSize); }
 104     Value const& at(size_type nPos) const { return mvVals.at(nPos); }
 105     Value const& operator[](size_type nPos) const { return mvVals[nPos]; }
 106     Value& operator[](size_type nPos) { return mvVals[nPos]; }
 107
 108     // free any remaining child objects based on mPolicy
 109     virtual ~SwVectorModifyBase()
 110     {
 111         if (mPolicy == DestructorPolicy::FreeElements)
 112             for(const_iterator it = begin(); it != end(); ++it)
 113                 delete *it;
 114     }
 115
 116     //TODO: These functions are apparently brittle (but the copy functions are actually used by the
 117     // code; the move functions will be implicitly-defined as deleted anyway) and should probably
 118     // only be used with DestructorPolicy::KeepELements:
 119     SwVectorModifyBase(SwVectorModifyBase const &) = default;
 120     SwVectorModifyBase(SwVectorModifyBase &&) = default;
 121     SwVectorModifyBase & operator =(SwVectorModifyBase const &) = default;
 122     SwVectorModifyBase & operator =(SwVectorModifyBase &&) = default;
 123
 124     void DeleteAndDestroy(int aStartIdx, int aEndIdx)
 125     {
 126         if (aEndIdx < aStartIdx)
 127             return;
 128         for (const_iterator it = begin() + aStartIdx;
 129                             it != begin() + aEndIdx; ++it)
 130             delete *it;
 131         erase( begin() + aStartIdx, begin() + aEndIdx);
 132     }
 133
 134     size_t GetPos(Value const& p) const
 135     {
 136         const_iterator const it = std::find(begin(), end(), p);
 137         return it == end() ? SIZE_MAX : it - begin();
 138     }
 139
 140     /// check that given format is still alive (i.e. contained here)
 141     bool IsAlive(typename std::remove_pointer<Value>::type const*const p) const
 142         { return std::find(begin(), end(), p) != end(); }
 143
 144     static void dumpAsXml(xmlTextWriterPtr /*pWriter*/) {};
 145 };
 146
 147 template<typename Value>
 148 class SwFormatsModifyBase : public SwVectorModifyBase<Value>, public SwFormatsBase
 149 {
 150 protected:
 151     SwFormatsModifyBase(typename SwVectorModifyBase<Value>::DestructorPolicy
 152             policy = SwVectorModifyBase<Value>::DestructorPolicy::FreeElements)
 153         : SwVectorModifyBase<Value>(policy) {}
 154
 155 public:
 156     virtual size_t GetFormatCount() const override
 157         { return SwVectorModifyBase<Value>::size(); }
 158
 159     virtual Value GetFormat(size_t idx) const override
 160         { return SwVectorModifyBase<Value>::operator[](idx); }
 161
 162     size_t GetPos(const SwFormat *p) const
 163         { return SwVectorModifyBase<Value>::GetPos( static_cast<Value>( const_cast<SwFormat*>( p ) ) ); }
 164
 165     // Override return type to reduce casting
 166     virtual Value FindFormatByName(const OUString& rName) const override
 167     { return static_cast<Value>(SwFormatsBase::FindFormatByName(rName)); }
 168 };
 169
 170 class SwGrfFormatColls final : public SwFormatsModifyBase<SwGrfFormatColl*>
 171 {
 172 public:
 173     SwGrfFormatColls() : SwFormatsModifyBase( DestructorPolicy::KeepElements ) {}
 174 };
 175
 176
 177 /// Unsorted, undeleting SwFrameFormat vector
 178 class SwFrameFormatsV final : public SwFormatsModifyBase<SwFrameFormat*>
 179 {
 180 public:
 181     SwFrameFormatsV() : SwFormatsModifyBase( DestructorPolicy::KeepElements ) {}
 182 };
 183
 184 class SwTextFormatColls final : public SwFormatsModifyBase<SwTextFormatColl*>
 185 {
 186 public:
 187     SwTextFormatColls() : SwFormatsModifyBase( DestructorPolicy::KeepElements ) {}
 188     void dumpAsXml(xmlTextWriterPtr pWriter) const;
 189 };
 190
 191 /// Array of Undo-history.
 192 class SwSectionFormats final : public SwFormatsModifyBase<SwSectionFormat*>
 193 {
 194 public:
 195     void dumpAsXml(xmlTextWriterPtr pWriter) const;
 196 };
 197
 198 class SwFieldTypes : public std::vector<std::unique_ptr<SwFieldType>> {
 199 public:
 200     void dumpAsXml(xmlTextWriterPtr pWriter) const;
 201 };
 202
 203 class SwTOXTypes : public std::vector<std::unique_ptr<SwTOXType>> {};
 204
 205 class SwNumRuleTable final : public SwVectorModifyBase<SwNumRule*> {
 206 public:
 207     void dumpAsXml(xmlTextWriterPtr pWriter) const;
 208 };
 209
 210 struct CompareSwRedlineTable
 211 {
 212     bool operator()(SwRangeRedline* const &lhs, SwRangeRedline* const &rhs) const;
 213 };
 214
 215 // Notification type for notifying about redlines to LOK clients
 216 enum class RedlineNotification { Add, Remove, Modify };
 217
 218 class SwRedlineTable
 219 {
 220 public:
 221     typedef o3tl::sorted_vector<SwRangeRedline*, CompareSwRedlineTable,
 222                 o3tl::find_partialorder_ptrequals> vector_type;
 223     typedef vector_type::size_type size_type;
 224     static constexpr size_type npos = SAL_MAX_INT32;
 225 private:
 226     vector_type maVector;
 227     /// Sometimes we load bad data, and we need to know if we can use
 228     /// fast binary search, or if we have to fall back to a linear search
 229     bool m_bHasOverlappingElements = false;
 230 public:
 231     ~SwRedlineTable();
 232     bool Contains(const SwRangeRedline* p) const { return maVector.find(const_cast<SwRangeRedline*>(p)) != maVector.end(); }
 233     size_type GetPos(const SwRangeRedline* p) const;
 234
 235     bool Insert(SwRangeRedline*& p);
 236     bool Insert(SwRangeRedline*& p, size_type& rInsPos);
 237     bool InsertWithValidRanges(SwRangeRedline*& p, size_type* pInsPos = nullptr);
 238     bool HasOverlappingElements() const { return m_bHasOverlappingElements; }
 239
 240     void Remove( size_type nPos );
 241     void Remove( const SwRangeRedline* p );
 242     void DeleteAndDestroy(size_type nPos);
 243     void DeleteAndDestroyAll();
 244
 245     void dumpAsXml(xmlTextWriterPtr pWriter) const;
 246
 247     size_type FindNextOfSeqNo( size_type nSttPos ) const;
 248     size_type FindPrevOfSeqNo( size_type nSttPos ) const;
 249     /** Search next or previous Redline with the same Seq. No.
 250        Search can be restricted via Lookahead.
 251        Using 0 makes search the whole array. */
 252     size_type FindNextSeqNo( sal_uInt16 nSeqNo, size_type nSttPos ) const;
 253     size_type FindPrevSeqNo( sal_uInt16 nSeqNo, size_type nSttPos ) const;
 254
 255     /**
 256      Find the redline at the given position.
 257
 258      @param tableIndex position in SwRedlineTable to start searching at, will be updated with the index of the returned
 259                        redline (or the next redline after the given position if not found)
 260      @param next true: redline starts at position and ends after, false: redline starts before position and ends at or after
 261     */
 262     const SwRangeRedline* FindAtPosition( const SwPosition& startPosition, size_type& tableIndex, bool next = true ) const;
 263     // is there a redline with the same text content from the same author (near the redline),
 264     // but with the opposite type (Insert or Delete). It's used to recognize tracked text moving.
 265     bool isMoved(size_type tableIndex) const;
 266
 267     bool                        empty() const { return maVector.empty(); }
 268     size_type                   size() const { return maVector.size(); }
 269     SwRangeRedline*             operator[]( size_type idx ) const { return maVector[idx]; }
 270     vector_type::const_iterator begin() const { return maVector.begin(); }
 271     vector_type::const_iterator end() const { return maVector.end(); }
 272     void                        Resort() { maVector.Resort(); }
 273
 274     // Notifies all LOK clients when redlines are added/modified/removed
 275     static void                 LOKRedlineNotification(RedlineNotification eType, SwRangeRedline* pRedline);
 276
 277 private:
 278     void CheckOverlapping(vector_type::const_iterator it);
 279 };
 280
 281 /// Table that holds 'extra' redlines, such as 'table row insert/delete', 'paragraph moves' etc...
 282 class SwExtraRedlineTable
 283 {
 284 private:
 285     std::vector<SwExtraRedline*>    m_aExtraRedlines;
 286
 287 public:
 288     ~SwExtraRedlineTable();
 289
 290     void Insert( SwExtraRedline* p );
 291
 292     void DeleteAndDestroy( sal_uInt16 nPos);
 293     void DeleteAndDestroyAll();
 294
 295     void dumpAsXml(xmlTextWriterPtr pWriter) const;
 296
 297     sal_uInt16 GetSize() const                              {     return m_aExtraRedlines.size();                }
 298     SwExtraRedline* GetRedline( sal_uInt16 uIndex ) const   {     return m_aExtraRedlines.operator[]( uIndex );  }
 299
 300     SW_DLLPUBLIC bool DeleteAllTableRedlines( SwDoc& rDoc, const SwTable& rTable, bool bSaveInUndo, RedlineType nRedlineTypeToDelete );
 301     bool DeleteTableRowRedline ( SwDoc* pDoc, const SwTableLine& rTableLine, bool bSaveInUndo, RedlineType nRedlineTypeToDelete );
 302     bool DeleteTableCellRedline( SwDoc* pDoc, const SwTableBox& rTableBox, bool bSaveInUndo, RedlineType nRedlineTypeToDelete );
 303 };
 304
 305 typedef std::vector<SwOLENode*> SwOLENodes;
 306
 307 #endif // INCLUDED_SW_INC_DOCARY_HXX
 308
 309 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */