Renegade/Code/wwlib/bufffile.cpp

/*
**	Command & Conquer Renegade(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program is free software: you can redistribute it and/or modify
**	it under the terms of the GNU General Public License as published by
**	the Free Software Foundation, either version 3 of the License, or
**	(at your option) any later version.
**
**	This program 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 General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/*********************************************************************************************** 
 ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               *** 
 *********************************************************************************************** 
 *                                                                                             * 
 *                 Project Name : Command & Conquer                                            * 
 *                                                                                             * 
 *                     $Archive:: /Commando/Code/wwlib/bufffile.cpp                           $* 
 *                                                                                             * 
 *                      $Author:: Jani_p                                                      $*
 *                                                                                             * 
 *                     $Modtime:: 9/13/01 7:15p                                               $*
 *                                                                                             * 
 *                    $Revision:: 4                                                           $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------* 
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */


#include	"always.h"
#include	"bufffile.h"
#include	"wwdebug.h"
#include	<string.h>

int		BufferedFileClass::_DesiredBufferSize	=	1024*16;	

/***********************************************************************************************
 * BufferedFileClass::BufferedFileClass -- Default constructor for a file object.              *
 *=============================================================================================*/
BufferedFileClass::BufferedFileClass(void) :
	RawFileClass(),
	Buffer( NULL ),
	BufferSize( 0 ),
	BufferAvailable( 0 ),
	BufferOffset( 0 )
{
}

/***********************************************************************************************
 * BufferedFileClass::BufferedFileClass -- Simple constructor for a file object.                         *
 *=============================================================================================*/
BufferedFileClass::BufferedFileClass(char const * filename) :
	RawFileClass( filename ),
	Buffer( NULL ),
	BufferSize( 0 ),
	BufferAvailable( 0 ),
	BufferOffset( 0 )
{
}

/***********************************************************************************************
 * BufferedFileClass::~BufferedFileClass -- Default deconstructor for a file object.                     *
 *=============================================================================================*/
BufferedFileClass::~BufferedFileClass(void)
{
	Reset_Buffer();
}

/***********************************************************************************************
 * BufferedFileClass::Close -- Perform a closure of the file.                                       *
 *=============================================================================================*/
void BufferedFileClass::Close(void)
{
	BASECLASS::Close();

	Reset_Buffer();
}


/***********************************************************************************************
 * BufferedFileClass::Read -- Reads the specified number of bytes into a memory buffer.             *
 *                                                                                             *
 *    This routine will read the specified number of bytes and place the data into the buffer  *
 *    indicated. It is legal to call this routine with a request for more bytes than are in    *
 *    the file. This condition can result in fewer bytes being read than requested. Determine  *
 *    this by examining the return value.                                                      *
 *                                                                                             *
 * INPUT:   buffer   -- Pointer to the buffer to read data into. If NULL is passed, no read    *
 *                      is performed.                                                          *
 *                                                                                             *
 *          size     -- The number of bytes to read. If NULL is passed, then no read is        *
 *                      performed.                                                             *
 *                                                                                             *
 * OUTPUT:  Returns with the number of bytes read into the buffer. If this number is less      *
 *          than requested, it indicates that the file has been exhausted.                     *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   10/18/1994 JLB : Created.                                                                 *
 *=============================================================================================*/
int BufferedFileClass::Read(void * buffer, int size)
{
	int read = 0;

	// If there is anything in the buffer, copy it in.
	if ( BufferAvailable > 0 ) {
		int amount = min( size, BufferAvailable );
		::memcpy( buffer, &Buffer[BufferOffset], amount );
		BufferAvailable -= amount;
		BufferOffset += amount;
		size -= amount;
		buffer = (char *)buffer + amount;
		read += amount;
	}

	if ( size == 0 ) {
		return read;
	}

	// We need to get a copy of the _DesiredBufferSize into
	// a local variable to protect us from modifications
	// from another thread. Otherwise, we could pass the test
	// (size > amount) below, only to allocate a buffer that's
	// too small in the next block. (DRM, 04/20/01)
	int desired_buffer_size = _DesiredBufferSize;

	// If we need more than the buffer will hold, just read it
	int amount = BufferSize;
	if ( amount == 0 ) {
		amount = desired_buffer_size;
	}
	if ( size > amount ) {
		return BASECLASS::Read( buffer, size ) + read;
	}

	// If we dont have a buffer, get one
	if ( BufferSize == 0 ) {
		BufferSize = desired_buffer_size;
		Buffer = new unsigned char [BufferSize];
		BufferAvailable = 0;
		BufferOffset = 0;
	}

	// Fill the buffer
	if ( BufferAvailable == 0 ) {
		BufferAvailable = BASECLASS::Read( Buffer, BufferSize );
		BufferOffset = 0;
	}

	// If there is anything in the buffer, copy it in.
	if ( BufferAvailable > 0 ) {
		int amount = min( size, BufferAvailable );
		::memcpy( buffer, &Buffer[BufferOffset], amount );
		BufferAvailable -= amount;
		BufferOffset += amount;
		read += amount;
	}

	return read;
}


/***********************************************************************************************
 * BufferedFileClass::Write -- Writes the specified data to the buffer specified.                   *
 *                                                                                             *
 *    This routine will write the data specified to the file.                                  *
 *                                                                                             *
 * INPUT:   buffer   -- The buffer that holds the data to write.                               *
 *                                                                                             *
 *          size     -- The number of bytes to write to the file.                              *
 *                                                                                             *
 * OUTPUT:  Returns with the number of bytes written to the file. This routine catches the     *
 *          case of a disk full condition, so this routine will always return with the number  *
 *          matching the size request.                                                         *
 *                                                                                             *
 * WARNINGS:   A fatal file condition could cause this routine to never return.                *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   10/18/1994 JLB : Created.                                                                 *
 *=============================================================================================*/
int BufferedFileClass::Write(void const * buffer, int size)
{
	if ( BufferSize != 0 ) {
		WWASSERT( 0 );
	}

	return BASECLASS::Write( buffer, size );
}


/***********************************************************************************************
 * BufferedFileClass::Seek -- Reposition the file pointer as indicated.                             *
 *                                                                                             *
 *    Use this routine to move the filepointer to the position indicated. It can move either   *
 *    relative to current position or absolute from the beginning or ending of the file. This  *
 *    routine will only return if it successfully performed the seek.                          *
 *                                                                                             *
 * INPUT:   pos   -- The position to seek to. This is interpreted as relative to the position  *
 *                   indicated by the "dir" parameter.                                         *
 *                                                                                             *
 *          dir   -- The relative position to relate the seek to. This can be either SEEK_SET  *
 *                   for the beginning of the file, SEEK_CUR for the current position, or      *
 *                   SEEK_END for the end of the file.                                         *
 *                                                                                             *
 * OUTPUT:  This routine returns the position that the seek ended up at.                       *
 *                                                                                             *
 * WARNINGS:   If there was a file error, then this routine might never return.                *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   10/18/1994 JLB : Created.                                                                 *
 *=============================================================================================*/
int BufferedFileClass::Seek(int pos, int dir)
{
	if ( (dir != SEEK_CUR) || (pos < 0) ) {
		Reset_Buffer();
	}

	// If not buffered, pass through
	if ( BufferAvailable == 0 ) {
		return BASECLASS::Seek( pos, dir );
	}

	// use up what we can of the buffer
	int amount = min( pos, BufferAvailable );
	pos -= amount;
	BufferAvailable -= amount;
	BufferOffset += amount;

	return BASECLASS::Seek( pos, dir ) - BufferAvailable;
}

/*
**
*/
void	BufferedFileClass::Reset_Buffer( void )
{
	if ( Buffer != NULL ) {
		delete [] Buffer;
		Buffer = NULL;
		BufferSize = 0;
		BufferAvailable = 0;
		BufferOffset = 0;
	}
}