file.h

#pragma once
#include "oxygine-include.h"
#include <vector>
#include "Object.h"
#include "FileSystem.h"
#include <string>

namespace oxygine
{
    namespace file
    {
        class STDFileSystem;


        typedef file::fileHandle* handle;

        class buffer
        {
        public:
            typedef unsigned char uchar;

            uchar& front() { return data.front(); }
            const uchar& front() const { return data.front(); }

            uchar& back() { return data.back(); }
            const uchar& back() const { return data.back(); }

            uchar& operator[](size_t i) { return data[i]; }
            const uchar& operator[](size_t i) const { return data[i]; }

            uchar& at(size_t i) { return data.at(i); }
            const uchar& at(size_t i) const { return data.at(i); }

            void push_back(uchar v) { return data.push_back(v); }
            uchar pop_back() { uchar v = data.back();  data.pop_back(); return v; }
            void reserve(size_t v) { data.reserve(v); }
            void resize(size_t v) { data.resize(v); }

            size_t size() const { return data.size(); }
            bool empty() const { return data.empty(); }

            const void* getData() const {if (data.empty()) return 0; return &data[0];}
            void* getData() { if (data.empty()) return 0; return &data[0]; }
            unsigned int getSize() const {return (unsigned int)data.size();}

            std::string getString() const {return std::string((char*)&data[0], size());}

            typedef std::vector<uchar> buff;
            buff data;
        };

        handle open(const std::string& file, const char* mode, error_policy ep = ep_show_error);

        void close(handle);

        int seek(handle, unsigned int offset, int whence);

        unsigned int tell(handle);

        unsigned int read(handle, void* dest, unsigned int size);

        bool read(const std::string& file, buffer& dest, error_policy ep = ep_show_error);

        unsigned int read(handle, buffer& dest);

        unsigned int write(handle, const void* data, unsigned int size);

        unsigned int write(const std::string& file, const buffer& data, error_policy ep = ep_show_error);
        unsigned int write(const std::string& file, const void* data, unsigned int size, error_policy ep = ep_show_error);

        bool exists(const std::string& file);

        unsigned int size(handle);

        bool deleteFile(const std::string& path, error_policy ep = ep_show_warning);

        bool rename(const std::string& src, const std::string& dest, error_policy ep = ep_show_warning);

        bool makeDirectory(const std::string& path);
        void makeDirectories(const std::string& path);

        void deleteDirectory(const std::string& path);

        file::STDFileSystem& fs();

        file::STDFileSystem& wfs();

        void mount(FileSystem* fs);

        void unmount(FileSystem* fs);

        class autoClose
        {
        public:
            autoClose(handle h): _handle(h) {}
            ~autoClose() {if (_handle) close(_handle);}

            handle getHandle() const {return _handle;}

        private:
            //non copyable
            autoClose(const autoClose&);
            const autoClose& operator=(const autoClose&);

            handle _handle;
        };



        void init(const char* company, const char* app);

        void free();
    }
}