#include <vsfilesystem.h>

Public Member Functions
char *	get_pk3_data ()

	VSFile ()

	VSFile (const char *buffer, long size, VSFileType type=ZoneBuffer, VSFileMode=ReadOnly)

	VSFile (const char *filename, VSFileType type=UnknownFile, VSFileMode=ReadOnly)

	~VSFile ()

FILE *	GetFP ()

char *	GetFileBuffer ()

VSError	OpenReadOnly (const char *filename, VSFileType type=UnknownFile)

VSError	OpenReadOnly (const string &filename, VSFileType type=UnknownFile)

VSError	OpenReadWrite (const char *filename, VSFileType type=UnknownFile)

VSError	OpenReadWrite (const string &filename, VSFileType type=UnknownFile)

VSError	OpenCreateWrite (const char *filename, VSFileType type=UnknownFile)

VSError	OpenCreateWrite (const string &filename, VSFileType type=UnknownFile)

void	Close ()

size_t	Read (void *ptr, size_t length)

VSError	ReadLine (void *ptr, size_t length)

string	ReadFull ()

size_t	Write (const void *ptr, size_t length)

size_t	Write (const string &content)

VSError	WriteLine (const void *ptr)

void	WriteFull (void *ptr)

void	GoAfterEOL (unsigned int length)

void	GoAfterEOL ()

template<class A >
int	Fscanf (const char format, A a)

template<class A , class B >
int	Fscanf (const char format, A a, B *b)

template<class A , class B , class C >
int	Fscanf (const char format, A a, B b, C c)

template<class A , class B , class C , class D >
int	Fscanf (const char format, A a, B b, C c, D *d)

template<class A , class B , class C , class D , class E >
int	Fscanf (const char format, A a, B b, C c, D d, E e)

template<class A , class B , class C , class D , class E , class F >
int	Fscanf (const char format, A a, B b, C c, D d, E e, F *f)

int	Fprintf (const char *format,...)

long	Size ()

void	Begin ()

long	GetPosition ()

void	End ()

void	GoTo (long offset)

void	Clear ()

bool	Eof ()

bool	Valid ()

const string &	GetFilename () const

const string &	GetDirectory () const

const string &	GetSubDirectory () const

const string &	GetRoot () const

void	SetFilename (const string &filename)

void	SetDirectory (const string &directory)

void	SetSubDirectory (const string &subdirectory)

void	SetRoot (const string &root)

string	GetFullPath ()

string	GetAbsPath ()

void	SetType (VSFileType type)

void	SetAltType (VSFileType type)

VSFileType	GetType () const

VSFileType	GetAltType () const

void	SetIndex (int index)

void	SetVolume (VSVolumeType big)

bool	UseVolume ()

Friends
class	VSImage

Detailed Description

Definition at line 296 of file vsfilesystem.h.

Constructor & Destructor Documentation

VSFileSystem::VSFile::VSFile ( )

Definition at line 1338 of file vsfilesystem.cpp.

 {
     private_init();
 }

VSFileSystem::VSFile::VSFile	(	const char *	buffer,
		long	size,
		VSFileType	type = `ZoneBuffer`,
		VSFileMode	mode = `ReadOnly`
	)

Definition at line 1343 of file vsfilesystem.cpp.

References bufsize, VsnetOSS::memcpy(), size, VSFileSystem::VSFSBig, and VSFileSystem::ZoneBuffer.

 {
     private_init();
     this->size = bufsize;
     this->pk3_extracted_file    = new char[bufsize+1];
     memcpy( this->pk3_extracted_file, buffer, bufsize );
     pk3_extracted_file[bufsize] = 0;
     this->file_type   = this->alt_type = ZoneBuffer;
     this->file_mode   = mode;
     //To say we want to read in volume even if it is not the case then it will read in pk3_extracted_file
     this->volume_type = VSFSBig;
 }

VSFileSystem::VSFile::VSFile	(	const char *	filename,
		VSFileType	type = `UnknownFile`,
		VSFileMode	mode = `ReadOnly`
	)

Definition at line 1356 of file vsfilesystem.cpp.

References VSFileSystem::CreateWrite, OpenCreateWrite(), OpenReadOnly(), OpenReadWrite(), VSFileSystem::ReadOnly, and VSFileSystem::ReadWrite.

 {
     private_init();
     if (mode == ReadOnly)
         this->OpenReadOnly( filename, type );
     else if (mode == ReadWrite)
         this->OpenReadWrite( filename, type );
     else if (mode == CreateWrite)
         this->OpenCreateWrite( filename, type );
 }

VSFileSystem::VSFile::~VSFile ( )

Definition at line 1367 of file vsfilesystem.cpp.

References fclose.

 {
     if (fp) {
         fclose( fp );
         this->fp = NULL;
     }
     if (pk3_extracted_file)
         delete[] pk3_extracted_file;
 }

Member Function Documentation

void VSFileSystem::VSFile::Begin ( )

Definition at line 1763 of file vsfilesystem.cpp.

References VSFileSystem::q_volume_format, VSFileSystem::ReadOnly, VSFileSystem::UseVolumes, VSFileSystem::vfmtPK3, VSFileSystem::vfmtVSR, and VSFileSystem::VSFSNone.

 {
     if (!UseVolumes[alt_type] || this->volume_type == VSFSNone || this->file_mode != ReadOnly) {
         fseek( this->fp, 0, SEEK_SET );
     } else {
         if (q_volume_format == vfmtVSR)
             offset = 0;
         else if (q_volume_format == vfmtPK3)
             offset = 0;
     }
 }

void VSFileSystem::VSFile::Clear ( )

Definition at line 1818 of file vsfilesystem.cpp.

References fclose, fopen, VSFileSystem::GetError(), GetFullPath(), VSFileSystem::ReadOnly, VSFileSystem::UseVolumes, VSExit(), and VSFileSystem::VSFSNone.

 {
     if (!UseVolumes[alt_type] || this->volume_type == VSFSNone || file_mode != ReadOnly) {
         fclose( fp );
         this->fp = fopen( this->GetFullPath().c_str(), "w+b" );
         //This should not happen
         if (!fp) {
             GetError( "Clear" );
             VSExit( 1 );
         }
     } else {
         cerr<<"!!! ERROR : Writing is not supported within resource/volume files"<<endl;
         VSExit( 1 );
     }
 }

void VSFileSystem::VSFile::Close ( void )

Definition at line 1865 of file vsfilesystem.cpp.

References VSFileSystem::AnimFile, VSFileSystem::CockpitFile, VSFileSystem::current_path, VSFileSystem::current_subdirectory, VSFileSystem::current_type, VSFileSystem::DisplayType(), fclose, VSFileSystem::q_volume_format, VSFileSystem::ReadOnly, size, VSFileSystem::UnitFile, VSFileSystem::UnknownFile, VSFileSystem::UseVolumes, VSFileSystem::vfmtPK3, VSFileSystem::vfmtVSR, VSFS_DEBUG(), VSFileSystem::VSFSNone, VSFileSystem::VSSpriteFile, and VSFileSystem::ZoneBuffer.

Referenced by BaseComputer::actionConfirmedSaveGame(), BaseComputer::actionSaveGame(), AnimatedTexture::AnimatedTexture(), Animation::Animation(), AUDCreateSoundMP3(), AUDLoadSoundFile(), ROLES::buildroles(), ROLES::buildscripts(), VsnetDownload::Client::File::childAppend(), CloseFile(), GameStarSystem::createBackground(), EnvironmentMapGeneratorMain(), getAITypes(), GetHelperPlayerSaveGame(), getProgramSource(), FileUtil::HashCompute(), XMLDOM::VSFileXMLSerializer::importXML(), Cockpit::Init(), InitUnitTables(), Texture::Load(), LoadAccounts(), AnimatedTexture::LoadFrame(), Mesh::LoadMeshes(), AnimatedTexture::LoadVideoSource(), Nebula::LoadXML(), easyDomFactory< configNode >::LoadXML(), Unit::makeMasterPartList(), SaveGame::ParseSaveGame(), parseTurretSizes(), StarSystemGent::readColorGrads(), StarSystemGent::readentity(), readnames(), AccountServer::recvMsg(), SaveFileCopy(), Screenshot(), AccountServer::sendAuthorized(), NetServer::start(), VSSprite::VSSprite(), XMLSerializer::Write(), VSImage::WriteImage(), FileUtil::WriteSaveFiles(), SaveGame::WriteSaveGame(), Unit::WriteUnit(), and VsnetDownload::Client::File::~File().

 {
     if (this->file_type >= ZoneBuffer && this->file_type != UnknownFile && this->pk3_extracted_file) {
         delete this->pk3_extracted_file;
         this->pk3_extracted_file = NULL;
         return;
     }
     if ( this->valid && this->file_mode == ReadOnly
         && (file_type == UnitFile || file_type == AnimFile || file_type == VSSpriteFile || file_type == CockpitFile) ) {
         assert( current_path.size() > 1 );
         current_path.pop_back();
         current_subdirectory.pop_back();
         current_type.pop_back();
         if (VSFS_DEBUG() > 2) {
             cerr<<"END OF ";
             DisplayType( this->file_type );
             cerr<<endl<<endl;
         }
     }
     if (!UseVolumes[file_type] || this->volume_type == VSFSNone || file_mode != ReadOnly) {
         fclose( this->fp );
         this->fp = NULL;
     } else {
         if (q_volume_format == vfmtVSR) {} else if (q_volume_format == vfmtPK3) {
             if (pk3_extracted_file)
                 delete[] pk3_extracted_file;
             pk3_extracted_file = NULL;
         }
     }
     this->size = -1;
     this->valid = false;
     this->filename = "";
     this->directoryname    = "";
     this->subdirectoryname = "";
     this->rootname         = "";
     this->offset           = 0;
     this->file_index       = -1;
 }

void VSFileSystem::VSFile::End ( )

Definition at line 1775 of file vsfilesystem.cpp.

References VSFileSystem::q_volume_format, VSFileSystem::ReadOnly, size, VSFileSystem::UseVolumes, VSFileSystem::vfmtPK3, VSFileSystem::vfmtVSR, and VSFileSystem::VSFSNone.

 {
     if (!UseVolumes[alt_type] || this->volume_type == VSFSNone || this->file_mode != ReadOnly) {
         fseek( this->fp, 0, SEEK_END );
     } else {
         if (q_volume_format == vfmtVSR)
             offset = size;
         else if (q_volume_format == vfmtPK3)
             offset = size;
     }
 }

bool VSFileSystem::VSFile::Eof ( )

Definition at line 1847 of file vsfilesystem.cpp.

References VSFileSystem::q_volume_format, VSFileSystem::ReadOnly, Size(), VSFileSystem::UseVolumes, VSFileSystem::vfmtPK3, VSFileSystem::vfmtVSR, VSFileSystem::vs_feof(), and VSFileSystem::VSFSNone.

Referenced by AnimatedTexture::LoadAni(), StarSystemGent::readColorGrads(), and readnames().

 {
     bool eof = false;
     if (!UseVolumes[alt_type] || this->volume_type == VSFSNone || file_mode != ReadOnly) {
         eof = vs_feof( this->fp );
     } else {
         if (q_volume_format == vfmtVSR) {} else if (q_volume_format == vfmtPK3) {
             eof = (this->Size() < 0) || ( offset == (unsigned long)this->Size() );
         }
     }
     return eof;
 }

int VSFileSystem::VSFile::Fprintf	(	const char *	format,
			...
	)

Definition at line 1714 of file vsfilesystem.cpp.

References VSFileSystem::UseVolumes, VSExit(), and VSFileSystem::VSFSNone.

Referenced by dotabs(), Tab(), XMLElement::Write(), XMLnode::Write(), GalaxyXML::SGalaxy::writeGalaxy(), GalaxyXML::Galaxy::writeGalaxy(), and GalaxyXML::SGalaxy::writeSector().

 {
     if (!UseVolumes[alt_type] || this->volume_type == VSFSNone) {
         va_list ap;
         va_start( ap, format );
 
         return vfprintf( this->fp, format, ap );
     } else {
         cerr<<"!!! ERROR : Writing is not supported within resource/volume files"<<endl;
         VSExit( 1 );
     }
     return 0;
 }

template<class A >

int VSFileSystem::VSFile::Fscanf	(	const char *	format,
		A *	a
	)

inline

Definition at line 382 of file vsfilesystem.h.

References GoAfterEOL(), VsnetOSS::memcpy(), VSFileSystem::q_volume_format, VSFileSystem::UseVolumes, VSFileSystem::vfmtPK3, and VSFileSystem::vfmtVSR.

Referenced by AnimatedTexture::AnimatedTexture(), Animation::Animation(), AnimatedTexture::LoadAni(), StarSystemGent::readentity(), and VSSprite::VSSprite().

     {
         int ret = -1;
         if (!UseVolumes[this->alt_type]) {
             ret = fscanf( fp, format, a );
         } else {
             if (q_volume_format == vfmtPK3) {
                 checkExtracted();
                 int   ret       = -1, readbytes = 0;
                 int   length    = strlen( format );
                 int   newlength = length+3;
                 char *newformat = new char[newlength];
                 memset( newformat, 0, newlength );
                 memcpy( newformat, format, length );
                 strcat( newformat, "%n" );
                 ret = sscanf( this->pk3_extracted_file+offset, newformat, a, &readbytes );
                 delete[] newformat;
                 std::cerr<<"FSCANF : sscanf read "<<readbytes<<" bytes - OFFSET="<<offset<<" VALUES : a="<<(*a)<<std::endl;
                 this->offset += readbytes;
                 this->GoAfterEOL();
             } else if (q_volume_format == vfmtVSR) {}
         }
         return ret;
     }

template<class A , class B >

int VSFileSystem::VSFile::Fscanf	(	const char *	format,
		A *	a,
		B *	b
	)

inline

Definition at line 407 of file vsfilesystem.h.

References GoAfterEOL(), VsnetOSS::memcpy(), VSFileSystem::q_volume_format, VSFileSystem::UseVolumes, VSFileSystem::vfmtPK3, and VSFileSystem::vfmtVSR.

     {
         int ret = -1;
         if (!UseVolumes[this->alt_type]) {
             ret = fscanf( fp, format, a, b );
         } else {
             if (q_volume_format == vfmtPK3) {
                 checkExtracted();
                 int   ret       = -1, readbytes = 0;
                 int   length    = strlen( format );
                 int   newlength = length+3;
                 char *newformat = new char[newlength];
                 memset( newformat, 0, newlength );
                 memcpy( newformat, format, length );
                 strcat( newformat, "%n" );
                 ret = sscanf( this->pk3_extracted_file+offset, newformat, a, b, &readbytes );
                 delete[] newformat;
                 std::cerr<<"FSCANF : sscanf read "<<readbytes<<" bytes - OFFSET="<<offset<<" VALUES : a="<<(*a)<<", b="<<(*b)
                          <<std::endl;
                 this->offset += readbytes;
                 this->GoAfterEOL();
             } else if (q_volume_format == vfmtVSR) {}
         }
         return ret;
     }

template<class A , class B , class C >

int VSFileSystem::VSFile::Fscanf	(	const char *	format,
		A *	a,
		B *	b,
		C *	c
	)

inline

Definition at line 433 of file vsfilesystem.h.

References GoAfterEOL(), VsnetOSS::memcpy(), VSFileSystem::q_volume_format, VSFileSystem::UseVolumes, VSFileSystem::vfmtPK3, and VSFileSystem::vfmtVSR.

     {
         int ret = -1;
         if (!UseVolumes[this->alt_type]) {
             ret = fscanf( fp, format, a, b, c );
         } else {
             if (q_volume_format == vfmtPK3) {
                 checkExtracted();
                 int   ret       = -1, readbytes = 0;
                 int   length    = strlen( format );
                 int   newlength = length+3;
                 char *newformat = new char[newlength];
                 memset( newformat, 0, newlength );
                 memcpy( newformat, format, length );
                 strcat( newformat, "%n" );
                 ret = sscanf( this->pk3_extracted_file+offset, newformat, a, b, c, &readbytes );
                 delete[] newformat;
                 std::cerr<<"FSCANF : sscanf read "<<readbytes<<" bytes - OFFSET="<<offset<<" VALUES : a="<<(*a)<<", b="<<(*b)
                          <<", c="<<(*c)<<std::endl;
                 this->offset += readbytes;
                 this->GoAfterEOL();
             } else if (q_volume_format == vfmtVSR) {}
         }
         return ret;
     }

template<class A , class B , class C , class D >

int VSFileSystem::VSFile::Fscanf	(	const char *	format,
		A *	a,
		B *	b,
		C *	c,
		D *	d
	)

inline

Definition at line 459 of file vsfilesystem.h.

References GoAfterEOL(), VsnetOSS::memcpy(), VSFileSystem::q_volume_format, VSFileSystem::UseVolumes, VSFileSystem::vfmtPK3, and VSFileSystem::vfmtVSR.

     {
         int ret = -1;
         if (!UseVolumes[this->alt_type]) {
             ret = fscanf( fp, format, a, b, c, d );
         } else {
             if (q_volume_format == vfmtPK3) {
                 checkExtracted();
                 int   ret       = -1, readbytes = 0;
                 int   length    = strlen( format );
                 int   newlength = length+3;
                 char *newformat = new char[newlength];
                 memset( newformat, 0, newlength );
                 memcpy( newformat, format, length );
                 strcat( newformat, "%n" );
                 ret = sscanf( this->pk3_extracted_file+offset, newformat, a, b, c, d, &readbytes );
                 delete[] newformat;
                 this->offset += readbytes;
                 this->GoAfterEOL();
             } else if (q_volume_format == vfmtVSR) {}
         }
         return ret;
     }

template<class A , class B , class C , class D , class E >

int VSFileSystem::VSFile::Fscanf	(	const char *	format,
		A *	a,
		B *	b,
		C *	c,
		D *	d,
		E *	e
	)

inline

Definition at line 483 of file vsfilesystem.h.

References GoAfterEOL(), VsnetOSS::memcpy(), VSFileSystem::q_volume_format, VSFileSystem::UseVolumes, VSFileSystem::vfmtPK3, and VSFileSystem::vfmtVSR.

     {
         int ret = -1;
         if (!UseVolumes[this->alt_type]) {
             ret = fscanf( fp, format, a, b, c, d, e );
         } else {
             if (q_volume_format == vfmtPK3) {
                 checkExtracted();
                 int   ret       = -1, readbytes = 0;
                 int   length    = strlen( format );
                 int   newlength = length+3;
                 char *newformat = new char[newlength];
                 memset( newformat, 0, newlength );
                 memcpy( newformat, format, length );
                 strcat( newformat, "%n" );
                 ret = sscanf( this->pk3_extracted_file+offset, newformat, a, b, c, d, e, &readbytes );
                 delete[] newformat;
                 this->offset += readbytes;
                 this->GoAfterEOL();
             } else if (q_volume_format == vfmtVSR) {}
         }
         return ret;
     }

template<class A , class B , class C , class D , class E , class F >

int VSFileSystem::VSFile::Fscanf	(	const char *	format,
		A *	a,
		B *	b,
		C *	c,
		D *	d,
		E *	e,
		F *	f
	)

inline

Definition at line 507 of file vsfilesystem.h.

References GoAfterEOL(), VsnetOSS::memcpy(), VSFileSystem::q_volume_format, VSFileSystem::UseVolumes, VSFileSystem::vfmtPK3, and VSFileSystem::vfmtVSR.

     {
         int ret = -1;
         if (!UseVolumes[this->alt_type]) {
             ret = fscanf( fp, format, a, b, c, d, e, f );
         } else {
             if (q_volume_format == vfmtPK3) {
                 checkExtracted();
                 int   ret       = -1, readbytes = 0;
                 int   length    = strlen( format );
                 int   newlength = length+3;
                 char *newformat = new char[newlength];
                 memset( newformat, 0, newlength );
                 memcpy( newformat, format, length );
                 strcat( newformat, "%n" );
                 ret = sscanf( this->pk3_extracted_file+offset, newformat, a, b, c, d, e, f, &readbytes );
                 delete[] newformat;
                 this->offset += readbytes;
                 this->GoAfterEOL();
             } else if (q_volume_format == vfmtVSR) {}
         }
         return ret;
     }

char* VSFileSystem::VSFile::get_pk3_data ( )

inline

Definition at line 325 of file vsfilesystem.h.

     {
         return pk3_extracted_file;
     }

string VSFileSystem::VSFile::GetAbsPath ( )

Definition at line 1922 of file vsfilesystem.cpp.

References VSFileSystem::pathAppend().

 {
     string tmp = this->directoryname;
     pathAppend( tmp, this->subdirectoryname );
     pathAppend( tmp, this->filename );
     return tmp;
 }

VSFileType VSFileSystem::VSFile::GetAltType ( ) const

inline

Definition at line 587 of file vsfilesystem.h.

     {
         return alt_type;
     }

const string& VSFileSystem::VSFile::GetDirectory ( ) const

inline

Definition at line 548 of file vsfilesystem.h.

     {
         return this->directoryname;
     }

char* VSFileSystem::VSFile::GetFileBuffer ( )

inline

Definition at line 339 of file vsfilesystem.h.

     {
         return this->pk3_extracted_file;
     }

const string& VSFileSystem::VSFile::GetFilename ( ) const

inline

Definition at line 544 of file vsfilesystem.h.

Referenced by AnimatedTexture::LoadAni(), Mesh::LoadMeshes(), AnimatedTexture::LoadVideoSource(), and VSFileSystem::LookForFile().

     {
         return this->filename;
     }

FILE* VSFileSystem::VSFile::GetFP ( )

inline

Definition at line 335 of file vsfilesystem.h.

     {
         return this->fp;
     }                                                        //This is still needed for special cases (when loading PNG files)

string VSFileSystem::VSFile::GetFullPath ( )

Definition at line 1913 of file vsfilesystem.cpp.

References VSFileSystem::pathAppend().

Referenced by Clear(), GetHelperPlayerSaveGame(), OpenReadOnly(), ReadFull(), XMLSerializer::Write(), and Unit::WriteUnit().

 {
     string tmp = this->rootname;
     pathAppend( tmp, this->directoryname );
     pathAppend( tmp, this->subdirectoryname );
     pathAppend( tmp, this->filename );
     return tmp;
 }

long VSFileSystem::VSFile::GetPosition ( )

Definition at line 1834 of file vsfilesystem.cpp.

References VSFileSystem::q_volume_format, VSFileSystem::ReadOnly, VSFileSystem::UseVolumes, VSFileSystem::vfmtPK3, VSFileSystem::vfmtVSR, and VSFileSystem::VSFSNone.

Referenced by GetPosition().

 {
     long ret = 0;
     if (!UseVolumes[alt_type] || this->volume_type == VSFSNone || file_mode != ReadOnly) {
         ret = ftell( this->fp );
     } else {
         if (q_volume_format == vfmtVSR) {} else if (q_volume_format == vfmtPK3) {
             ret = offset;
         }
     }
     return ret;
 }

const string& VSFileSystem::VSFile::GetRoot ( ) const

inline

Definition at line 556 of file vsfilesystem.h.

Referenced by getAITypes(), InitUnitTables(), and Unit::makeMasterPartList().

     {
         return this->rootname;
     }

const string& VSFileSystem::VSFile::GetSubDirectory ( ) const

inline

Definition at line 552 of file vsfilesystem.h.

Referenced by VSFileSystem::LookForFile().

     {
         return this->subdirectoryname;
     }

VSFileType VSFileSystem::VSFile::GetType ( ) const

inline

Definition at line 583 of file vsfilesystem.h.

Referenced by AnimatedTexture::Load(), AnimatedTexture::LoadAni(), and AnimatedTexture::LoadVideoSource().

     {
         return file_type;
     }

void VSFileSystem::VSFile::GoAfterEOL ( unsigned int length)

Definition at line 1952 of file vsfilesystem.cpp.

References size.

 {
     while ( this->offset < length && this->offset < this->size
            && (this->pk3_extracted_file[offset] == '\r' || this->pk3_extracted_file[offset] == '\n') )
         this->offset++;
 }

void VSFileSystem::VSFile::GoAfterEOL ( )

Definition at line 1958 of file vsfilesystem.cpp.

References size.

Referenced by Fscanf(), and ReadLine().

 {
     while ( this->offset < this->size && (this->pk3_extracted_file[offset] == '\r' || this->pk3_extracted_file[offset] == '\n') )
         this->offset++;
 }

void VSFileSystem::VSFile::GoTo ( long offset)

Definition at line 1787 of file vsfilesystem.cpp.

References VSFileSystem::q_volume_format, VSFileSystem::ReadOnly, VSFileSystem::UseVolumes, VSFileSystem::vfmtPK3, VSFileSystem::vfmtVSR, and VSFileSystem::VSFSNone.

Referenced by isBFXM(), Mesh::LoadMeshes(), and SetPosition().

 {
     if (!UseVolumes[alt_type] || this->volume_type == VSFSNone || this->file_mode != ReadOnly) {
         fseek( this->fp, foffset, SEEK_SET );
     } else {
         if (q_volume_format == vfmtVSR)
             offset = foffset;
         else if (q_volume_format == vfmtPK3)
             offset = foffset;
     }
 }

VSError VSFileSystem::VSFile::OpenCreateWrite	(	const char *	filename,
		VSFileType	type = `UnknownFile`
	)

Definition at line 1542 of file vsfilesystem.cpp.

References VSFileSystem::AccountFile, VSFileSystem::CreateDirectoryHome(), VSFileSystem::CreateWrite, VSFileSystem::datadir, VSFileSystem::FileNotFound, fopen, getStarSystemSector(), VSFileSystem::homedir, VSFileSystem::LocalPermissionDenied, VSFileSystem::Ok, VSFileSystem::savedunitpath, VSFileSystem::SaveFile, VSFileSystem::sharedsectors, VSFileSystem::sharedtextures, VSFileSystem::SystemFile, VSFileSystem::TextureFile, VSFileSystem::UnitFile, VSFileSystem::universe_name, VSFileSystem::UnknownFile, and VSFileSystem::ZoneBuffer.

Referenced by BaseComputer::actionConfirmedSaveGame(), VsnetDownload::Client::File::childSetSize(), CopySavedShips(), GetHelperPlayerSaveGame(), OpenCreateWrite(), AccountServer::recvMsg(), SaveFileCopy(), VSFile(), XMLSerializer::Write(), VSImage::WriteImage(), FileUtil::WriteSaveFiles(), SaveGame::WriteSaveGame(), and Unit::WriteUnit().

 {
     if (type >= ZoneBuffer && type != UnknownFile)
         return FileNotFound;
     this->file_type = this->alt_type = type;
     this->filename  = string( filenam );
     this->file_mode = CreateWrite;
     if (type == SystemFile) {
         string dirpath( sharedsectors+"/"+universe_name );
         CreateDirectoryHome( dirpath );
         CreateDirectoryHome( dirpath+"/"+getStarSystemSector( this->filename ) );
         string fpath( homedir+"/"+dirpath+"/"+this->filename );
         this->fp = fopen( fpath.c_str(), "wb" );
         if (!fp)
             return LocalPermissionDenied;
     } else if (type == TextureFile) {
         string fpath( homedir+"/"+sharedtextures+"/"+this->filename );
         this->fp = fopen( fpath.c_str(), "wb" );
         if (!fp)
             return LocalPermissionDenied;
     } else if (type == UnitFile) {
         string fpath( homedir+"/"+savedunitpath+"/"+this->filename );
         this->rootname = homedir;
         this->directoryname = savedunitpath;
         this->fp = fopen( fpath.c_str(), "wb" );
         if (!fp)
             return LocalPermissionDenied;
     } else if (type == SaveFile) {
         string fpath( homedir+"/save/"+this->filename );
         this->fp = fopen( fpath.c_str(), "wb" );
         if (!fp)
             return LocalPermissionDenied;
     } else if (type == AccountFile) {
         string fpath( datadir+"/accounts/"+this->filename );
         this->fp = fopen( fpath.c_str(), "wb" );
         if (!fp)
             return LocalPermissionDenied;
     } else if (type == UnknownFile) {
         string fpath( homedir+"/"+this->filename );
         this->rootname = homedir;
         this->directoryname = "";
         this->fp = fopen( fpath.c_str(), "wb" );
         if (!fp)
             return LocalPermissionDenied;
     }
     return Ok;
 }

VSError VSFileSystem::VSFile::OpenCreateWrite	(	const string &	filename,
		VSFileType	type = `UnknownFile`
	)

inline

Definition at line 359 of file vsfilesystem.h.

References OpenCreateWrite().

     {
         return OpenCreateWrite( filename.c_str(), type );
     }

VSError VSFileSystem::VSFile::OpenReadOnly	(	const char *	filename,
		VSFileType	type = `UnknownFile`
	)

Definition at line 1416 of file vsfilesystem.cpp.

References VSFileSystem::AnimFile, VSFileSystem::CockpitFile, VSFileSystem::current_directory, VSFileSystem::current_path, VSFileSystem::current_subdirectory, VSFileSystem::current_type, VSFileSystem::DisplayType(), VSFileSystem::failed, accountXML::file, VSFileSystem::FileExists(), VSFileSystem::FileNotFound, fopen, GetFullPath(), VSFileSystem::LookForFile(), VSFileSystem::Ok, VSFileSystem::q_volume_format, VSFileSystem::ReadOnly, VSFileSystem::Rootdir, VSFileSystem::UnitFile, VSFileSystem::UnknownFile, VSFileSystem::UseVolumes, VSFileSystem::vfmtPK3, VSFileSystem::vfmtVSR, VSExit(), VSFS_DEBUG(), VSFileSystem::VSFSNone, VSFileSystem::VSSpriteFile, and VSFileSystem::ZoneBuffer.

Referenced by BaseComputer::actionSaveGame(), AnimatedTexture::AnimatedTexture(), Animation::Animation(), AUDCreateSoundMP3(), AUDLoadSoundFile(), ROLES::buildroles(), ROLES::buildscripts(), AnimatedTexture::Clone(), CopySavedShips(), GameStarSystem::createBackground(), AnimatedTexture::CreateVideoTexture(), EnvironmentMapGeneratorMain(), Universe::Generate1(), getAITypes(), VSFileSystem::GetCorrectStarSysPath(), GetHelperPlayerSaveGame(), getProgramSource(), FileUtil::HashCompute(), XMLDOM::VSFileXMLSerializer::importXML(), Cockpit::Init(), InitUnitTables(), Texture::Load(), LoadAccounts(), LoadFile(), AnimatedTexture::LoadFrame(), Mesh::LoadMeshes(), Nebula::LoadXML(), easyDomFactory< configNode >::LoadXML(), Unit::makeMasterPartList(), OpenReadOnly(), SaveGame::ParseSaveGame(), parseTurretSizes(), StarSystemGent::readColorGrads(), StarSystemGent::readentity(), readnames(), AccountServer::recvMsg(), SaveFileCopy(), Screenshot(), AccountServer::sendAuthorized(), NetServer::start(), VSFile(), and VSSprite::VSSprite().

 {
     string filestr;
     int    found = -1;
     this->file_type = this->alt_type = type;
     this->file_mode = ReadOnly;
     this->filename  = string( file );
     failed = "";
 
     VSError err = Ok;
     if ( VSFS_DEBUG() )
         cerr<<"Loading a "<<type<<" : "<<file<<endl;
     if (type < ZoneBuffer || type == UnknownFile) {
         //It is a "classic file"
         if (!UseVolumes[type]) {
             if (type == UnknownFile) {
                 //We look in the current_path or for a full relative path to either homedir or datadir
                 if (current_path.back() != "") {
                     string filestr1 = current_directory.back()
                                       +"/"+current_subdirectory.back()+"/"+string( file );
                     filestr = current_path.back()+"/"+filestr1;
                     if ( ( found = FileExists( current_path.back(), filestr1 ) ) < 0 )
                         failed += "\t"+filestr+" NOT FOUND !\n";
                 }
                 if (found < 0) {
                     for (unsigned int ij = 0; ij < Rootdir.size() && found < 0; ij++) {
                         filestr = Rootdir[ij]+"/"+file;
                         found   = FileExists( Rootdir[ij], file );
                         if (found < 0)
                             failed += "\tRootdir : "+filestr+" NOT FOUND !\n";
                     }
                     //Look for relative (to datadir) or absolute named file
                     if (found < 0) {
                         filestr = file;
                         if ( ( found = FileExists( "", filestr ) ) < 0 )
                             failed += "\tAbs or rel : "+filestr+" NOT FOUND !\n";
                     }
                 }
                 if (found < 0) {
                     if ( VSFS_DEBUG() )
                         cerr<<failed<<endl;
                     this->valid = false;
                     err = FileNotFound;
                 } else {
                     if ( ( this->fp = fopen( filestr.c_str(), "rb" ) ) == NULL ) {
                         cerr<<"!!! SERIOUS ERROR : failed to open Unknown file "<<filestr<<" - this should not happen"<<endl;
                         VSExit( 1 );
                     }
                     this->valid = true;
                     if (VSFS_DEBUG() > 1)
                         cerr<<filestr<<" SUCCESS !!!"<<endl;
                 }
             } else {
                 err = VSFileSystem::LookForFile( *this, type, file_mode );
                 if (err > Ok) {
                     this->valid = false;
                     return FileNotFound;
                 }
                 filestr  = this->GetFullPath();
                 this->fp = fopen( filestr.c_str(), "rb" );
                 if (!this->fp) {
                     cerr<<"!!! SERIOUS ERROR : failed to open "<<filestr<<" - this should not happen"<<endl;
                     this->valid = false;
                     return FileNotFound;                     //fault!
                 }
                 this->valid = true;
             }
         } else {
             if (q_volume_format == vfmtVSR) {} else if (q_volume_format == vfmtPK3) {
                 //Here we look for the file but we don't really open it, we just check if it exists
                 err = VSFileSystem::LookForFile( *this, type, file_mode );
                 if (err > Ok) {
                     this->valid = false;
                     return FileNotFound;
                 }
                 //Test if we have found a file in another FileType's dir and if it doesn't use volumes
                 //If so we open the file as a normal one
                 if ( this->volume_type == VSFSNone || (this->alt_type != this->file_type && !UseVolumes[this->alt_type]) ) {
                     filestr  = this->GetFullPath();
                     this->fp = fopen( filestr.c_str(), "rb" );
                     if (!this->fp) {
                         cerr<<"!!! SERIOUS ERROR : failed to open "<<filestr<<" - this should not happen"<<endl;
                         this->valid = false;
                         return FileNotFound;                         //fault
                     }
                 }
                 this->valid = true;
             }
         }
         if (err <= Ok) {
             //We save the current path only when loading a unit, an animation, a sprite or a cockpit
             if ( (type == UnitFile || type == AnimFile || type == VSSpriteFile || type == CockpitFile) ) {
                 current_path.push_back( this->rootname );
                 current_subdirectory.push_back( this->subdirectoryname );
                 current_type.push_back( this->alt_type );
                 if (VSFS_DEBUG() > 1) {
                     cerr<<endl<<"BEGINNING OF ";
                     DisplayType( type );
                     cerr<<endl;
                 }
             }
         }
     } else {
         //This is a "buffer file"
         if (!this->pk3_extracted_file)
             err = FileNotFound;
         else
             err = Ok;
     }
     return err;
 }

VSError VSFileSystem::VSFile::OpenReadOnly	(	const string &	filename,
		VSFileType	type = `UnknownFile`
	)

inline

Definition at line 347 of file vsfilesystem.h.

References OpenReadOnly().

     {
         return OpenReadOnly( filename.c_str(), type );
     }

VSError VSFileSystem::VSFile::OpenReadWrite	(	const char *	filename,
		VSFileType	type = `UnknownFile`
	)

Definition at line 1530 of file vsfilesystem.cpp.

References VSFileSystem::FileNotFound, VSFileSystem::Ok, VSFileSystem::ReadWrite, VSFileSystem::UnknownFile, and VSFileSystem::ZoneBuffer.

Referenced by OpenReadWrite(), and VSFile().

 {
     if (type >= ZoneBuffer && type != UnknownFile)
         return FileNotFound;
     this->file_type = this->alt_type = type;
     this->file_mode = ReadWrite;
 
     return Ok;
 }

VSError VSFileSystem::VSFile::OpenReadWrite	(	const string &	filename,
		VSFileType	type = `UnknownFile`
	)

inline

Definition at line 353 of file vsfilesystem.h.

References OpenReadWrite().

     {
         return OpenReadWrite( filename.c_str(), type );
     }

size_t VSFileSystem::VSFile::Read	(	void *	ptr,
		size_t	length
	)

Definition at line 1590 of file vsfilesystem.cpp.

References VsnetOSS::memcpy(), VSFileSystem::q_volume_format, size, VSFileSystem::UseVolumes, VSFileSystem::vfmtPK3, VSFileSystem::vfmtVSR, and VSFileSystem::VSFSNone.

Referenced by AUDCreateSoundMP3(), AUDLoadSoundFile(), CopyFile(), VsnetDownload::Server::DownloadItemFile::copyFromFile(), GetHelperPlayerSaveGame(), FileUtil::HashCompute(), XMLDOM::VSFileXMLSerializer::importXML(), isBFXM(), Mesh::LoadMeshes(), readc(), readf(), ReadFloat(), readi(), ReadInt(), reads(), and ReadString().

 {
     size_t nbread = 0;
     if (!UseVolumes[this->alt_type] || this->volume_type == VSFSNone) {
         assert( fp != NULL );
         nbread = fread( ptr, 1, length, this->fp );
     } else {
         if (q_volume_format == vfmtVSR) {} else if (q_volume_format == vfmtPK3) {
             checkExtracted();
             if (length > this->size-this->offset)
                 length = this->size-this->offset;
             memcpy( ptr, (pk3_extracted_file+offset), length );
             offset += length;
             nbread  = length;
         }
     }
     return nbread;
 }

string VSFileSystem::VSFile::ReadFull ( )

Definition at line 1651 of file vsfilesystem.cpp.

References VSFileSystem::GetError(), GetFullPath(), VSFileSystem::q_volume_format, Size(), VSFileSystem::UseVolumes, VSFileSystem::vfmtPK3, VSFileSystem::vfmtVSR, and VSFileSystem::VSFSNone.

Referenced by CopySavedShips(), LoadAccounts(), Nebula::LoadXML(), easyDomFactory< configNode >::LoadXML(), SaveGame::ParseSaveGame(), SaveFileCopy(), AccountServer::sendAuthorized(), and NetServer::start().

 {
     if (this->Size() < 0) {
         cerr<<"Attempt to call ReadFull on a bad file "<<this->filename<<" "<<this->Size()<<" "<<this->GetFullPath().c_str()<<endl;
         return string();
     }
     if (!UseVolumes[alt_type] || this->volume_type == VSFSNone) {
         char *content  = new char[this->Size()+1];
         content[this->Size()] = 0;
         int   readsize = fread( content, 1, this->Size(), this->fp );
         if (this->Size() != readsize) {
             cerr<<"Only read "<<readsize<<" out of "<<this->Size()<<" bytes of "<<this->filename<<endl;
             GetError( "ReadFull" );
             if (readsize <= 0)
                 return string();
             else
                 content[readsize] = '\0';
         }
         string res( content );
         delete[] content;
         return res;
     } else {
         if (q_volume_format == vfmtVSR) {} else if (q_volume_format == vfmtPK3) {
             checkExtracted();
             offset = this->Size();
             return string( pk3_extracted_file );
         }
     }
     return string( "" );
 }

VSError VSFileSystem::VSFile::ReadLine	(	void *	ptr,
		size_t	length
	)

Definition at line 1609 of file vsfilesystem.cpp.

References GoAfterEOL(), i, VSFileSystem::Ok, VSFileSystem::q_volume_format, size, VSFileSystem::Unspecified, VSFileSystem::UseVolumes, VSFileSystem::vfmtPK3, VSFileSystem::vfmtVSR, VSFS_DEBUG(), and VSFileSystem::VSFSNone.

Referenced by ROLES::buildroles(), ROLES::buildscripts(), getProgramSource(), AnimatedTexture::LoadAni(), SaveGame::ParseSaveGame(), parseTurretSizes(), StarSystemGent::readColorGrads(), readnames(), and AccountServer::recvMsg().

 {
     char *ret;
     if (!UseVolumes[alt_type] || this->volume_type == VSFSNone) {
         ret = fgets( (char*) ptr, length, this->fp );
         if (!ret)
             return Unspecified;
     } else {
         if (q_volume_format == vfmtVSR) {} else if (q_volume_format == vfmtPK3) {
             checkExtracted();
             ret = (char*) ptr;
 
             bool nl_found  = false;
             unsigned int i = 0;
             if (VSFS_DEBUG() > 1)
                 cerr<<"READLINE STARTING OFFSET="<<offset;
             for (i = 0; !nl_found && i < length && offset < size; offset++, i++) {
                 if (pk3_extracted_file[offset] == '\n' || pk3_extracted_file[offset] == '\r') {
                     nl_found = true;
                     if (VSFS_DEBUG() > 1) {
                         if (pk3_extracted_file[offset] == '\n')
                             cerr<<"\\n ";
                         if (pk3_extracted_file[offset] == '\r')
                             cerr<<"\\r ";
                     }
                 } else {
                     ret[i] = pk3_extracted_file[offset];
                     if (VSFS_DEBUG() > 1)
                         cerr<<std::hex<<ret[i]<<" ";
                 }
             }
             this->GoAfterEOL( length );
             ret[i] = 0;
             if (VSFS_DEBUG() > 1)
                 cerr<<std::dec<<" - read "<<i<<" char - "<<ret<<endl;
             if (!nl_found)
                 return Unspecified;
         }
     }
     return Ok;
 }

void VSFileSystem::VSFile::SetAltType ( VSFileType type)

Definition at line 1934 of file vsfilesystem.cpp.

Referenced by VSFileSystem::LookForFile().

 {
     this->alt_type = type;
 }

void VSFileSystem::VSFile::SetDirectory ( const string & directory)

inline

Definition at line 565 of file vsfilesystem.h.

Referenced by VSFileSystem::LookForFile().

     {
         this->directoryname = directory;
     }

void VSFileSystem::VSFile::SetFilename ( const string & filename)

inline

Definition at line 561 of file vsfilesystem.h.

Referenced by VSFileSystem::LookForFile().

     {
         this->filename = filename;
     }

void VSFileSystem::VSFile::SetIndex ( int index)

Definition at line 1938 of file vsfilesystem.cpp.

References index.

Referenced by VSFileSystem::LookForFile().

 {
     this->file_index = index;
 }

void VSFileSystem::VSFile::SetRoot ( const string & root)

inline

Definition at line 573 of file vsfilesystem.h.

Referenced by VSFileSystem::LookForFile().

     {
         this->rootname = root;
     }

void VSFileSystem::VSFile::SetSubDirectory ( const string & subdirectory)

inline

Definition at line 569 of file vsfilesystem.h.

Referenced by VSFileSystem::LookForFile().

     {
         this->subdirectoryname = subdirectory;
     }

void VSFileSystem::VSFile::SetType ( VSFileType type)

Definition at line 1930 of file vsfilesystem.cpp.

 {
     this->file_type = type;
 }

void VSFileSystem::VSFile::SetVolume ( VSVolumeType big)

Definition at line 1943 of file vsfilesystem.cpp.

Referenced by VSFileSystem::LookForFile().

 {
     this->volume_type = big;
 }

long VSFileSystem::VSFile::Size ( )

Definition at line 1799 of file vsfilesystem.cpp.

References VSFileSystem::q_volume_format, VSFileSystem::ReadOnly, size, stat::st_size, VSFileSystem::UseVolumes, VSFileSystem::vfmtPK3, VSFileSystem::vfmtVSR, and VSFileSystem::VSFSNone.

Referenced by VsnetDownload::Server::Manager::addCmdDownload(), AUDCreateSoundMP3(), AUDLoadSoundFile(), ROLES::buildroles(), ROLES::buildscripts(), Eof(), GetHelperPlayerSaveGame(), LoadAccounts(), Mesh::LoadMeshes(), Nebula::LoadXML(), easyDomFactory< configNode >::LoadXML(), parseTurretSizes(), ReadFull(), and AccountServer::sendAuthorized().

 {
     if (size == 0) {
         if (!UseVolumes[alt_type] || this->volume_type == VSFSNone || file_mode != ReadOnly) {
             struct stat st;
             if ( (fp != NULL) && fstat( fileno( fp ), &st ) == 0 )
                 return this->size = st.st_size;
             return -1;
         } else {
             if (q_volume_format == vfmtVSR) {} else if (q_volume_format == vfmtPK3) {
                 checkExtracted();
                 return this->size;
             }
         }
         return -1;
     }
     return this->size;
 }

bool VSFileSystem::VSFile::UseVolume ( )

Definition at line 1947 of file vsfilesystem.cpp.

References VSFileSystem::UseVolumes, and VSFileSystem::VSFSNone.

 {
     return UseVolumes[alt_type] && volume_type != VSFSNone;
 }

bool VSFileSystem::VSFile::Valid ( )

Definition at line 1860 of file vsfilesystem.cpp.

Referenced by Texture::Load(), and VSSprite::ReadTexture().

 {
     return valid;
 }

size_t VSFileSystem::VSFile::Write	(	const void *	ptr,
		size_t	length
	)

Definition at line 1682 of file vsfilesystem.cpp.

References VSFileSystem::Ok, VSFileSystem::UseVolumes, VSExit(), and VSFileSystem::VSFSNone.

Referenced by VsnetDownload::Client::File::childAppend(), CopyFile(), CopySavedShips(), GetHelperPlayerSaveGame(), SaveFileCopy(), Write(), FileUtil::WriteSaveFiles(), SaveGame::WriteSaveGame(), and Unit::WriteUnit().

 {
     if (!UseVolumes[this->alt_type] || this->volume_type == VSFSNone) {
         size_t nbwritten = fwrite( ptr, 1, length, this->fp );
         return nbwritten;
     } else {
         cerr<<"!!! ERROR : Writing is not supported within resource/volume files"<<endl;
         VSExit( 1 );
     }
     return Ok;
 }

size_t VSFileSystem::VSFile::Write ( const string & content)

Definition at line 1694 of file vsfilesystem.cpp.

References Write().

 {
     std::string::size_type length = content.length();
     return this->Write( content.c_str(), length );
 }

void VSFileSystem::VSFile::WriteFull ( void * ptr)

Definition at line 1711 of file vsfilesystem.cpp.

1712 {}

VSError VSFileSystem::VSFile::WriteLine ( const void * ptr)

Definition at line 1700 of file vsfilesystem.cpp.

References VSFileSystem::Ok, VSFileSystem::UseVolumes, VSExit(), and VSFileSystem::VSFSNone.

Referenced by AccountServer::recvMsg().

 {
     if (!UseVolumes[alt_type] || this->volume_type == VSFSNone) {
         fputs( (const char*) ptr, this->fp );
     } else {
         cerr<<"!!! ERROR : Writing is not supported within resource/volume files"<<endl;
         VSExit( 1 );
     }
     return Ok;
 }

Friends And Related Function Documentation

friend class VSImage

friend

Definition at line 596 of file vsfilesystem.h.

The documentation for this class was generated from the following files:

src/vsfilesystem.h
src/vsfilesystem.cpp

Public Member Functions

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation