writerfilter/source/doctok/PLCF.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: PLCF.hxx,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #ifndef INCLUDED_PLCF_HXX
  32 #define INCLUDED_PLCF_HXX
  33
  34 #include <boost/shared_ptr.hpp>
  35 #include <WW8StructBase.hxx>
  36
  37 namespace writerfilter {
  38 namespace doctok
  39 {
  40
  41 class Empty
  42 {
  43 public:
  44     typedef boost::shared_ptr<Empty> Pointer_t;
  45
  46     Empty() {}
  47     virtual ~Empty() {}
  48
  49     sal_uInt32 getSize() { return 0; }
  50 };
  51
  52 template <class T>
  53 /**
  54    Plex in File
  55
  56    A PLCF is a concatenation of two arrays. The first array contains
  57    file character positions. The second array contains elements of
  58    type T. If the first array contains N elements, the second contains
  59    N - 1 elements. The N-th element in the first array corresponds to
  60    the N-th element of the second array.
  61
  62    The second array is referred to as the payload.
  63  */
  64 class PLCF : public WW8StructBase
  65 {
  66     /// number of entries
  67     sal_uInt32 nEntryCount;
  68
  69     /// offset to payload
  70     sal_uInt32 nPayloadOffset;
  71
  72     /// internal method to calculate the number of entries
  73     sal_uInt32 getEntryCount_() const;
  74
  75 public:
  76     typedef boost::shared_ptr< PLCF< T > > Pointer_t;
  77
  78     PLCF(sal_uInt32 nLength)
  79     : WW8StructBase(nLength), nEntryCount(getEntryCount_()),
  80       nPayloadOffset((nEntryCount + 1) * 4)
  81     {
  82     }
  83
  84     PLCF(WW8Stream & rStream,
  85          sal_Int32 nOffset, sal_Int32 nCount)
  86     : WW8StructBase(rStream, nOffset, nCount),
  87       nEntryCount(getEntryCount_()),
  88       nPayloadOffset((nEntryCount + 1) * 4)
  89     {
  90     }
  91
  92     PLCF(const Sequence & rSequence)
  93     : WW8StructBase(rSequence), nEntryCount(getEntryCount_()),
  94       nPayloadOffset((nEntryCount + 1) * 4)
  95     {
  96     }
  97
  98     /**
  99        Return the number of elements in the PLCF-
 100      */
 101     sal_uInt32 getEntryCount() const { return nEntryCount; }
 102
 103     /**
 104        Return the file character position of a certain element.
 105
 106        @param nIndex      the index of the element
 107      */
 108     sal_uInt32 getFc(sal_uInt32 nIndex) const;
 109
 110     /**
 111        Return a C++ pointer to a certain payload entry.
 112
 113        @param nIndex      the index of the element
 114      */
 115     T * getEntryPointer(sal_uInt32 nIndex) const;
 116
 117     /**
 118        Return a shared pointer to a certain payload element.
 119
 120        @param nIndex      the index of the element
 121      */
 122     typename T::Pointer_t getEntry(sal_uInt32 nIndex) const;
 123
 124     /**
 125        Return a C++ pointer a certain payload element.
 126
 127        @param nFc         the file character position of the element
 128      */
 129     T * getEntryByFc(sal_uInt32 nFc) const;
 130
 131     virtual void dump(OutputWithDepth<string> & out) const;
 132 };
 133
 134 template <class T>
 135 sal_uInt32 PLCF<T>::getEntryCount_() const
 136 {
 137     return (getCount() - 4) / (T::getSize() + 4);
 138 }
 139
 140 template <class T>
 141 sal_uInt32 PLCF<T>::getFc(sal_uInt32 nIndex) const
 142 {
 143     return getU32(nIndex * 4);
 144 }
 145
 146 template <class T>
 147 T * PLCF<T>::getEntryPointer(sal_uInt32 nIndex) const
 148 {
 149     return new T(mSequence, nPayloadOffset + nIndex * T::getSize(),
 150                  T::getSize());
 151 }
 152
 153 template <class T>
 154 typename T::Pointer_t PLCF<T>::getEntry(sal_uInt32 nIndex) const
 155 {
 156     typename T::Pointer_t pResult(getEntryPointer(nIndex));
 157
 158     return pResult;
 159 }
 160
 161
 162 template <class T>
 163 T * PLCF<T>::getEntryByFc(sal_uInt32 nFc) const
 164 {
 165     T * pResult = NULL;
 166
 167     sal_uInt32 n = getEntryCount();
 168
 169     while (getFc(n) > nFc)
 170         n--;
 171
 172     pResult = getEntryPointer(n);
 173
 174     return pResult;
 175 }
 176
 177 template <class T>
 178 void PLCF<T>::dump(OutputWithDepth<string> & output_) const
 179 {
 180     output_.addItem("<plcf>");
 181     WW8StructBase::dump(output_);
 182
 183     sal_uInt32 nCount = getEntryCount();
 184     for (sal_uInt32 n = 0; n < nCount; ++n)
 185     {
 186         Fc aFc = getFc(n);
 187         typename T::Pointer_t pT = getEntry(n);
 188
 189         output_.addItem("<plcfentry cpandfc=\"" + aFc.toString() + "\">");
 190         pT->dump(output_);
 191         output_.addItem("</plcfentry>");
 192     }
 193     output_.addItem("</plcf>>");
 194 }
 195
 196 }}
 197
 198 #endif // INCLUDED_PLCF_HXX