Move buffering logic from RageFile into RageFileObj.
Common file interface class, RageBasicFile, shared by RageFile and RageFileObj. This makes most uses of these objects interchangeable. RageFile is now just a simple wrapper for RageFileObj, to create files in FILEMAN's namespace; file objects can also be created independently. This means that, for example, IniFile can be used to write a file to a CString, without having to jump through hoops, and without having to use a separate file access wrapper; just do something like: RageFileObjMem string_file; ini.WriteFile( string ); const CString &sString = string_file.GetString();
This commit is contained in:
Glenn Maynard
+71
-299
@@ -1,3 +1,10 @@
|
||||
/*
|
||||
* This provides an interface to open files in RageFileManager's namespace
|
||||
* This is just a simple RageBasicFile wrapper on top of another RageBasicFile;
|
||||
* when a file is open, is acts like the underlying RageBasicFile, except that
|
||||
* a few extra sanity checks are made to check file modes.
|
||||
*/
|
||||
|
||||
#include "global.h"
|
||||
#include "RageFile.h"
|
||||
#include "RageUtil.h"
|
||||
@@ -6,26 +13,15 @@
|
||||
RageFile::RageFile()
|
||||
{
|
||||
m_File = NULL;
|
||||
m_BufAvail = 0;
|
||||
m_EOF = false;
|
||||
m_FilePos = 0;
|
||||
}
|
||||
|
||||
RageFile::RageFile( const RageFile &cpy )
|
||||
RageFile::RageFile( const RageFile &cpy ):
|
||||
RageBasicFile( cpy )
|
||||
{
|
||||
ResetBuf();
|
||||
|
||||
/* This will copy the file driver, including its internal file pointer. */
|
||||
m_File = FILEMAN->CopyFileObj( cpy.m_File );
|
||||
m_Path = cpy.m_Path;
|
||||
m_Mode = cpy.m_Mode;
|
||||
m_Error = cpy.m_Error;
|
||||
m_EOF = cpy.m_EOF;
|
||||
m_FilePos = cpy.m_FilePos;
|
||||
memcpy( this->m_Buffer, cpy.m_Buffer, sizeof(m_Buffer) );
|
||||
m_pBuf = m_Buffer + (cpy.m_pBuf-cpy.m_Buffer);
|
||||
|
||||
m_BufAvail = cpy.m_BufAvail;
|
||||
}
|
||||
|
||||
CString RageFile::GetPath() const
|
||||
@@ -49,9 +45,6 @@ bool RageFile::Open( const CString& path, int mode )
|
||||
FixSlashesInPlace(m_Path);
|
||||
|
||||
m_Mode = mode;
|
||||
m_EOF = false;
|
||||
m_FilePos = 0;
|
||||
ResetBuf();
|
||||
|
||||
if( (m_Mode&READ) && (m_Mode&WRITE) )
|
||||
{
|
||||
@@ -83,291 +76,90 @@ void RageFile::Close()
|
||||
m_File = NULL;
|
||||
}
|
||||
|
||||
/* Fill the internal buffer. This never marks EOF, since this is an internal, hidden
|
||||
* read; EOF should only be set as a result of a real read. (That is, disabling buffering
|
||||
* shouldn't cause the results of AtEOF to change.) */
|
||||
int RageFile::FillBuf()
|
||||
{
|
||||
/* The buffer starts at m_Buffer; any data in it starts at m_pBuf; space between
|
||||
* the two is old data that we've read. (Don't mangle that data; we can use it
|
||||
* for seeking backwards.) */
|
||||
const int iBufAvail = sizeof(m_Buffer) - (m_pBuf-m_Buffer) - m_BufAvail;
|
||||
ASSERT_M( iBufAvail >= 0, ssprintf("%p, %p, %i", m_pBuf, m_Buffer, (int) sizeof(m_Buffer) ) );
|
||||
const int size = m_File->Read( m_pBuf+m_BufAvail, iBufAvail );
|
||||
|
||||
if( size == -1 )
|
||||
SetError( m_File->GetError() );
|
||||
|
||||
if( size > 0 )
|
||||
m_BufAvail += size;
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
void RageFile::ResetBuf()
|
||||
{
|
||||
m_BufAvail = 0;
|
||||
m_pBuf = m_Buffer;
|
||||
}
|
||||
|
||||
/* Read up to the next \n, and return it in out. Strip the \n. If the \n is
|
||||
* preceded by a \r (DOS newline), strip that, too. */
|
||||
#define ASSERT_OPEN ASSERT_M( IsOpen(), ssprintf("\"%s\" is not open.", m_Path.c_str()) );
|
||||
#define ASSERT_READ ASSERT_OPEN; ASSERT_M( !!(m_Mode&READ), ssprintf("\"%s\" is not open for reading", m_Path.c_str()) );
|
||||
#define ASSERT_WRITE ASSERT_OPEN; ASSERT_M( !!(m_Mode&WRITE), ssprintf("\"%s\" is not open for writing", m_Path.c_str()) );
|
||||
int RageFile::GetLine( CString &out )
|
||||
{
|
||||
out = "";
|
||||
|
||||
if ( !IsOpen() )
|
||||
RageException::Throw("\"%s\" is not open.", m_Path.c_str());
|
||||
|
||||
if( !(m_Mode&READ) )
|
||||
RageException::Throw("\"%s\" is not open for reading", GetPath().c_str());
|
||||
|
||||
if( m_EOF )
|
||||
return 0;
|
||||
|
||||
bool GotData = false;
|
||||
while( 1 )
|
||||
{
|
||||
bool done = false;
|
||||
|
||||
/* Find the end of the block we'll move to out. */
|
||||
char *p = (char *) memchr( m_pBuf, '\n', m_BufAvail );
|
||||
bool ReAddCR = false;
|
||||
if( p == NULL )
|
||||
{
|
||||
/* Hack: If the last character of the buffer is \r, then it's likely that an
|
||||
* \r\n has been split across buffers. Move everything else, then move the
|
||||
* \r to the beginning of the buffer and handle it the next time around the loop. */
|
||||
if( m_BufAvail && m_pBuf[m_BufAvail-1] == '\r' )
|
||||
{
|
||||
ReAddCR = true;
|
||||
--m_BufAvail;
|
||||
}
|
||||
|
||||
p = m_pBuf+m_BufAvail; /* everything */
|
||||
}
|
||||
else
|
||||
done = true;
|
||||
|
||||
if( p >= m_pBuf )
|
||||
{
|
||||
char *RealEnd = p;
|
||||
if( done && p > m_pBuf && p[-1] == '\r' )
|
||||
--RealEnd; /* not including \r */
|
||||
out.append( m_pBuf, RealEnd );
|
||||
|
||||
if( done )
|
||||
++p; /* skip \n */
|
||||
|
||||
const int used = p-m_pBuf;
|
||||
if( used )
|
||||
{
|
||||
m_BufAvail -= used;
|
||||
m_FilePos += used;
|
||||
GotData = true;
|
||||
m_pBuf = p;
|
||||
}
|
||||
}
|
||||
|
||||
if( ReAddCR )
|
||||
{
|
||||
ASSERT( m_BufAvail == 0 );
|
||||
m_pBuf = m_Buffer;
|
||||
m_Buffer[m_BufAvail] = '\r';
|
||||
++m_BufAvail;
|
||||
}
|
||||
|
||||
if( done )
|
||||
break;
|
||||
|
||||
/* We need more data. */
|
||||
m_pBuf = m_Buffer;
|
||||
|
||||
const int size = FillBuf();
|
||||
|
||||
/* If we've read data already, then don't mark EOF yet. Wait until the
|
||||
* next time we're called. */
|
||||
if( size == 0 && !GotData )
|
||||
{
|
||||
m_EOF = true;
|
||||
return 0;
|
||||
}
|
||||
if( size == -1 )
|
||||
return -1; // error
|
||||
if( size == 0 )
|
||||
break; // EOF or error
|
||||
}
|
||||
return GotData? 1:0;
|
||||
ASSERT_READ;
|
||||
return m_File->GetLine( out );
|
||||
}
|
||||
|
||||
// Always use "\r\n". Even though the program may be running on Unix, the
|
||||
// files written to a memory card are likely to be edited using Windows.
|
||||
//#if defined(_WIN32)
|
||||
#define NEWLINE "\r\n"
|
||||
//#else
|
||||
//#define NEWLINE "\n"
|
||||
//#endif
|
||||
|
||||
int RageFile::PutLine( const CString &str )
|
||||
{
|
||||
if( Write(str) == -1 )
|
||||
return -1;
|
||||
return Write( CString(NEWLINE) );
|
||||
ASSERT_WRITE;
|
||||
return m_File->PutLine( str );
|
||||
}
|
||||
|
||||
bool RageFile::AtEOF() const
|
||||
{
|
||||
ASSERT_READ;
|
||||
return m_File->AtEOF();
|
||||
}
|
||||
|
||||
void RageFile::ClearError()
|
||||
{
|
||||
if( m_File != NULL )
|
||||
m_File->ClearError();
|
||||
m_sError = "";
|
||||
}
|
||||
|
||||
CString RageFile::GetError() const
|
||||
{
|
||||
if( m_File != NULL && m_File->GetError() != "" )
|
||||
return m_File->GetError();
|
||||
return m_sError;
|
||||
}
|
||||
|
||||
|
||||
int RageFile::Read( void *buffer, size_t bytes )
|
||||
void RageFile::SetError( const CString &err )
|
||||
{
|
||||
if( !IsOpen() )
|
||||
RageException::Throw("\"%s\" is not open.", GetPath().c_str());
|
||||
if( m_File != NULL )
|
||||
m_File->ClearError();
|
||||
m_sError = err;
|
||||
}
|
||||
|
||||
if( !(m_Mode&READ) )
|
||||
RageException::Throw("\"%s\" is not open for reading", GetPath().c_str());
|
||||
|
||||
int ret = 0;
|
||||
|
||||
while( !m_EOF && bytes > 0 )
|
||||
{
|
||||
/* Copy data out of the buffer first. */
|
||||
int FromBuffer = min( (int) bytes, m_BufAvail );
|
||||
memcpy( buffer, m_pBuf, FromBuffer );
|
||||
|
||||
ret += FromBuffer;
|
||||
m_FilePos += FromBuffer;
|
||||
bytes -= FromBuffer;
|
||||
m_BufAvail -= FromBuffer;
|
||||
m_pBuf += FromBuffer;
|
||||
|
||||
buffer = (char *) buffer + FromBuffer;
|
||||
|
||||
if( !bytes )
|
||||
break;
|
||||
|
||||
ASSERT( !m_BufAvail );
|
||||
|
||||
/* We need more; either fill the buffer and keep going, or just read directly
|
||||
* into the destination buffer. */
|
||||
if( bytes >= sizeof(m_Buffer) )
|
||||
{
|
||||
/* We have a lot more to read, so don't waste time copying it into the
|
||||
* buffer. */
|
||||
int FromFile = m_File->Read( buffer, bytes );
|
||||
if( FromFile == -1 )
|
||||
{
|
||||
SetError( m_File->GetError() );
|
||||
return -1;
|
||||
}
|
||||
if( FromFile == 0 )
|
||||
m_EOF = true;
|
||||
ret += FromFile;
|
||||
m_FilePos += FromFile;
|
||||
return ret;
|
||||
}
|
||||
|
||||
m_pBuf = m_Buffer;
|
||||
int got = FillBuf();
|
||||
if( got < 0 )
|
||||
return got;
|
||||
if( got == 0 )
|
||||
m_EOF = true;
|
||||
}
|
||||
|
||||
return ret;
|
||||
int RageFile::Read( void *pBuffer, size_t iBytes )
|
||||
{
|
||||
ASSERT_READ;
|
||||
return m_File->Read( pBuffer, iBytes );
|
||||
}
|
||||
|
||||
int RageFile::Seek( int offset )
|
||||
{
|
||||
if( !IsOpen() )
|
||||
RageException::Throw("\"%s\" is not open.", GetPath().c_str());
|
||||
ASSERT_READ;
|
||||
return m_File->Seek( offset );
|
||||
}
|
||||
|
||||
if( !(m_Mode&READ) )
|
||||
RageException::Throw("\"%s\" is not open for reading; can't seek", GetPath().c_str());
|
||||
|
||||
m_EOF = false;
|
||||
|
||||
ResetBuf();
|
||||
|
||||
int pos = m_File->Seek( offset );
|
||||
if( pos == -1 )
|
||||
{
|
||||
SetError( m_File->GetError() );
|
||||
return -1;
|
||||
}
|
||||
|
||||
m_FilePos = pos;
|
||||
return pos;
|
||||
int RageFile::Tell() const
|
||||
{
|
||||
ASSERT_READ;
|
||||
return m_File->Tell();
|
||||
}
|
||||
|
||||
int RageFile::GetFileSize() const
|
||||
{
|
||||
if( !IsOpen() )
|
||||
RageException::Throw("\"%s\" is not open.", GetPath().c_str());
|
||||
|
||||
if( !(m_Mode&READ) )
|
||||
RageException::Throw("\"%s\" is not open for reading; can't GetFileSize", GetPath().c_str());
|
||||
|
||||
/* GetFileSize() may need to do non-const-like things--the default implementation reads
|
||||
* until the end of file to emulate it. However, it should always restore the state to
|
||||
* the way it was, so pretend it's const. */
|
||||
int iRet = const_cast<RageFileObj*>(m_File)->GetFileSize();
|
||||
ASSERT_M( iRet >= 0, ssprintf("%i", iRet) );
|
||||
return iRet;
|
||||
ASSERT_READ;
|
||||
return m_File->GetFileSize();
|
||||
}
|
||||
|
||||
int RageFile::Read( CString &buffer, int bytes )
|
||||
{
|
||||
buffer.erase( buffer.begin(), buffer.end() );
|
||||
buffer.reserve( bytes != -1? bytes: this->GetFileSize() );
|
||||
|
||||
int ret = 0;
|
||||
char buf[4096];
|
||||
while( bytes == -1 || ret < bytes )
|
||||
{
|
||||
int ToRead = sizeof(buf);
|
||||
if( bytes != -1 )
|
||||
ToRead = min( ToRead, bytes-ret );
|
||||
|
||||
const int got = Read( buf, ToRead );
|
||||
if( got == 0 )
|
||||
break;
|
||||
if( got == -1 )
|
||||
return -1;
|
||||
|
||||
buffer.append( buf, got );
|
||||
ret += got;
|
||||
}
|
||||
|
||||
return ret;
|
||||
ASSERT_READ;
|
||||
return m_File->Read( buffer, bytes );
|
||||
}
|
||||
|
||||
int RageFile::Write( const void *buffer, size_t bytes )
|
||||
{
|
||||
if( !IsOpen() )
|
||||
RageException::Throw("\"%s\" is not open.", GetPath().c_str());
|
||||
|
||||
if( !(m_Mode&WRITE) )
|
||||
RageException::Throw("\"%s\" is not open for writing", GetPath().c_str());
|
||||
|
||||
int iRet = m_File->Write( buffer, bytes );
|
||||
if( iRet == -1 )
|
||||
{
|
||||
SetError( m_File->GetError() );
|
||||
return -1;
|
||||
}
|
||||
return iRet;
|
||||
ASSERT_WRITE;
|
||||
return m_File->Write( buffer, bytes );
|
||||
}
|
||||
|
||||
|
||||
int RageFile::Write( const void *buffer, size_t bytes, int nmemb )
|
||||
{
|
||||
/* Simple write. We never return partial writes. */
|
||||
int ret = Write( buffer, bytes*nmemb ) / bytes;
|
||||
if( ret == -1 )
|
||||
{
|
||||
SetError( m_File->GetError() );
|
||||
return -1;
|
||||
}
|
||||
return ret / bytes;
|
||||
ASSERT_WRITE;
|
||||
return m_File->Write( buffer, bytes, nmemb );
|
||||
}
|
||||
|
||||
int RageFile::Flush()
|
||||
@@ -378,42 +170,22 @@ int RageFile::Flush()
|
||||
return -1;
|
||||
}
|
||||
|
||||
int iRet = m_File->Flush();
|
||||
if( iRet == -1 )
|
||||
{
|
||||
SetError( m_File->GetError() );
|
||||
return -1;
|
||||
}
|
||||
return iRet;
|
||||
return m_File->Flush();
|
||||
}
|
||||
|
||||
int RageFile::Read( void *buffer, size_t bytes, int nmemb )
|
||||
{
|
||||
const int ret = Read( buffer, bytes*nmemb );
|
||||
if( ret == -1 )
|
||||
return -1;
|
||||
|
||||
/* If we're reading 10-byte blocks, and we got 27 bytes, we have 7 extra bytes.
|
||||
* Seek back. */
|
||||
const int extra = ret % bytes;
|
||||
Seek( Tell()-extra );
|
||||
|
||||
return ret/bytes;
|
||||
ASSERT_READ;
|
||||
return m_File->Read( buffer, bytes, nmemb );
|
||||
}
|
||||
|
||||
int RageFile::Seek( int offset, int whence )
|
||||
{
|
||||
switch( whence )
|
||||
{
|
||||
case SEEK_CUR:
|
||||
return Seek( Tell() + offset );
|
||||
case SEEK_END:
|
||||
offset += GetFileSize();
|
||||
}
|
||||
return Seek( (int) offset );
|
||||
ASSERT_READ;
|
||||
return m_File->Seek( offset, whence );
|
||||
}
|
||||
|
||||
void FileReading::ReadBytes( RageFile &f, void *buf, int size, CString &sError )
|
||||
void FileReading::ReadBytes( RageBasicFile &f, void *buf, int size, CString &sError )
|
||||
{
|
||||
if( sError.size() != 0 )
|
||||
return;
|
||||
@@ -425,7 +197,7 @@ void FileReading::ReadBytes( RageFile &f, void *buf, int size, CString &sError )
|
||||
sError = "Unexpected end of file";
|
||||
}
|
||||
|
||||
uint8_t FileReading::read_8( RageFile &f, CString &sError )
|
||||
uint8_t FileReading::read_8( RageBasicFile &f, CString &sError )
|
||||
{
|
||||
uint8_t val;
|
||||
ReadBytes( f, &val, sizeof(uint8_t), sError );
|
||||
@@ -435,7 +207,7 @@ uint8_t FileReading::read_8( RageFile &f, CString &sError )
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint16_t FileReading::read_u16_le( RageFile &f, CString &sError )
|
||||
uint16_t FileReading::read_u16_le( RageBasicFile &f, CString &sError )
|
||||
{
|
||||
uint16_t val;
|
||||
ReadBytes( f, &val, sizeof(uint16_t), sError );
|
||||
@@ -445,7 +217,7 @@ uint16_t FileReading::read_u16_le( RageFile &f, CString &sError )
|
||||
return 0;
|
||||
}
|
||||
|
||||
int16_t FileReading::read_16_le( RageFile &f, CString &sError )
|
||||
int16_t FileReading::read_16_le( RageBasicFile &f, CString &sError )
|
||||
{
|
||||
int16_t val;
|
||||
ReadBytes( f, &val, sizeof(int16_t), sError );
|
||||
@@ -455,7 +227,7 @@ int16_t FileReading::read_16_le( RageFile &f, CString &sError )
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint32_t FileReading::read_u32_le( RageFile &f, CString &sError )
|
||||
uint32_t FileReading::read_u32_le( RageBasicFile &f, CString &sError )
|
||||
{
|
||||
uint32_t val;
|
||||
ReadBytes( f, &val, sizeof(uint32_t), sError );
|
||||
@@ -465,7 +237,7 @@ uint32_t FileReading::read_u32_le( RageFile &f, CString &sError )
|
||||
return 0;
|
||||
}
|
||||
|
||||
int32_t FileReading::read_32_le( RageFile &f, CString &sError )
|
||||
int32_t FileReading::read_32_le( RageBasicFile &f, CString &sError )
|
||||
{
|
||||
int32_t val;
|
||||
ReadBytes( f, &val, sizeof(int32_t), sError );
|
||||
|
||||
Reference in New Issue
Block a user