IO.hpp

Go to the documentation of this file.

#pragma once

#include <Gosu/Platform.hpp>
#include <algorithm>
#include <cstddef>
#include <memory>
#include <string>
#include <vector>

namespace Gosu
{
    class Resource;
    
    enum ByteOrder { BO_LITTLE, BO_BIG, BO_DONT_CARE };
#ifdef __BIG_ENDIAN__
    const ByteOrder BO_NATIVE = BO_BIG, BO_OTHER = BO_LITTLE;
#else
    const ByteOrder BO_NATIVE = BO_LITTLE, BO_OTHER = BO_BIG;
#endif

    class Reader
    {
        const Resource* res;
        std::size_t pos;

    public:
        Reader(const Resource& resource, std::size_t position)
        : res(&resource), pos(position)
        {
        }

        const Resource& resource() const
        {
            return *res;
        }

        std::size_t position() const
        {
            return pos;
        }

        void set_position(std::size_t value)
        {
            // TODO: Check?
            pos = value;
        }

        void seek(std::ptrdiff_t offset)
        {
            // TODO: Check?
            pos += offset;
        }

        void read(void* dest_buffer, std::size_t length);
        
        template<typename T>
        void read_pod(T& t, ByteOrder bo = BO_DONT_CARE)
        {
            read(&t, sizeof t);
            if (bo == BO_OTHER) {
                char* begin = reinterpret_cast<char*>(&t);
                std::reverse(begin, begin + sizeof t);
            }
        }

        template<typename T>
        T get_pod(ByteOrder bo = BO_DONT_CARE)
        {
            T t;
            read_pod<T>(t, bo);
            return t;
        }
    };
    
    class Writer
    {
        Resource* res;
        std::size_t pos;

    public:
        Writer(Resource& resource, std::size_t position)
        : res(&resource), pos(position)
        {
        }

        Resource& resource() const
        {
            return *res;
        }

        std::size_t position() const
        {
            return pos;
        }

        void set_position(std::size_t value)
        {
            // TODO: Check?
            pos = value;
        }

        void seek(std::ptrdiff_t offset)
        {
            // TODO: Check?
            pos += offset;
        }

        void write(const void* source_buffer, std::size_t length);

        template<typename T>
        void write_pod(const T& t, ByteOrder bo = BO_DONT_CARE)
        {
            if (bo == BO_OTHER) {
                char buf[sizeof t];
                const char* begin = reinterpret_cast<const char*>(&t);
                std::reverse_copy(begin, begin + sizeof t, buf);
                write(buf, sizeof buf);
            }
            else {
                write(&t, sizeof t);
            }
        }
    };

    class Resource
    {
        // Non-copyable and non-movable to avoid slicing.
        Resource(const Resource&) = delete;
        Resource& operator=(const Resource&) = delete;
        Resource(Resource&&) = delete;
        Resource& operator=(Resource&&) = delete;

    public:
        Resource()
        {
        }
        
        virtual ~Resource()
        {
        }

        Reader front_reader() const
        {
            return Reader(*this, 0);
        }

        Writer back_writer()
        {
            return Writer(*this, size());
        }

        virtual std::size_t size() const = 0;

        virtual void resize(std::size_t new_size) = 0;

        virtual void read(std::size_t offset, std::size_t length, void* dest_buffer) const = 0;

        virtual void write(std::size_t offset, std::size_t length, const void* source_buffer) = 0;
    };

    class Buffer : public Resource
    {
        std::vector<char> buf;

    public:
        Buffer()
        {
        }

        Buffer(const Buffer& other)
        : Resource()
        , buf(other.buf)
        {
        }

        Buffer& operator=(const Buffer& other)
        {
            buf = other.buf;
            return *this;
        }

        std::size_t size() const override;

        void resize(std::size_t new_size) override;

        void read(std::size_t offset, std::size_t length, void* dest_buffer) const override;
        
        void write(std::size_t offset, std::size_t length, const void* source_buffer) override;

        const void* data() const
        {
            return &buf[0];
        }

        void* data()
        {
            return &buf[0];
        }
    };

    enum FileMode
    {
        FM_READ,
        FM_REPLACE,
        FM_ALTER
    };

    class File : public Resource
    {
        struct Impl;
        const std::unique_ptr<Impl> pimpl;

    public:
        explicit File(const std::string& filename, FileMode mode = FM_READ);
        ~File();

        std::size_t size() const override;
        
        void resize(std::size_t new_size) override;
        
        void read(std::size_t offset, std::size_t length, void* dest_buffer) const override;
        
        void write(std::size_t offset, std::size_t length, const void* source_buffer) override;
    };

    void load_file(Buffer& buffer, const std::string& filename);
    void save_file(const Buffer& buffer, const std::string& filename);
}