// // BufferedStreamBuf.h // // $Id: //poco/Main/Foundation/include/Poco/BufferedStreamBuf.h#6 $ // // Library: Foundation // Package: Streams // Module: StreamBuf // // Definition of template BasicBufferedStreamBuf and class BufferedStreamBuf. // // Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH. // and Contributors. // // Permission is hereby granted, free of charge, to any person or organization // obtaining a copy of the software and accompanying documentation covered by // this license (the "Software") to use, reproduce, display, distribute, // execute, and transmit the Software, and to prepare derivative works of the // Software, and to permit third-parties to whom the Software is furnished to // do so, all subject to the following: // // The copyright notices in the Software and this entire statement, including // the above license grant, this restriction and the following disclaimer, // must be included in all copies of the Software, in whole or in part, and // all derivative works of the Software, unless such copies or derivative // works are solely in the form of machine-executable object code generated by // a source language processor. // // 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, TITLE AND NON-INFRINGEMENT. IN NO EVENT // SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE // FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER // DEALINGS IN THE SOFTWARE. // #ifndef Foundation_BufferedStreamBuf_INCLUDED #define Foundation_BufferedStreamBuf_INCLUDED #include "Poco/Foundation.h" #include "Poco/BufferAllocator.h" #include "Poco/StreamUtil.h" #include #include #include namespace Poco { template > class BasicBufferedStreamBuf: public std::basic_streambuf /// This is an implementation of a buffered streambuf /// that greatly simplifies the implementation of /// custom streambufs of various kinds. /// Derived classes only have to override the methods /// readFromDevice() or writeToDevice(). /// /// This streambuf only supports unidirectional streams. /// In other words, the BasicBufferedStreamBuf can be /// used for the implementation of an istream or an /// ostream, but not for an iostream. { protected: typedef std::basic_streambuf Base; typedef std::basic_ios IOS; typedef ch char_type; typedef tr char_traits; typedef ba Allocator; typedef typename Base::int_type int_type; typedef typename Base::pos_type pos_type; typedef typename Base::off_type off_type; typedef typename IOS::openmode openmode; public: BasicBufferedStreamBuf(std::streamsize bufferSize, openmode mode): _bufsize(bufferSize), _pBuffer(Allocator::allocate(_bufsize)), _mode(mode) { this->setg(_pBuffer + 4, _pBuffer + 4, _pBuffer + 4); this->setp(_pBuffer, _pBuffer + (_bufsize - 1)); } ~BasicBufferedStreamBuf() { Allocator::deallocate(_pBuffer, _bufsize); } virtual int_type overflow(int_type c) { if (!(_mode & IOS::out)) return char_traits::eof(); if (c != char_traits::eof()) { *this->pptr() = char_traits::to_char_type(c); this->pbump(1); } if (flushBuffer() == std::streamsize(-1)) return char_traits::eof(); return c; } virtual int_type underflow() { if (!(_mode & IOS::in)) return char_traits::eof(); if (this->gptr() && (this->gptr() < this->egptr())) return char_traits::to_int_type(*this->gptr()); int putback = int(this->gptr() - this->eback()); if (putback > 4) putback = 4; char_traits::move(_pBuffer + (4 - putback), this->gptr() - putback, putback); int n = readFromDevice(_pBuffer + 4, _bufsize - 4); if (n <= 0) return char_traits::eof(); this->setg(_pBuffer + (4 - putback), _pBuffer + 4, _pBuffer + 4 + n); // return next character return char_traits::to_int_type(*this->gptr()); } virtual int sync() { if (this->pptr() && this->pptr() > this->pbase()) { if (flushBuffer() == -1) return -1; } return 0; } protected: void setMode(openmode mode) { _mode = mode; } openmode getMode() const { return _mode; } private: virtual int readFromDevice(char_type* buffer, std::streamsize length) { return 0; } virtual int writeToDevice(const char_type* buffer, std::streamsize length) { return 0; } int flushBuffer() { int n = int(this->pptr() - this->pbase()); if (writeToDevice(this->pbase(), n) == n) { this->pbump(-n); return n; } return -1; } std::streamsize _bufsize; char_type* _pBuffer; openmode _mode; BasicBufferedStreamBuf(const BasicBufferedStreamBuf&); BasicBufferedStreamBuf& operator = (const BasicBufferedStreamBuf&); }; // // We provide an instantiation for char // typedef BasicBufferedStreamBuf > BufferedStreamBuf; } // namespace Poco #endif // Foundation_BufferedStreamBuf_INCLUDED