diff --git a/src/kits/support/BufferIO.cpp b/src/kits/support/BufferIO.cpp index 35a4915c4f..9a4b7da13b 100644 --- a/src/kits/support/BufferIO.cpp +++ b/src/kits/support/BufferIO.cpp @@ -1,108 +1,296 @@ -/* Just a skeleton of the BBufferIO class */ -/* To be implemented */ - - -#include - -BBufferIO::BBufferIO(BPositionIO *stream, size_t buf_size, bool owns_stream) - : - m_stream(stream), - m_buffer(new char[buf_size]), - m_buffer_phys(buf_size), - m_owns_stream(owns_stream) - -{ -} - - -BBufferIO::~BBufferIO() -{ - Flush(); //only guessed - delete[] m_buffer; - if (m_owns_stream) //only guessed - delete m_stream; -} - - -ssize_t -BBufferIO::ReadAt(off_t pos, void *buffer, size_t size) -{ - return 0; -} - - -ssize_t -BBufferIO::WriteAt(off_t pos, const void *buffer, size_t size) -{ - return 0; -} - - -off_t -BBufferIO::Seek(off_t position, uint32 seek_mode) -{ - return m_stream->Seek(position, seek_mode); -} - - -off_t -BBufferIO::Position() const -{ - return m_stream->Position(); -} - - -status_t -BBufferIO::SetSize(off_t size) -{ - return B_ERROR; -} - - -status_t -BBufferIO::Flush() -{ - return B_ERROR; -} - - -BPositionIO * -BBufferIO::Stream() const -{ - return m_stream; -} - - -size_t -BBufferIO::BufferSize() const -{ - return m_buffer_phys //or should we return m_buffer_used? -} - - -bool -BBufferIO::OwnsStream() const -{ - return m_owns_stream; -} - - -void -BBufferIO::SetOwnsStream(bool owns_stream) -{ - m_owns_stream = owns_stream; -} - - -void -BBufferIO::PrintToStream() const -{ -} - - -//FBC -status_t _Reserved_BufferIO_0(void *) {} -status_t _Reserved_BufferIO_1(void *) {} -status_t _Reserved_BufferIO_2(void *) {} -status_t _Reserved_BufferIO_3(void *) {} -status_t _Reserved_BufferIO_4(void *) {} \ No newline at end of file +//------------------------------------------------------------------------------ +// Copyright (c) 2001-2002, OpenBeOS +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the "Software"), +// to deal in the Software without restriction, including without limitation +// the rights to use, copy, modify, merge, publish, distribute, sublicense, +// and/or sell copies of the Software, and to permit persons to whom the +// Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. +// +// File Name: BufferIO.cpp +// Author(s): Stefano Ceccherini (burton666@libero.it) +// +// Description: A buffered adapter for BPositionIO objects. +//------------------------------------------------------------------------------ + + +/* XXX: Currently, this class implement buffered reading, + but not (yet) buffered writing. + I'm doing tests to ensure that the implementation of the buffered + writing will be correct. +*/ + +// Standard Includes ----------------------------------------------------------- +#include +#include + +// System Includes ------------------------------------------------------------- +#include + + +/*! \class BBufferIO + \brief A buffered adapter for BPositionIO objects. + \author m_buffer_phys) + return ReadAt(pos, buffer, size); + + // If the data we are looking for is not in the buffer... + if (size > m_buffer_used + || pos < m_buffer_start + || pos > m_buffer_start + m_buffer_used) + { + // ...cache as much as we can from the stream + ssize_t readSize = m_stream->ReadAt(pos, m_buffer, m_buffer_phys); + m_buffer_used += readSize; + + if (readSize > 0) + m_buffer_start = pos; // The data is buffered starting from this offset + } + + size = min_c(size, m_buffer_used); + + // copy data from the cache to the given buffer + memcpy(buffer, m_buffer + pos, size); + + return size; +} + + +/*! \brief Writes the specified amount of bytes at the given position. + \param pos The offset into the stream where to write. + \param buffer A pointer to a buffer which contains the data to write. + \param size The amount of bytes to write. + \return The amount of bytes actually written, or an error code. +*/ +ssize_t +BBufferIO::WriteAt(off_t pos, const void *buffer, size_t size) +{ + if (m_stream == NULL) + return B_NO_INIT; + + // XXX: Implement buffered write + + return m_stream->WriteAt(pos, buffer, size); +} + + +/*! \brief Sets the position in the stream. + + Sets the position in the stream where the Read() and Write() functions + (inherited from BPositionIO) begin reading and writing. + How the position argument is understood depends on the seek_mode flag. + + \param position The position where you want to seek. + \param seek_mode Can have three values: + + - \oSEEK_SET. The position passed is an offset from the beginning of the stream; + in other words, the current position is set to position. + For this mode, position should be a positive value. + + - \oSEEK_CUR. The position argument is an offset from the current position; + the value of the argument is added to the current position. + + - \oSEEK_END. The position argument is an offset from the end of the stream. + In this mode the position argument should be negative (or zero). + + \return The current position as an offset in bytes + from the beginning of the stream. +*/ +off_t +BBufferIO::Seek(off_t position, uint32 seek_mode) +{ + if (m_stream == NULL) + return B_NO_INIT; + + return m_stream->Seek(position, seek_mode); +} + + +/*! \brief Return the current position in the stream. + \return The current position as an offset in bytes + from the beginning of the stream. +*/ +off_t +BBufferIO::Position() const +{ + if (m_stream == NULL) + return B_NO_INIT; + + return m_stream->Position(); +} + + +/*! \brief Calls the SetSize() function of the assigned BPositionIO object. + \param size The new size of the BPositionIO object. + \return An error code. +*/ +status_t +BBufferIO::SetSize(off_t size) +{ + if (m_stream == NULL) + return B_NO_INIT; + + return m_stream->SetSize(size); +} + + +/*! \brief Writes pending modifications to the stream. + \return An error code. +*/ +status_t +BBufferIO::Flush() +{ + m_buffer_dirty = false; + + // XXX: Not implemented... yet + return B_ERROR; +} + + +/*! \brief Returns a pointer to the stream specified on construction + \return A pointer to the BPositionIO stream specified on construction. +*/ +BPositionIO * +BBufferIO::Stream() const +{ + return m_stream; +} + + +/*! \brief Returns the size of the internal buffer + \return The size of the buffer allocated by the object +*/ +size_t +BBufferIO::BufferSize() const +{ + return m_buffer_phys; +} + + +/*! \brief Tells if the BBufferIO object "owns" the specified stream. + \return A boolean value, which is true if the object "owns" + the stream (and so will delete it upon destruction), false if not. +*/ +bool +BBufferIO::OwnsStream() const +{ + return m_owns_stream; +} + + +/*! \brief Set the "owns_stream" property of the object. + \param owns_stream If it's true, the object will delete the stream + upon destruction, if it's false it will not. +*/ +void +BBufferIO::SetOwnsStream(bool owns_stream) +{ + m_owns_stream = owns_stream; +} + + +/*! \brief Prints the object to stdout. +*/ +void +BBufferIO::PrintToStream() const +{ + printf("stream %p\n", m_stream); + printf("buffer %p\n", m_buffer); + printf("start %lld\n", m_buffer_start); + printf("used %ld\n", m_buffer_used); + printf("phys %ld\n", m_buffer_phys); + printf("dirty %s\n", (m_buffer_dirty) ? "true" : "false"); + printf("owns %s\n", (m_owns_stream) ? "true" : "false"); +} + + +// These functions are here to maintain future binary +// compatibility. +status_t BBufferIO::_Reserved_BufferIO_0(void *) { return B_ERROR; } +status_t BBufferIO::_Reserved_BufferIO_1(void *) { return B_ERROR; } +status_t BBufferIO::_Reserved_BufferIO_2(void *) { return B_ERROR; } +status_t BBufferIO::_Reserved_BufferIO_3(void *) { return B_ERROR; } +status_t BBufferIO::_Reserved_BufferIO_4(void *) { return B_ERROR; } diff --git a/src/kits/support/support.src b/src/kits/support/support.src index 7229fcf690..7f5027beb2 100644 --- a/src/kits/support/support.src +++ b/src/kits/support/support.src @@ -2,6 +2,7 @@ SUPPORT_KIT_SOURCE = Archivable.cpp BlockCache.cpp DataIO.cpp + BufferIO.cpp Flattenable.cpp List.cpp Locker.cpp