jmStreams.h

#ifndef JUGIMAP_STREAMS_H
#define JUGIMAP_STREAMS_H
 
#include <string>
#include <iostream>
#include <fstream>
 
#include "jmCommon.h"
 
 
 
namespace jugimap{
 
 
 
class SourceGraphics;
class Map;
class GraphicFile;
class GraphicItem;
class SourceSprite;
class VectorShape;
class FrameAnimation;
class SpriteLayer;
class VectorLayer;
class ComposedSprite;
class ObjectFactory;
 
 
 
 
class BinaryStreamReader
{
public:
 
    virtual ~BinaryStreamReader() {}
 
    virtual bool IsOpen() = 0;
 
    virtual int Pos() = 0;
 
    virtual void Seek(int _pos) = 0;
 
    virtual int Size() = 0;
 
    virtual void Close() = 0;
 
    virtual unsigned char ReadByte() = 0;
 
    virtual int ReadInt() = 0;
 
    virtual float ReadFloat() = 0;
 
    virtual std::string ReadString() = 0;
 
};
 
 
 
class StdBinaryFileStreamReader : public BinaryStreamReader
{
public:
 
    StdBinaryFileStreamReader(const std::string &fileName);
 
 
    bool IsOpen() override {return fs.is_open();}
    int Pos() override {return fs.tellg();}
    void Seek(int _pos) override {fs.seekg(_pos);}
    int Size() override {return size;}
    void Close() override {fs.close();}
 
 
    unsigned char ReadByte()  override
    {
        unsigned char value;
        fs.read(reinterpret_cast<char*>(&value), 1);
        return value;
    }
 
    int ReadInt()  override
    {
        int value;
        fs.read(reinterpret_cast<char*>(&value), 4);
        return value;
    }
 
    float ReadFloat()  override
    {
        float value;
        fs.read(reinterpret_cast<char*>(&value), 4);
        return value;
    }
 
    std::string ReadString() override;
 
 
 
 
private:
    std::ifstream fs;
    int size;
};
 
 
 
class BinaryBufferStreamReader : public BinaryStreamReader
{
public:
 
 
    BinaryBufferStreamReader(unsigned char *_buff, int _size, bool _ownedBuffer) : buff(_buff), size(_size), ownedBuffer(_ownedBuffer){}
 
 
    ~BinaryBufferStreamReader() override
    {
        if(ownedBuffer && buff!=nullptr){
            delete [] buff;
        }
    }
 
    bool IsOpen() override { return size > 0; }
    int Pos() override {return pos;}
    void Seek(int _pos) override { pos = _pos; }
    int Size() override {return size;}
    void Close() override {}
    unsigned char* GetBuffer() {return buff;}
 
 
    unsigned char ReadByte()  override
    {
        unsigned char value = (buff+pos)[0];
        pos += 1;
        return value;
    }
 
    int ReadInt()  override
    {
        int value = reinterpret_cast<int*>(buff+pos)[0];
        pos +=4;
        return value;
    }
 
    float ReadFloat()  override
    {
        float value = reinterpret_cast<float*>(buff+pos)[0];
        pos +=4;
        return value;
    }
 
 
    std::string ReadString() override
    {
        int length = ReadInt();
        std::string value(reinterpret_cast<char*>(buff+pos), length);
        pos += length;
        return value;
    }
 
protected:
 
    unsigned char* buff = nullptr;
    int size = 0;
    int pos = 0;
    bool ownedBuffer = false;
 
};
 
 
class TextStreamReader
{
public:
 
    virtual ~TextStreamReader() {}
 
    virtual bool IsOpen() = 0;
 
    virtual void ReadLine(std::string &s) = 0;
 
    virtual bool Eof() = 0;
 
    virtual void Close() = 0;
 
};
 
 
class StdTextFileStreamReader : public TextStreamReader
{
public:
 
    StdTextFileStreamReader(const std::string &fileName);
 
    virtual ~StdTextFileStreamReader() {}
 
 
    virtual bool IsOpen() override {return fs.is_open();}
 
 
    virtual void ReadLine(std::string &s) override {  std::getline(fs, s); };
 
 
    virtual bool Eof() override { return fs.eof(); }
 
 
    virtual void Close() override { fs.close(); }
 
 
private:
    std::ifstream fs;
    int size;
};
 
 
 
 
}
 
 
 
 
 
#endif