sprint/io/file.h

Go to the documentation of this file.

/******************************************************************************
*   sprint::file
*
*   Copyright (C) 2003-2004  Paolo Medici and LostOnesLandTeam
*   Copyright (C) 2005-2011  Paolo Medici <www.pmx.it>
*
*  This library is free software; you can redistribute it and/or
*  modify it under the terms of the GNU Lesser General Public
*  License as published by the Free Software Foundation; either
*  version 2.1 of the License, or (at your option) any later version.
*
*  This library is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
*  Lesser General Public License for more details.
*
*  You should have received a copy of the GNU Lesser General Public
*  License along with this library; if not, write to the Free Software
*  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*
*******************************************************************************/

#ifndef _SPRINT_IO_FILE_H
#define _SPRINT_IO_FILE_H

#include <sprint/platform.h>
#include <sprint/io/type.h>
#include <sprint/cpptraits.h>
#include <cstring>

#ifdef WIN32

# include <windows.h>

#elif defined (LINUX)

#include <unistd.h>
#include <sys/types.h> 
#include <sys/stat.h>
#include <fcntl.h> 

#endif

namespace sprint {
    namespace io {

      namespace detail {
          
#ifdef WIN32
/* Todo: creare anche la versione File64 per i file +4GB */

template<bool bManaged>
class file : public if_copiable<!bManaged> {
        HANDLE m_h;
public:
        file(HANDLE h = INVALID_HANDLE_VALUE) : m_h(h) {
        }
        
        file(const char *filename, flag_t mode)
        {
          if(mode == sprint::io::read)
            OpenForRead(filename);
          else if(mode == sprint::io::write)
            OpenForWrite(filename);
          else if(mode == sprint::io::readwrite)
            OpenForBothReadWrite(filename);
          
        }

        ~file()
        {
                if(bManaged)
                        if(m_h!=INVALID_HANDLE_VALUE)
                         CloseHandle(m_h);
        }
        inline bool good()
        {
                return m_h!=INVALID_HANDLE_VALUE;
        }
        
        bool OpenForWrite(LPCWSTR lpszFileName)
        {
        m_h = CreateFileW(
    lpszFileName,       // pointer to name of the file 
    GENERIC_WRITE,      // access (read-write) mode 
    0,  // share mode 
    NULL,       // pointer to security attributes 
    CREATE_ALWAYS,      // how to create 
    FILE_ATTRIBUTE_NORMAL,      // file attributes 
    NULL);
        return m_h!=INVALID_HANDLE_VALUE;
        }

        bool OpenForWrite(LPCSTR lpszFileName)
        {
        m_h = CreateFileA(
    lpszFileName,       // pointer to name of the file 
    GENERIC_WRITE,      // access (read-write) mode 
    0,  // share mode 
    NULL,       // pointer to security attributes 
    CREATE_ALWAYS,      // how to create 
    FILE_ATTRIBUTE_NORMAL,      // file attributes 
    NULL);
        return m_h!=INVALID_HANDLE_VALUE;
        }

        bool OpenForRead(LPCWSTR lpszFileName)
        {
        m_h = CreateFileW(
    lpszFileName,       // pointer to name of the file 
    GENERIC_READ,       // access (read-write) mode 
    0,  // share mode 
    NULL,       // pointer to security attributes 
    OPEN_EXISTING,      // how to create 
    FILE_ATTRIBUTE_NORMAL,      // file attributes 
    NULL);
        return m_h!=INVALID_HANDLE_VALUE;
        }

        bool OpenForRead(LPCSTR lpszFileName)
        {
        m_h = CreateFileA(
    lpszFileName,       // pointer to name of the file 
    GENERIC_READ,       // access (read-write) mode 
    0,  // share mode 
    NULL,       // pointer to security attributes 
    OPEN_EXISTING,      // how to create 
    FILE_ATTRIBUTE_NORMAL,      // file attributes 
    NULL);
        return m_h!=INVALID_HANDLE_VALUE;
        }

        bool OpenForBothReadWrite(LPCWSTR lpszFileName)
        {
        m_h = CreateFileW(
    lpszFileName,       // pointer to name of the file 
    GENERIC_READ|GENERIC_WRITE, // access (read-write) mode 
    0,  // share mode 
    NULL,       // pointer to security attributes 
    OPEN_EXISTING,      // how to create 
    FILE_ATTRIBUTE_NORMAL,      // file attributes 
    NULL);
        return m_h!=INVALID_HANDLE_VALUE;
        }

        bool OpenForBothReadWrite(LPCSTR lpszFileName)
        {
        m_h = CreateFileA(
    lpszFileName,       // pointer to name of the file 
    GENERIC_READ|GENERIC_WRITE, // access (read-write) mode 
    0,  // share mode 
    NULL,       // pointer to security attributes 
    OPEN_EXISTING,      // how to create 
    FILE_ATTRIBUTE_NORMAL,      // file attributes 
    NULL);
        return m_h!=INVALID_HANDLE_VALUE;
        }

        bool CreateForBothReadWrite(LPCWSTR lpszFileName)
        {
        m_h = CreateFileW(
    lpszFileName,       // pointer to name of the file 
    GENERIC_READ|GENERIC_WRITE, // access (read-write) mode 
    0,  // share mode 
    NULL,       // pointer to security attributes 
    CREATE_ALWAYS,      // how to create 
    FILE_ATTRIBUTE_NORMAL,      // file attributes 
    NULL);
        return m_h!=INVALID_HANDLE_VALUE;
        }

        bool CreateForBothReadWrite(LPCSTR lpszFileName)
        {
        m_h = CreateFileA(
    lpszFileName,       // pointer to name of the file 
    GENERIC_READ|GENERIC_WRITE, // access (read-write) mode 
    0,  // share mode 
    NULL,       // pointer to security attributes 
    CREATE_ALWAYS,      // how to create 
    FILE_ATTRIBUTE_NORMAL,      // file attributes 
    NULL);
        return m_h!=INVALID_HANDLE_VALUE;
        }

        bool CreateForWrite(LPCWSTR lpszFileName)
        {
        m_h = CreateFileW(
    lpszFileName,       // pointer to name of the file 
    GENERIC_WRITE,      // access (read-write) mode 
    0,  // share mode 
    NULL,       // pointer to security attributes 
    CREATE_ALWAYS,      // how to create 
    FILE_ATTRIBUTE_NORMAL,      // file attributes 
    NULL);
        return m_h!=INVALID_HANDLE_VALUE;
        }

        bool CreateForWrite(LPCSTR lpszFileName)
        {
        m_h = CreateFileA(
    lpszFileName,       // pointer to name of the file 
    GENERIC_WRITE,      // access (read-write) mode 
    0,  // share mode 
    NULL,       // pointer to security attributes 
    CREATE_ALWAYS,      // how to create 
    FILE_ATTRIBUTE_NORMAL,      // file attributes 
    NULL);
        return m_h!=INVALID_HANDLE_VALUE;
        }

        bool OpenForAppend(LPCWSTR lpszFileName)
        {
        m_h = CreateFileW(
    lpszFileName,       // pointer to name of the file 
    GENERIC_WRITE,      // access (read-write) mode 
    0,  // share mode 
    NULL,       // pointer to security attributes 
    OPEN_ALWAYS,        // how to create 
    FILE_ATTRIBUTE_NORMAL,      // file attributes 
    NULL);
        if(m_h==INVALID_HANDLE_VALUE)
                return false;
        SetFilePointer(m_h, 0, NULL, FILE_END);
        return true;
        }

        bool OpenForAppend(LPCSTR lpszFileName)
        {
        m_h = CreateFileA(
    lpszFileName,       // pointer to name of the file 
    GENERIC_WRITE,      // access (read-write) mode 
    0,  // share mode 
    NULL,       // pointer to security attributes 
    OPEN_ALWAYS,        // how to create 
    FILE_ATTRIBUTE_NORMAL,      // file attributes 
    NULL);
        if(m_h==INVALID_HANDLE_VALUE)
                return false;
        SetFilePointer(m_h, 0, NULL, FILE_END);
        return true;
        }

        void close()
        {
        CloseHandle(m_h);
        m_h = INVALID_HANDLE_VALUE;
        }

      sprint::io::file_size_t seek(file_size_t offset, sprint::io::seek_t type)
      {
                  return -1;
      }
      
      sprint::io::state_t state()
      {
        // TODO
                return sprint::io::unimplemented;
      }

// Length
        inline io::file_size_t length() const
        {
        return GetFileSize(m_h, NULL);
        }

        int write(LPCVOID lpBuffer, UINT uBufferLen) const
        {
        DWORD dwWrite;
        WriteFile(m_h, lpBuffer, uBufferLen, &dwWrite, NULL);
        return dwWrite;
        }

        int read(LPVOID lpBuffer, UINT uBufferLen) const
        {
        DWORD dwRead;
        ReadFile(m_h, lpBuffer, uBufferLen, &dwRead, NULL);
        return dwRead;
        }
        
        void flush()
        {
    // no
    }

        inline unsigned long tell() const
        {
        return SetFilePointer(m_h, 0, NULL, FILE_CURRENT);
        }

        inline unsigned long SeekFromBegin(UINT uPos) const
        {
        return SetFilePointer(m_h, uPos, NULL, FILE_BEGIN);
        }

        inline unsigned long Skip(UINT uPos) const
        {
        return SetFilePointer(m_h, uPos, NULL, FILE_CURRENT);
        }
        
        inline BOOL Rewind() const 
        {
        return SetFilePointer(m_h, 0, NULL, FILE_BEGIN);        
    }
    
    // The Trunc function moves the end-of-file (EOF) position for the specified file 
    //  to the current position of the file pointer. 
    inline BOOL trunc() const 
    {
    return SetEndOfFile(m_h);
    }

        int get() const
        {
                int c;
                return (read(&c, 1)) ? c : -1;
        }

        int put(char c)
        {
        return write(&c, 1);
        }

  inline BOOL SetFileTime(const FILETIME* lpCreationTime,
  const FILETIME* lpLastAccessTime,
  const FILETIME* lpLastWriteTime)
        {
                return ::SetFileTime(m_h, lpCreationTime, lpLastAccessTime, lpLastWriteTime);
        }
        inline BOOL GetFileTime(FILETIME* lpCreationTime,
  FILETIME* lpLastAccessTime,
  FILETIME* lpLastWriteTime)
        {
                return ::GetFileTime(m_h, lpCreationTime, lpLastAccessTime, lpLastWriteTime);
        }

};    

#elif defined(__unix__)

template<bool bManaged>
class file : public if_copiable<!bManaged> {
        int i;
public:
        file(int h = -1) {
                i = h;
        }
        
        ~file()
        {
        if(bManaged)
            ::close(i);
        }
        
        file(const char *filename, flag_t mode)
        {
          if(mode == sprint::io::read)
            OpenForRead(filename);
          else if(mode == sprint::io::write)
            OpenForWrite(filename);
          else if(mode == sprint::io::readwrite)
            OpenForBothReadWrite(filename);
          
        }

        inline void close()
        {
        ::close(i);
        i = -1;
        }

        inline bool good()
        {
                return i!=-1;
        }

        inline bool OpenForWrite(const char *lpszFileName)
        {
        i = ::open(lpszFileName, O_WRONLY | O_CREAT, 0777);
        return i != -1;
        }

        inline bool OpenForRead(const char * lpszFileName)
        {
        #if defined(__USE_LARGEFILE64) && defined(__linux__) 
        i = ::open(lpszFileName, O_RDONLY | O_LARGEFILE);
        #else
        i = ::open(lpszFileName, O_RDONLY);
        #endif
        return i != -1;
        }

        inline bool OpenForBothReadWrite(const char * lpszFileName)
        {
        i = ::open(lpszFileName, O_CREAT|O_RDWR);
        return i != -1;
        }

        inline bool CreateForBothReadWrite(const char * lpszFileName)
        {
                /* TODO */
        i = ::open(lpszFileName, O_RDWR);
        return i != -1;
        }

        bool CreateForWrite(const char * lpszFileName)
        {
        i = ::open(lpszFileName, O_CREAT|O_WRONLY);
        return i != -1;
        }

        bool OpenForAppend(const char * lpszFileName)
        {
        i = ::open(lpszFileName, O_APPEND);
        return i != -1;
        }

        unsigned long length()
        {
        unsigned long here = ::lseek(i, 0, SEEK_SET);
        unsigned long end = ::lseek(i, 0, SEEK_END); // go to end
        ::lseek(i, here, SEEK_SET);
        return end;
        }
        
        int flush()
        {
        }

        int write(const void *lpBuffer, unsigned int uBufferLen)
        {
        return ::write(i, lpBuffer, uBufferLen);
        }

        int read(void *lpBuffer, unsigned int uBufferLen)
        {
        return ::read(i, lpBuffer, uBufferLen);
        }

        unsigned long tell()
        {
        return ::lseek(i, 0, SEEK_CUR);
        }

        unsigned long seek(unsigned long uPos, seek_t mode)
        {
        return ::lseek(i, uPos, (mode == sprint::io::start) ? SEEK_SET : 
                                (mode == sprint::io::cur) ? SEEK_CUR :
                                SEEK_END);
        }

        int get()
        {
                int c;
                return (read(&c, 1)) ? c : -1;
        }

        int put(char c)
        {
        return write(&c, 1);
        }
        
        state_t state() const { return (i != -1) ? sprint::io::good : sprint::io::error; }

};

#endif // WIN32

} // namespace detail

typedef detail::file<false> file_handle;
typedef detail::file<true> file;

} // namespace io
} // namespace sprint

#endif // FILE_H