writerfilter/inc/resourcemodel/SubSequence.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: SubSequence.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_SUB_SEQUENCE_HXX
  32 #define INCLUDED_SUB_SEQUENCE_HXX
  33
  34 #include <com/sun/star/uno/Sequence.hxx>
  35
  36 #include <boost/shared_ptr.hpp>
  37 #include <iostream>
  38 #include <stdio.h>
  39 #include <ctype.h>
  40 #include "exceptions.hxx"
  41 #include <WriterFilterDllApi.hxx>
  42 #include <resourcemodel/OutputWithDepth.hxx>
  43
  44 namespace writerfilter {
  45 using namespace ::std;
  46
  47 template <class T>
  48 class SubSequence;
  49
  50 template <typename T>
  51 void dumpLine(OutputWithDepth<string> & o, SubSequence<T> & rSeq,
  52               sal_uInt32 nOffset, sal_uInt32 nStep);
  53
  54 template <class T>
  55 class WRITERFILTER_DLLPUBLIC SubSequence
  56 {
  57     typedef boost::shared_ptr<com::sun::star::uno::Sequence<T> >
  58     SequencePointer;
  59
  60     SequencePointer mpSequence;
  61     sal_uInt32 mnOffset;
  62     sal_uInt32 mnCount;
  63
  64 public:
  65     typedef boost::shared_ptr<SubSequence> Pointer_t;
  66
  67     SubSequence() : mpSequence(new ::com::sun::star::uno::Sequence<T>()),
  68                     mnOffset(0), mnCount(0)
  69     {
  70     }
  71
  72     SubSequence(SequencePointer pSequence, sal_uInt32 nOffset_,
  73                 sal_uInt32 nCount_)
  74         : mpSequence(pSequence), mnOffset(nOffset_), mnCount(nCount_)
  75     {
  76     }
  77
  78     SubSequence(SequencePointer pSequence)
  79         : mpSequence(pSequence), mnOffset(0), mnCount(pSequence->getLength())
  80     {
  81     }
  82
  83     SubSequence(const SubSequence & rSubSequence, sal_uInt32 nOffset_,
  84                 sal_uInt32 nCount_)
  85         : mpSequence(rSubSequence.mpSequence),
  86           mnOffset(rSubSequence.mnOffset + nOffset_),
  87           mnCount(nCount_)
  88     {
  89     }
  90
  91     SubSequence(const T * pStart, sal_uInt32 nCount_)
  92         : mpSequence(new com::sun::star::uno::Sequence<T>(pStart, nCount_)),
  93           mnOffset(0), mnCount(nCount_)
  94     {
  95     }
  96
  97     SubSequence(sal_Int32 nCount_)
  98         : mpSequence(new com::sun::star::uno::Sequence<T>(nCount_)), mnOffset(0),
  99           mnCount(nCount_)
 100     {
 101     }
 102
 103     ::com::sun::star::uno::Sequence<T> & getSequence()
 104     {
 105         return *mpSequence;
 106     }
 107
 108     const ::com::sun::star::uno::Sequence<T> & getSequence() const
 109     {
 110         return *mpSequence;
 111     }
 112
 113     void reset() {
 114         mnOffset = 0;
 115         mnCount = mpSequence->getLength();
 116     }
 117
 118     sal_uInt32 getOffset() const { return mnOffset; }
 119     sal_uInt32 getCount() const { return mnCount; }
 120
 121     const T & operator[] (sal_uInt32 nIndex) const
 122     {
 123         if (mnOffset + nIndex >=
 124             sal::static_int_cast<sal_uInt32>(mpSequence->getLength()))
 125             throw ExceptionOutOfBounds("SubSequence::operator[]");
 126
 127         return (*mpSequence)[mnOffset + nIndex];
 128     }
 129
 130     void dump(ostream & o) const
 131     {
 132         {
 133             char sBuffer[256];
 134
 135             snprintf(sBuffer, sizeof(sBuffer),
 136                      "<sequence id='%p' offset='%lx' count='%lx'>",
 137                      mpSequence.get(), mnOffset, mnCount);
 138             o << sBuffer << endl;
 139         }
 140
 141         sal_uInt32 n = 0;
 142         sal_uInt32 nStep = 16;
 143
 144         while (n < getCount())
 145         {
 146             char sBuffer[256];
 147
 148             o << "<line>";
 149
 150             snprintf(sBuffer, 255, "%08lx: ", n);
 151
 152             o << sBuffer;
 153
 154             for (sal_uInt32 i = 0; i < nStep; i++)
 155             {
 156                 if (n + i < getCount())
 157                 {
 158                     snprintf(sBuffer, 255, "%02x ", operator[](n + i));
 159                     o << sBuffer;
 160                 }
 161                 else
 162                     o << "   ";
 163
 164                 if (i % 8 == 7)
 165                     o << " ";
 166             }
 167
 168             {
 169                 for (sal_uInt32 i = 0; i < nStep; i++)
 170                 {
 171                     if (n + i < getCount())
 172                     {
 173                         unsigned char c =
 174                             static_cast<unsigned char>(operator[](n + i));
 175
 176                         if (c=='&')
 177                             o << "&amp;";
 178                         else if (c=='<')
 179                             o << "&lt;";
 180                         else if (c=='>')
 181                             o << "&gt;";
 182                         else if (c < 128 && isprint(c))
 183                             o << c;
 184                         else
 185                             o << ".";
 186                     }
 187
 188                 }
 189             }
 190
 191             o << "</line>" << endl;
 192
 193             n += nStep;
 194         }
 195
 196         o << "</sequence>" << endl;
 197     }
 198
 199     void dump(OutputWithDepth<string> & o)
 200     {
 201         {
 202             char sBuffer[256];
 203
 204             snprintf(sBuffer, sizeof(sBuffer),
 205                      "<sequence id='%p' offset='%" SAL_PRIxUINT32 "' count='%" SAL_PRIxUINT32 "'>",
 206                      mpSequence.get(), mnOffset, mnCount);
 207             o.addItem(sBuffer);
 208         }
 209
 210         sal_uInt32 n = 0;
 211         sal_uInt32 nStep = 16;
 212
 213         try
 214         {
 215             sal_uInt32 nCount = getCount();
 216             while (n < nCount)
 217             {
 218                 sal_uInt32 nBytes = nCount - n;
 219
 220                 if (nBytes > nStep)
 221                     nBytes = nStep;
 222
 223                 SubSequence<T> aSeq(*this, n, nBytes);
 224                 dumpLine(o, aSeq, n, nStep);
 225
 226                 n += nBytes;
 227             }
 228         }
 229         catch (...)
 230         {
 231             o.addItem("<exception/>");
 232         }
 233
 234         o.addItem("</sequence>");
 235     }
 236
 237     string toString() const
 238     {
 239         sal_uInt32 n = 0;
 240         sal_uInt32 nStep = 16;
 241
 242         string sResult;
 243
 244         while (n < getCount())
 245         {
 246             char sBuffer[256];
 247
 248             snprintf(sBuffer, 255, "<line>%08" SAL_PRIxUINT32 ": ", n);
 249
 250             sResult += sBuffer;
 251
 252             for (sal_uInt32 i = 0; i < nStep; i++)
 253             {
 254                 if (n + i < getCount())
 255                 {
 256                     snprintf(sBuffer, 255, "%02x ", operator[](n + i));
 257                     sResult += sBuffer;
 258                 }
 259                 else
 260                     sResult += "   ";
 261
 262                 if (i % 8 == 7)
 263                     sResult += " ";
 264             }
 265
 266             {
 267                 for (sal_uInt32 i = 0; i < nStep; i++)
 268                 {
 269                     if (n + i < getCount())
 270                     {
 271                         unsigned char c =
 272                             static_cast<unsigned char>(operator[](n + i));
 273
 274                         if (c=='&')
 275                             sResult += "&amp;";
 276                         else if (c=='<')
 277                             sResult += "&lt;";
 278                         else if (c=='>')
 279                             sResult += "&gt;";
 280                         else if (c < 128 && isprint(c))
 281                             sResult += c;
 282                         else
 283                             sResult += ".";
 284                     }
 285                 }
 286             }
 287
 288             sResult += "</line>\n";
 289
 290             n += nStep;
 291         }
 292
 293         return sResult;
 294     }
 295 };
 296
 297 template <typename T>
 298 void dumpLine(OutputWithDepth<string> & o, SubSequence<T> & rSeq,
 299               sal_uInt32 nOffset, sal_uInt32 nStep)
 300 {
 301     sal_uInt32 nCount = rSeq.getCount();
 302     char sBuffer[256];
 303
 304     string tmpStr = "<line>";
 305
 306     snprintf(sBuffer, 255, "%08" SAL_PRIxUINT32 ": ", nOffset);
 307
 308     tmpStr += sBuffer;
 309
 310     for (sal_uInt32 i = 0; i < nStep; i++)
 311     {
 312         if (i < nCount)
 313         {
 314             snprintf(sBuffer, 255, "%02x ", rSeq[i]);
 315             tmpStr += sBuffer;
 316         }
 317         else
 318             tmpStr += "   ";
 319
 320         if (i % 8 == 7)
 321             tmpStr += " ";
 322     }
 323
 324     {
 325         for (sal_uInt32 i = 0; i < nStep; i++)
 326         {
 327             if (i < nCount)
 328             {
 329                 unsigned char c =
 330                     static_cast<unsigned char>(rSeq[i]);
 331
 332                 if (c=='&')
 333                     tmpStr += "&amp;";
 334                 else if (c=='<')
 335                     tmpStr += "&lt;";
 336                 else if (c=='>')
 337                     tmpStr += "&gt;";
 338                 else if (c < 128 && isprint(c))
 339                     tmpStr += c;
 340                 else
 341                     tmpStr += ".";
 342             }
 343
 344         }
 345     }
 346
 347     tmpStr += "</line>";
 348
 349     o.addItem(tmpStr);
 350 }
 351
 352 }
 353
 354 #endif // INCLUDED_SUB_SEQUENCE_HXX