added source folders
This commit is contained in:
purpleyouko committed
1 parent
f23521f720
commit
cfdc19df45
145 files changed
+54574
No files matched your search
@@ -0,0 +1,941 @@
|
||||
//Made by Caali
|
||||
|
||||
#define __CROSEFILE_HPP__
|
||||
|
||||
/* Includes */
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#ifndef __CARRAY_HPP__
|
||||
#include "CRoseArray.hpp"
|
||||
#endif
|
||||
|
||||
/* MS Visual C++ Deprecation control defines */
|
||||
#ifdef _MSC_VER
|
||||
# ifdef _CRT_SECURE_NO_DEPRECATE
|
||||
# define CFILE_NODEPRECATE
|
||||
# endif
|
||||
#else
|
||||
# define CFILE_NODEPRECATE
|
||||
#endif
|
||||
|
||||
//Debug:
|
||||
//#define CFILE_NOUNICODE
|
||||
|
||||
/* Various defines */
|
||||
#define CFILE_MAXLINELENGHT 255
|
||||
#define CFILE_UNICODE_HEADER 0xFEFF
|
||||
|
||||
/* Variable type declarations */
|
||||
/* ETC */
|
||||
typedef bool CFILE_BOOLEAN;
|
||||
typedef size_t CFILE_SIZE;
|
||||
|
||||
/* Unsigned */
|
||||
typedef unsigned long long int CFILE_ULONGLONG;
|
||||
typedef unsigned long int CFILE_ULONG;
|
||||
typedef unsigned int CFILE_UINT;
|
||||
typedef unsigned short int CFILE_USHORT;
|
||||
typedef unsigned char CFILE_UCHAR;
|
||||
|
||||
/* Signed */
|
||||
typedef signed long long int CFILE_SLONGLONG;
|
||||
typedef signed long int CFILE_SLONG;
|
||||
typedef signed int CFILE_SINT;
|
||||
typedef signed short int CFILE_SSHORT;
|
||||
typedef signed char CFILE_SCHAR;
|
||||
typedef char CFILE_CHAR;
|
||||
|
||||
/* File types */
|
||||
typedef enum
|
||||
{
|
||||
FT_NONE,
|
||||
FT_BINARY,
|
||||
FT_ASCII,
|
||||
FT_UNICODE
|
||||
} FILETYPE;
|
||||
/* File open modes */
|
||||
typedef enum
|
||||
{
|
||||
FM_NONE = 0,
|
||||
FM_READ = (1<<0),
|
||||
FM_WRITE = (1<<1),
|
||||
FM_CREATEIFDOESNTEXIST = (1<<2),
|
||||
FM_BINARY = (1<<3),
|
||||
FM_UNICODE = (1<<4),
|
||||
FM_READWRITE = (FM_READ | FM_WRITE),
|
||||
FM_RW = (FM_READWRITE | FM_CREATEIFDOESNTEXIST)
|
||||
} FILEMODE;
|
||||
|
||||
/* File errors */
|
||||
typedef enum
|
||||
{
|
||||
FE_SUCCESS = 0, //No error
|
||||
FE_EOF, //CFile::EndOfFile( ) == true
|
||||
FE_NOFILEOPENED, //fh == NULL
|
||||
FE_NORIGHTSFORACTION, //Like when trying to read when only opening in write mode
|
||||
FE_INTERNALERROR, //CFile-internal errors, supposed to destruct the CFile now!
|
||||
FE_UNICODENOTALLOWED, //#ifdef CFILE_NOUNICODE and file is unicode
|
||||
FE_UNABLETOOPENFILE //fopen( ) == NULL
|
||||
} FILEERROR;
|
||||
|
||||
/* The CFile class */
|
||||
class CRoseFile
|
||||
{
|
||||
private:
|
||||
/** The current filetype
|
||||
*/
|
||||
FILETYPE ftype;
|
||||
/** The last error occured
|
||||
*/
|
||||
FILEERROR flasterr;
|
||||
/** The current file open mode bitfield
|
||||
*/
|
||||
CFILE_CHAR fmode;
|
||||
/** Function to throw an error
|
||||
@param
|
||||
err: A FILEERROR
|
||||
*/
|
||||
void DoError( FILEERROR err )
|
||||
{
|
||||
flasterr = err;
|
||||
}
|
||||
/** Converts the bitfield file open mode to c standart ASCII open modes
|
||||
@param
|
||||
mode: A byte with the bitfield
|
||||
@result
|
||||
string with the ASCII string
|
||||
*/
|
||||
CFILE_CHAR* ConvertBitFieldFileModeToASCIIFileMode( CFILE_SCHAR mode )
|
||||
{
|
||||
CFILE_CHAR* result = new CFILE_CHAR[30];
|
||||
CFILE_UCHAR len = 0;
|
||||
for( CFILE_CHAR i = 0; i<30; i++ ) result[i] = 0x00;
|
||||
if( (mode & FM_READWRITE) == FM_READWRITE )
|
||||
{
|
||||
if( (mode & FM_CREATEIFDOESNTEXIST) == FM_CREATEIFDOESNTEXIST )
|
||||
{
|
||||
result[0] = 'w';
|
||||
result[1] = '+';
|
||||
len = 2;
|
||||
}
|
||||
else
|
||||
{
|
||||
result[0] = 'r';
|
||||
result[1] = '+';
|
||||
len = 2;
|
||||
}
|
||||
}
|
||||
else if( (mode & FM_READ) == FM_READ )
|
||||
{
|
||||
result[0] = 'r';
|
||||
len = 1;
|
||||
}
|
||||
else if( (mode & FM_WRITE) == FM_WRITE )
|
||||
{
|
||||
result[0] = 'w';
|
||||
len = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
DoError( FE_INTERNALERROR );
|
||||
delete[] result;
|
||||
return NULL;
|
||||
}
|
||||
if( (mode & FM_BINARY) == FM_BINARY )
|
||||
{
|
||||
result[len] = 'b';
|
||||
len++;
|
||||
}
|
||||
if( (mode & FM_UNICODE) == FM_UNICODE )
|
||||
{
|
||||
printf( (CFILE_CHAR*)result, 30, "%s, ccs=UNICODE", (CFILE_CHAR*)result );
|
||||
len += 13;
|
||||
}
|
||||
result[len] = 0x00;
|
||||
return result;
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
/** The current filehandle
|
||||
*/
|
||||
FILE* fh;
|
||||
/** Contructor
|
||||
*/
|
||||
CRoseFile( )
|
||||
{
|
||||
fh = NULL;
|
||||
ftype = FT_NONE;
|
||||
fmode = FM_NONE;
|
||||
flasterr = FE_SUCCESS;
|
||||
}
|
||||
/** Contructor opening a file after contructing
|
||||
@param
|
||||
fname: A string with the filename
|
||||
@param
|
||||
mode: A bitfield using the FILETYPE enumerator to specify the fopen mode
|
||||
*/
|
||||
CRoseFile( CFILE_CHAR* fname, CFILE_CHAR mode )
|
||||
{
|
||||
fh = NULL;
|
||||
ftype = FT_NONE;
|
||||
fmode = FM_NONE;
|
||||
flasterr = FE_SUCCESS;
|
||||
Open( fname, mode );
|
||||
}
|
||||
|
||||
//Destructors
|
||||
~CRoseFile( )
|
||||
{
|
||||
if( fh != NULL ) Close( );
|
||||
}
|
||||
|
||||
/** Opens a file
|
||||
@param
|
||||
fname: A string with the filename
|
||||
@param
|
||||
mode: A bitfield using the FILETYPE enumerator to specify the fopen mode
|
||||
@result
|
||||
Boolean indicating if Open successed or failed
|
||||
@note
|
||||
If there is already an opened file, CFile will close it and open the new file
|
||||
*/
|
||||
CFILE_BOOLEAN Open( CFILE_CHAR* fname, CFILE_CHAR mode )
|
||||
{
|
||||
if( fh != NULL ) Close( );
|
||||
fmode = mode;
|
||||
CFILE_CHAR* fasciimode = ConvertBitFieldFileModeToASCIIFileMode( fmode );
|
||||
if( fasciimode == NULL )
|
||||
{
|
||||
DoError( FE_INTERNALERROR );
|
||||
return false;
|
||||
}
|
||||
if( (fmode & FM_BINARY) == FM_BINARY )
|
||||
{
|
||||
ftype = FT_BINARY;
|
||||
}
|
||||
#ifndef CFILE_NODEPRECATE
|
||||
if( fopen_s( &fh, fname, fasciimode ) == 0 )
|
||||
{
|
||||
#else
|
||||
if( ( fh = fopen( fname, fasciimode ) ) != NULL )
|
||||
{
|
||||
#endif
|
||||
delete[] fasciimode;
|
||||
//Check if unicode or ascii
|
||||
if( ftype != FT_BINARY )
|
||||
{
|
||||
CFILE_USHORT buf;
|
||||
Read( &buf, sizeof( buf ), 1 );
|
||||
if( buf == CFILE_UNICODE_HEADER )
|
||||
{
|
||||
#ifndef CFILE_NOUNICODE
|
||||
fmode |= FM_UNICODE;
|
||||
Close( );
|
||||
CFILE_CHAR* fasciimode = ConvertBitFieldFileModeToASCIIFileMode( fmode );
|
||||
//fasciimode = ConvertBitFieldFileModeToASCIIFileMode( fmode );
|
||||
if( fasciimode == NULL )
|
||||
{
|
||||
DoError( FE_INTERNALERROR );
|
||||
return false;
|
||||
}
|
||||
#ifndef CFILE_NODEPRECATE
|
||||
fopen_s( &fh, fname, fasciimode );
|
||||
#else
|
||||
fh = fopen( fname, fasciimode );
|
||||
#endif
|
||||
SetAbsPos( 2 );
|
||||
ftype = FT_UNICODE;
|
||||
#else
|
||||
DoError( FE_UNICODENOTALLOWED );
|
||||
Close( );
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
SetAbsPos( 0 );
|
||||
ftype = FT_ASCII;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
SetAbsPos( 0 );
|
||||
}
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
DoError( FE_UNABLETOOPENFILE );
|
||||
fh = NULL;
|
||||
delete[] fasciimode;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/** Closes the current open file
|
||||
*/
|
||||
void Close( )
|
||||
{
|
||||
if( fh != 0 )
|
||||
{
|
||||
DoError( FE_SUCCESS );
|
||||
fclose( fh );
|
||||
fh = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
CFILE_BOOLEAN IsOpen( )
|
||||
{
|
||||
return (fh != NULL)?(true):(false);
|
||||
}
|
||||
|
||||
/** Returns if the file has been opened in read mode
|
||||
@result
|
||||
Boolean indicating if the current file has been opened in read mode
|
||||
*/
|
||||
CFILE_BOOLEAN IsRead( )
|
||||
{
|
||||
return ((fmode & FM_READ) == FM_READ)?(true):(false);
|
||||
}
|
||||
/** Returns if the file has been opened in write mode
|
||||
@result
|
||||
Boolean indicating if the current file has been opened in write mode
|
||||
*/
|
||||
CFILE_BOOLEAN IsWrite( )
|
||||
{
|
||||
return ((fmode & FM_WRITE) == FM_WRITE)?(true):(false);
|
||||
}
|
||||
/** Returns filehandle
|
||||
@result
|
||||
Returns the current filehandle
|
||||
*/
|
||||
FILE* FileHandle( )
|
||||
{
|
||||
return fh;
|
||||
}
|
||||
/** Returns filetype
|
||||
@result
|
||||
returns the current filetype
|
||||
*/
|
||||
FILETYPE FileType( )
|
||||
{
|
||||
return ftype;
|
||||
}
|
||||
/** Returns last error
|
||||
@result
|
||||
Returns the last error occured
|
||||
*/
|
||||
FILEERROR GetLastError( )
|
||||
{
|
||||
return flasterr;
|
||||
}
|
||||
|
||||
/** Moves the file position to a custom point
|
||||
@param
|
||||
offset: Indicates how many bytes to move from origin
|
||||
@param
|
||||
origin: SEEK_SET -> File start | SEEK_CUR -> Current position | SEEK_END -> Last byte in file
|
||||
@result
|
||||
Boolean indicating if the seek process has successed
|
||||
@note
|
||||
Offset can be negative, too.
|
||||
*/
|
||||
CFILE_BOOLEAN Seek( CFILE_SLONG offset, signed int origin )
|
||||
{
|
||||
if( fh == NULL )
|
||||
{
|
||||
DoError( FE_NOFILEOPENED );
|
||||
return false;
|
||||
}
|
||||
if( fseek( fh, offset, origin ) == 0 )
|
||||
{
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
/** Moves the file position to an absolute position from the file start
|
||||
@param
|
||||
offset: Indicates how many bytes to move from SEEK_SET
|
||||
@result
|
||||
Boolean indicating if the seek process has successed
|
||||
@note
|
||||
Offset MUST NOT be negative, else it will not do anything
|
||||
*/
|
||||
CFILE_BOOLEAN SetAbsPos( CFILE_SLONG offset )
|
||||
{
|
||||
if( fh == NULL )
|
||||
{
|
||||
DoError( FE_NOFILEOPENED );
|
||||
return false;
|
||||
}
|
||||
if( offset < 0 )
|
||||
{
|
||||
DoError( FE_INTERNALERROR );
|
||||
return false;
|
||||
}
|
||||
return Seek(offset,SEEK_SET);
|
||||
}
|
||||
/** Moves the file position to the start of the file
|
||||
@result
|
||||
Boolean indicating if the rewinding process has successed
|
||||
@note
|
||||
This function checks if the file has been opened in unicode mode, and if so, it sets the pointer to 2,
|
||||
the start of the file AFTER the unicode file header
|
||||
*/
|
||||
CFILE_BOOLEAN GoToStart( )
|
||||
{
|
||||
if( fh == NULL )
|
||||
{
|
||||
DoError( FE_NOFILEOPENED );
|
||||
return false;
|
||||
}
|
||||
if( ftype == FT_ASCII || ftype == FT_BINARY )
|
||||
{
|
||||
return SetAbsPos( 0 );
|
||||
}
|
||||
else if( ftype == FT_UNICODE )
|
||||
{
|
||||
return SetAbsPos( 2 );
|
||||
}
|
||||
DoError( FE_INTERNALERROR );
|
||||
return false;
|
||||
}
|
||||
/** Tells the current position in the file
|
||||
@result
|
||||
Signed long indicating the absolute offset from SEEK_SET
|
||||
*/
|
||||
CFILE_SLONG Tell( )
|
||||
{
|
||||
if( fh == NULL )
|
||||
{
|
||||
DoError( FE_NOFILEOPENED );
|
||||
return EOF;
|
||||
}
|
||||
return ftell( fh );
|
||||
}
|
||||
/** Checks if the file position is set after the end of the file
|
||||
@result
|
||||
Boolean indicating if the file pointer is at the end of the file
|
||||
*/
|
||||
CFILE_BOOLEAN EndOfFile( )
|
||||
{
|
||||
if( fh == NULL )
|
||||
{
|
||||
DoError( FE_NOFILEOPENED );
|
||||
return true;
|
||||
}
|
||||
return (feof( fh )==0)?(false):(true);
|
||||
}
|
||||
/** Moves the file position to a custom point
|
||||
@result
|
||||
Unsigned long indicating the size of the file in bytes
|
||||
*/
|
||||
CFILE_ULONG FileSize( )
|
||||
{
|
||||
if( fh == NULL )
|
||||
{
|
||||
DoError( FE_NOFILEOPENED );
|
||||
return 0;
|
||||
}
|
||||
CFILE_SLONG tmp_offset = Tell( );
|
||||
if( tmp_offset < 0 ) return 0;
|
||||
Seek( 0, SEEK_END );
|
||||
CFILE_SLONG result = Tell( );
|
||||
SetAbsPos( tmp_offset );
|
||||
return result;
|
||||
}
|
||||
/** Reads from the file starting at the current position
|
||||
@param
|
||||
buf: A pointer to a buffer where the data will be stored
|
||||
@param
|
||||
element_size: The size of each block being read
|
||||
@param
|
||||
element_count: The number of blocks being read
|
||||
@result
|
||||
Unsigned int indicating the number of bytes read
|
||||
*/
|
||||
CFILE_UINT Read( void* buf, CFILE_SIZE element_size, CFILE_SIZE element_count = 1 )
|
||||
{
|
||||
if( fh == NULL )
|
||||
{
|
||||
DoError( FE_NOFILEOPENED );
|
||||
return 0;
|
||||
}
|
||||
if( !IsRead( ) )
|
||||
{
|
||||
DoError( FE_NORIGHTSFORACTION );
|
||||
return 0;
|
||||
}
|
||||
return (CFILE_UINT)( fread( buf, element_size, element_count, fh ) );
|
||||
}
|
||||
/** Reads from the file starting at [offset] relative to [origin]
|
||||
@param
|
||||
buf: A pointer to a buffer where the data will be stored
|
||||
@param
|
||||
element_size: The size of each block being read
|
||||
@param
|
||||
element_count: The number of blocks being read
|
||||
@param
|
||||
offset: The offset to start reading from, relative to [origin]
|
||||
@param
|
||||
origin: Where offset is relative to, SEEK_SET -> Beginning of file | SEEK_CUR -> Current position | SEEK_END -> End of file
|
||||
@result
|
||||
Unsigned int indicating the number of bytes read
|
||||
*/
|
||||
CFILE_UINT ReadFrom( void* buf, CFILE_UINT element_size, CFILE_UINT element_count, CFILE_SLONG offset, signed int origin = SEEK_SET )
|
||||
{
|
||||
if( fh == NULL )
|
||||
{
|
||||
DoError( FE_NOFILEOPENED );
|
||||
return 0;
|
||||
}
|
||||
if( !IsRead( ) )
|
||||
{
|
||||
DoError( FE_NORIGHTSFORACTION );
|
||||
return 0;
|
||||
}
|
||||
if( !Seek( offset, origin ) ) return 0;
|
||||
return (CFILE_UINT)( Read( buf, element_size, element_count ) );
|
||||
}
|
||||
/** Reads from the file starting at from and ending at to
|
||||
@param
|
||||
buf: A pointer to a buffer where the data will be stored
|
||||
@param
|
||||
from: The offset to start reading from, absolute, aka relative to SEEK_SET
|
||||
@param
|
||||
to: The offset to end reading at, absolute, aka relative to SEEK_SET
|
||||
@result
|
||||
Unsigned int indicating the number of bytes read
|
||||
@note
|
||||
If (to-from) > the size of buf, it throws an exception (-> access violation), so check it before calling this function!
|
||||
*/
|
||||
CFILE_UINT ReadFromTo( void* buf, CFILE_SLONG from, CFILE_SLONG to )
|
||||
{
|
||||
if( fh == NULL )
|
||||
{
|
||||
DoError( FE_NOFILEOPENED );
|
||||
return 0;
|
||||
}
|
||||
if( !IsRead( ) )
|
||||
{
|
||||
DoError( FE_NORIGHTSFORACTION );
|
||||
return 0;
|
||||
}
|
||||
if( to < from ) return 0;
|
||||
if( !SetAbsPos( from ) ) return 0;
|
||||
return (CFILE_UINT)( Read( buf, (to-from), 1 ) );
|
||||
}
|
||||
/** Reads one byte and returns it as signed char
|
||||
@result
|
||||
char with the byte read
|
||||
*/
|
||||
CFILE_CHAR GetC( )
|
||||
{
|
||||
if( fh == NULL )
|
||||
{
|
||||
DoError( FE_NOFILEOPENED );
|
||||
return EOF;
|
||||
}
|
||||
if( !IsRead( ) )
|
||||
{
|
||||
DoError( FE_NORIGHTSFORACTION );
|
||||
return EOF;
|
||||
}
|
||||
if( ftype == FT_ASCII || ftype == FT_BINARY )
|
||||
{
|
||||
return (CFILE_CHAR)( fgetc( fh ) );
|
||||
}
|
||||
else if( ftype == FT_UNICODE )
|
||||
{
|
||||
#ifndef CFILE_NOUNICODE
|
||||
CFILE_CHAR buf;
|
||||
wchar_t buffer;
|
||||
buffer = fgetwc( fh );
|
||||
#ifndef CFILE_NODEPRECATE
|
||||
size_t tmp;
|
||||
wcstombs_s( &tmp, &buf, (size_t)(sizeof(buf)), &buffer, 1 );
|
||||
#else
|
||||
wcstombs( &buf, &buffer, 1 );
|
||||
#endif
|
||||
return (CFILE_CHAR)buf;
|
||||
#else
|
||||
DoError( FE_UNICODENOTALLOWED );
|
||||
return EOF;
|
||||
#endif
|
||||
}
|
||||
return EOF;
|
||||
}
|
||||
|
||||
/** Reads from the file starting at from and ending at to
|
||||
@param
|
||||
buf: A pointer to a buffer where the data will be stored
|
||||
@param
|
||||
max_count: The maximum number of bytes to read
|
||||
@result
|
||||
string with the string read
|
||||
@note
|
||||
GetS either reads up to [max_count] bytes or until the end of one line has been reached. (0x0D 0x0A)
|
||||
@note
|
||||
If the file is opened in binary mode, GetS throws an error and does nothing
|
||||
*/
|
||||
CFILE_CHAR* GetS( CRoseArray<CFILE_CHAR>* buf, CFILE_UINT max_count )
|
||||
{
|
||||
if( fh == NULL )
|
||||
{
|
||||
DoError( FE_NOFILEOPENED );
|
||||
return NULL;
|
||||
}
|
||||
if( !IsRead( ) )
|
||||
{
|
||||
DoError( FE_NORIGHTSFORACTION );
|
||||
return NULL;
|
||||
}
|
||||
if( ftype == FT_ASCII )
|
||||
{
|
||||
fgets( buf->arr, max_count, fh );
|
||||
return NULL;
|
||||
}
|
||||
else if( ftype == FT_UNICODE )
|
||||
{
|
||||
#ifndef CFILE_NOUNICODE
|
||||
wchar_t* buffer = new wchar_t[max_count];
|
||||
fgetws( buffer, max_count, fh );
|
||||
#ifndef CFILE_NODEPRECATE
|
||||
size_t tmp;
|
||||
wcstombs_s( &tmp, buf->arr, (size_t)(buf->absSize()), buffer, max_count );
|
||||
#else
|
||||
wcstombs( buf->arr, buffer, max_count );
|
||||
#endif
|
||||
return NULL;
|
||||
#else
|
||||
DoError( FE_UNICODENOTALLOWED );
|
||||
return NULL;
|
||||
#endif
|
||||
}
|
||||
DoError( FE_INTERNALERROR );
|
||||
return NULL;
|
||||
}
|
||||
/** Reads one line
|
||||
@result
|
||||
string with the line read
|
||||
@note
|
||||
If the file is opened in binary mode, the call to GetS throws an error and does nothing
|
||||
*/
|
||||
CFILE_CHAR* ReadLn( )
|
||||
{
|
||||
if( fh == NULL )
|
||||
{
|
||||
DoError( FE_NOFILEOPENED );
|
||||
return NULL;
|
||||
}
|
||||
if( !IsRead( ) )
|
||||
{
|
||||
DoError( FE_NORIGHTSFORACTION );
|
||||
return NULL;
|
||||
}
|
||||
if( EndOfFile( ) )
|
||||
{
|
||||
DoError( FE_INTERNALERROR );
|
||||
return NULL;
|
||||
}
|
||||
CRoseArray<CFILE_CHAR>* result = new CRoseArray<CFILE_CHAR>( CFILE_MAXLINELENGHT );
|
||||
result->Clean( );
|
||||
if( GetS( result, CFILE_MAXLINELENGHT ) == NULL )
|
||||
{
|
||||
CFILE_CHAR* res = new CFILE_CHAR[ (size_t)( result->size() ) ];
|
||||
for( CFILE_UINT i = 0;i<result->size(); i++ ) res[i] = 0x00;
|
||||
memcpy( res, result->arr, (size_t)(result->size()*sizeof(CFILE_CHAR)) );
|
||||
for( CFILE_UINT i = 0;i<CFILE_MAXLINELENGHT; i++ )
|
||||
{
|
||||
if( (CFILE_UCHAR)res[i] == 0x0D || (CFILE_UCHAR)res[i] == 0x0A )
|
||||
{
|
||||
if( (CFILE_ULONG)Tell( ) >= FileSize( ) - 2 )
|
||||
{
|
||||
delete result;
|
||||
delete[] res;
|
||||
return NULL;
|
||||
}
|
||||
res[i] = 0x00;
|
||||
break;
|
||||
}
|
||||
}
|
||||
delete result;
|
||||
return res;
|
||||
}
|
||||
else
|
||||
{
|
||||
DoError( FE_INTERNALERROR );
|
||||
delete result;
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
/** Template to read different types
|
||||
@<param>
|
||||
typename
|
||||
@result
|
||||
typename: the value being read
|
||||
*/
|
||||
template<typename T> T Get( )
|
||||
{
|
||||
T result;
|
||||
Read( &result, sizeof( T ), 1 );
|
||||
return result;
|
||||
}
|
||||
/*template<typename T> CVector2F Get( )
|
||||
{
|
||||
if( fh == NULL )
|
||||
{
|
||||
DoError( FE_NOFILEOPENED );
|
||||
return CVector2F(0,0);
|
||||
}
|
||||
if( !IsRead( ) )
|
||||
{
|
||||
DoError( FE_NORIGHTSFORACTION );
|
||||
return CVector2F(0,0);
|
||||
}
|
||||
CVector2F result;
|
||||
Read( &result, sizeof( CVector2F ), 1 );
|
||||
return result;
|
||||
} */
|
||||
/** Reads the whole file into the memory
|
||||
@result
|
||||
string: pointer to the memory section, NULL on error
|
||||
@note
|
||||
The current file position pointer DOES NOT get affected by this function!
|
||||
*/
|
||||
/*string ReadFileToMemory( )
|
||||
{
|
||||
if( fh == NULL )
|
||||
{
|
||||
DoError( FE_NOFILEOPENED );
|
||||
return 0;
|
||||
}
|
||||
if( !IsRead( ) )
|
||||
{
|
||||
DoError( FE_NORIGHTSFORACTION );
|
||||
return 0;
|
||||
}
|
||||
CFILE_SLONG curpos = Tell( );
|
||||
SetAbsPos( 0 );
|
||||
string mem = new char[(CFILE_SIZE)(FileSize( ))];
|
||||
if( mem == NULL ) //not enough RAM
|
||||
{
|
||||
SetAbsPos( curpos );
|
||||
return NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
for( CFILE_UINT i = 0; i < FileSize( ); i++ ) mem[i] = 0x00;
|
||||
Read( mem, (CFILE_SIZE)(FileSize( )) );
|
||||
SetAbsPos( curpos );
|
||||
return mem;
|
||||
/*
|
||||
if( Read( mem, (CFILE_SIZE)(FileSize( )) ) != FileSize( ) )
|
||||
{
|
||||
delete[] mem;
|
||||
return NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
SetAbsPos( curpos );
|
||||
return mem;
|
||||
}
|
||||
*
|
||||
}
|
||||
}*/
|
||||
|
||||
/** Writes to the file
|
||||
@param
|
||||
ptr: A pointer to a buffer where the data will be read to write from
|
||||
@param
|
||||
element_size: The size of one block being written
|
||||
@param
|
||||
element_count: The number of blocks being written
|
||||
@result
|
||||
unsigned int indicating the number of bytes being written
|
||||
*/
|
||||
CFILE_UINT Write( void* ptr, CFILE_SIZE element_size, CFILE_SIZE element_count=1 )
|
||||
{
|
||||
if( fh == NULL )
|
||||
{
|
||||
DoError( FE_NOFILEOPENED );
|
||||
return 0;
|
||||
}
|
||||
if( !IsWrite( ) )
|
||||
{
|
||||
DoError( FE_NORIGHTSFORACTION );
|
||||
return 0;
|
||||
}
|
||||
return (CFILE_UINT)( fwrite( ptr, (size_t)( element_size ), (size_t)( element_count ), fh ) );
|
||||
}
|
||||
/** Writes to the file starting at [offset] bytes relative to [origin]
|
||||
@param
|
||||
ptr: A pointer to a buffer where the data will be read to write from
|
||||
@param
|
||||
element_size: The size of one block being written
|
||||
@param
|
||||
element_count: The number of blocks being written
|
||||
@param
|
||||
offset: The offset to start writing from, relative to [origin]
|
||||
@param
|
||||
origin: The position offset is relative to, SEEK_SET -> Start of file | SEEK_CUR -> Current position | SEEK_END -> End of file
|
||||
@result
|
||||
unsigned int indicating the number of bytes being written
|
||||
*/
|
||||
CFILE_UINT WriteFrom( void* ptr, CFILE_SIZE element_size, CFILE_SIZE element_count, CFILE_SLONG offset, signed int origin )
|
||||
{
|
||||
if( fh == NULL )
|
||||
{
|
||||
DoError( FE_NOFILEOPENED );
|
||||
return 0;
|
||||
}
|
||||
if( !IsWrite( ) )
|
||||
{
|
||||
DoError( FE_NORIGHTSFORACTION );
|
||||
return 0;
|
||||
}
|
||||
if( !Seek( offset, origin ) ) return 0;
|
||||
return (CFILE_UINT)( Write( ptr, element_size, element_count ) );
|
||||
}
|
||||
/** Writes to the file, from [from] to [to]
|
||||
@param
|
||||
ptr: A pointer to a buffer where the data will be read to write from
|
||||
@param
|
||||
from: The absolute (aka relative to SEEK_SET) offset to start writing from
|
||||
@param
|
||||
to: The absolute (aka relative to SEEK_SET) offset to stop writing at
|
||||
@result
|
||||
unsigned int indicating the number of bytes being written
|
||||
@note
|
||||
If (to-from) > the size of ptr, it throws an exception, so check it before calling this function!
|
||||
*/
|
||||
CFILE_UINT WriteFromTo( void* ptr, CFILE_SLONG from, CFILE_SLONG to )
|
||||
{
|
||||
if( fh == NULL )
|
||||
{
|
||||
DoError( FE_NOFILEOPENED );
|
||||
return 0;
|
||||
}
|
||||
if( !IsWrite( ) )
|
||||
{
|
||||
DoError( FE_NORIGHTSFORACTION );
|
||||
return 0;
|
||||
}
|
||||
if( to < from ) return 0;
|
||||
if( !SetAbsPos( from ) ) return 0;
|
||||
return (CFILE_UINT)( Write( ptr, (to-from), 1 ) );
|
||||
}
|
||||
/** Writes one byte to the file, as char
|
||||
@param
|
||||
chr: The byte to be written
|
||||
@result
|
||||
signed char: If success, it returns the char being written, else it returns EOF
|
||||
*/
|
||||
CFILE_SCHAR PutC( CFILE_SCHAR chr )
|
||||
{
|
||||
if( fh == NULL )
|
||||
{
|
||||
DoError( FE_NOFILEOPENED );
|
||||
return EOF;
|
||||
}
|
||||
if( !IsWrite( ) )
|
||||
{
|
||||
DoError( FE_NORIGHTSFORACTION );
|
||||
return EOF;
|
||||
}
|
||||
if( ftype == FT_ASCII || ftype == FT_BINARY )
|
||||
{
|
||||
return fputc( chr, fh );
|
||||
}
|
||||
else if( ftype == FT_UNICODE )
|
||||
{
|
||||
#ifndef CFILE_NOUNICODE
|
||||
wchar_t buffer;
|
||||
#ifndef CFILE_NODEPRECATE
|
||||
size_t tmp;
|
||||
mbstowcs_s( &tmp, &buffer, 1, (CFILE_CHAR*)(&chr), 1 );
|
||||
#else
|
||||
mbstowcs( &buffer, (CFILE_CHAR*)(&chr), 1 );
|
||||
#endif
|
||||
return (CFILE_SCHAR)(fputwc( buffer, fh ));
|
||||
#else
|
||||
DoError( FE_UNICODENOTALLOWED );
|
||||
return EOF;
|
||||
#endif
|
||||
}
|
||||
return EOF;
|
||||
}
|
||||
|
||||
/** Writes a string
|
||||
@param
|
||||
str: A string to the string to be written
|
||||
@result
|
||||
boolean indicating if writing the string has worked
|
||||
@note
|
||||
If the file is opened in binary mode, it throws an error and does nothing
|
||||
*/
|
||||
CFILE_BOOLEAN PutS( CRoseArray<CFILE_CHAR>* str )
|
||||
{
|
||||
if( fh == NULL )
|
||||
{
|
||||
DoError( FE_NOFILEOPENED );
|
||||
return false;
|
||||
}
|
||||
if( !IsWrite( ) )
|
||||
{
|
||||
DoError( FE_NORIGHTSFORACTION );
|
||||
return false;
|
||||
}
|
||||
if( ftype == FT_ASCII )
|
||||
{
|
||||
return (fputs( str->arr, fh )!=EOF)?(true):(false);
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifndef CFILE_NOUNICODE
|
||||
wchar_t* buffer = new wchar_t[ (size_t)(str->size()) ];
|
||||
#ifndef CFILE_NODEPRECATE
|
||||
size_t tmp;
|
||||
mbstowcs_s( &tmp, buffer, (size_t)(str->size()), str->arr, (size_t)(str->size()) );
|
||||
#else
|
||||
mbstowcs( buffer, str->arr, str->size() );
|
||||
#endif
|
||||
return (fputws( buffer, fh )!=EOF)?(true):(false);
|
||||
#else
|
||||
DoError( FE_UNICODENOTALLOWED );
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
DoError( FE_INTERNALERROR );
|
||||
return false;
|
||||
}
|
||||
|
||||
/** Template to write different types
|
||||
@<param>
|
||||
typename
|
||||
@param
|
||||
typename val: the value to be written
|
||||
@param
|
||||
cnt: times val will be written
|
||||
@result
|
||||
typename: If success, it returns the value being written, else it returns 0
|
||||
*/
|
||||
template<typename T> T Put( T val, CFILE_UINT cnt=1 )
|
||||
{
|
||||
if( fh == NULL )
|
||||
{
|
||||
DoError( FE_NOFILEOPENED );
|
||||
return 0;
|
||||
}
|
||||
if( !IsWrite( ) )
|
||||
{
|
||||
DoError( FE_NORIGHTSFORACTION );
|
||||
return 0;
|
||||
}
|
||||
return (Write( &val, sizeof( val ), cnt ) != 0)?(val):(0);
|
||||
}
|
||||
};
|
||||
Reference in new issue
Block a user