PByteStream.h

Go to the documentation of this file.

/*
 * Copyright (C) 2015-2018 Digital Barriers plc. All rights reserved.
 * Contact: http://www.digitalbarriers.com/
 *
 * This file is part of the Papillon SDK.
 *
 * You can't use, modify or distribute any part of this file without
 * the explicit written agreements of Digital Barriers.
 */

#pragma once
#include <PObject.h>
#include <PResult.h>

PAPILLON_BEGIN_NAMESPACE

class PByteArray;

class PAPILLON_API_CORE PByteStream : public PObject
{
public:
    PByteStream();

    PByteStream(const PByteStream& other);

    virtual ~PByteStream();

    PByteStream& operator=(const PByteStream& other);

    bool operator==(const PByteStream& other) const;

    PResult IsOpened() const;

    PResult Flush();

    PResult Close();

    bool CanSeek() const;

    papillon::int64 GetPosition() const;

    PResult Seek(papillon::uint64 n);

    PResult Rewind();

    bool HasSize() const;

    papillon::int64 Size() const;

    PResult Resize(papillon::uint64 newSize);

    bool CanRead() const;

    PResult ReadByte(papillon::int8& value);

    PResult ReadBytes(void* destinationBuffer, papillon::uint64 n);

    PResult ReadBytes(PByteArray& destinationArray, papillon::uint64 position, papillon::uint64 n);

    template <typename T>
    PResult ReadObject(T& t)
    {
        return t.Read(*this);
    }

    template <typename T>
    PByteStream& operator>>(T& t)
    {
        if (ReadObject(t).LogErrorIfAny2(PAPILLON_SRC_POS).Failed())
            throw std::exception();
        return *this;
    }

    bool CanWrite() const;

    PResult WriteByte(papillon::int8 value);

    PResult WriteBytes(const void* sourceBuffer, papillon::uint64 n);

    PResult WriteBytes(const PByteArray& sourceArray, papillon::uint64 sourcePosition, papillon::uint64 numBytes = 0);

    template <typename T>
    PResult WriteObject(const T& t)
    {
        return t.Write(*this);
    }

    template <typename T>
    PByteStream& operator<<(const T& t)
    {
        if (WriteObject(t).LogErrorIfAny2(PAPILLON_SRC_POS).Failed())
            throw std::exception();
        return *this;
    }

    static PResult ReadClassIdAndCheck(PByteStream& is, classid expectedClassId);

    private:
        PResult ReadBytesWithoutChecks(void* destinationBuffer, papillon::uint64 n);
};

template <> inline PResult PByteStream::ReadObject(bool& value)                   { return ReadBytesWithoutChecks(&value, sizeof(int8  )); }
template <> inline PResult PByteStream::ReadObject(papillon::int8& value)         { return ReadBytesWithoutChecks(&value, sizeof(int8  )); }
template <> inline PResult PByteStream::ReadObject(papillon::int16& value)        { return ReadBytesWithoutChecks(&value, sizeof(int16 )); }
template <> inline PResult PByteStream::ReadObject(papillon::int32& value)        { return ReadBytesWithoutChecks(&value, sizeof(int32 )); }
template <> inline PResult PByteStream::ReadObject(papillon::int64& value)        { return ReadBytesWithoutChecks(&value, sizeof(int64 )); }
template <> inline PResult PByteStream::ReadObject(papillon::uint8& value)        { return ReadBytesWithoutChecks(&value, sizeof(uint8 )); }
template <> inline PResult PByteStream::ReadObject(papillon::uint16& value)       { return ReadBytesWithoutChecks(&value, sizeof(uint16)); }
template <> inline PResult PByteStream::ReadObject(papillon::uint32& value)       { return ReadBytesWithoutChecks(&value, sizeof(uint32)); }
template <> inline PResult PByteStream::ReadObject(papillon::uint64& value)       { return ReadBytesWithoutChecks(&value, sizeof(uint64)); }
template <> inline PResult PByteStream::ReadObject(float& value)                  { return ReadBytesWithoutChecks(&value, sizeof(float )); }
template <> inline PResult PByteStream::ReadObject(double& value)                 { return ReadBytesWithoutChecks(&value, sizeof(double)); }

template <> inline PResult PByteStream::WriteObject(const bool& value)            { return WriteBytes(&value, sizeof(bool  )); }
template <> inline PResult PByteStream::WriteObject(const papillon::int8& value)  { return WriteBytes(&value, sizeof(int8  )); }
template <> inline PResult PByteStream::WriteObject(const papillon::int16& value) { return WriteBytes(&value, sizeof(int16 )); }
template <> inline PResult PByteStream::WriteObject(const papillon::int32& value) { return WriteBytes(&value, sizeof(int32 )); }
template <> inline PResult PByteStream::WriteObject(const papillon::int64& value) { return WriteBytes(&value, sizeof(int64 )); }
template <> inline PResult PByteStream::WriteObject(const papillon::uint8& value) { return WriteBytes(&value, sizeof(uint8 )); }
template <> inline PResult PByteStream::WriteObject(const papillon::uint16& value){ return WriteBytes(&value, sizeof(uint16)); }
template <> inline PResult PByteStream::WriteObject(const papillon::uint32& value){ return WriteBytes(&value, sizeof(uint32)); }
template <> inline PResult PByteStream::WriteObject(const papillon::uint64& value){ return WriteBytes(&value, sizeof(uint64)); }
template <> inline PResult PByteStream::WriteObject(const float& value)           { return WriteBytes(&value, sizeof(float )); }
template <> inline PResult PByteStream::WriteObject(const double& value)          { return WriteBytes(&value, sizeof(double)); }

PAPILLON_END_NAMESPACE