writerfilter/source/doctok/WW8CpAndFc.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: WW8CpAndFc.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_WW8_CP_AND_FC_HXX
  32 #define INCLUDED_WW8_CP_AND_FC_HXX
  33
  34 #include <sal/types.h>
  35 #ifndef INCLUDED_DOCUMENT_HXX
  36 #include <doctok/WW8Document.hxx>
  37 #endif
  38 #include <set>
  39 #include <hash_map>
  40 #include <iostream>
  41
  42 namespace writerfilter {
  43 namespace doctok
  44 {
  45 using namespace ::std;
  46
  47 template <class T>
  48 bool operator <= (const T & rA, const T & rB)
  49 {
  50     return ! ( rB < rA );
  51 }
  52
  53 /**
  54    A character position.
  55
  56    This is a wrapper to make the type for WW8 character position (CP)
  57    distinct from WW8 file character positions (FC).
  58 */
  59 struct Cp
  60 {
  61     sal_uInt32 nCp; // the WW8 character position
  62
  63     Cp() : nCp(0) {}
  64
  65     Cp(sal_uInt32 nCp_) : nCp(nCp_) {}
  66
  67     /**
  68        Returns the WW8 character position.
  69
  70        @return the WW8 character position
  71     */
  72     sal_uInt32 get() const { return nCp; }
  73
  74     /**
  75        Sets the WW8 character position.
  76
  77        @param nCp_    the WW8 character position to set
  78     */
  79     void set(sal_uInt32 nCp_) { nCp = nCp_; }
  80
  81     /**
  82        Calculate CP moved backward.
  83
  84        None of the involved CPs is changed.
  85
  86        @param n     amount of movement
  87
  88        @return CP moved @n steps backward
  89      */
  90     sal_uInt32 operator - (const Cp & rCp) const
  91     { return nCp - rCp.nCp; }
  92
  93     /**
  94        Calculate CP moved forward.
  95
  96        None of the involved CPs is changed.
  97
  98        @param n     amount of movement
  99
 100        @return CP moved @n steps forward
 101      */
 102     Cp operator + (sal_uInt32 n) const
 103     { return Cp(nCp + n); }
 104
 105     /**
 106        Advance CP forward.
 107
 108        @attention The CP is altered.
 109
 110        @param n      amount of movement
 111
 112        @return  CP moved @n steps forward
 113      */
 114     Cp & operator += (sal_uInt32 n)
 115     {
 116         nCp += n;
 117
 118         return *this;
 119     }
 120
 121     /**
 122        Return string representation of CP.
 123      */
 124     string toString() const;
 125
 126     friend bool operator < (const Cp & rA, const Cp & rB);
 127     friend bool operator == (const Cp & rA, const Cp & rB);
 128     friend ostream & operator << (ostream & o, const Cp & rCp);
 129 };
 130
 131 /**
 132    A file character position.
 133
 134    This is a wrapper to make the type for WW8 character position (CP)
 135    distinct from WW8 file character positions (FC).
 136
 137    \see{Cp}
 138 */
 139 struct Fc
 140 {
 141     sal_uInt32 mnFc; // the WW8 character position
 142     bool mbComplex;
 143
 144     Fc() : mnFc(0), mbComplex(false) {}
 145
 146     Fc(sal_uInt32 nFc, bool bComplex = true)
 147     : mnFc(nFc), mbComplex(bComplex)
 148     {}
 149
 150     sal_uInt32 complexFactor() const { return mbComplex ? 1 : 2; }
 151
 152     /**
 153        Returns the WW8 character position.
 154
 155        @return the WW8 character position
 156     */
 157     sal_uInt32 get() const { return mnFc; }
 158
 159     /**
 160        Sets the WW8 file character position.
 161
 162        @param nFc    the WW8 file character position to set
 163     */
 164     void set(sal_uInt32 nFc) { mnFc = nFc; }
 165
 166     /**
 167        Set if the FC is complex.
 168
 169        @param bComplex      true if FC is set to be complex
 170      */
 171     void setComplex(bool bComplex) { mbComplex = bComplex; }
 172
 173     /**
 174        Return if FC is complex.
 175
 176        @retval true   FC is complex
 177        @retval false  else
 178      */
 179     bool isComplex() const { return mbComplex; }
 180
 181     /**
 182        Distance of FCs.
 183
 184        None of the involved FCs is changed.
 185
 186        @param  rFc      FC to calculate distance to
 187
 188        @return Distance from @a rFc to this FC
 189      */
 190     sal_uInt32 operator - (const Fc & rFc) const
 191     { return (mnFc - rFc.mnFc) / complexFactor(); }
 192
 193     /**
 194        Calculate FC moved backward.
 195
 196        None of the involved FCs is changed.
 197
 198        @param n     amount of movement
 199
 200        @return FC moved @n steps backward
 201      */
 202     Fc operator - (sal_uInt32 n) const
 203     { return Fc(mnFc - n * complexFactor(), mbComplex); }
 204
 205     /**
 206        Calculate FC moved forward.
 207
 208        None of the involved FCs is changed.
 209
 210        @param n     amount of movement
 211
 212        @return FC moved @n steps Forward
 213      */
 214     Fc operator + (sal_uInt32 n) const
 215     { return Fc(mnFc + n * complexFactor(), mbComplex); }
 216
 217     /**
 218        Return string representation of FC.
 219      */
 220     string toString() const;
 221
 222     friend bool operator < (const Fc & rA, const Fc & rB);
 223     friend bool operator == (const Fc & rA, const Fc & rB);
 224     friend ostream & operator << (ostream & o, const Fc & rFc);
 225 };
 226
 227 /**
 228    A character position and a corresponding file character position
 229    paired.
 230  */
 231 class CpAndFc
 232 {
 233 private:
 234     /**
 235        character position
 236     */
 237     Cp mCp;
 238
 239     /**
 240        file character position
 241     */
 242     Fc mFc;
 243
 244     /**
 245        property type
 246     */
 247     PropertyType mType;
 248
 249 public:
 250     CpAndFc() {}
 251     CpAndFc(const Cp & rCp, const Fc & rFc, PropertyType eType_);
 252
 253     /**
 254        Return character position.
 255     */
 256     const Cp & getCp() const { return mCp; }
 257
 258     /**
 259        Return file character position.
 260     */
 261     const Fc & getFc() const { return mFc; }
 262
 263     /**
 264        Return property type.
 265     */
 266     PropertyType getType() const { return mType; }
 267
 268     /**
 269        Return if FC is complex.
 270
 271        @retval true    FC is complex
 272        @retval false   else
 273      */
 274     bool isComplex() const { return mFc.isComplex(); }
 275
 276     /**
 277        Return the distance to other CpAndFc.
 278
 279        @param  rCpAndFc    the other CpAndFc
 280
 281        @return the distance from the CP in @a rCpAndFc to the CP in
 282        CpAndFc.
 283      */
 284     sal_uInt32 operator-(const CpAndFc & rCpAndFc) const
 285     { return mCp - rCpAndFc.mCp; }
 286
 287     /**
 288        Return string representation of the CpAndFc.
 289     */
 290     string toString() const;
 291
 292     friend bool operator < (const CpAndFc & rA, const CpAndFc & rB);
 293     friend bool operator == (const CpAndFc & rA, const CpAndFc & rB);
 294     friend ostream & operator << (ostream & o, const CpAndFc & rCpAndFc);
 295 };
 296
 297 struct CpAndFcLess
 298 {
 299     CpAndFcLess()
 300     {
 301     }
 302
 303     bool operator()(const CpAndFc & rA, const CpAndFc & rB) const
 304     {
 305         return rA < rB;
 306     }
 307
 308     bool operator()(const CpAndFc & rA, const Cp & rB) const
 309     {
 310         return rA.getCp() < rB;
 311     }
 312
 313     bool operator()(const Cp & rA, const CpAndFc & rB) const
 314     {
 315         return rA < rB.getCp();
 316     }
 317 };
 318
 319
 320 typedef set<CpAndFc, CpAndFcLess> CpAndFcs;
 321
 322 ostream & operator << (ostream & o, const CpAndFcs & rCpAndFcs);
 323
 324 struct CpHash
 325 {
 326     size_t operator()(const Cp & rCp) const
 327     {
 328         return rCp.get();
 329     }
 330 };
 331
 332 struct FcHash
 333 {
 334     size_t operator()(const Fc & rFc) const
 335     {
 336         return rFc.get();
 337     }
 338 };
 339
 340 struct CpEq
 341 {
 342     bool operator() (const Cp & rA, const Cp &rB) const
 343     {
 344         return rA == rB;
 345     }
 346 };
 347
 348 struct CpAndFcHash
 349 {
 350     size_t operator()(const CpAndFc & rCpAndFc) const
 351     {
 352         CpHash aHash;
 353
 354         return aHash(rCpAndFc.getCp());
 355     }
 356 };
 357
 358 typedef hash_map<Cp, Fc, CpHash, CpEq> Cp2FcHashMap_t;
 359
 360 } // namespace doctok
 361 } // namespace writerfilter
 362
 363 #endif // INCLUDED_WW8_CP_AND_FC_HXX