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

 	m_bBinary = bBinary;
 	_sFilename = sFilename.asFilename();
 	// check if there are any directories, and split the file and directory parts
 	if ( _sFilename.contains('/') ) {
-		_sDirIO.setDir(_sFilename.tokens(L"/", 1, -2).toString());
+		_sDirIO.setDir(_sFilename.tokens(L"/", 1, -2));
 		_sFile = _sFilename.token(L"/", -1);
+	}
 	else
 		_sFile = _sFilename;
 	if ( pSize ) (*pSize) = m_lSize;
 	return data;
+}
-bool CFileIO::read(unsigned char *buf, size_t iSize, bool bEndChar)
+bool CFileIO::read(wchar_t* buf, size_t iSize, bool bEndChar)
+{
-	if ( !this->isOpened() ) startRead();
+	if (!this->isOpened()) startRead();
-	if ( !this->isOpened() ) return false;
+	if (!this->isOpened()) return false;
-	if ( iSize > m_lSize ) iSize = 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());
+		return false;
+	}
+	if (bEndChar) buf[iSize] = '\0';
+	return !m_fId.bad();
+}
+bool CFileIO::read(unsigned char* buf, size_t iSize, bool bEndChar)
+{
+	if (!this->isOpened()) startRead();
+	if (!this->isOpened()) return false;
+	if (iSize > m_lSize) iSize = m_lSize;
 	try {
-		m_fId.read((char *)buf, iSize);
+		m_fId.read((char*)buf, iSize);
+	}
-	catch (std::exception &e) {
+	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());
 		return false;
+	}
-	if ( bEndChar ) buf[iSize] = '\0';
+	if (bEndChar) buf[iSize] = '\0';
 	return !m_fId.bad();
+}
 bool CFileIO::WritePartFile ( size_t *offsets, size_t numOffset )
+	}
 	size_t off = 0;
 	size_t startPos = 0;
 	size_t remainingSize = fullsize;
 	while ( off < numOffset ) {
 		startPos = static_cast<size_t>(File.tellg());
 		size_t offset = offsets[off++];
 		size_t size = offset - startPos;
 		try {
 	File.close();
 	writeFile.close();
 	// now copy to original file
-	std::remove(_fileData());
+	CFileIO::Remove(_sFilename);
-	return std::rename(CPackages::tempDirectory() + "/temp.tmp", _fileData()) != 0;
+	return CFileIO::Rename(CPackages::tempDirectory() + L"/temp.tmp", _sFilename);
+}
 void CFileIO::setDir(const Utils::WString &dir)
+{
+{
 	m_lSize = 0;
 	std::fstream file(_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 = static_cast<size_t>(file.tellg());
 	file.close();
+}
+{
 	if ( NoFile() ) return FILEERR_NOFILE;
 	if ( !this->startRead() ) return FILEERR_NOOPEN;
 	if ( (offset + datasize) > m_lSize ) return FILEERR_TOSMALL;
 	CFileIO File(CPackages::tempDirectory() + "/temp.tmp");
 	if ( !File.startWrite() ) return FILEERR_NOWRITE;
 	File.setAutoDelete(true);
 	if ( !File.write(*this, offset) ) return false;
 	// next fseek after and write
 	this->seek(datasize);
 	size_t size = m_lSize - offset - datasize;
 	if ( size > 0 ) {
 		File.write(*this, size);
 	}
 	File.close();
 	this->close();
 	File.setAutoDelete(false);
 	// now copy to original file
-	if ( std::remove(_fileData()) == 0) {
+	if (CFileIO::Remove(_sFilename)) {
-		std::rename(CPackages::tempDirectory() + ";/temp.tmp", _fileData());
+		if (CFileIO::Rename(CPackages::tempDirectory() + L";/temp.tmp", _sFilename))
+		{
-		size_t oldSize = m_lSize;
+			size_t oldSize = m_lSize;
-		size_t checkFileSize = m_lSize - datasize;
+			size_t checkFileSize = m_lSize - datasize;
-		this->_readFileSize();
+			this->_readFileSize();
-		if ( checkFileSize != m_lSize ) {
+			if (checkFileSize != m_lSize) {
-			CLog::log(CLog::Log_IO, 3, Utils::String("WARNING: CFileIO::TruncateFile, file size mismatch, ") + (long)checkFileSize + " => " + (long)m_lSize);
+				CLog::log(CLog::Log_IO, 3, Utils::WString(L"WARNING: CFileIO::TruncateFile, file size mismatch, ") + (long)checkFileSize + L" => " + (long)m_lSize);
+			}
+			return FILEERR_NONE;
+		}
-		return FILEERR_NONE;
+		return FILEERR_NOWRITE;
+	}
 	return FILEERR_NOWRITE;
 }
 int CFileIO::_in() const
+{
 	if ( m_bBinary ) return std::ios::in | std::ios::binary;
 	return std::ios::in;
+}
 	std::fstream file(_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;
 	File.close();
 	if ( ret ) this->_readFileSize();
 	return ret;
 }
 bool CFileIO::writeString ( const Utils::String &data )
 {
 	return WriteData ( data.c_str(), data.length() );
 }
 bool CFileIO::Exists(const Utils::WString &filename)
 {
-	std::fstream File(filename, std::ios::in | std::ios::binary);
+	std::wfstream 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::startWrite()
+{
 	return _start(_out(), true);
 }
 bool CFileIO::startModify()
+{
 	return _start(_inout(), true);
+}
 	m_bSeekP = bSeekP;
 	return m_fId.is_open();
+}
 std::vector<Utils::String>* CFileIO::readLines() const
 {
 	if (_sFilename.empty()) return 0;
 	std::vector<Utils::String>* file = new std::vector<Utils::String>;
 	Utils::String line;
 	file->clear();
 	std::ifstream infile(_sFilename.c_str(), std::ios_base::in);
 	while (getline(infile, line, '\n')) {
 		file->push_back(Utils::String(line).removeChar((char)0));
+	}
+	infile.close();
+	return file;
+}
+size_t CFileIO::readLines(std::vector<Utils::String>& to) const
+{
+	if (_sFilename.empty()) return 0;
+	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 file;
+	return to.size();
+}
-size_t CFileIO::readLines(std::vector<Utils::String>& to) const
+size_t CFileIO::readLines(std::vector<Utils::WString>& to) const
+{
 	if (_sFilename.empty()) return 0;
-	Utils::String line;
+	std::wstring line;
-	std::ifstream infile(_sFilename.c_str(), std::ios_base::in);
+	std::wifstream infile(_sFilename.c_str(), std::ios_base::in);
-	while (getline(infile, line, '\n')) {
+	while (getline(infile, line, L'\n')) {
-		to.push_back(Utils::String(line).removeChar((char)0));
+		to.push_back(Utils::WString(line).remove((char)0));
+	}
 	infile.close();
 	return to.size();
 bool CFileIO::write(const char *buf, size_t iSize)
+{
 	if ( !this->isOpened() ) startWrite();
 	if ( !this->isOpened() ) return false;
 	try {
-		m_fId.write((char *)buf, iSize);
+		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());
 		return false;
+	}
 	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)
+bool CFileIO::_write(const char* buf, va_list args)
+{
-	if ( !this->isOpened() ) return false;
+	if (!this->isOpened()) return false;
 	char buffer[10000];
-	vsprintf (buffer, buf, args);
+	vsprintf(buffer, buf, args);
 	try {
 		int iLen = strlen(buffer);
-		m_fId.write((char *)buffer, iLen);
+		m_fId.write((char*)buffer, iLen);
 		m_lSize += iLen;
 	}
-	catch (std::exception &e) {
+	catch (std::exception& e) {
 		CLog::logf(CLog::Log_IO, 2, "CFileIO::write() unable to write to file: %s (%s)", _sFilename.c_str(), e.what());
 		return false;
+	}
 	return !m_fId.bad();
 }
+bool CFileIO::_write(const wchar_t* buf, va_list args)
+{
+	if (!this->isOpened()) return false;
+	wchar_t buffer[10000];
+#ifdef _WIN32
+	vswprintf_s(buffer, 10000, buf, args);
+#else
+	vswprintf(buffer, buf, args);
+#endif
+	try {
+		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());
+		return false;
+	}
+	return !m_fId.bad();
+}
 bool CFileIO::write(const char *buf, ...)
+{
 	va_list args;
 	va_start(args, buf);
+{
 	_seek(iPos, std::ios::cur);
+}
 void CFileIO::seekEnd(size_t iPos)
 {
 	_seek(iPos, std::ios::end);
+}
 void CFileIO::seekStart(size_t iPos)
+{
+}
 std::fstream &CFileIO::stream()
+{
 	return m_fId;
 }
 bool CFileIO::isOpened() const
+{
 	if ( m_fId.is_open() )
 		return true;
 	return false;
 	if ( this->read(size, 4) ) return (size[0] << 24) + (size[1] << 16) + (size[2] << 8) + size[3];
 	return 0;
+}
 bool CFileIO::atEnd() const
 {
 	if ( !this->isOpened() ) return true;
 	if ( m_fId.eof() )		 return true;
 	return false;
+}
+		}
 		pos += read;
+	}
 	File.close();
 	return true;
 }
 bool CFileIO::AppendDataToPos ( const char *d, size_t size, size_t start )
+{
 	if ( start > m_lSize ) return false;
 	if ( m_lSize <= 0 ) {
 		if ( !this->startWrite() ) return false;
 		if ( !this->startModify() ) return false;
 		this->seekStart(start);
+	}
 	return this->write(d, size);
 }
+Utils::String CFileIO::readEndOfLineStr()
+{
+	if (!this->isOpened()) {
+		if (!startRead())	return "";
+	}
+	std::string str;
+	std::getline(m_fId, str, '\n');
+	return str;
+}
-Utils::String CFileIO::readEndOfLine()
+Utils::WString CFileIO::readEndOfLine()
 {
-	if ( !this->isOpened() ) {
+	if (!this->isOpened()) {
-		if ( !startRead() )	return "";
+		if (!startRead())	return L"";
 	}
-	Utils::String str;
+	std::string str;
 	std::getline(m_fId, str, '\n');
 	return str;
+}
 Utils::WString CFileIO::baseName() const
+{
-	return _sFile.tokens(L".", 1, -2).toString();
+	return _sFile.tokens(L".", 1, -2);
+}
 const Utils::WString& CFileIO::fullFilename() const { return _sFilename; }
 const Utils::WString& CFileIO::filename() const { return _sFile; }
 Utils::WString CFileIO::extension () const
+{
 	if ( _sFilename.empty() ) return Utils::WString::Null();
 	return _sFilename.token(L".", -1);
 }
 Utils::WString CFileIO::changeFileExtension(const Utils::WString &ext) const
 {
 	if ( _sFilename.empty() )
 		return Utils::WString::Null();
 	return _sFilename.tokens(L".", 1, -2) + L"." + ext;
 }
-bool CFileIO::Remove(const Utils::WString &rem)
+bool CFileIO::Remove(const Utils::WString& rem)
 {
+#ifdef _WIN32
+	return DeleteFile(rem.c_str());
+#else
 	//if ( !Exists() ) return false;
 	return (std::remove(_toFileData(rem)) == 0) ? true : false;
+#endif
+}
+bool CFileIO::Rename(const Utils::WString& from, const Utils::WString &to)
+{
+	if (std::rename(_toFileData(from).c_str(), _toFileData(to).c_str()) == 0)
+		return true;
+	return false;
+}
 bool CFileIO::remove()
+{
 	if ( this->isOpened() ) this->close();
 	if ( !this->exists() ) return false;
-	if ( std::remove(_fileData()) == 0) return true;
+	if ( CFileIO::Remove(_sFilename)) return true;
 	return false;
+}
-bool CFileIO::writeFileUTF(std::vector<Utils::String> *lines)
+bool CFileIO::writeFileUTF(std::vector<Utils::String>* lines)
+{
 	if (!lines || _sFilename.empty())
 		return false;
 	// we need to create the directory
 			return false;
+	}
 #ifdef _WIN32
 	TCHAR buf[5000];
-	wsprintf(buf, L"%hs", _sFilename.c_str());
-	FILE *id = _wfopen(buf, L"wt+,ccs=UTF-8");
+	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++)
+	for (auto itr = lines->begin(); itr != lines->end(); itr++)
+	{
 		Utils::String l = (*itr);
 		if (l.isin('\n'))
+		{
 			int max;
-			Utils::String *strs = l.tokenise("\n", &max);
+			Utils::String* strs = l.tokenise("\n", &max);
 			if (strs && max)
+			{
 				for (int i = 0; i < max; i++)
+				{
 					Utils::String line = strs[i];
 	//TODO: write utf8 file writing function
 	return false;
 #endif
+}
-bool CFileIO::writeFile(std::vector<Utils::String> *lines)
+bool CFileIO::writeFileUTF(std::vector<Utils::WString>* lines)
+{
 	if (!lines || _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);
+		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(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::writeFile(std::vector<Utils::String> *lines)
+{
+	if (!lines || _sFilename.empty())
+		return false;
+	// we need to create the directory
+	if (!_sDirIO.exists())
+	{
+		if (!_sDirIO.create())
+			return false;
 	}
 	std::ofstream out(_sFilename.c_str());
 	if (!out)
 		return false;
 	for (auto itr = lines->begin(); itr != lines->end(); itr++)
 		out << (*itr).c_str() << std::endl;
+	out.close();
+	return true;
+}
+bool CFileIO::writeFile(const std::vector<Utils::WString> &lines) const
+{
+	if (lines.empty() || _sFilename.empty())
+		return false;
+	// we need to create the directory
+	if (!_sDirIO.exists())
+	{
+		if (!_sDirIO.create())
+			return false;
+	}
+	std::wofstream out(_sFilename.c_str());
+	if (!out)
+		return false;
+	for (auto itr = lines.begin(); itr != lines.end(); itr++)
+		out << (*itr).c_str() << std::endl;
 	out.close();
 	return true;
+}
 bool CFileIO::writeFile(Utils::WStringList* lines)
 {
 	if (!lines || _sFilename.empty())
 		return false;
 	// we need to create the directory
 	if (!_sDirIO.exists())
 	{
 		if (!_sDirIO.create())
 			return false;
 	}
-	std::ofstream out(_sFilename.c_str());
+	std::wofstream out(_sFilename.c_str());
 	if (!out)
 		return false;
 	for (auto itr = lines->begin(); itr != lines->end(); itr++)
 		out << (*itr)->str.c_str() << std::endl;
 	out.close();
 	return true;
 }
 bool CFileIO::writeFile(Utils::CStringList* lines)
+{
 	if (!lines || _sFilename.empty())
 		return false;
 	if (!out)
 		return false;
 	for(auto itr = lines->begin(); itr != lines->end(); itr++)
 		out << (*itr)->str.c_str() << std::endl;
 	out.close();
 	return true;
+}
 bool CFileIO::Rename(const Utils::WString &toFile)
 {
-	if ( rename(_fileData(), _toFileData(toFile)) == 0)
+	return CFileIO::Rename(_sFilename, toFile);
-		return true;
-	return false;
+}
 Utils::WString CFileIO::getWindowsFilename() const
+{
 	return _sFilename.findReplace(L"/", L"\\");
+{
 	if (_sFilename.empty()) _sExt = Utils::WString::Null();
 	_sExt = _sFilename.token(L".", -1);
+}
-const char* CFileIO::_fileData() const
+std::string CFileIO::_fileData() const
+{
-	return std::string(_sFilename.begin(), _sFilename.end()).c_str();
+	return _toFileData(_sFilename);
+}
-const char* CFileIO::_toFileData(const Utils::WString &str)
+std::string CFileIO::_toFileData(const Utils::WString &str)
+{
-	return std::string(str.begin(), str.end()).c_str();
+	return std::string(str.begin(), str.end());
+}

Subversion Repositories spk

(root)/libspk/src/File_IO.cpp – Rev 196 → 197