io/source/stm/streamhelper.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: streamhelper.cxx,v $
  10  * $Revision: 1.6 $
  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 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_io.hxx"
  33 #include <rtl/alloc.h>
  34
  35 #include <limits>
  36 #include <string.h>
  37
  38 #include <com/sun/star/uno/Sequence.hxx>
  39
  40 #include <com/sun/star/uno/Exception.hpp>
  41
  42 using namespace ::com::sun::star::uno;
  43
  44 #include "streamhelper.hxx"
  45
  46 namespace io_stm {
  47
  48 void MemFIFO::write( const Sequence< sal_Int8 > &seq )
  49     throw ( IFIFO_OutOfMemoryException,
  50             IFIFO_OutOfBoundsException )
  51 {
  52     try
  53     {
  54         writeAt(getSize(), seq );
  55     }
  56     catch( IRingBuffer_OutOfMemoryException & )
  57     {
  58         throw IFIFO_OutOfMemoryException();
  59     }
  60     catch( IRingBuffer_OutOfBoundsException & )
  61     {
  62         throw IFIFO_OutOfBoundsException();
  63     }
  64 }
  65
  66 void MemFIFO::read( Sequence<sal_Int8> &seq , sal_Int32 nBufferLen ) throw (IFIFO_OutOfBoundsException)
  67 {
  68     try
  69     {
  70         readAt(0, seq , nBufferLen);
  71         forgetFromStart( nBufferLen );
  72     }
  73     catch ( IRingBuffer_OutOfBoundsException & )
  74     {
  75         throw IFIFO_OutOfBoundsException();
  76     }
  77 }
  78
  79 void MemFIFO::skip( sal_Int32 nBytesToSkip ) throw ( IFIFO_OutOfBoundsException )
  80 {
  81     try
  82     {
  83         forgetFromStart( nBytesToSkip );
  84     }
  85     catch( IRingBuffer_OutOfBoundsException & )
  86     {
  87         throw IFIFO_OutOfBoundsException();
  88     }
  89 }
  90
  91
  92
  93 MemRingBuffer::MemRingBuffer()
  94 {
  95     m_nBufferLen                        = 0;
  96     m_p                                         = 0;
  97     m_nStart                            = 0;
  98     m_nOccupiedBuffer           = 0;
  99 }
 100
 101 MemRingBuffer::~MemRingBuffer()
 102 {
 103     if( m_p ) {
 104         rtl_freeMemory( m_p );
 105     }
 106 }
 107
 108 void MemRingBuffer::resizeBuffer( sal_Int32 nMinSize ) throw( IRingBuffer_OutOfMemoryException)
 109 {
 110     sal_Int32 nNewLen = 1;
 111
 112     while( nMinSize > nNewLen ) {
 113         nNewLen = nNewLen << 1;
 114     }
 115
 116     // buffer never shrinks !
 117     if( nNewLen < m_nBufferLen ) {
 118         nNewLen = m_nBufferLen;
 119     }
 120
 121     if( nNewLen != m_nBufferLen ) {
 122         m_p = ( sal_Int8 * ) rtl_reallocateMemory( m_p , nNewLen );
 123         if( !m_p ) {
 124             throw IRingBuffer_OutOfMemoryException();
 125         }
 126
 127         if( m_nStart + m_nOccupiedBuffer > m_nBufferLen ) {
 128             memmove( &( m_p[m_nStart+(nNewLen-m_nBufferLen)]) , &(m_p[m_nStart]) , m_nBufferLen - m_nStart );
 129             m_nStart += nNewLen - m_nBufferLen;
 130         }
 131         m_nBufferLen = nNewLen;
 132     }
 133 }
 134
 135
 136 void MemRingBuffer::readAt( sal_Int32 nPos, Sequence<sal_Int8> &seq , sal_Int32 nBytesToRead ) const
 137                                                         throw(IRingBuffer_OutOfBoundsException)
 138 {
 139     if( nPos + nBytesToRead > m_nOccupiedBuffer ) {
 140         throw IRingBuffer_OutOfBoundsException();
 141     }
 142
 143     sal_Int32 nStartReadingPos = nPos + m_nStart;
 144     if( nStartReadingPos >= m_nBufferLen ) {
 145         nStartReadingPos -= m_nBufferLen;
 146     }
 147
 148     seq.realloc( nBytesToRead );
 149
 150     if( nStartReadingPos + nBytesToRead > m_nBufferLen ) {
 151         sal_Int32 nDeltaLen = m_nBufferLen - nStartReadingPos;
 152         memcpy( seq.getArray() , &(m_p[nStartReadingPos]) , nDeltaLen );
 153         memcpy( &(seq.getArray()[nDeltaLen]), m_p , nBytesToRead - nDeltaLen );
 154     }
 155     else {
 156         memcpy( seq.getArray() , &(m_p[nStartReadingPos]) , nBytesToRead );
 157     }
 158 }
 159
 160
 161 void MemRingBuffer::writeAt( sal_Int32 nPos, const Sequence<sal_Int8> &seq )
 162                                                         throw (IRingBuffer_OutOfBoundsException,
 163                                                                 IRingBuffer_OutOfMemoryException )
 164 {
 165     checkInvariants();
 166     sal_Int32 nLen = seq.getLength();
 167
 168     if( nPos < 0 || nPos > std::numeric_limits< sal_Int32 >::max() - nLen )
 169     {
 170         throw IRingBuffer_OutOfBoundsException();
 171     }
 172
 173     if( nPos + nLen - m_nOccupiedBuffer > 0 ) {
 174         resizeBuffer( nPos + seq.getLength() );
 175     }
 176
 177     sal_Int32 nStartWritingIndex = m_nStart + nPos;
 178     if( nStartWritingIndex >= m_nBufferLen ) {
 179         nStartWritingIndex -= m_nBufferLen;
 180     }
 181
 182     if( nLen + nStartWritingIndex > m_nBufferLen ) {
 183         // two area copy
 184         memcpy( &(m_p[nStartWritingIndex]) , seq.getConstArray(), m_nBufferLen-nStartWritingIndex );
 185         memcpy( m_p , &( seq.getConstArray()[m_nBufferLen-nStartWritingIndex] ),
 186                                         nLen - (m_nBufferLen-nStartWritingIndex) );
 187
 188     }
 189     else {
 190         // one area copy
 191         memcpy( &( m_p[nStartWritingIndex]), seq.getConstArray() , nLen );
 192     }
 193     m_nOccupiedBuffer = Max( nPos + seq.getLength() , m_nOccupiedBuffer );
 194     checkInvariants();
 195 }
 196
 197
 198 sal_Int32 MemRingBuffer::getSize()  const throw()
 199 {
 200     return m_nOccupiedBuffer;
 201 }
 202
 203 void MemRingBuffer::forgetFromStart( sal_Int32 nBytesToForget ) throw (IRingBuffer_OutOfBoundsException)
 204 {
 205     checkInvariants();
 206     if( nBytesToForget > m_nOccupiedBuffer ) {
 207         throw IRingBuffer_OutOfBoundsException();
 208     }
 209     m_nStart += nBytesToForget;
 210     if( m_nStart >= m_nBufferLen ) {
 211         m_nStart = m_nStart - m_nBufferLen;
 212     }
 213     m_nOccupiedBuffer -= nBytesToForget;
 214     checkInvariants();
 215 }
 216
 217
 218 void MemRingBuffer::forgetFromEnd( sal_Int32 nBytesToForget ) throw (IRingBuffer_OutOfBoundsException)
 219 {
 220     checkInvariants();
 221     if( nBytesToForget > m_nOccupiedBuffer ) {
 222         throw IRingBuffer_OutOfBoundsException();
 223     }
 224     m_nOccupiedBuffer -= nBytesToForget;
 225     checkInvariants();
 226 }
 227
 228
 229 void MemRingBuffer::shrink() throw ()
 230 {
 231     checkInvariants();
 232
 233     // Up to now, only shrinking of while buffer works.
 234     // No other shrinking supported up to now.
 235     if( ! m_nOccupiedBuffer ) {
 236         if( m_p ) {
 237             free( m_p );
 238         }
 239         m_p = 0;
 240         m_nBufferLen = 0;
 241         m_nStart = 0;
 242     }
 243
 244     checkInvariants();
 245 }
 246
 247 }