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

 #ifdef _WIN32
 #include <windows.h>
 #endif
 #include <locale>
+#include <codecvt>
 #include "DirIO.h"
 #include "File.h"
 #include "Logging/Log.h"
 #include "Packages.h"
 	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());
+		CLog::logf(CLog::Log_IO, 2, L"ERROR: CFileIO::read(size_t) unable to malloc data, %d (%hs)", 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", _sFilename.c_str(), iAmount);
+		CLog::logf(CLog::Log_IO, 2, L"ERROR: CFileIO::read(size_t) unable to read data from file, %s/%d", _sFilename.c_str(), iAmount);
 		delete[] data;
 		return NULL;
+	}
 	return data;
 	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());
+		CLog::logf(CLog::Log_IO, 2, L"ERROR: CFileIO::readAll() unable to malloc data, %d (%hs)", 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", _sFilename.c_str(), m_lSize);
+		CLog::logf(CLog::Log_IO, 2, L"ERROR: CFileIO::readAll() unable to read data from file, %s/%d", _sFilename.c_str(), m_lSize);
 		delete[] data;
 		return NULL;
+	}
 	if ( pSize ) (*pSize) = m_lSize;
 	if (iSize > m_lSize) iSize = m_lSize;
 	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)", _sFilename.c_str(), e.what());
+		CLog::logf(CLog::Log_IO, 3, L"ERROR: CFileIO::read() unable to read from file: %s (%hs)", _sFilename.c_str(), e.what());
 		return false;
+	}
 	if (bEndChar) buf[iSize] = '\0';
 	if (iSize > m_lSize) iSize = m_lSize;
 	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)", _sFilename.c_str(), e.what());
+		CLog::logf(CLog::Log_IO, 3, L"ERROR: CFileIO::read() unable to read from file: %s (%hs)", _sFilename.c_str(), e.what());
 		return false;
+	}
 	if (bEndChar) buf[iSize] = '\0';
 			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)", _sFilename.c_str(), e.what());
+			CLog::logf(CLog::Log_IO, 2, L"CFileIO::WritePartFilea() unable to read data from file: %s (%hs)", _sFilename.c_str(), e.what());
 			return false;
+		}
 		size_t datasize = offsets[off++];
 		File.seekg(datasize, std::ios::beg);
 			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)", _sFilename.c_str(), e.what());
+				CLog::logf(CLog::Log_IO, 2, L"CFileIO::WritePartFilea() unable to read data from file: %s (%hs)", _sFilename.c_str(), e.what());
 				return false;
+			}
 			remainingSize -= amountLeft;
 			amountLeft = 1000000;
 	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());
+		CLog::logf(CLog::Log_IO, 2, L"CFileIO::ReadToData() unable to malloc storage, %d (%hs)", 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());
+		CLog::logf(CLog::Log_IO, 2, L"CFileIO::ReadToData() unable to read data from file (%hs)", e.what());
 		file.close();
 		return NULL;
+	}
 	*size = m_lSize;
 bool CFileIO::WriteData ( const char *data, size_t size )
+{
 	if ( NoFile() )
 		return false;
-	std::fstream File(_fileData(), _out());
+	std::fstream File(_sFilename.c_str(), _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)", _sFilename.c_str(), e.what());
+		CLog::logf(CLog::Log_IO, 2, L"CFileIO::ReadToData() unable to read data from file: %s (%hs)", _sFilename.c_str(), e.what());
 		ret = false;
+	}
 	File.close();
 	bool bRet = File.good();
 	File.close();
 	return bRet;
+}
-bool CFileIO::ExistsOld () const
-{
-	return this->exists();
-}
 bool CFileIO::exists () const
+{
 	if ( this->isOpened() ) return true;
 	std::fstream File(_sFilename, _in());
 	bool bRet = File.good();
+}
 bool CFileIO::startWrite()
+{
 	return _start(_out(), true);
 }
 bool CFileIO::startModify()
+{
 	return _start(_inout(), true);
 }
 bool CFileIO::startAppend()
+{
 	return _start(_append(), false);
+}
+{
 	if ( !_sFilename.empty() ) {
 		if ( this->isOpened() ) this->close();
 		m_fId.open(_sFilename, iFlags);
 	}
 	m_bSeekP = bSeekP;
 	return m_fId.is_open();
+}
 size_t CFileIO::readLines(std::vector<Utils::String>& to) const
 	Utils::String line;
 	std::ifstream infile(_sFilename.c_str(), std::ios_base::in);
 	while (getline(infile, line, '\n')) {
 		to.push_back(Utils::String(line).removeChar((char)0));
 	}
 	infile.close();
 	return to.size();
 }
 size_t CFileIO::readLines(std::vector<Utils::WString>& to) const
 {
 	if (_sFilename.empty()) return 0;
 	std::wstring line;
 	std::wifstream infile(_sFilename.c_str(), std::ios_base::in);
+	if (getline(infile, line, L'\n'))
+	{
+		if (line.length() > 3)
+		{
+			// check for UTF-8 header
+			if (line[0] == 239 && line[1] == 187 && line[2] == 191)
+			{
+				infile.close();
+				return readLinesUTF(to);
+			}
+			to.push_back(Utils::WString(line).remove((char)0));
+		}
-	while (getline(infile, line, L'\n')) {
+		while (getline(infile, line, L'\n')) {
-		to.push_back(Utils::WString(line).remove((char)0));
+			to.push_back(Utils::WString(line).remove((char)0));
+		}
 	}
 	infile.close();
 	return to.size();
 }
+size_t CFileIO::readLinesUTF(std::vector<Utils::WString>& to) const
+{
+	if (_sFilename.empty()) return 0;
+	std::wstring line;
+	std::wifstream infile(_sFilename.c_str(), std::ios_base::in);
+	infile.imbue(std::locale(std::locale::empty(), new std::codecvt_utf8<wchar_t>));
+	if (getline(infile, line, L'\n'))
+	{
+		if (line.length() > 3)
+		{
+			// check for UTF-8 header
+			if (line[0] == 239 && line[1] == 187 && line[2] == 191)
+				line = line.erase(0, 3);
+			to.push_back(Utils::WString(line).remove((char)0).remove(65279));
+		}
+		while (getline(infile, line, L'\n')) {
+			to.push_back(Utils::WString(line).remove((char)0).remove(65279));
+		}
+	}
+	infile.close();
+	return to.size();
+}
 size_t CFileIO::readLines(Utils::WStringList& to) const
+{
 	if (_sFilename.empty()) return 0;
 	std::wstring line;
 	std::wifstream infile(_sFilename.c_str(), std::ios_base::in);
 	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());
+		CLog::logf(CLog::Log_IO, 2, L"ERROR: CFileIO::write(CFileIO, size_t) unable to malloc data, %d (%hs)", 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;
 		iSizeLeft -= iDoSize;
 	}
 	delete data;
 	return bSuccess;
+}
 bool CFileIO::write(const char *buf, size_t iSize)
 	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)", _sFilename.c_str(), e.what());
+		CLog::logf(CLog::Log_IO, 2, L"CFileIO::write() unable to write to file: %s (%hs)", _sFilename.c_str(), e.what());
 		return false;
+	}
 	m_lSize += iSize;
 	return !m_fId.bad();
+}
 bool CFileIO::write(const unsigned char *buf, size_t 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)", _sFilename.c_str(), e.what());
+		CLog::logf(CLog::Log_IO, 2, L"CFileIO::write() unable to write to file: %s (%hs)", _sFilename.c_str(), e.what());
 		return false;
+	}
 	return !m_fId.bad();
+}
 bool CFileIO::_write(const wchar_t* buf, va_list args)
 		size_t iLen = wcslen(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: %ls (%s)", _sFilename.c_str(), e.what());
+		CLog::logf(CLog::Log_IO, 2, L"CFileIO::write() unable to write to file: %ls (%hs)", _sFilename.c_str(), e.what());
 		return false;
+	}
 	return !m_fId.bad();
+}
 	if ( !fromFile.is_open() ) return false;
 	std::fstream toFile(_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 = static_cast<size_t>(fromFile.tellg());
 		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)", _sFilename.c_str(), e.what());
+			CLog::logf(CLog::Log_IO, 2, L"CFileIO::AppendData() unable to write data to file: %s (%hs)", _sFilename.c_str(), e.what());
 			File.close();
 			return false;
+		}
 		pos += read;
+	}
 #endif
+}
 bool CFileIO::Rename(const Utils::WString& from, const Utils::WString &to)
+{
-	if (std::rename(_toFileData(from).c_str(), _toFileData(to).c_str()) == 0)
+	if (_wrename(from.c_str(), to.c_str()) == 0)
 		return true;
 	return false;
+}
 bool CFileIO::remove()
 	if ( !this->exists() ) return false;
 	if ( CFileIO::Remove(_sFilename)) return true;
 	return false;
+}
-bool CFileIO::writeFileUTF(std::vector<Utils::WString>* lines)
+bool CFileIO::writeFileUTF(const std::vector<Utils::WString>* lines)
+{
 	if (!lines || _sFilename.empty())
 		return false;
 	// we need to create the directory
+	{
 		Utils::WString l = (*itr);
 		if (l.contains('\n'))
+		{
 			std::vector<Utils::WString> strs;
-			if(l.tokenise(L"\n", strs) && !strs.empty())
+			if (l.tokenise(L"\n", strs) && !strs.empty())
+			{
-				for(auto itr = strs.begin(); itr != strs.end(); itr++)
+				for (auto itr = strs.begin(); itr != strs.end(); itr++)
+				{
 					Utils::WString line = *itr;
 					line += L"\n";
 					fwrite(l.c_str(), sizeof(TCHAR), wcslen(l.c_str()), id);
+				}
+			}
+		}
+		else
+		{
+			l += L"\n";
+			fwrite(l.c_str(), sizeof(TCHAR), wcslen(l.c_str()), id);
+		}
+	}
+	fclose(id);
+	return true;
+#else
+	//TODO: write utf8 file writing function
+	return false;
+#endif
+}
+bool CFileIO::writeFileUTF(const Utils::WStringList &lines)
+{
+	if (lines.empty() || _sFilename.empty())
+		return false;
+	// we need to create the directory
+	if (!_sDirIO.exists())
+	{
+		if (!_sDirIO.create())
+			return false;
+	}
+#ifdef _WIN32
+	FILE* id = _wfopen(_sFilename.c_str(), L"wt+,ccs=UTF-8");
+	if (!id)
+		return false;
+	// write the rest
+	for (auto itr = lines.begin(); itr != lines.end(); itr++)
+	{
+		Utils::WString l = (*itr)->str;
+		if (l.contains('\n'))
+		{
+			std::vector<Utils::WString> strs;
+			if (l.tokenise(L"\n", strs) && !strs.empty())
+			{
+				for (auto itr = strs.begin(); itr != strs.end(); itr++)
+				{
+					Utils::WString line = *itr;
+					line += L"\n";
+					fwrite(line.c_str(), sizeof(TCHAR), wcslen(line.c_str()), id);
+				}
+			}
+		}
 		else
+		{

Subversion Repositories spk

(root)/libspk/src/File_IO.cpp – Rev 223 → 227