stream.h

Go to the documentation of this file.

 
#ifndef _STREAM_CLASS_HEADER_
#define _STREAM_CLASS_HEADER_
 
namespace adtf
{
namespace ucom
{
namespace ant
{
 
class DOEXPORT cStream : public catwo::object<IInputStream, IOutputStream, IStream>
 
{
    A_UTILS_D(cStream)
 
    public:
        typedef enum : uint8_t
        {
            INPUT_STREAM    = 1,
            OUTPUT_STREAM   = 2
        } tStreamType;
 
    protected:
 
        tStreamType             m_eType;                            
        typedef enum // untyped for combinations
        {
            FLG_KEEP_POSITION   = 1,
            FLG_DONT_GROW       = 2
        } tStreamFlags;
 
    private:
        cStream() = delete;
        //USE CopyFrom
        cStream(const cStream& oStream) = delete;
        //USE CopyFrom or CopyTo
        // We need an return value because
        cStream& operator=(const cStream& oStream) = delete;
        cStream& operator=(cStream&& oStream) = delete;
        cStream(cStream&& oStream) = delete;
 
    public:
        explicit cStream(tStreamType eType,
                         tFileSize szBuffer=0,
                         uint32_t ui32Flags=0);;
 
        virtual ~cStream();
 
        tResult SetSize(tFileSize szBuffer, uint32_t ui32Flags=0);
 
        tResult CopyTo(cStream& strmOutput) const;
 
        tResult CopyFrom(cStream& strmInput);
 
        const void* GetCurrentPtr() const;
 
        tFileSize GetCurrentSize() const;
 
        tFileSize GetHighestPosIndex() const;
 
        tResult AttachReference(void* pReferenceBuffer, tFileSize szBufferSize);
 
        tResult DetachReference();
 
 
    public: // implements IStream
        tResult Read(void* pvBuffer, size_t nBufferSize, size_t* pnBytesRead=nullptr) const override;
 
        tResult Write(const void* pvBuffer, size_t nBufferSize, size_t* pnBytesWritten=nullptr) override;
 
        tResult Seek(tFilePos nPos, tSeekOrigin eOrigin, tFilePos* pNewPos=nullptr) const override;
 
        tResult Reset() override;
 
        tResult Flush() override;
 
    protected:
        bool IsEof() const;
        tFileSize GetRemainingBytes() const;
};
 
 
/**********************************************************************************************/
// Writer Helper functions
/**********************************************************************************************/
extern tResult ucom_write_to_stream_buffer(IOutputStream& oOutStream,
    const void* pBuffer,
    size_t szBuffer,
    size_t& szCount);
 
extern tResult ucom_write_to_stream_string(IOutputStream& oOutStream,
    const adtf_util::cString& strValue,
    size_t& szCount);
 
/**********************************************************************************************/
// READER Helper functions
/**********************************************************************************************/
extern tResult ucom_read_from_stream_buffer(const IInputStream& oInStream,
    void* pBuffer,
    size_t szBuffer,
    size_t& szCount);
 
extern tResult ucom_read_from_stream_string(const IInputStream& oInStream,
    adtf_util::cString& strValue,
    size_t& szReadCount);
 
template<typename T>
struct ucom_type_streamer
{
public:
    static tResult Write(IOutputStream& oOutStream,
                         const T& oValue,
                         size_t& szCount)
    {
        //we need access to swap value in memory
        T oValueToWrite = oValue;
        if (IStream::m_ui8PlatformByteOrder == PLATFORM_BIG_ENDIAN_8)
        {
            RETURN_IF_FAILED(adtf_util::cSystem::SwapEndian(&oValueToWrite));
        }
 
        auto pReadPosition = reinterpret_cast<const uint8_t*>(&oValueToWrite);
        size_t nBytesToWrite = sizeof(oValueToWrite);
        while (nBytesToWrite)
        {
            size_t szWrittenSize = 0;
            RETURN_IF_FAILED(oOutStream.Write(pReadPosition, nBytesToWrite, &szWrittenSize));
            szCount += szWrittenSize;
            pReadPosition += szWrittenSize;
            nBytesToWrite -= szWrittenSize;
        }
 
        RETURN_NOERROR;
    }
 
    static tResult Read(const IInputStream& oInStream,
                        T& oValue,
                        size_t& szCount)
    {
        auto pWritePosition = reinterpret_cast<uint8_t*>(&oValue);
        size_t nBytesToRead = sizeof(oValue);
        while (nBytesToRead)
        {
            size_t szReadSize = 0;
            RETURN_IF_FAILED(oInStream.Read(pWritePosition, nBytesToRead, &szReadSize));
            szCount += szReadSize;
            pWritePosition += szReadSize;
            nBytesToRead -= szReadSize;
        }
        
        RETURN_NOERROR;
    }
};
 
template<>
struct ucom_type_streamer<adtf_util::cString>
{
public:
    static tResult Write(IOutputStream& oOutStream,
                         const adtf_util::cString& strValue,
                         size_t& szCount)
    {
        return ucom_write_to_stream_string(oOutStream, strValue, szCount);
    }
    static tResult Read(const IInputStream& oInStream,
                        adtf_util::cString& strValue,
                        size_t& szReadCount)
    {
        return ucom_read_from_stream_string(oInStream, strValue, szReadCount);
    }
};
 
//Function template for writing and reading types to and from a IStream
template<typename T>
tResult ucom_write_to_stream(IOutputStream& oOutStream, const T& oValue, size_t& szCount)
{
    return ucom_type_streamer<T>::Write(oOutStream, oValue, szCount);
}
 
template<typename T>
tResult ucom_read_from_stream(const IInputStream& oInStream, T& oValue, size_t& szCount)
{
    return ucom_type_streamer<T>::Read(oInStream, oValue, szCount);
}
 
template<typename T>
IOutputStream& operator<<(IOutputStream& oWriteStream, const T& oValue)
{
    size_t szCount = 0;
    ucom_type_streamer<T>::Write(oWriteStream, oValue, szCount);
    return oWriteStream;
}
 
template<typename T>
const IInputStream& operator>>(const IInputStream& oReadStream, T& oValue)
{
    size_t szCount = 0;
    ucom_type_streamer<T>::Read(oReadStream, oValue, szCount);
    return oReadStream;
}
 
 
}//ns ant
 
using ant::cStream;
 
using ant::ucom_type_streamer;
 
using ant::ucom_write_to_stream;
using ant::ucom_read_from_stream;
 
using ant::ucom_write_to_stream_buffer;
using ant::ucom_read_from_stream_buffer;
 
using ant::ucom_write_to_stream_string;
using ant::ucom_read_from_stream_string;
 
}//ns ucom
}//ns adtf
 
#endif // _STREAM_CLASS_HEADER_