Subversion Repositories spk

#include "File_IO.h"

#ifdef _WIN32

#include <windows.h>

#endif

#include <locale>

#include "DirIO.h"

#include "File.h"

#include "Logging/Log.h"

CFileIO::CFileIO () : m_bOpened(false), m_lSize(0), m_bBinary(true)

{

}

CFileIO::CFileIO(CyString filename) : m_bOpened(false), m_lSize(0), m_bBinary(true)

{

	Open ( filename, true );

}

CFileIO::CFileIO(C_File *file) : m_bOpened(false), m_lSize(0), m_bBinary(true)

{

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

}

CFileIO::~CFileIO()

{

	if ( m_bOpened ) m_fId.close();

}

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

{

	m_bBinary = binary;

	m_sFilename = filename.ToString();

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

	m_sFilename = m_sFilename.findReplace("//", "/");

	if ( m_sFilename.isin('/') ) {

		m_sDirIO.SetDir(m_sFilename.tokens("/", 1, -2));

		m_sFile = m_sFilename.token("/", -1);

	}

	else

		m_sFile = filename.ToString();

	this->_readFileSize();

	return true;

}

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

{

	if ( NoFile() )	return false;

	std::fstream File(m_sFilename, _in());

	if ( !File.is_open() ) return false;

	// first find file size

	File.seekg(0, std::ios::end);

	size_t fullsize = File.tellg(), size = fullsize;

	File.seekg(0, std::ios::beg);

	std::fstream writeFile("temp.tmp", _out());

	if ( !File.is_open() ) {

		File.close();

		return false;

	}

	size_t off = 0;

	size_t startPos = 0;

	size_t remainingSize = fullsize;

	while ( off < numOffset ) {

		startPos = File.tellg();

		size_t offset = offsets[off++];

		size_t size = offset - startPos;

		try {

			char *data = new char[size];

			File.read(data, size);

			writeFile.write(data, size);

			delete data;

		}

		catch(std::exception &e) {

			CLog::logf(CLog::Log_IO, 2, "CFileIO::WritePartFilea() unable to read data from file: %s (%s)", m_sFilename.c_str(), e.what());

			return false;

		}

		size_t datasize = offsets[off++];

		File.seekg(datasize, std::ios::beg);

		remainingSize = fullsize - offset - datasize;

	}

	if ( remainingSize ) {

		char data[1000000];

		size_t amountLeft = 1000000;

		while ( remainingSize )

		{

			if ( amountLeft > remainingSize ) amountLeft = remainingSize;

			try {

				File.read(data, amountLeft);

				writeFile.write(data, amountLeft);

			}

			catch(std::exception &e) {

				CLog::logf(CLog::Log_IO, 2, "CFileIO::WritePartFilea() unable to read data from file: %s (%s)", m_sFilename.c_str(), e.what());

				return false;

			}

			remainingSize -= amountLeft;

			amountLeft = 1000000;

		}

	}

	File.close();

	writeFile.close();

	// now copy to original file

	std::remove(m_sFilename);

	std::rename("temp.tmp", m_sFilename);

	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 ()

{

	m_lSize = 0;

	std::fstream file(m_sFilename, (m_bBinary) ? (std::ios::in | std::ios::binary) : (std::ios::in));

	if ( !file.is_open() ) return;

	file.seekg(0, std::ios::end);

	m_lSize = file.tellg();

	file.close();

}

bool CFileIO::WipeFile()

{

	if ( NoFile() )	return false;

	std::ofstream file;

	file.open(m_sFilename, std::ios::out | std::ios::trunc);

	bool bDone = file.is_open();

	file.close();

	return bDone;

}

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;

	// next fseek after and write

	fseek ( id, datasize, SEEK_CUR );

	size = fullsize - offset - datasize;

	if ( size > 0 ) {

		data = new char[size];

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

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

		delete data;

	}

	fclose ( writeId );

	fclose ( id );

	// now copy to original file

	std::remove(m_sFilename.c_str());

	std::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;

}

int CFileIO::_in()

{

	if ( m_bBinary ) return std::ios::in | std::ios::binary;

	return std::ios::in;

}

int CFileIO::_out()

{

	if ( m_bBinary ) return std::ios::out | std::ios::binary;

	return std::ios::out;

}

int CFileIO::_append()

{

	if ( m_bBinary ) return std::ios::out | std::ios::binary | std::ios::app;

	return std::ios::out | std::ios::app;

}

char *CFileIO::ReadToData ( size_t *size )

{

	*size = 0;

	if ( NoFile() ) return NULL;

	if ( !m_lSize )	this->_readFileSize();

	if ( !m_lSize ) return NULL;

	std::fstream file(m_sFilename, _in());

	if ( !file.is_open() ) return NULL;

	char *data;

	try {

		data = new char[m_lSize + 1];

	}

	catch (std::exception &e) {

		CLog::logf(CLog::Log_IO, 2, "CFileIO::ReadToData() unable to malloc storage, %d (%s)", m_lSize + 1, e.what());

		file.close();

		return NULL;

	}

	try {

		file.read((char *)data, m_lSize);

	}

	catch (std::exception &e) {

		CLog::logf(CLog::Log_IO, 2, "CFileIO::ReadToData() unable to read data from file (%s)", e.what());

		file.close();

		return NULL;

	}

	*size = m_lSize;

	file.close();

	return data;

}

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

{

	if ( NoFile() )

		return false;

	std::fstream File(m_sFilename, _out());

	if ( !File.is_open() ) return false;

	bool ret = true;

	try {

		File.write(data, size);

	}

	catch (std::exception &e) {

		CLog::logf(CLog::Log_IO, 2, "CFileIO::ReadToData() unable to read data from file: %s (%s)", m_sFilename.c_str(), e.what());

		ret = false;

	}

	File.close();

	if ( ret ) this->_readFileSize();

	return ret;

}

bool CFileIO::WriteString ( CyString data )

{

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

}

bool CFileIO::Exists ()

{

	std::fstream File(m_sFilename, _in());

	bool bRet = File.good();

	File.close();

	return bRet;

}

bool CFileIO::StartRead()

{

	if ( !m_sFilename.empty() ) {

		if ( m_bOpened ) StopRead();

		m_fId.open(m_sFilename, _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_fId.is_open() ) m_fId.close();

	m_bOpened = false;

}

bool CFileIO::IsOpened()

{

	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;

	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 ( !this->IsOpened() ) return true;

	if ( m_fId.eof() )		 return true;

	return false;

}

bool CFileIO::AppendFile ( CyString filename )

{

	std::fstream fromFile(filename.ToString().c_str(), _in());

	if ( !fromFile.is_open() ) return false;

	std::fstream toFile(m_sFilename, _append());

	if ( !toFile.is_open() ) {

		fromFile.close();

		return false;

	}

	// move to the end of the file

	toFile.seekg(0, std::ios::end);

	// get size of file

	fromFile.seekg(0, std::ios::end);

	size_t size = fromFile.tellg();

	fromFile.seekg(0, std::ios::beg);

	char data[500000];

	while ( size > 0 )

	{

		size_t read = 500000;

		if ( read > size )

			read = size;

		size -= read;

		fromFile.read(data, read);

		toFile.write(data, read);

	}

	fromFile.close();

	toFile.close();

	return true;

}

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

{

	std::fstream File(m_sFilename, _append());

	if ( !File.is_open() ) return false;

	// move to the end of the file

	File.seekg(0, std::ios::end);

	char *pos = (char *)d;

	while ( size > 0 ) {

		size_t read = 500000;

		if ( read > size ) read = size;

		size -= read;

		try {

			File.write(pos, read);

		} 

		catch(std::exception &e) {

			CLog::logf(CLog::Log_IO, 2, "CFileIO::AppendData() unable to write data to file: %s (%s)", m_sFilename.c_str(), e.what());

			File.close();

			return false;

		}

		pos += read;

	}

	File.close();

	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;

	}

	if ( start == end ) {

		fseek(aid, 0, SEEK_END);

	}

	else {

		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.token(".", -2);

}

CyString CFileIO::GetFileExtension ()

{

	if ( m_sFilename.empty() ) return NullString;

	return m_sFilename.token(".", -1);

}

CyString CFileIO::ChangeFileExtension ( CyString ext )

{

	if ( m_sFilename.empty() )

		return NullString;

	return m_sFilename.tokens(".", 1, -2) + "." + ext.ToString();

}

bool CFileIO::Remove()

{

	if ( !Exists() )

		return false;

	if ( std::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;

}