D:/Zythum/DinoKod/Common/File.cpp

#include <windows.h>
#include "Common/Assert.h"

#include "Common/File.h"

//---------------------------------------------------------------------------------------------------------------------
KFile::KFile()
{
        m_hFile = 0;
        m_Mode  = KFM_READWRITE;
        m_bEOF  = false;
}

//---------------------------------------------------------------------------------------------------------------------
int KFile::Create( KStr sFileName, KFILEMODE Mode )
{
        int             Access;

        m_bEOF  = false;

        switch( Mode )
        {
        case KFM_READ:                  Access = GENERIC_READ;                                  break;
        case KFM_WRITE:                 Access = GENERIC_WRITE;                                 break;
        case KFM_READWRITE:             Access = GENERIC_READ | GENERIC_WRITE;  break;
        default:                                KASSERT(0);
        }
        
        m_Mode = Mode;
        m_hFile = CreateFile( sFileName.GetpString(), Access, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );

        if ( m_hFile == INVALID_HANDLE_VALUE )
                return false;

        m_sFileName = sFileName;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
int KFile::Open( KStr sFileName, KFILEMODE Mode )
{
        int             Access;
        int             Share;

        m_bEOF  = false;

        switch( Mode )
        {
        case KFM_READ:
                Access  = GENERIC_READ;
                Share   = FILE_SHARE_READ;
                break;
        case KFM_WRITE:
                Access  = GENERIC_WRITE;
                Share   = FILE_SHARE_WRITE;
                break;
        case KFM_READWRITE:
                Access  = GENERIC_READ | GENERIC_WRITE;
                Share   = FILE_SHARE_READ | FILE_SHARE_WRITE;
                break;
        default:                                
                KASSERT(0);
        }
        
        m_Mode = Mode;
        m_hFile = CreateFile( sFileName.GetpString(), Access, Share, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );

        if ( m_hFile == INVALID_HANDLE_VALUE )
        {
                m_hFile = 0;
                return false;
        }

        m_sFileName = sFileName;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
int KFile::Close()
{
        m_bEOF  = false;
        m_sFileName = "";

        if( !CloseHandle( m_hFile ) )
                return false;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
int KFile::Read( unsigned char* pBuffer, unsigned long ByteToRead, unsigned long* pByteRead )
{
        if( !m_hFile )
                return false;
        
        unsigned long   pRead;

        m_bEOF  = false;

        if( !ReadFile( m_hFile, pBuffer, ByteToRead, pByteRead ? pByteRead : &pRead, NULL ) )
        {
                if( GetLastError() == ERROR_HANDLE_EOF )
                        m_bEOF = true;

                return false;
        }

        if( pByteRead )
        {
                if( ByteToRead != *pByteRead )
                        m_bEOF = true;
        }
        else
        {
                if( ByteToRead != pRead )
                        m_bEOF = true;
        }

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
int KFile::Write( unsigned char* pBuffer, unsigned long ByteToWrite, unsigned long* pByteWrite )
{
        if( !m_hFile )
                return false;
        
        unsigned long   pWrite;

        m_bEOF  = false;

        if( !WriteFile( m_hFile, pBuffer, ByteToWrite, pByteWrite ? pByteWrite : &pWrite, NULL ) )
                return false;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
int KFile::Seek( long Distance, KFILESEEK SeekMode )
{
        if( !m_hFile )
                return false;
        
        unsigned long   MoveMethod;
        
        m_bEOF  = false;

        switch( SeekMode )
        {
        case KFS_BEGIN:         MoveMethod = FILE_BEGIN;        break;
        case KFS_CURRENT:       MoveMethod = FILE_CURRENT;      break;
        case KFS_END:           MoveMethod = FILE_END;          break;
        default:                        KASSERT(0);
        }
        
        SetFilePointer( m_hFile, Distance, NULL, MoveMethod );// == -1 )

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
int KFile::Tell( unsigned long* pCurrentPos )
{
        if( !m_hFile )
                return false;

        *pCurrentPos = SetFilePointer( m_hFile, 0, NULL, FILE_CURRENT );

        return true;
}


//---------------------------------------------------------------------------------------------------------------------
int KFile::Rewind()
{
        if( !m_hFile )
                return false;
        
        if( !Seek( 0, KFS_BEGIN ) )
                return false;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
int KFile::ReadChar( char* pChar )
{
        if( !m_hFile )
                return false;
        
        unsigned long   pByteRead;
        
        if( !Read( (unsigned char*)pChar, 1, &pByteRead ) || pByteRead != 1 )
                return false;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
int KFile::ReadString( KStr& sString )
{
        if( !m_hFile )
                return false;
        
        char    Char;
        char    pString[1024];
        u32             i = 0;

        while( i < sizeof( pString ) )
        {
                if( !ReadChar( &Char ) )
                {
                        sString = "";
                        return false;
                }

                if( (Char == '\0') )
                {
                        pString[i] = '\0';
                        sString = pString;
                        return true;
                }

                pString[i] = Char;
                i ++;
        }

        return false;
}

//---------------------------------------------------------------------------------------------------------------------
int KFile::WriteString( KStr& sString )
{
        return Write( (u8*)sString.GetpString(), sString.GetLength() + 1 );
}

//---------------------------------------------------------------------------------------------------------------------
int KFile::ReadText( KStr& sString )
{
        if( !m_hFile )
                return false;
        
        char    Char;
        char    pString[1024];
        u32             i = 0;

        while( i < sizeof( pString ) )
        {
                if( !ReadChar( &Char ) )
                {
                        sString = "";
                        return false;
                }

                if( (Char == '\r') || (Char == '\n') )
                {
                        if( i == 0 )
                                continue;

                        pString[i] = '\0';
                        sString = pString;
                        return true;
                }

                pString[i] = Char;
                i ++;
        }

        return false;
}
//---------------------------------------------------------------------------------------------------------------------
int KFile::WriteText( KStr& sString )
{
        return Write( (u8*)sString.GetpString(), sString.GetLength() );
}

//---------------------------------------------------------------------------------------------------------------------
int KFile::GetSize()
{
        int     Size;

        Size = GetFileSize( m_hFile, NULL );

        return Size;
}

//---------------------------------------------------------------------------------------------------------------------
char* KFile::GetFileExtension( char* pFileName )
{
        u32             u;
        for( u = (u32)strlen( pFileName ); u > 0; u -- )
                if( pFileName[u] == '.' )
                        return &pFileName[u + 1];

        return NULL;
}

//---------------------------------------------------------------------------------------------------------------------
char* KFile::GetFileName( char* pFileName )
{
        u32             u;
        for( u = (u32)strlen( pFileName ); u > 0; u -- )
                if( ( pFileName[u] == '\\' ) || ( pFileName[u] == '/' ) )
                        return &pFileName[u + 1];

        return NULL;
}

//---------------------------------------------------------------------------------------------------------------------
int KFile::GetLastWriteTime( KFileTime* pFileTime )
{
        FILETIME        FileTime;
        FILETIME        LocalFileTime;
        SYSTEMTIME      SystemTime;

        if( !m_hFile )
                return false;
        
        if( !GetFileTime( m_hFile, NULL, NULL, &FileTime ) )
                return false;
        
        if( !FileTimeToLocalFileTime( &FileTime, &LocalFileTime ) )
                return false;

        if( !FileTimeToSystemTime( &LocalFileTime, &SystemTime ) )
                return false;

        pFileTime->m_Year       = SystemTime.wYear;
        pFileTime->m_Month      = SystemTime.wMonth;
        pFileTime->m_Day        = SystemTime.wDay;
        pFileTime->m_Hour       = SystemTime.wHour;
        pFileTime->m_Minute     = SystemTime.wMinute;
        pFileTime->m_Second     = SystemTime.wSecond;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
int KFile::Reset()
{
        if( !Seek( 0, KFS_BEGIN ) )
                return false;
        
        if( !SetEndOfFile( m_hFile ) )
                return false;

        return true;
}

---