writerfilter/source/doctok/WW8PieceTableImpl.cxx

   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: WW8PieceTableImpl.cxx,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 #include <algorithm>
  32 #include <iterator>
  33
  34 #ifndef INCLUDED_DOCTOK_EXCEPTIONS
  35 #include <resourcemodel/exceptions.hxx>
  36 #endif
  37 #include <WW8PieceTableImpl.hxx>
  38 #include <WW8Clx.hxx>
  39
  40 namespace writerfilter {
  41 namespace doctok
  42 {
  43 using namespace ::std;
  44
  45 ostream & operator << (ostream & o, const WW8PieceTable & rPieceTable)
  46 {
  47     rPieceTable.dump(o);
  48
  49     return o;
  50 }
  51
  52 WW8PieceTableImpl::WW8PieceTableImpl(WW8Stream & rStream,
  53                                      sal_uInt32 nOffset,
  54                                      sal_uInt32 nCount)
  55 {
  56     WW8Clx aClx(rStream, nOffset, nCount);
  57
  58     sal_uInt32 nPieceCount = aClx.getPieceCount();
  59
  60     if (nPieceCount > 0)
  61     {
  62         for (sal_uInt32 n = 0; n < nPieceCount;  n++)
  63         {
  64             Cp aCp(aClx.getCp(n));
  65             Fc aFc(aClx.getFc(n), aClx.isComplexFc(n));
  66
  67             CpAndFc aCpAndFc(aCp, aFc, PROP_DOC);
  68
  69             mEntries.push_back(aCpAndFc);
  70         }
  71
  72         CpAndFc aBack = mEntries.back();
  73         Cp aCp(aClx.getCp(aClx.getPieceCount()));
  74         Fc aFc(aBack.getFc() + (aCp - aBack.getCp()));
  75
  76         CpAndFc aCpAndFc(aCp, aFc, PROP_DOC);
  77
  78         mEntries.push_back(aCpAndFc);
  79     }
  80 }
  81
  82 sal_uInt32 WW8PieceTableImpl::getCount() const
  83 {
  84     return mEntries.size();
  85 }
  86
  87 WW8PieceTableImpl::tEntries::const_iterator
  88 WW8PieceTableImpl::findCp(const Cp & rCp) const
  89 {
  90     tEntries::const_iterator aResult = mEntries.end();
  91     tEntries::const_iterator aEnd = mEntries.end();
  92
  93     for (tEntries::const_iterator aIt = mEntries.begin(); aIt != aEnd;
  94          aIt++)
  95     {
  96         if (aIt->getCp() <= rCp)
  97         {
  98             aResult = aIt;
  99
 100             //break;
 101         }
 102     }
 103
 104     return aResult;
 105 }
 106
 107 WW8PieceTableImpl::tEntries::const_iterator
 108 WW8PieceTableImpl::findFc(const Fc & rFc) const
 109 {
 110     tEntries::const_iterator aResult = mEntries.end();
 111     tEntries::const_iterator aEnd = mEntries.end();
 112
 113     if (mEntries.size() > 0)
 114     {
 115         if (rFc < mEntries.begin()->getFc())
 116             aResult = mEntries.begin();
 117         else
 118         {
 119             for (tEntries::const_iterator aIt = mEntries.begin();
 120                  aIt != aEnd; aIt++)
 121             {
 122                 if (aIt->getFc() <= rFc)
 123                 {
 124                     tEntries::const_iterator aItNext = aIt;
 125                     aItNext++;
 126
 127                     if (aItNext != aEnd)
 128                     {
 129                         sal_uInt32 nOffset = rFc.get() - aIt->getFc().get();
 130                         sal_uInt32 nLength = aItNext->getCp() - aIt->getCp();
 131
 132                         if (! aIt->isComplex())
 133                             nLength *= 2;
 134
 135                         if (nOffset < nLength)
 136                         {
 137                             aResult = aIt;
 138
 139                             break;
 140                         }
 141                     }
 142
 143                 }
 144             }
 145         }
 146     }
 147
 148     return aResult;
 149 }
 150
 151 Cp WW8PieceTableImpl::getFirstCp() const
 152 {
 153     Cp aResult;
 154
 155     if (getCount() > 0)
 156         aResult = getCp(0);
 157     else
 158         throw ExceptionNotFound("WW8PieceTableImpl::getFirstCp");
 159
 160     return aResult;
 161 }
 162
 163 Fc WW8PieceTableImpl::getFirstFc() const
 164 {
 165     Fc aResult;
 166
 167     if (getCount() > 0)
 168         aResult = getFc(0);
 169     else
 170         throw ExceptionNotFound(" WW8PieceTableImpl::getFirstFc");
 171
 172     return aResult;
 173 }
 174
 175 Cp WW8PieceTableImpl::getLastCp() const
 176 {
 177     Cp aResult;
 178
 179     if (getCount() > 0)
 180         aResult = getCp(getCount() - 1);
 181     else
 182         throw ExceptionNotFound("WW8PieceTableImpl::getLastCp");
 183
 184     return aResult;
 185 }
 186
 187 Fc WW8PieceTableImpl::getLastFc() const
 188 {
 189     Fc aResult;
 190
 191     if (getCount() > 0)
 192         aResult = getFc(getCount() - 1);
 193     else
 194         throw ExceptionNotFound("WW8PieceTableImpl::getLastFc");
 195
 196     return aResult;
 197 }
 198
 199 Cp WW8PieceTableImpl::getCp(sal_uInt32 nIndex) const
 200 {
 201     return mEntries[nIndex].getCp();
 202 }
 203
 204 Fc WW8PieceTableImpl::getFc(sal_uInt32 nIndex) const
 205 {
 206     return mEntries[nIndex].getFc();
 207 }
 208
 209 Cp WW8PieceTableImpl::fc2cp(const Fc & rFc) const
 210 {
 211     Cp cpResult;
 212
 213     if (mEntries.size() > 0)
 214     {
 215         Fc aFc;
 216
 217         if (rFc < mEntries.begin()->getFc())
 218             aFc = mEntries.begin()->getFc();
 219         else
 220             aFc = rFc;
 221
 222         tEntries::const_iterator aIt = findFc(aFc);
 223
 224         if (aIt != mEntries.end())
 225         {
 226             cpResult = aIt->getCp() + (aFc - aIt->getFc());
 227         }
 228         else
 229             throw ExceptionNotFound("WW8PieceTableImpl::fc2cp: " + aFc.toString());
 230     }
 231
 232     return cpResult;
 233 }
 234
 235 Fc WW8PieceTableImpl::cp2fc(const Cp & rCp) const
 236 {
 237     Fc aResult;
 238
 239     Cp2FcHashMap_t::iterator aItCp = mCp2FcCache.find(rCp);
 240
 241     if (aItCp == mCp2FcCache.end())
 242     {
 243         tEntries::const_iterator aIt = findCp(rCp);
 244
 245         if (aIt != mEntries.end())
 246         {
 247             aResult = aIt->getFc() + (rCp - aIt->getCp());
 248             mCp2FcCache[rCp] = aResult;
 249         }
 250         else
 251             throw ExceptionNotFound
 252                 ("WW8PieceTableImpl::cp2fc: " + rCp.toString());
 253     }
 254     else
 255         aResult = mCp2FcCache[rCp];
 256
 257     return aResult;
 258 }
 259
 260 bool WW8PieceTableImpl::isComplex(const Cp & rCp) const
 261 {
 262     bool bResult = false;
 263
 264     tEntries::const_iterator aIt = findCp(rCp);
 265
 266     if (aIt != mEntries.end())
 267         bResult = aIt->isComplex();
 268
 269     return bResult;
 270 }
 271
 272 bool WW8PieceTableImpl::isComplex(const Fc & rFc) const
 273 {
 274     bool bResult = false;
 275
 276     tEntries::const_iterator aIt = findFc(rFc);
 277
 278     if (aIt != mEntries.end())
 279         bResult = aIt->isComplex();
 280
 281     return bResult;
 282 }
 283
 284 CpAndFc WW8PieceTableImpl::createCpAndFc
 285 (const Cp & rCp, PropertyType eType) const
 286 {
 287     return CpAndFc(rCp, cp2fc(rCp), eType);
 288 }
 289
 290 CpAndFc WW8PieceTableImpl::createCpAndFc
 291 (const Fc & rFc, PropertyType eType) const
 292 {
 293     return CpAndFc(fc2cp(rFc), rFc, eType);
 294 }
 295
 296 void WW8PieceTableImpl::dump(ostream & o) const
 297 {
 298     o << "<piecetable>" << endl;
 299     copy(mEntries.begin(), mEntries.end(), ostream_iterator<CpAndFc>(o, "\n"));
 300     o << "</piecetable>" << endl;
 301 }
 302 }}