writerfilter/source/doctok/WW8StructBase.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: WW8StructBase.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_STRUCT_BASE_HXX
  32 #define INCLUDED_WW8_STRUCT_BASE_HXX
  33
  34 #include <boost/shared_ptr.hpp>
  35 #include <doctok/WW8Document.hxx>
  36 #include <resourcemodel/OutputWithDepth.hxx>
  37
  38 namespace writerfilter {
  39 namespace doctok {
  40
  41 class WW8DocumentImpl;
  42
  43 /**
  44    Part of a stream.
  45
  46    A part can have a parent, meaning its sequence of data is a
  47    subsequence of its parent's sequence of data.
  48  */
  49 class WW8StructBase
  50 {
  51 public:
  52     typedef SubSequence<sal_uInt8> Sequence;
  53     typedef boost::shared_ptr<WW8StructBase> Pointer_t;
  54
  55 protected:
  56     /**
  57        Stream this part was created from.
  58     */
  59     ::com::sun::star::uno::Reference<com::sun::star::io::
  60     XInputStream> mrStream;
  61
  62     /**
  63        The data.
  64      */
  65     mutable Sequence mSequence;
  66
  67     /**
  68        This part's parent.
  69      */
  70     WW8StructBase * mpParent;
  71
  72     /**
  73        This part's offset in parent.
  74     */
  75     sal_uInt32 mnOffsetInParent;
  76
  77     /**
  78        The document of this struct.
  79      */
  80     WW8DocumentImpl * mpDocument;
  81
  82 public:
  83     WW8StructBase(sal_Int32 nLength)
  84     : mSequence(nLength)
  85     {
  86     }
  87
  88     /**
  89        Creates a part from a steam.
  90
  91        @param rStream    the stream
  92        @param nOffset    offset in @a rStream to start at
  93        @param nCount     count of bytes in the new part
  94      */
  95     WW8StructBase(WW8Stream & rStream,
  96                   sal_Int32 nOffset, sal_Int32 nCount)
  97     : mSequence(rStream.get(nOffset, nCount)), mpParent(0), mpDocument(0)
  98     {
  99     }
 100
 101     /**
 102        Creates a part from a sequence.
 103
 104        @param rSequence    the sequence
 105        @param nOffset    offset in @a rSequence to start at
 106        @param nCount     count of bytes in the new part
 107      */
 108     WW8StructBase(const Sequence & rSequence, sal_uInt32 nOffset = 0,
 109                   sal_uInt32 nCount = 0)
 110     : mSequence(rSequence, nOffset, nCount), mpParent(0), mpDocument(0)
 111     {
 112     }
 113
 114     /**
 115        Creates a part from a parent part.
 116
 117        @param pParent    the parent
 118        @param nOffset    offset in @a pParent to start at
 119        @param nCount     count of bytes in the new part
 120      */
 121     WW8StructBase(const WW8StructBase & rParent,
 122                   sal_uInt32 nOffset, sal_uInt32 nCount);
 123
 124     /**
 125        Creates a part from a parent part.
 126
 127        @param pParent    the parent
 128        @param nOffset    offset in @a pParent to start at
 129        @param nCount     count of bytes in the new part
 130      */
 131     WW8StructBase(WW8StructBase * pParent,
 132                   sal_uInt32 nOffset, sal_uInt32 nCount)
 133     : mSequence(pParent->mSequence, nOffset, nCount), mpParent(pParent),
 134       mnOffsetInParent(nOffset), mpDocument(pParent->getDocument())
 135     {
 136         if (nOffset + nCount > pParent->mSequence.getCount())
 137             throw ExceptionOutOfBounds("WW8StructBase");
 138     }
 139
 140
 141     virtual ~WW8StructBase()
 142     {
 143     }
 144
 145     /**
 146        Assign a part to this part.
 147
 148        After assignment this part has the same content as the assigned
 149        part.
 150
 151        @param rSrc     part to assign
 152
 153        @return this part after assignment
 154      */
 155     virtual WW8StructBase & Assign(const WW8StructBase & rSrc);
 156
 157     /**
 158        Set the document of this struct.
 159      */
 160     void setDocument(WW8DocumentImpl * pDocument);
 161
 162     /**
 163        Return the document of this struct.
 164     */
 165     WW8DocumentImpl * getDocument() const;
 166
 167     /**
 168        Return count of bytes in this part.
 169      */
 170     sal_uInt32 getCount() const { return mSequence.getCount(); }
 171
 172     /**
 173        Return unsigned byte value at an offset.
 174
 175        @param offset     offset to get value from
 176      */
 177     sal_uInt8 getU8(sal_uInt32 nOffset) const;
 178
 179     /**
 180        Return unsigned 16-bit value at an offset.
 181
 182        @param offset     offset to get value from
 183      */
 184     sal_uInt16 getU16(sal_uInt32 nOffset) const;
 185
 186     /**
 187        Return unsigned 32-bit value at an offset.
 188
 189        @param offset     offset to get value from
 190      */
 191     sal_uInt32 getU32(sal_uInt32 nOffset) const;
 192
 193     /**
 194        Return signed 8-bit value at an offset.
 195
 196        @param offset     offset to get value from
 197      */
 198     sal_Int8 getS8(sal_uInt32 nOffset) const
 199     { return (sal_Int8) getU8(nOffset); }
 200
 201     /**
 202        Return signed 16-bit value at an offset.
 203
 204        @param offset     offset to get value from
 205      */
 206     sal_Int16 getS16(sal_uInt32 nOffset) const
 207     {return (sal_Int16) getU16(nOffset); }
 208
 209     /**
 210        Return signed 32-bit value at an offset.
 211
 212        @param offset     offset to get value from
 213      */
 214     sal_Int32 getS32(sal_uInt32 nOffset) const
 215     { return (sal_Int32) getU32(nOffset); }
 216
 217     /**
 218        Return bit value from a 32-bit unsigned value.
 219
 220        @param nValue     value to retreive bit from
 221        @param nBit       number of bit to retreive (0 = least significant)
 222      */
 223     sal_Bool getBit(sal_uInt32 nValue, sal_uInt16 nBit) const;
 224
 225     /**
 226         Return nibble from a 32-bit unsigned value.
 227
 228         @param nValue   value to retreive nibble from (most significant bit left)
 229         @param nShift   amount of bits to shift right before returning least significant nibble
 230     */
 231     sal_uInt8 getNibble(sal_uInt32 nValue, sal_uInt16 nShift) const;
 232
 233     /**
 234        Returns byte at an index.
 235
 236        @param nIndex  index in this part of the byte to return
 237      */
 238     const sal_uInt8 * get(sal_uInt32 nIndex) const
 239     { return &((mSequence.getSequence())[nIndex + mSequence.getOffset()]); }
 240
 241     /**
 242        Returns two byte character string starting at an offset.
 243
 244        The string has to be Pascal like, e.g. the first word contains
 245        the lengthof the string in characters and is followed by the
 246        string's characters.
 247
 248        @param nOffset    offset the string starts at
 249
 250        @return  the string
 251      */
 252     rtl::OUString getString(sal_uInt32 nOffset) const;
 253
 254     /**
 255        Returns binary object for remainder of this WW8StructBase
 256
 257        @param nOffset     offset where remainder starts
 258      */
 259     WW8StructBase * getRemainder(sal_uInt32 nOffset) const;
 260
 261     /**
 262        Returns two byte character string starting at an offset with a
 263        given length.
 264
 265        @param nOffset     offset the string starts at
 266        @param nLength     number of characters in the string
 267      */
 268     rtl::OUString getString(sal_uInt32 nOffset, sal_uInt32) const;
 269
 270     /**
 271        Dump the part.
 272
 273        @param o       stream to dump to
 274      */
 275     virtual void dump(OutputWithDepth<string> & o) const { mSequence.dump(o); }
 276 };
 277
 278 class WW8StructBaseTmpOffset
 279 {
 280     sal_uInt32 mnOffset;
 281     WW8StructBase * mpStructBase;
 282
 283 public:
 284     WW8StructBaseTmpOffset(WW8StructBase * pStructBase);
 285
 286     sal_uInt32 set(sal_uInt32 nOffset);
 287     sal_uInt32 get() const;
 288     sal_uInt32 inc(sal_uInt32 nOffset);
 289
 290     operator sal_uInt32 () const;
 291 };
 292
 293 /**
 294    Return unsigned byte from a sequence.
 295
 296    @param rSeq        sequence to get value from
 297    @param nOffset     offset in sequence to get value from
 298  */
 299 sal_uInt8 getU8(const WW8StructBase::Sequence & rSeq,  sal_uInt32 nOffset);
 300
 301 /**
 302    Return unsigned 16-bit value from a sequence.
 303
 304    @param rSeq        sequence to get value from
 305    @param nOffset     offset in sequence to get value from
 306  */
 307 sal_uInt16 getU16(const WW8StructBase::Sequence & rSeq, sal_uInt32 nOffset);
 308
 309 /**
 310    Return unsigned 32-bit value from a sequence.
 311
 312    @param rSeq        sequence to get value from
 313    @param nOffset     offset in sequence to get value from
 314  */
 315 sal_uInt32 getU32(const WW8StructBase::Sequence & rSeq, sal_uInt32 nOffset);
 316
 317 }}
 318
 319 #endif // INCLUDED_WW8_STRUCT_BASE_HXX