Subversion Repositories spk

#include "File_IO.h"

#ifdef _WIN32

#include <windows.h>

#endif

#include <locale>

#include "DirIO.h"

#include "File.h"

CFileIO::CFileIO ()

{

	m_bOpened = false;

	m_lSize = 0;

	m_bBinary = true;

	m_fIdOld = NULL;

}

CFileIO::CFileIO(CyString filename)

{

	m_bOpened = false;

	m_lSize = 0;

	m_bBinary = true;

	m_fIdOld = NULL;

	Open ( filename, true );

}

CFileIO::CFileIO(C_File *file)

{

	m_bOpened = false;

	m_lSize = 0;

	m_bBinary = true;

	m_fIdOld = NULL;

	Open ( file->GetFilePointer(), true );

}

CFileIO::~CFileIO()

{

	if ( m_bOpened )

	{

		if ( m_fIdOld )

			fclose(m_fIdOld);

		else

			m_fId.close();

	}

}

bool CFileIO::Open ( CyString filename, bool binary )

{

	m_bBinary = binary;

	m_sFilename = filename;

	m_sFilename = m_sFilename.FindReplace ( "\\", "/" );

	if ( m_sFilename.IsIn('/') )

	{

		m_sDirIO.SetDir(m_sFilename.GetToken ( "/", 1, m_sFilename.NumToken ( "/" ) - 1 ));

		m_sFile = m_sFilename.GetToken ( "/", m_sFilename.NumToken ( "/" ) );

	}

	else

		m_sFile = filename;

	ReadFileSize();

	return true;

}

bool CFileIO::WritePartFile ( size_t *offsets, size_t numOffset )

{

	if ( NoFile() )

		return false;

	FILE *id = fopen ( m_sFilename.c_str(), (m_bBinary) ? "rb+" : "r+" );

	if ( !id )

		return false;

	// first find file size

	fseek ( id, 0, SEEK_END );

	size_t fullsize = ftell ( id ), size = fullsize;

	fseek ( id, 0, SEEK_SET );

	FILE *writeId = fopen ( "temp.tmp", (m_bBinary) ? "wb" : "w" );

	if ( !writeId )

	{

		fclose ( id );

		return false;

	}

	size_t off = 0;

	size_t startPos = 0;

	size_t remainingSize = fullsize;

	while ( off < numOffset )

	{

		startPos = ftell(id);

		size_t offset = offsets[off++];

		size_t size = offset - startPos;

		char *data = new char[size];

		fread ( data, sizeof(unsigned char), size, id );

		fwrite ( data, sizeof(unsigned char), size, writeId );

		delete data;

		size_t datasize = offsets[off++];

		fseek ( id, datasize, SEEK_CUR );

		remainingSize = fullsize - offset - datasize;

	}

	if ( remainingSize )

	{

		char data[1000000];

		size_t amountLeft = 1000000;

		while ( remainingSize )

		{

			if ( amountLeft > remainingSize )

				amountLeft = remainingSize;

			fread ( data, sizeof(unsigned char), amountLeft, id );

			fwrite ( data, sizeof(unsigned char), amountLeft, writeId );

			remainingSize -= amountLeft;

			amountLeft = 1000000;

		}

	}

	fclose ( writeId );

	fclose ( id );

	// now copy to original file

	remove ( m_sFilename.c_str() );

	rename ( "temp.tmp", m_sFilename.c_str() );

	return true;

}

void CFileIO::SetDir ( CyString dir )

{

	if ( m_sFile.Empty() )

		m_sDirIO.SetDir(dir);

	else

		Open ( dir + "/" + m_sFile, m_bBinary );

}

void CFileIO::ReadFileSize ()

{

	FILE *id = fopen ( m_sFilename.c_str(), (m_bBinary) ? "rb" : "r" );

	if ( !id )

	{

		m_lSize = 0;

		return;

	}

	fseek ( id, 0, SEEK_END );

	m_lSize = ftell ( id );

	fseek ( id, 0, SEEK_SET );

	fclose ( id );

}

bool CFileIO::WipeFile()

{

	if ( NoFile() )

		return false;

	FILE *id = fopen ( m_sFilename.c_str(), (m_bBinary) ? "rb+" : "r+" );

	if ( !id )

		return false;

	fclose(id);

	return true;

}

int CFileIO::TruncateFile ( size_t offset, size_t datasize )

{

	if ( NoFile() )

		return FILEERR_NOFILE;

	FILE *id = fopen ( m_sFilename.c_str(), (m_bBinary) ? "rb+" : "r+" );

	if ( !id )

		return FILEERR_NOOPEN;

	// first find file size

	fseek ( id, 0, SEEK_END );

	size_t fullsize = ftell ( id ), size = fullsize;

	fseek ( id, 0, SEEK_SET );

	if ( (offset + datasize) > fullsize )

		return FILEERR_TOSMALL;

//	char data[500000];

#ifdef _WIN32

	FILE *writeId = fopen ( "temp.tmp", (m_bBinary) ? "wb" : "w" );

	if ( !writeId )

	{

		fclose ( id );

		return FILEERR_NOWRITE;

	}

	char *data = new char[offset];

	fread ( data, sizeof(unsigned char), offset, id );

	fwrite ( data, sizeof(unsigned char), offset, writeId );

	delete data;

	/*

	// first write the data before the file

	size_t tosize = offset;

	while ( tosize )

	{

		int read = 500000;

		if ( read > tosize )

			read = tosize;

		fread ( data, sizeof(unsigned char), read, id );

		fwrite ( data, sizeof(unsigned char), read, writeId );

		tosize -= read;

	}

*/

	// next fseek after and write

	fseek ( id, datasize, SEEK_CUR );

	size = fullsize - offset - datasize;

	data = new char[size];

	fread ( data, sizeof(unsigned char), size, id );

	fwrite ( data, sizeof(unsigned char), size, writeId );

	delete data;

	/*

	while ( size )

	{

		int read = 500000;

		if ( read > size )

			read = size;

		fread ( data, sizeof(unsigned char), read, id );

		fwrite ( data, sizeof(unsigned char), read, writeId );

		size -= read;

	}*/

	fclose ( writeId );

	fclose ( id );

	// now copy to original file

	remove ( m_sFilename.c_str() );

	rename ( "temp.tmp", m_sFilename.c_str() );

#else

	// move to beginning of file data to remove

	fseek ( id, offset, SEEK_SET );

	size_t writepos = offset;

	size_t readpos = offset + datasize;

	size -= readpos;

	while ( size > 0 )

	{

		int read = 500000;

		if ( read > size )

			read = size;

		// read data

		fseek ( id, readpos, SEEK_SET );

		fread ( data, sizeof(unsigned char), read, id );

		size -= read;

		readpos += read;

		// now seek back and write

		fseek ( id, writepos, SEEK_SET );

		fwrite ( data, sizeof(unsigned char), read, id );

		writepos += read;

	}

	truncate ( m_sFilename.c_str(), fullsize - datasize );

	fclose ( id );

#endif

	return FILEERR_NONE;

}

char *CFileIO::ReadToData ( size_t *size )

{

	*size = 0;

	if ( NoFile() )

		return NULL;

	if ( !m_lSize )

		ReadFileSize();

	if ( !m_lSize )

		return NULL;

	FILE *id = fopen ( m_sFilename.c_str(), (m_bBinary) ? "rb" : "r" );

	if ( !id )

		return NULL;

	char *data = new char[m_lSize];

	fread ( data, sizeof(char), m_lSize, id );

	if ( ferror (id) )

	{

		fclose ( id );

		return NULL;

	}

	*size = m_lSize;

	fclose ( id );

	return data;

}

bool CFileIO::WriteData ( const char *data, size_t size )

{

	if ( NoFile() )

		return false;

	FILE *id = fopen ( m_sFilename.c_str(), (m_bBinary) ? "wb" : "w" );

	if ( !id )

		return false;

	fwrite ( data, size, sizeof(char), id );

	fclose ( id );

	ReadFileSize();

	return true;

}

bool CFileIO::WriteString ( CyString data )

{

	return WriteData ( data.c_str(), data.Length() );

}

bool CFileIO::Exists ()

{

	FILE *id = fopen ( m_sFilename.c_str(), (m_bBinary) ? "rb" : "r" );

	if ( !id )

		return false;

	fclose ( id );

	return true;

}

bool CFileIO::StartReadOld()

{

	if ( !m_sFilename.Empty() )

	{

		if ( m_bOpened )

			StopRead();

		m_fIdOld = fopen(m_sFilename.c_str(), "rb");

		if ( !m_fIdOld )

			return false;

		m_bOpened = true;

		return true;

	}

	return false;

}

bool CFileIO::StartRead()

{

	if ( !m_sFilename.Empty() )

	{

		if ( m_bOpened )

			StopRead();

		m_fId.open(m_sFilename.c_str(), std::ios_base::in);

		if ( m_fId.is_open() )

		{

			m_bOpened = true;

			return true;

		}

	}

	return false;

}

std::vector<CyString> *CFileIO::ReadLines()

{

	if ( m_sFilename.Empty() )

		return 0;

	std::vector<CyString> *file = new std::vector<CyString>;

	std::string line;

	file->clear();

	std::ifstream infile (m_sFilename.c_str(), std::ios_base::in);

	while (getline(infile, line, '\n'))

	{

		CyString l = line;

		l.RemoveChar((char)0);

		file->push_back(l);

	}

	infile.close();

	return file;

}

CyStringList *CFileIO::ReadLinesStr()

{

	if ( m_sFilename.Empty() )

		return 0;

	CyStringList *file = new CyStringList;

	std::string line;

	std::ifstream infile (m_sFilename.c_str(), std::ios_base::in);

	while (getline(infile, line, '\n'))

	{

		CyString l = line;

		l.RemoveChar((char)0);

		file->PushBack(l);

	}

	infile.close();

	return file;

}

void CFileIO::StopRead()

{

	if ( m_bOpened )

	{

		if ( m_fIdOld )

			fclose(m_fIdOld);

		else

			m_fId.close();

	}

	m_fIdOld = NULL;

	m_bOpened = false;

}

bool CFileIO::IsOpened()

{

	if ( !m_bOpened )

		return false;

	if ( m_fIdOld )

		return true;

	if ( m_fId.is_open() )

		return true;

	return false;

}

CyString CFileIO::ReadToEndLine(bool autoclose)

{

	if ( !this->IsOpened() )

	{

		if ( !StartRead() )

			return "";

	}

	int pos = 0;

	char sLine[10000];

	char cur = 0;

	if ( m_fIdOld )

	{

		while ( !feof(m_fIdOld) )

		{

			cur = fgetc(m_fIdOld);

			if ( cur == '\n' || cur == '\r' )

				break;

			sLine[pos++] = cur;

		}

	}

	else

	{

		while ( !m_fId.eof() )

		{

			cur = m_fId.get();

			if ( cur == '\n' || cur == '\r' )

				break;

			sLine[pos++] = cur;

		}

	//	m_fId.getline(sLine, 255, '\n');

		std::string line;

		if ( getline(m_fId, line, '\n') )

			return CyString(line);

	}

	sLine[pos] = 0;

	if ( pos )

		return CyString(sLine);

	if ( autoclose )

		StopRead();

	return "";

}

bool CFileIO::AtEnd()

{

	if ( !m_bOpened )

		return true;

	if ( m_fIdOld )

	{

		if ( feof(m_fIdOld) )

			return true;

	}

	else

	{

		if ( m_fId.eof() )

			return true;

	}

	return false;

}

bool CFileIO::AppendFile ( CyString filename )

{

	FILE *id = fopen ( filename.c_str(), (m_bBinary) ? "rb" : "r" );

	if ( !id )

		return false;

	FILE *aid = fopen ( m_sFilename.c_str(), (m_bBinary) ? "ab" : "a" );

	if ( !aid )

	{

		return false;

		fclose ( id );

	}

	// move to the end of the file

	fseek ( aid, 0, SEEK_END );

	// get size of file

	fseek ( id, 0, SEEK_END );

	size_t size = ftell ( id );

	fseek ( id, 0, SEEK_SET );

	char data[500000];

	while ( size > 0 )

	{

		size_t read = 500000;

		if ( read > size )

			read = size;

		size -= read;

		fread ( data, sizeof(char), read, id );

		fwrite ( data, sizeof(char), read, aid );

	}

	fclose ( aid );

	fclose ( id );

	return true;

}

bool CFileIO::AppendData ( const char *d, size_t size )

{

	FILE *aid = fopen ( m_sFilename.c_str(), (m_bBinary) ? "ab" : "a" );

	if ( !aid )

		return false;

	// move to the end of the file

	fseek ( aid, 0, SEEK_END );

	char *pos = (char *)d;

	while ( size > 0 )

	{

		size_t read = 500000;

		if ( read > size )

			read = size;

		size -= read;

		fwrite ( pos, sizeof(char), read, aid );

		pos += read;

	}

	fclose ( aid );

	return true;

}

bool CFileIO::AppendDataToPos ( const char *d, size_t size, size_t start )

{

	FILE *aid = fopen ( m_sFilename.c_str(), (m_bBinary) ? "ab" : "a" );

	if ( !aid )

		return false;

	// move to the end of the file

	fseek ( aid, 0, SEEK_END );

	size_t end = ftell(aid);

	if ( start > end )

	{

		fclose ( aid);

		return false;

	}

	fseek ( aid, start, SEEK_SET );

	char *pos = (char *)d;

	while ( size > 0 )

	{

		size_t read = 500000;

		if ( read > size )

			read = size;

		size -= read;

		fwrite ( pos, sizeof(char), read, aid );

		pos += read;

	}

	fclose ( aid );

	return true;

}

CyString CFileIO::GetBaseName()

{

	return m_sFile.GetTokenRev(".", 1, -1);

}

CyString CFileIO::GetFileExtension ()

{

	if ( m_sFilename.Empty() )

		return NullString;

	CyString ext = m_sFilename.GetToken ( ".", m_sFilename.NumToken ( "." ) );

	return ext;

}

CyString CFileIO::ChangeFileExtension ( CyString ext )

{

	if ( m_sFilename.Empty() )

		return NullString;

	CyString noext = m_sFilename.GetToken ( ".", 1, m_sFilename.NumToken ( "." ) - 1 );

	return noext + "." + ext;

}

bool CFileIO::Remove()

{

	if ( !Exists() )

		return false;

	if ( remove(m_sFilename.c_str()) == 0 )

		return true;

	return false;

}

bool CFileIO::WriteFileUTF(std::vector<CyString> *lines)

{

	if ( !lines || m_sFilename.Empty() )

		return false;

	// we need to create the directory

	if ( !m_sDirIO.Exists() )

	{

		if ( !m_sDirIO.Create() )

			return false;

	}

#ifdef _WIN32

	TCHAR buf[5000];

	wsprintf(buf, L"%hs", m_sFilename.c_str());

	FILE *id = _wfopen(buf, L"wt+,ccs=UTF-8");

	if ( !id )

		return false;

	// write the rest

	for ( int i = 0; i < (int)lines->size(); i++ )

	{

		CyString l = lines->at(i);

		if ( l.IsIn('\n') )

		{

			int max;

			CyString *strs = l.SplitToken("\n", &max);

			if ( strs && max )

			{

				for ( int i = 0; i < max; i++ )

				{

					CyString line = strs[i];

					line += "\n";

					int size = wsprintf(buf, L"%hs", line.c_str());

					fwrite(buf, sizeof(TCHAR), wcslen(buf), id);

				}

				CLEANSPLIT(strs, max);

			}

		}

		else

		{

			l += "\n";

			int size = wsprintf(buf, L"%hs", l.c_str());

			fwrite(buf, sizeof(TCHAR), wcslen(buf), id);

		}

	}

	fclose(id);

	return true;

#else

    //TODO: write utf8 file writing function

    return false;

#endif

}

bool CFileIO::WriteFile(std::vector<CyString> *lines)

{

	if ( !lines || m_sFilename.Empty() )

		return false;

	// we need to create the directory

	if ( !m_sDirIO.Exists() )

	{

		if ( !m_sDirIO.Create() )

			return false;

	}

	std::ofstream out(m_sFilename.c_str());

	if ( !out )

		return false;

	for ( int i = 0; i < (int)lines->size(); i++ )

	{

		CyString l = lines->at(i);

		out << l.c_str() << std::endl;

	}

	out.close();

	return true;

}

bool CFileIO::WriteFile(CyStringList *lines)

{

	if ( !lines || m_sFilename.Empty() )

		return false;

	// we need to create the directory

	if ( !m_sDirIO.Exists() )

	{

		if ( !m_sDirIO.Create() )

			return false;

	}

	std::ofstream out(m_sFilename.c_str());

	if ( !out )

		return false;

	/*

	if ( utf )

	{

		unsigned char smarker[4];

		smarker[0] = 0xEF;

		smarker[1] = 0xBB;

		smarker[2] = 0xBF;

		smarker[3] = 0x00;

		out << smarker;

	}

*/

	for ( int i = 0; i < (int)lines->Count(); i++ )

	{

		CyString l = lines->StringAt(i);

		out << l.c_str() << std::endl;

	}

	out.close();

	return true;

}

bool CFileIO::Rename(CyString toFile)

{

	if ( rename(m_sFilename.c_str(), toFile.c_str()) == 0 )

		return true;

	return false;

}

CyString CFileIO::GetWindowsFilename()

{

	CyString returnString = m_sFilename;

	returnString = returnString.FindReplace("/", "\\");

	return returnString;

}

void CFileIO::SetCreationTime(time_t time)

{

#ifdef _WIN32

	// Note that LONGLONG is a 64-bit value

    LONGLONG ll;

	FILETIME ft;

    ll = Int32x32To64(time, 10000000) + 116444736000000000;

    ft.dwLowDateTime = (DWORD)ll;

    ft.dwHighDateTime = ll >> 32;

	HANDLE filename = CreateFile((LPCWSTR)GetWindowsFilename().c_str(), FILE_WRITE_ATTRIBUTES, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

	// Set the file time on the file

	SetFileTime(filename,(LPFILETIME) NULL,(LPFILETIME) NULL,&ft);

	// Close our handle.

	CloseHandle(filename);

#endif

}

time_t CFileIO::GetCreationTime()

{

#ifdef _WIN32

	WIN32_FILE_ATTRIBUTE_DATA wfad;

	GetFileAttributesEx((LPCWSTR)GetWindowsFilename().c_str(), GetFileExInfoStandard, &wfad);

	LARGE_INTEGER date, adjust;

	date.HighPart = wfad.ftCreationTime.dwHighDateTime;

	date.LowPart = wfad.ftCreationTime.dwLowDateTime;

	// 100-nanoseconds = milliseconds * 10000

	adjust.QuadPart = 11644473600000 * 10000;

	// removes the diff between 1970 and 1601

	date.QuadPart -= adjust.QuadPart;

	// converts back from 100-nanoseconds to seconds

	return (time_t)(date.QuadPart / 10000000);

#else

	struct stat fileStat;

	if ( !stat(GetWindowsFilename().c_str(), &fileStat) )

		return (time_t)fileStat.st_atime;

#endif

	return 0;

}

/**

 * Copys the contents of a file to another

 *

 * Reads and writes the files in block

 */

bool CFileIO::Copy(CyString toFile, bool keepTime)

{

	//open both files

	FILE *id = fopen(GetWindowsFilename().c_str(), "rb");

	if ( !id )

		return false;

	FILE *toID = fopen(toFile.c_str(), "wb");

	if ( !toID )

	{

		fclose(id);

		return false;

	}

	time_t time = GetCreationTime();

	// get length of file

	fseek(id, 0, SEEK_END);

	size_t remainingLen = ftell(id);

	fseek(id, 0, SEEK_SET);

	if ( remainingLen <= 0 )

	{

		fclose(id);

		fclose(toID);

		return false;

	}

	// read then write a block

	char block[100000];

	while ( remainingLen )

	{

		size_t amt = 100000;

		if ( amt > remainingLen )

			amt = remainingLen;

		fread(block, amt, sizeof(char), id);

		fwrite(block, amt, sizeof(char), toID);

		remainingLen -= amt;

	}

	fclose(id);

	fclose(toID);

	if ( keepTime )

		CFileIO(toFile.c_str()).SetCreationTime(time);

	return true;

}