File.h

Go to the documentation of this file.

#ifndef BASIC_FILE_H
#define BASIC_FILE_H

#define FILEREAD 0x1
#define FILEWRITE 0x2
#define FILECLIENT 0x1
#define FILESERVER 0x2
#define FILESEEKSTART 0
#define FILESEEKCURRENT 1
#define FILESEEKEND 2

#ifdef _WIN32
#include <basetsd.h>
typedef UINT_PTR SOCKET;
#else
typedef int SOCKET;
#endif // _WIN32

//opaque pointer
struct FileImpl;

class File
{
public:
        File();
        ~File();
        bool Open(const char*, int openmode = FILEREAD | FILEWRITE);
        bool Open(void*, int openmode = FILEREAD | FILEWRITE);
        bool OpenData(void* buf, int size, int openmode = FILEREAD | FILEWRITE);
        bool OpenData(int openmode = FILEREAD | FILEWRITE);
        bool OpenTCPSocket(SOCKET sockfd);
        bool OpenUDPSocket(SOCKET sockfd);
        void Close();

        bool Seek(int amount, int from = FILESEEKCURRENT);
        int Position() const;
        int Length() const;

        bool ReadData(void*, int size);
        bool WriteData(const void*, int size);

        bool ReadString(char*, int bufsize);
        bool WriteString(const char*);

        bool IsOpen() const;
        void ResizeDataBuffer(int size);
        unsigned char* GetDataBuffer() const; 
        void* FileObjectPointer(); 
        bool ReadAvailable(int numbytes=1) const;
        bool WriteAvailable(int numbytes=1) const;

private:
        int mode;               //file read/write mode
        int srctype;    //data source mode (file,data,etc)
        
        FileImpl* impl;
};

template <class type>
bool ReadFile(File& f, type& t) { return t.Read(f); }
template <class type>
bool WriteFile(File& f, const type& t) { return t.Write(f); }

template <class type>
bool ReadArrayFile(File& f, type* t, int n)
{
  for(int i=0;i<n;i++)
    if(!ReadFile(f,t[i])) return false;
  return true;
}

template <class type>
bool WriteArrayFile(File& f, const type* t, int n)
{
  for(int i=0;i<n;i++)
    if(!WriteFile(f,t[i])) return false;
  return true;
}

#define _DECLARE_READ_WRITE_FILE_BASIC(type) \
  template <> bool ReadFile(File& f, type& t); \
  template <> bool WriteFile(File& f, const type& t); \
  template <> bool ReadArrayFile(File& f, type* t,int n); \
  template <> bool WriteArrayFile(File& f, const type* t,int n); 

#define _DEFINE_READ_WRITE_FILE_BASIC(type) \
  template <> bool ReadFile(File& f, type& t) \
  { return f.ReadData(&t, sizeof(t)); } \
  template <> bool WriteFile(File& f, const type& t) \
  { return f.WriteData(&t, sizeof(t)); } \
  template <> bool ReadArrayFile(File& f, type* t,int n) \
  { return f.ReadData(t, sizeof(type)*n); } \
  template <> bool WriteArrayFile(File& f, const type* t,int n) \
  { return f.WriteData(t, sizeof(type)*n); }


_DECLARE_READ_WRITE_FILE_BASIC(bool);
_DECLARE_READ_WRITE_FILE_BASIC(char);
_DECLARE_READ_WRITE_FILE_BASIC(signed char);
_DECLARE_READ_WRITE_FILE_BASIC(unsigned char);
_DECLARE_READ_WRITE_FILE_BASIC(short);
_DECLARE_READ_WRITE_FILE_BASIC(unsigned short);
_DECLARE_READ_WRITE_FILE_BASIC(int);
_DECLARE_READ_WRITE_FILE_BASIC(unsigned int);
_DECLARE_READ_WRITE_FILE_BASIC(long);
_DECLARE_READ_WRITE_FILE_BASIC(unsigned long);
_DECLARE_READ_WRITE_FILE_BASIC(long long);
_DECLARE_READ_WRITE_FILE_BASIC(unsigned long long);
_DECLARE_READ_WRITE_FILE_BASIC(float);
_DECLARE_READ_WRITE_FILE_BASIC(double);
_DECLARE_READ_WRITE_FILE_BASIC(long double);

#endif