SequentialWriteBuffer.hpp

Go to the documentation of this file.

/*==========================================================================
 * Copyright (c) 2004 University of Massachusetts.  All Rights Reserved.
 *
 * Use of the Lemur Toolkit for Language Modeling and Information Retrieval
 * is subject to the terms of the software license set forth in the LICENSE
 * file included with this software, and also available at
 * http://www.lemurproject.org/license.html
 *
 *==========================================================================
 */

//
// SequentialWriteBuffer
//
// 15 November 2004 -- tds
//

#ifndef INDRI_SEQUENTIALWRITEBUFFER_HPP
#define INDRI_SEQUENTIALWRITEBUFFER_HPP

#include "indri/File.hpp"
#include "indri/InternalFileBuffer.hpp"
namespace indri
{
  namespace file
  {
    class SequentialWriteBuffer {
    private:
      File& _file;
      InternalFileBuffer _current;
      UINT64 _position;
      UINT64 _eof;

    public:
      SequentialWriteBuffer( File& file, size_t length ) :
        _file(file),
        _current(length),
        _position(0),
        _eof(0)
      {
        _eof = _file.size();
        _position = _eof;
      }

      void seek( UINT64 position ) {
        // this only resets the file pointer; notice that data may not be written to
        // disk until write is called
        _position = position;
      }

      char* write( size_t length ) {
        UINT64 endBuffer = _current.filePosition + _current.buffer.size();
        UINT64 endBufferData = _current.filePosition + _current.buffer.position();
        UINT64 endWrite = length + _position;
        UINT64 startWrite = _position;
        UINT64 startBuffer = _current.filePosition;
        char* writeSpot;

        // if this write starts before the buffered data does, we have to flush
        bool writeStartsBeforeBuffer = startBuffer > startWrite;
        // if this write ends after the end of our buffer, we need to flush the buffer
        // to make room for this data.
        bool writeEndsAfterBuffer = endBuffer < endWrite;
        // if this write creates a "gap" in the buffer, we have to write data.

        // here's an example.  Suppose we have already written 1MB of 0's to 
        // the file.  Then, we seek to the beginning of the file and write 
        // 20 bytes of 1's.  Then, we seek forward to 100 bytes and try to write
        // more 0's.  There is enough space in the buffer for that write to 
        // succeed, but that would leave an 80 byte gap in the buffer.
        // when the buffer is flushed to disk, that 80 byte gap would clobber
        // the 0's that are already on disk.
        // Notice that there's no problem if the 'gap' is after the current end of
        // the file, because that space is undefined anyway.
        bool dataGap = (endBufferData < _eof && startWrite > endBufferData);

        if( writeStartsBeforeBuffer || writeEndsAfterBuffer || dataGap ) {
          flush();
          _current.filePosition = _position;

          startBuffer = _current.filePosition;
          endBuffer = _current.filePosition + _current.buffer.size();
          endBufferData = _current.filePosition + _current.buffer.position();
        }

        // There's a possibility that there isn't enough room to buffer this write,
        // even though we cleared it out.  In that case, make it bigger.
        if( endWrite > endBufferData ) {
          // need to move the buffer pointer to the end, potentially resizing buffer
          _current.buffer.write( size_t(endWrite - endBufferData) );
          endBufferData = _current.filePosition + _current.buffer.position();
        }

        assert( endWrite <= endBufferData && startWrite >= startBuffer );
        writeSpot = _current.buffer.front() + (_position - _current.filePosition);
        assert( writeSpot + length <= _current.buffer.front() + _current.buffer.position() );
        _position += length;

        return writeSpot;
      }

      void write( const void* buffer, size_t length ) {
        memcpy( write( length ), buffer, length );
      }
  
      void unwrite( size_t length ) {
        assert( length <= _current.buffer.position() );
        _current.buffer.unwrite( length );
        _position -= length;
      }

      UINT64 tell() const {
        return _position;
      }

      void flush() {
        size_t bytes = _current.buffer.position();
        // write current buffered data out to the file
        _file.write( _current.buffer.front(), _current.filePosition, _current.buffer.position() );
        // clear out the data in the buffer
        _current.buffer.clear();
        _current.filePosition += bytes;
        // update the end of file marker if necessary
        _eof = lemur_compat::max( _current.filePosition, _eof );
      }

      void flushRegion( UINT64 start, UINT64 length ) {
        if( (start+length) >= _current.filePosition &&
            start <= _current.filePosition + _current.buffer.position() )
        {
          flush();
        }
      }
    };
  }
}

#endif // INDRI_SEQUENTIALWRITEBUFFER_HPP

---