Stream.h

Go to the documentation of this file.

#pragma once
#include <stdint.h>
#include <iostream>
#include <vector>
#include "../Types.h"
#include "../SGuid.h"
#include "../Geometry/Point.h"
#include "../Geometry/Size.h"
#include "../Graphics/Color.h"
 
namespace Gorgon { namespace IO { 
 
    template<class E_>
    inline E_ ReadEnum32(std::istream &stream) {
        int32_t r;
        stream.read(reinterpret_cast<char*>(&r), sizeof(int32_t));
 
        return E_(r);
    }
 
    inline long ReadInt32(std::istream &stream) {
        int32_t r;
        stream.read(reinterpret_cast<char*>(&r), sizeof(int32_t));
 
        return r;
    }
 
    inline unsigned long ReadUInt32(std::istream &stream) {
        uint32_t r;
        stream.read(reinterpret_cast<char*>(&r), sizeof(uint32_t));
 
        return r;
    }
 
    inline int ReadInt16(std::istream &stream) {
        int16_t r;
        stream.read(reinterpret_cast<char*>(&r), sizeof(int16_t));
 
        return r;
    }
 
    inline unsigned ReadUInt16(std::istream &stream) {
        uint16_t r;
        stream.read(reinterpret_cast<char*>(&r), sizeof(uint16_t));
 
        return r;
    }
 
    inline char ReadInt8(std::istream &stream) {
        int8_t r;
        stream.read(reinterpret_cast<char*>(&r), sizeof(int8_t));
 
        return r;
    }
 
    inline Byte ReadUInt8(std::istream &stream) {
        uint8_t r;
        stream.read(reinterpret_cast<char*>(&r), sizeof(uint8_t));
 
        return r;
    }
 
    inline float ReadFloat(std::istream &stream) {
        static_assert(sizeof(float) == 4, "Current implementation only supports 32bit floats");
 
        float r;
        // cppcheck-suppress invalidPointerCast
        //this is ok due to requirement of standard float and double is necessary for Gorgon library
        stream.read(reinterpret_cast<char*>(&r), 4);
 
        return r;
    }
 
    inline double ReadDouble(std::istream &stream) {
        static_assert(sizeof(double) == 8, "Current implementation only supports 64bit floats");
 
        float r;
        // cppcheck-suppress invalidPointerCast
        //this is ok due to requirement of standard float and double is necessary for Gorgon library
        stream.read(reinterpret_cast<char*>(&r), 4);
 
        return r;
    }
 
    inline bool ReadBool(std::istream &stream) {
        return ReadInt32(stream) != 0;
    }
    
    inline Graphics::RGBA ReadRGBA(std::istream &stream) {
        Graphics::RGBA color;
        
        color.R = ReadUInt8(stream);
        color.G = ReadUInt8(stream);
        color.B = ReadUInt8(stream);
        color.A = ReadUInt8(stream);
        
        return color;
    }
    
    inline Graphics::RGBAf ReadRGBAf(std::istream &stream) {
        Graphics::RGBAf color;
        
        color.R = ReadFloat(stream);
        color.G = ReadFloat(stream);
        color.B = ReadFloat(stream);
        color.A = ReadFloat(stream);
        
        return color;
    }
 
    inline std::string ReadString(std::istream &stream) {
        unsigned long size;
        std::string ret;
        size = ReadUInt32(stream);
        ret.resize(size);
        stream.read(&ret[0], size);
 
        return ret;
    }
 
    inline std::string ReadString(std::istream &stream, unsigned long size) {
        std::string ret;
        ret.resize(size);
        stream.read(&ret[0], size);
        return ret;
    }
 
    template<class T_>
    inline void ReadArray(std::istream &stream, T_ *data, unsigned long size) {
        stream.read((char*)data, size*sizeof(T_));
    }
 
    inline SGuid ReadGuid(std::istream &stream) {
        return SGuid(stream);
    }
    
    inline Geometry::Point ReadPoint(std::istream &stream) {
        auto x = ReadInt32(stream);
        auto y = ReadInt32(stream);
        
        return {(int)x, (int)y};
    }
    
    inline Geometry::Pointf ReadPointf(std::istream &stream) {
        auto x = ReadFloat(stream);
        auto y = ReadFloat(stream);
        
        return {x, y};
    }
    
    inline Geometry::Size ReadSize(std::istream &stream) {
        auto w = ReadInt32(stream);
        auto h = ReadInt32(stream);
        
        return {(int)w, (int)h};
    }
 
    
    template<class E_>
    inline void WriteEnum32(std::ostream &stream, E_ v) {
        int32_t r = (int32_t)(v);
        stream.write(reinterpret_cast<char*>(&r), sizeof(int32_t));
    }
 
    inline void WriteInt32(std::ostream &stream, long value) {
        int32_t r = value;
        stream.write(reinterpret_cast<const char*>(&r), sizeof(int32_t));
    }
 
    inline void WriteUInt32(std::ostream &stream, unsigned long value) {
        uint32_t r = value;
        stream.write(reinterpret_cast<const char*>(&r), sizeof(uint32_t));
    }
 
    inline void WriteInt16(std::ostream &stream, int value) {
        int16_t r = value;
        stream.write(reinterpret_cast<const char*>(&r), sizeof(int16_t));
    }
 
    inline void WriteUInt16(std::ostream &stream, unsigned value) {
        uint16_t r = value;
        stream.write(reinterpret_cast<const char*>(&r), sizeof(uint16_t));
    }
 
    inline void WriteInt8(std::ostream &stream, char value) {
        stream.write(reinterpret_cast<const char*>(&value), sizeof(int8_t));
    }
 
    inline void WriteUInt8(std::ostream &stream, Byte value) {
        stream.write(reinterpret_cast<const char*>(&value), sizeof(uint8_t));
    }
 
    inline void WriteFloat(std::ostream &stream, float value) {
        static_assert(sizeof(float) == 4, "Current implementation only supports 32bit floats");
 
        // cppcheck-suppress invalidPointerCast
        //this is ok due to requirement of standard float and double is necessary for Gorgon library
        stream.write(reinterpret_cast<const char*>(&value), 4);
    }
 
    inline void WriteDouble(std::ostream &stream, double value) {
        static_assert(sizeof(double) == 8, "Current implementation only supports 64bit floats");
 
        // cppcheck-suppress invalidPointerCast
        //this is ok due to requirement of standard float and double is necessary for Gorgon library
        stream.write(reinterpret_cast<const char*>(&value), 4);
    }
 
    inline void WriteBool(std::ostream &stream, bool value) {
        WriteInt32(stream, value);
    }
    
    inline void WriteRGBA(std::ostream &stream, Graphics::RGBA value) {
        WriteUInt8(stream, value.R);
        WriteUInt8(stream, value.G);
        WriteUInt8(stream, value.B);
        WriteUInt8(stream, value.A);
    }
    
    inline void WriteRGBAf(std::ostream &stream, Graphics::RGBAf value) {
        WriteFloat(stream, value.R);
        WriteFloat(stream, value.G);
        WriteFloat(stream, value.B);
        WriteFloat(stream, value.A);
    }
 
    inline void WriteStringWithSize(std::ostream &stream, const std::string &value) {
        WriteUInt32(stream, (unsigned long)value.size());
        
        stream.write(&value[0], value.size());
    }
 
    inline void WriteString(std::ostream &stream, const std::string &value) {
        stream.write(&value[0], value.size());
    }
 
    template<class T_>
    inline void WriteArray(std::ostream &stream, const T_ *data, unsigned long size) {
        stream.write((const char*)data, size*sizeof(T_));
    }
    
 
    template<class T_>
    inline void WriteVector(std::ostream &stream, const std::vector<T_> &data) {
        stream.write((const char*)&data[0], data.size()*sizeof(T_));
    }
    
 
    inline void WriteGuid(std::ostream &stream, const SGuid &value) {
        WriteArray(stream, value.Bytes, 8);
    }
    
    inline void WritePoint(std::ostream &stream, Geometry::Point p) {
        WriteInt32(stream, p.X);
        WriteInt32(stream, p.Y);
    }
    
    template<class F_ = Float>
    typename std::enable_if<std::is_same<F_, float>::value, void>::type
    WritePointf(std::ostream &stream, Geometry::Pointf p) {
        WriteFloat(stream, p.X);
        WriteFloat(stream, p.Y);
    }
 
    inline void WriteSize(std::ostream &stream, Geometry::Size s) {
        WriteInt32(stream, s.Width);
        WriteInt32(stream, s.Height);
    }
} }
 
 
inline long operator +(const std::streampos &l, long r) {
    return (long)l + r;
}
 
inline long operator +(const std::streampos &l, int r) {
    return (long)l + r;
}
 
inline unsigned long operator +(const std::streampos &l, unsigned long r) {
    return (unsigned long)l + r;
}
 
inline long operator -(const std::streampos &l, unsigned long r) {
    return (long)l - r;
}
 
inline long operator -(const std::streampos &l, long r) {
    return (long)l - r;
}
 
inline long operator -(const std::streampos &l, int r) {
    return (unsigned long)l - r;
}