IO.hpp

Go to the documentation of this file.

#ifndef GOSU_IO_HPP
#define GOSU_IO_HPP

#include <boost/utility.hpp>
#include <boost/scoped_ptr.hpp>
#include <cstddef>
#include <algorithm>
#include <string>
#include <vector>

namespace Gosu
{
    class Resource;
    
    enum ByteOrder { boLittle, boBig, boDontCare };
#ifdef __BIG_ENDIAN__
    const ByteOrder nativeByteOrder = boBig, otherByteOrder = boLittle;
#else
    const ByteOrder nativeByteOrder = boLittle, otherByteOrder = boBig;
#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 setPosition(std::size_t value)
        {
            // TODO: Check?
            pos = value;
        }

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

        void read(void* destBuffer, std::size_t length);
        
        template<typename T>
        void readPod(T& t, ByteOrder bo = boDontCare)
        {
            read(&t, sizeof t);
            if (bo == otherByteOrder)
            {
                char* begin = reinterpret_cast<char*>(&t);
                std::reverse(begin, begin + sizeof t);
            }
        }

        template<typename T>
        T getPod(ByteOrder bo = boDontCare)
        {
            T t;
            readPod<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 setPosition(std::size_t value)
        {
            // TODO: Check?
            pos = value;
        }

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

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

        template<typename T>
        void writePod(const T& t, ByteOrder bo = boDontCare)
        {
            if (bo == otherByteOrder)
            {
                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 : boost::noncopyable
    {
    public:
        virtual ~Resource()
        {
        }

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

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

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

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

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

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

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

    public:
        Buffer()
        {
        }

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

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

        std::size_t size() const
        {
            return buf.size();
        }

        void resize(std::size_t newSize)
        {
            buf.resize(newSize);
        }

        void read(std::size_t offset, std::size_t length,
            void* destBuffer) const;

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

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

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

    enum FileMode
    {
        fmRead,
        fmReplace,
        fmAlter
    };

    class File : public Resource
    {
        struct Impl;
        boost::scoped_ptr<Impl> pimpl;

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

        std::size_t size() const;
        void resize(std::size_t newSize);
        void read(std::size_t offset, std::size_t length,
            void* destBuffer) const;
        void write(std::size_t offset, std::size_t length,
            const void* sourceBuffer);
    };

    void loadFile(Buffer& buffer, const std::wstring& filename);
    void saveFile(const Buffer& buffer, const std::wstring& filename);
}

#endif

Documentation not clear enough? Please go to one of the places listed on http://www.libgosu.org/ and leave feedback. Thanks!