D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/Base/spInputOutputFile.hpp

Go to the documentation of this file.

/*
 * File interface header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_INPUTOUTPUT_FILE_H__
#define __SP_INPUTOUTPUT_FILE_H__


#include "Base/spStandard.hpp"
#include "Base/spInputOutputString.hpp"
#include "Base/spDimensionVector3D.hpp"
#include "Base/spDimensionQuaternion.hpp"
#include "Base/spDimensionMatrix4.hpp"
#include "Base/spMaterialColor.hpp"

#include <cstdlib>
#include <sstream>
#include <string>
#include <cstdio>


namespace sp
{
namespace io
{


enum EFileSeekTypes
{
    FILEPOS_BEGIN   = SEEK_SET,
    FILEPOS_CURRENT = SEEK_CUR,
    FILEPOS_END     = SEEK_END
};

enum EFilePermission
{
    FILE_UNDEFINED,         
    FILE_READ,              
    FILE_WRITE,             
    FILE_WRITE_APPEND,      
    FILE_READWRITE,         
    FILE_READWRITE_APPEND,  
};

enum EFileTypes
{
    FILE_PHYSICAL,  
    FILE_VIRTUAL,   
    FILE_ASSET,     
};


class SP_EXPORT File
{
    
    public:
        
        virtual ~File();
        
        /* === File access functions === */
        
        virtual bool open(const io::stringc &Filename, const EFilePermission Permission = FILE_READWRITE) = 0;
        
        virtual void close() = 0;
        
        /* === Write functions === */
        
        virtual s32 writeString(const stringc &Str, u32 Count = 1);
        
        virtual s32 writeStringN(const stringc &Str, u32 Count = 1);
        
        virtual s32 writeStringC(const stringc &Str, u32 Count = 1);
        
        virtual s32 writeStringData(const stringc &Str, u32 Count = 1);
        
        /* === Read functions === */
        
        virtual stringc readString(s32 Length) const;
        
        virtual stringc readString(bool BreakPrompt = false) const;
        
        virtual stringc readStringC() const;
        
        virtual stringc readStringData() const;
        
        /* === Other reading/writing functions === */
        
        virtual s32 writeBuffer(const void* Buffer, u32 Size, u32 Count = 1) = 0;
        virtual s32 readBuffer(void* Buffer, u32 Size, u32 Count = 1) const = 0;
        
        virtual void writeColor(const video::color &Color);
        virtual video::color readColor() const;
        
        virtual void setSeek(s32 Pos, const EFileSeekTypes PosType = FILEPOS_BEGIN) = 0;
        virtual s32 getSeek() const = 0;
        
        virtual bool isEOF() const = 0;
        
        virtual u32 getSize() const = 0;
        
        virtual void* getHandle() = 0;
        
        virtual bool opened() const = 0;
        
        /* === Inline functions === */
        
        inline void setFilename(const io::stringc &Filename)
        {
            Filename_ = Filename;
        }
        inline stringc getFilename() const
        {
            return Filename_;
        }
        
        inline EFileTypes getType() const
        {
            return Type_;
        }
        inline EFilePermission getPermission() const
        {
            return Permission_;
        }
        
        inline bool hasReadAccess() const
        {
            return Permission_ == FILE_READ || Permission_ == FILE_READWRITE || Permission_ == FILE_READWRITE_APPEND;
        }
        inline bool hasWriteAccess() const
        {
            return Permission_ == FILE_WRITE || Permission_ == FILE_WRITE_APPEND || Permission_ == FILE_READWRITE || Permission_ == FILE_READWRITE_APPEND;
        }
        
        inline void ignore(s32 Count)
        {
            setSeek(Count, FILEPOS_CURRENT);
        }
        
        /* === Templates === */
        
        template <typename T> s32 writeValue(const T &Value, u32 Count = 1)
        {
            return writeBuffer(&Value, sizeof(T), Count);
        }
        template <typename T> T readValue() const
        {
            T Value;
            readBuffer(&Value, sizeof(Value));
            return Value;
        }
        
        template <typename T> void writeVector(const dim::vector3d<T> &Vec)
        {
            writeBuffer(&Vec.X, sizeof(dim::vector3d<T>));
        }
        template <typename T> dim::vector3d<T> readVector() const
        {
            dim::vector3d<T> Vec;
            readBuffer(&Vec.X, sizeof(dim::vector3d<T>));
            return Vec;
        }
        
        template <typename T> void writeMatrix(const dim::matrix4<T> &Mat)
        {
            writeBuffer(Mat.getArray(), sizeof(dim::matrix4<T>));
        }
        template <typename T> dim::matrix4<T> readMatrix() const
        {
            dim::matrix4<T> Mat;
            readBuffer(&Mat[0], sizeof(dim::matrix4<T>));
            return Mat;
        }
        
        inline void writeQuaternion(const dim::quaternion &Quat)
        {
            writeBuffer(&Quat.X, sizeof(dim::quaternion));
        }
        inline dim::quaternion readQuaternion() const
        {
            dim::quaternion Quat;
            readBuffer(&Quat.X, sizeof(dim::quaternion));
            return Quat;
        }
        
    protected:
        
        File(const EFileTypes Type);
        
        /* Members */
        
        stringc Filename_;
        EFileTypes Type_;
        EFilePermission Permission_;
        
};


} // /namespace io

} // /namespace sp


#endif



// ================================================================================