WebSVN – spk – Diff – //libspk/src/File_IO.cpp

 #include "DirIO.h"
 #include "File.h"
 #include "Logging/Log.h"
-CFileIO::CFileIO () : m_bOpened(false), m_lSize(0), m_bBinary(true)
+CFileIO::CFileIO () : m_lSize(0), m_bBinary(true), m_bAutoDelete(false), m_bSeekP(false)
+{
+}
-CFileIO::CFileIO(CyString filename) : m_bOpened(false), m_lSize(0), m_bBinary(true)
+/*CFileIO::CFileIO(const Utils::String &sFilename, bool bBinary = true) : m_lSize(0), m_bBinary(bBinary), m_bAutoDelete(false)
+{
-	Open ( filename, true );
+	Open(sFilename, bBinary);
+}
+*/
-CFileIO::CFileIO(C_File *file) : m_bOpened(false), m_lSize(0), m_bBinary(true)
+CFileIO::CFileIO(CyString filename) : m_lSize(0), m_bBinary(true), m_bAutoDelete(false), m_bSeekP(false)
 {
-	Open ( file->GetFilePointer(), true );
+	Open(filename, true);
 }
-CFileIO::~CFileIO()
+CFileIO::CFileIO(C_File *file) : m_lSize(0), m_bBinary(true), m_bAutoDelete(false), m_bSeekP(false)
+{
+	Open(file->GetFilePointer(), true);
+}
+CFileIO::~CFileIO()
+{
-	if ( m_bOpened ) m_fId.close();
+	if ( this->isOpened() ) m_fId.close();
+	if ( m_bAutoDelete ) this->remove();
+}
+void CFileIO::setAutoDelete(bool bDelete)
+{
+	m_bAutoDelete = true;
+}
 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;
+}
+unsigned char *CFileIO::read(size_t iAmount)
+{
+	if ( !this->isOpened() ) startRead();
+	if ( !this->isOpened() ) return NULL;
+	if ( iAmount > m_lSize ) iAmount = m_lSize;
+	unsigned char *data;
+	try {
+		data = new unsigned char[iAmount + 1];
+	}
+	catch (std::exception &e) {
+		CLog::logf(CLog::Log_IO, 2, "ERROR: CFileIO::read(size_t) unable to malloc data, %d (%s)", iAmount + 1, e.what());
+		return NULL;
+	}
+	if ( !read(data, iAmount, true) ) {
+		CLog::logf(CLog::Log_IO, 2, "ERROR: CFileIO::read(size_t) unable to read data from file, %s/%d", m_sFilename.c_str(), iAmount);
+		delete data;
+		return NULL;
+	}
+	return data;
+}
+unsigned char *CFileIO::readAll(size_t *pSize)
+{
+	if ( pSize ) (*pSize) = 0;
+	if ( !this->isOpened() ) startRead();
+	if ( !this->isOpened() ) return NULL;
+	unsigned char *data;
+	try {
+		data = new unsigned char[m_lSize + 1];
+	}
+	catch (std::exception &e) {
+		CLog::logf(CLog::Log_IO, 2, "ERROR: CFileIO::readAll() unable to malloc data, %d (%s)", m_lSize + 1, e.what());
+		return NULL;
+	}
+	if ( !read(data, m_lSize, true) ) {
+		CLog::logf(CLog::Log_IO, 2, "ERROR: CFileIO::readAll() unable to read data from file, %s/%d", m_sFilename.c_str(), m_lSize);
+		delete data;
+		return NULL;
+	}
+	if ( pSize ) (*pSize) = m_lSize;
+	return data;
+}
+bool CFileIO::read(unsigned char *buf, size_t iSize, bool bEndChar)
+{
+	if ( !this->isOpened() ) startRead();
+	if ( !this->isOpened() ) return false;
+	try {
+		m_fId.read((char *)buf, iSize);
+	}
+	catch (std::exception &e) {
+		CLog::logf(CLog::Log_IO, 3, "ERROR: CFileIO::read() unable to read from file: %s (%s)", m_sFilename.c_str(), e.what());
+		return false;
+	}
+	if ( bEndChar ) buf[iSize] = '\0';
+	return !m_fId.bad();
+}
 bool CFileIO::WritePartFile ( size_t *offsets, size_t numOffset )
+{
 	if ( NoFile() )	return false;
 	std::fstream File(m_sFilename, _in());
 	bool bDone = file.is_open();
 	file.close();
 	return bDone;
+}
 int CFileIO::TruncateFile ( size_t offset, size_t datasize )
+{
-	if ( NoFile() )
-		return FILEERR_NOFILE;
+	if ( NoFile() ) return FILEERR_NOFILE;
-	FILE *id = fopen ( m_sFilename.c_str(), (m_bBinary) ? "rb+" : "r+" );
-	if ( !id )
-		return FILEERR_NOOPEN;
+	if ( !this->startRead() ) return FILEERR_NOOPEN;
-	// first find file size
-	fseek ( id, 0, SEEK_END );
-	size_t fullsize = ftell ( id ), size = fullsize;
+	if ( (offset + datasize) > m_lSize ) return FILEERR_TOSMALL;
-	fseek ( id, 0, SEEK_SET );
-	if ( (offset + datasize) &gt; fullsize )
+	CFileIO File(&quot;temp.tmp";);
-		return FILEERR_TOSMALL;
+	if ( !File.startWrite() ) return FILEERR_NOWRITE;
-//	char data[500000];
+	File.setAutoDelete(true);
-#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 );
+	if ( !File.write(*this, offset) ) return false;
-	delete data;
 	// next fseek after and write
-	fseek ( id, datasize, SEEK_CUR );
+	this->seek(datasize);
-	size = fullsize - offset - datasize;
+	size_t size = m_lSize - offset - datasize;
 	if ( size > 0 ) {
-		data = new char[size];
+		File.write(*this, size);
-		fread ( data, sizeof(unsigned char), size, id );
-		fwrite ( data, sizeof(unsigned char), size, writeId );
-		delete data;
 	}
-	fclose ( writeId );
+	File.close();
-	fclose ( id );
+	this->close();
+	File.setAutoDelete(false);
 	// 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()
+int CFileIO::_in() const
 {
 	if ( m_bBinary ) return std::ios::in | std::ios::binary;
 	return std::ios::in;
 }
-int CFileIO::_out()
+int CFileIO::_out() const
+{
 	if ( m_bBinary ) return std::ios::out | std::ios::binary;
 	return std::ios::out;
+}
+int CFileIO::_inout() const
+{
+	if ( m_bBinary ) return std::ios::in | std::ios::out | std::ios::binary;
+	return std::ios::in | std::ios::out;
+}
-int CFileIO::_append()
+int CFileIO::_append() const
+{
 	if ( m_bBinary ) return std::ios::out | std::ios::binary | std::ios::app;
 	return std::ios::out | std::ios::app;
+}
 	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();
 	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(const Utils::String &filename)
+{
+	std::fstream File(filename, std::ios::in | std::ios::binary);
+	bool bRet = File.good();
+	File.close();
+	return bRet;
+}
+bool CFileIO::ExistsOld () const
+{
+	return this->exists();
+}
-bool CFileIO::Exists ()
+bool CFileIO::exists () const
+{
+	if ( this->isOpened() ) return true;
 	std::fstream File(m_sFilename, _in());
 	bool bRet = File.good();
 	File.close();
 	return bRet;
 }
+bool CFileIO::StartRead() { return startRead(); }
-bool CFileIO::StartRead()
+bool CFileIO::startRead()
 {
+	return _start(_in(), false);
+}
-	if ( !m_sFilename.empty() ) {
+bool CFileIO::startWrite()
+{
-		if ( m_bOpened ) StopRead();
+	return _start(_out(), true);
+}
-		m_fId.open(m_sFilename, _in());
+bool CFileIO::startModify()
+{
-		if ( m_fId.is_open() ) {
+	return _start(_inout(), true);
+}
-			m_bOpened = true;
+bool CFileIO::startAppend()
+{
-			return true;
+	return _start(_append(), false);
-		}
+}
+bool CFileIO::_start(int iFlags, bool bSeekP)
+{
+	if ( !m_sFilename.empty() ) {
+		if ( this->isOpened() ) this->close();
+		m_fId.open(m_sFilename, iFlags);
+	}
+	m_bSeekP = bSeekP;
-	return false;
+	return m_fId.is_open();
+}
 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();
+	}
 	infile.close();
 	return file;
+}
+bool CFileIO::put(const unsigned char c)
+{
+	if ( !this->isOpened() ) return false;
+	m_fId.put(c);
+	return !m_fId.bad();
+}
+bool CFileIO::writeSize(unsigned int iSize)
+{
+	if ( !this->isOpened() ) return false;
+	if ( !this->put(static_cast<unsigned char>(iSize >> 24)) ) return false;
+	if ( !this->put(static_cast<unsigned char>(iSize >> 16)) ) return false;
+	if ( !this->put(static_cast<unsigned char>(iSize >> 8)) ) return false;
+	if ( !this->put(static_cast<unsigned char>(iSize)) ) return false;
+	m_lSize += 4;
+	return true;
+}
+bool CFileIO::write(CFileIO &file, size_t iSize)
+{
+	if ( !this->isOpened() ) startWrite();
+	if ( !this->isOpened() ) return false;
+	int iMaxSize = 1000000;
+	unsigned char *data;
+	try {
+		data = new unsigned char[iMaxSize + 1];
+	}
+	catch (std::exception &e) {
+		CLog::logf(CLog::Log_IO, 2, "ERROR: CFileIO::write(CFileIO, size_t) unable to malloc data, %d (%s)", iMaxSize + 1, e.what());
+		return false;
+	}
+	int iSizeLeft = iSize;
+	bool bSuccess = true;
+	while ( iSizeLeft > 0 ) {
+		int iDoSize = iMaxSize;
+		if ( iDoSize > iSizeLeft ) iDoSize = iSizeLeft;
+		if ( !file.read(data, iDoSize) ) bSuccess = false;
+		if ( bSuccess && !this->write(data, iDoSize) ) bSuccess = false;
+		if ( !bSuccess ) break;
+		m_lSize += iDoSize;
+		iSizeLeft -= iDoSize;
+	}
+	delete data;
+	return bSuccess;
+}
+bool CFileIO::write(const char *buf, unsigned int iSize)
+{
+	if ( !this->isOpened() ) startWrite();
+	if ( !this->isOpened() ) return false;
+	try {
+		m_fId.write((char *)buf, iSize);
+	}
+	catch (std::exception &e) {
+		CLog::logf(CLog::Log_IO, 2, "CFileIO::write() unable to write to file: %s (%s)", m_sFilename.c_str(), e.what());
+		return false;
+	}
+	m_lSize += iSize;
+	return !m_fId.bad();
+}
+bool CFileIO::write(const unsigned char *buf, unsigned int iSize)
+{
+	return this->write((char *)buf, iSize);
+}
+bool CFileIO::write(const unsigned char *buf, ...)
+{
+	va_list args;
+	va_start(args, buf);
+	bool ret = this->_write((char *)buf, args);
+	va_end(args);
+	return ret;
+}
+bool CFileIO::_write(const char *buf, va_list args)
+{
+	if ( !this->isOpened() ) return false;
+	char buffer[10000];
+	vsprintf (buffer, buf, args);
+	try {
+		int iLen = strlen(buffer);
+		m_fId.write((char *)buffer, iLen);
+		m_lSize += iLen;
+	}
+	catch (std::exception &e) {
+		CLog::logf(CLog::Log_IO, 2, "CFileIO::write() unable to write to file: %s (%s)", m_sFilename.c_str(), e.what());
+		return false;
+	}
+	return !m_fId.bad();
+}
+bool CFileIO::write(const char *buf, ...)
+{
+	va_list args;
+	va_start(args, buf);
+	bool ret = this->_write((char *)buf, args);
+	va_end(args);
+	return ret;
+}
+void CFileIO::_seek(int iPos, int iFrom)
+{
+	if ( !this->isOpened() ) {
+		if ( !this->startRead() ) return;
+	}
+	if ( m_bSeekP ) m_fId.seekp(iPos, iFrom);
+	else m_fId.seekg(iPos, iFrom);
+}
+void CFileIO::seek(unsigned int iPos)
+{
+	_seek(iPos, std::ios::cur);
+}
+void CFileIO::seekEnd()
+{
+	_seek(0, std::ios::end);
+}
+void CFileIO::seekStart(unsigned int iPos)
+{
+	_seek(iPos, std::ios::beg);
+}
+std::fstream &CFileIO::stream()
+{
+	return m_fId;
 }
 void CFileIO::StopRead()
+{
-	if ( m_fId.is_open() ) m_fId.close();
-	m_bOpened = false;
+	this->close();
+}
-bool CFileIO::IsOpened()
+bool CFileIO::isOpened() const
+{
 	if ( m_fId.is_open() )
 		return true;
 	return false;
+}
-CyString CFileIO::ReadToEndLine(bool autoclose)
+void CFileIO::close()
+{
-	if ( !this->IsOpened() )
+	if ( this->isOpened() ) m_fId.close();
-	{
-		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 ( !this->isOpened() ) return true;
 	if ( m_fId.eof() )		 return true;
 	return false;
+}
 bool CFileIO::AppendFile ( CyString filename )
 	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
+	if ( start > m_lSize ) return false;
-	fseek ( aid, 0, SEEK_END );
-	size_t end = ftell(aid);
-	if ( start &gt; end )
+	if ( m_lSize &lt;= 0 ) {
-	{
-		fclose ( aid);
-		return false;
+		if ( !this->startWrite() ) return false;
 	}
-	if ( start == end ) {
+	else if ( start == m_lSize ) {
-		fseek(aid, 0, SEEK_END);
+		if ( !this->startAppend() ) return false;
+	}
 	else {
+		if ( !this->startModify() ) return false;
-		fseek ( aid, start, SEEK_SET );
+		this->seekStart(start);
 	}
-	char *pos = (char *)d;
+	return this->write(d, size);
-	while ( size > 0 )
-	{
+}
-		size_t read = 500000;
-		if ( read > size )
-			read = size;
-		size -= read;
+Utils::String CFileIO::readEndOfLine()
+{
-		fwrite ( pos, sizeof(char), read, aid );
+	if ( !this->isOpened() ) {
-		pos += read;
+		if ( !StartRead() )	return "";
 	}
-	fclose ( aid );
+	Utils::String str;
+	std::getline(m_fId, str, '\n');
-	return true;
+	return str;
 }
 CyString CFileIO::GetBaseName()
+{
 	return m_sFile.token(".", -2);
+}
 		return NullString;
 	return m_sFilename.tokens(".", 1, -2) + "." + ext.ToString();
+}
-bool CFileIO::Remove()
+bool CFileIO::Remove(const Utils::String &rem)
+{
-	if ( !Exists() )
+	//if ( !Exists() ) return false;
-		return false;
+	return (std::remove(rem) == 0) ? true : false;
+}
-	if ( std::remove(m_sFilename.c_str()) == 0 )
-		return true;
+bool CFileIO::remove()
+{
+	if ( this->isOpened() ) this->close();
+	if ( !this->exists() ) return false;
+	if ( std::remove(m_sFilename.c_str()) == 0 ) return true;
 	return false;
+}
 bool CFileIO::WriteFileUTF(std::vector<CyString> *lines)
+{
 	return true;
+}
 bool CFileIO::Rename(CyString toFile)
 {
 	if ( rename(m_sFilename.c_str(), toFile.c_str()) == 0 )
 		return true;
 	return false;
+}
 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;
+	WCHAR    str[MAX_PATH];
+	MultiByteToWideChar(CP_ACP, NULL, GetWindowsFilename().c_str(), -1, str, GetWindowsFilename().Length() + 1);
-	HANDLE filename = CreateFile((LPCWSTR)GetWindowsFilename().c_str(), FILE_WRITE_ATTRIBUTES, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+	HANDLE filename = CreateFile(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()
+{
+	return modifiedTime();
+}
+time_t CFileIO::modifiedTime()
+{
 #ifdef _WIN32
+	WCHAR    str[MAX_PATH];
+	MultiByteToWideChar(CP_ACP, NULL, GetWindowsFilename().c_str(), -1, str, GetWindowsFilename().Length() + 1);
 	WIN32_FILE_ATTRIBUTE_DATA wfad;
-	GetFileAttributesEx((LPCWSTR)GetWindowsFilename().c_str(), GetFileExInfoStandard, &wfad);
+	GetFileAttributesEx(str, GetFileExInfoStandard, &wfad);
 	LARGE_INTEGER date, adjust;
-	date.HighPart = wfad.ftCreationTime.dwHighDateTime;
+	date.HighPart = wfad.ftLastWriteTime.dwHighDateTime;
-	date.LowPart = wfad.ftCreationTime.dwLowDateTime;
+	date.LowPart = wfad.ftLastWriteTime.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);
 /**
  * Copys the contents of a file to another
+ *
  * Reads and writes the files in block
  */
-bool CFileIO::Copy(CyString toFile, bool keepTime)
+bool CFileIO::copy(const Utils::String &toFile, bool keepTime)
+{
-	//open both files
-	FILE *id = fopen(GetWindowsFilename().c_str(), "rb");
-	if ( !id )
-		return false;
-	FILE *toID = fopen(toFile.c_str(), "wb");
+	time_t time = GetCreationTime();
-	if ( !toID )
-	{
-		fclose(id);
-		return false;
-	}
-	time_t time = GetCreationTime();
-	// get length of file
+	CFileIO File(toFile);
-	fseek(id, 0, SEEK_END);
+	if ( File.write(*this, m_lSize) ) {
-	size_t remainingLen = ftell(id);
+		if ( keepTime )	File.SetCreationTime(time);
-	fseek(id, 0, SEEK_SET);
-	if ( remainingLen <= 0 )
-	{
-		fclose(id);
-		fclose(toID);
-		return false;
+		return true;
-	}
-	// 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;
+	}
+/*
+	std::fstream f(GetWindowsFilename().c_str(), std::fstream::in | std::fstream::binary);
+	f << std::noskipws;
+	std::istream_iterator<unsigned char> begin(f);
+	std::istream_iterator<unsigned char> end;
+	std::fstream f2(toFile.c_str(), std::fstream::out | std::fstream::trunc | std::fstream::binary);
+	std::ostream_iterator<char> begin2(f2);
+	std::copy(begin, end, begin2);
+	return f2.good();
+*/
+	return false;
+}
-	fclose(id);
-	fclose(toID);
-	if ( keepTime )
-		CFileIO(toFile.c_str()).SetCreationTime(time);
+size_t CFileIO::fileSize() const
+{
-	return true;
+	return m_lSize;
+}

Subversion Repositories spk

(root)//libspk/src/File_IO.cpp – Rev 51 → 52