MemoryStream.h

Go to the documentation of this file.

//
// MemoryStream.h
//
// Library: Foundation
// Package: Streams
// Module:  MemoryStream
//
// Definition of MemoryStreamBuf, MemoryInputStream, MemoryOutputStream
//
// Copyright (c) 2009, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
 
 
#ifndef Foundation_MemoryStream_INCLUDED
#define Foundation_MemoryStream_INCLUDED
 
 
#include "Poco/Bugcheck.h"
#include "Poco/Foundation.h"
#include "Poco/StreamUtil.h"
#include <streambuf>
#include <iosfwd>
#include <ios>
#include <istream>
#include <ostream>
 
 
namespace Poco {
 
 
template <typename ch, typename tr>
class BasicMemoryStreamBuf: public std::basic_streambuf<ch, tr>
    /// BasicMemoryStreamBuf is a simple implementation of a 
    /// stream buffer for reading and writing from a memory area.
    ///
    /// This streambuf only supports unidirectional streams.
    /// In other words, the BasicMemoryStreamBuf can be
    /// used for the implementation of an istream or an
    /// ostream, but not for an iostream.
{
protected:
    typedef std::basic_streambuf<ch, tr> Base;
    typedef std::basic_ios<ch, tr> IOS;
    typedef ch char_type;
    typedef tr char_traits;
    typedef typename Base::int_type int_type;
    typedef typename Base::pos_type pos_type;
    typedef typename Base::off_type off_type;
 
public:
    BasicMemoryStreamBuf(char_type* pBuffer, std::streamsize bufferSize):
        _pBuffer(pBuffer),
        _bufferSize(bufferSize)
    {
        this->setg(_pBuffer, _pBuffer, _pBuffer + _bufferSize);
        this->setp(_pBuffer, _pBuffer + _bufferSize);
    }
 
    ~BasicMemoryStreamBuf()
    {
    }
 
    virtual int_type overflow(int_type /*c*/)
    {
        return char_traits::eof();
    }
 
    virtual int_type underflow()
    {
        return char_traits::eof();
    }
 
    virtual pos_type seekoff(off_type off, std::ios_base::seekdir way, std::ios_base::openmode which = std::ios_base::in | std::ios_base::out)
    {
        const pos_type fail = off_type(-1);
        off_type newoff = off_type(-1);
 
        if ((which & std::ios_base::in) != 0)
        {
            if (this->gptr() == 0)
                return fail;
 
            if (way == std::ios_base::beg)
            {
                newoff = 0;
            }
            else if (way == std::ios_base::cur)
            {
                // cur is not valid if both in and out are specified (Condition 3)
                if ((which & std::ios_base::out) != 0)
                    return fail;
                newoff = this->gptr() - this->eback();
            }
            else if (way == std::ios_base::end)
            {
                newoff = this->egptr() - this->eback();
            }
            else
            {
                poco_bugcheck();
            }
 
            if ((newoff + off) < 0 || (this->egptr() - this->eback()) < (newoff + off))
                return fail;
            this->setg(this->eback(), this->eback() + newoff + off, this->egptr());
        }
 
        if ((which & std::ios_base::out) != 0)
        {
            if (this->pptr() == 0)
                return fail;
 
            if (way == std::ios_base::beg)
            {
                newoff = 0;
            }
            else if (way == std::ios_base::cur)
            {
                // cur is not valid if both in and out are specified (Condition 3)
                if ((which & std::ios_base::in) != 0)
                    return fail;
                newoff = this->pptr() - this->pbase();
            }
            else if (way == std::ios_base::end)
            {
                newoff = this->epptr() - this->pbase();
            }
            else
            {
                poco_bugcheck();
            }
 
            if (newoff + off < 0 || (this->epptr() - this->pbase()) < newoff + off)
                return fail;
            this->pbump((int)(newoff + off - (this->pptr() - this->pbase())));
        }
 
        return newoff;
    }
 
    virtual int sync()
    {
        return 0;
    }
 
    std::streamsize charsWritten() const
    {
        return static_cast<std::streamsize>(this->pptr() - this->pbase());
    }
 
    void reset()
        /// Resets the buffer so that current read and write positions
        /// will be set to the beginning of the buffer.
    {
        this->setg(_pBuffer, _pBuffer, _pBuffer + _bufferSize);
        this->setp(_pBuffer, _pBuffer + _bufferSize);
    }
 
private:
    char_type*      _pBuffer;
    std::streamsize _bufferSize;
 
    BasicMemoryStreamBuf();
    BasicMemoryStreamBuf(const BasicMemoryStreamBuf&);
    BasicMemoryStreamBuf& operator = (const BasicMemoryStreamBuf&);
};
 
 
//
// We provide an instantiation for char
//
typedef BasicMemoryStreamBuf<char, std::char_traits<char>> MemoryStreamBuf;
 
 
class Foundation_API MemoryIOS: public virtual std::ios
    /// The base class for MemoryInputStream and MemoryOutputStream.
    ///
    /// This class is needed to ensure the correct initialization
    /// order of the stream buffer and base classes.
{
public:
    MemoryIOS(char* pBuffer, std::streamsize bufferSize);
        /// Creates the basic stream.
 
    ~MemoryIOS();
        /// Destroys the stream.
 
    MemoryStreamBuf* rdbuf();
        /// Returns a pointer to the underlying streambuf.
 
protected:
    MemoryStreamBuf _buf;
};
 
 
class Foundation_API MemoryInputStream: public MemoryIOS, public std::istream
    /// An input stream for reading from a memory area.
{
public:
    MemoryInputStream(const char* pBuffer, std::streamsize bufferSize);
        /// Creates a MemoryInputStream for the given memory area,
        /// ready for reading.
 
    ~MemoryInputStream();
        /// Destroys the MemoryInputStream.
};
 
 
class Foundation_API MemoryOutputStream: public MemoryIOS, public std::ostream
    /// An input stream for reading from a memory area.
{
public:
    MemoryOutputStream(char* pBuffer, std::streamsize bufferSize);
        /// Creates a MemoryOutputStream for the given memory area,
        /// ready for writing.
 
    ~MemoryOutputStream();
        /// Destroys the MemoryInputStream.
 
    std::streamsize charsWritten() const;
        /// Returns the number of chars written to the buffer.
};
 
 
//
// inlines
//
inline MemoryStreamBuf* MemoryIOS::rdbuf()
{
    return &_buf;
}
 
 
inline std::streamsize MemoryOutputStream::charsWritten() const
{
    return _buf.charsWritten();
}
 
 
} // namespace Poco
 
 
#endif // Foundation_MemoryStream_INCLUDED