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

 	DeleteData ();
 	if (!_sTmpFile.empty())
 		remove(_sTmpFile.c_str());
+}
+long C_File::uncompressedDataSize() const
+{
+	if (m_lUncomprDataSize)
+		return m_lUncomprDataSize;
+	if (m_lSize)
+		return m_lSize;
+	return m_lDataSize;
+}
 /*
-	Func:	GetDirectory()
+	Func:	getDirectory()
 	Return: Directory String
 	Desc:	Returns the directory the file goes into, based on m_sDir and Filetype
 */
-CyString C_File::GetDirectory ( CBaseFile *file )
-{
-	return getDirectory(file);
-}
 Utils::String C_File::getDirectory(CBaseFile *file) const
+{
 	if (IsFakePatch())
 		return "";
+		}
 		return dir;
+	}
 	return C_File::GetDirectory(m_iFileType, _sName, file);
-}
-CyString C_File::GetNameDirectory(CBaseFile *file)
-{
-	return getNameDirectory(file);
+}
 Utils::String C_File::getNameDirectory(CBaseFile *file) const
+{
 	Utils::String dir = getDirectory(file);
 	m_iPos = -1;
 	_iGame = 0;
+}
 bool C_File::UpdateSigned()
 {
 	switch ( m_iFileType )
+	{
 		// text files, readmes, screenshots can be always considered to be signed
 		case FILETYPE_TEXT:
 		case FILETYPE_README:
 			m_bSigned = false;
 			break;
 		// extra files are a special case
 		case FILETYPE_EXTRA:
-			if ( this->GetDir().Left(6).Compare("extras") )
+			if ( this->dir().left(6).Compare("extras") )
 				m_bSigned = true;
 			else
 				m_bSigned = false;
 			break;
+}
 /*
 	Func:	DeleteData()
 	Desc:	Clears the data stream, uses free() if created by malloc, otherwise use delete.
 */
 void C_File::DeleteData ()
+{
 	if ( m_sData )
+	{
 		if ( m_bUsedMalloc )
+	}
 	m_bUsedMalloc = false;
 	m_iDataCompression = SPKCOMPRESS_NONE;
+}
-int C_File::GetTextFileID(CyString filename)
+int C_File::textFileID(const Utils::String &sFilename) const
+{
 	if ( m_iFileType != FILETYPE_TEXT )
 		return -1;
+	Utils::String filename = sFilename;
-	if ( filename.Empty() )
+	if ( filename.empty() )
 		filename = _sName;
-	CyString textid;
+	Utils::String textid;
-	if ( filename.IsIn("-L") || filename.IsIn("-l") )
+	if ( filename.contains("-L") || filename.contains("-l") )
-		textid = filename.GetToken("-", 1, 1);
+		textid = filename.token("-", 1);
 	else
-		textid = filename.GetToken(".", -1).Right(4);
+		textid = filename.tokens(".", -1).right(4);
-	if ( textid.IsNumber() ) return textid.ToInt();
+	if (textid.isNumber()) return textid.toInt();
 	return -1;
+}
 bool C_File::isAutoTextFile ()
+{
-	int textid = GetTextFileID();
+	int textid = textFileID();
 	if ( textid == -1 ) return false;
 	if ( textid == 4 )
 		return true;
 	// check for original name
 	if ( !_sOriginalName.empty() )
+	{
-		textid = GetTextFileID(_sOriginalName);
+		textid = textFileID(_sOriginalName);
 		if ( textid >= 0 && textid <= 3 )
 			return true;
+	}
 	return false;
 	if (name.token(".", 1).toLong())
 		return true;
 	if (name.left(10) == "FakePatch_")
 		return true;
 	return false;
 }
 /*
 ########################################################################################################################
 ####################################             File Pointer Functions             ####################################
 ########################################################################################################################
 */
 /*
 	Func:	SetFilename
 	Accept:	filename - String for the filename of disk
 	Desc:	Sets the file pointer
 			Reads the file size and last modifed time to store in the class
 			Splits up the filename and dir path
 */
-void C_File::SetFilename(CyString filename)
-{
-	setFilename(filename.ToString());
-}
 void C_File::setFilename(const Utils::String &filename)
+{
 	Utils::String file = filename.findReplace ( "\\", "/" ).findReplace ( "//", "/" );
 	_sFullDir = file.tokens("/", 1, -2);
 		_sFullDir = _sFullDir.left(-2);
 	ReadFileSize ();
 	ReadLastModified ();
 }
 /*
 	Func:	ReadFromFile
 	Return:	Boolean - Returns true if read was successfull
 	Desc:	Reads data from file pointer into data stream
 			As its read from a file, there will be no compression, so its set to None
 */
 bool C_File::ReadFromFile ()
 {
 	return this->readFromFile(filePointer());
 }
-bool C_File::ReadFromFile(CyString filename)
-{
-	return readFromFile(filename.ToString());
-}
 bool C_File::readFromFile(const Utils::String filename)
+{
 	CFileIO File(filename);
 	if ( !File.startRead() ) {
 		m_iLastError = SPKERR_FILEOPEN;
 		return false;
+	}
 	m_iDataCompression = SPKCOMPRESS_NONE;
 	m_lDataSize = m_lUncomprDataSize = m_lSize;
 		DeleteData ();
 		m_lDataSize = 0;
 		return false;
+	}
 	return true;
 }
 void C_File::copyData(const unsigned char *data, size_t size)
+{
 	m_lDataSize = (long)size;
 	delete m_sData;
 	m_sData = new unsigned char[size];
 	memcpy(m_sData, data, size);
+}
+/*
+	Func:	filePointer
+	Desc:	Returns the file pointer name
+			Joins dir and name together
+			Works for relative paths as well
+*/
 Utils::String C_File::filePointer() const
+{
 	Utils::String fullfile = _sFullDir;
 	if ( !fullfile.empty() )
 		fullfile += "/";
 			return true;
+	}
 	return false;
+}
-/*
-	Func:	GetFilePointer
-	Desc:	Returns the file pointer name
-			Joins dir and name together
-			Works for relative paths as well
-*/
-CyString C_File::GetFilePointer ()
-{
-	return filePointer();
-}
 void C_File::updateSignature()
+{
 	_sSignature = "";
 	if ( file->name() != _sName )
+	{
 		// check if the base name matches, but only for certain file extensions
 		if (file->shouldCheckBaseName())
+		{
-			Utils::String baseName = CFileIO(file->GetName()).dir() + "/" + CFileIO(file->GetName()).baseName();
+			Utils::String baseName = CFileIO(file->name()).dir() + "/" + CFileIO(file->name()).baseName();
 			Utils::String compareBaseName = CFileIO(_sName).dir() + "/" + CFileIO(_sName).baseName();
 			if (baseName.Compare(compareBaseName))
 				return true;
+		}
 		return false;
 	return ret;
+}
 bool C_File::ChangeCompression ( int compressionType, CProgressInfo *progress )
 {
 	// no data to try to compress
 	if ( (!m_sData) || (!m_lDataSize) )
 		return false;
 	// laready compressed to correct type
 	if ( compressionType == m_iDataCompression )
 		return true;
 	// otherwise, lets recompress the file
 	if ( compressionType == SPKCOMPRESS_7ZIP )
 		compressionType = SPKCOMPRESS_LZMA;
 	// if its zlib, and we are trying to compress pcked files (ie already zlib compression) then switch to lzma instead
-	if ( compressionType == SPKCOMPRESS_ZLIB && (this->CheckFileExt("pck") || this->CheckFileExt("cat") || this->CheckFileExt("dat") || this->CheckFileExt("pbb") || this->CheckFileExt("pbd")) )
+	if ( compressionType == SPKCOMPRESS_ZLIB && (this->checkFileExt("pck") || this->checkFileExt("cat") || this->checkFileExt("dat") || this->checkFileExt("pbb") || this->checkFileExt("pbd")) )
 		compressionType = SPKCOMPRESS_LZMA;
 	// if its already compressed, no need to compress again
 	if ( compressionType == m_iDataCompression )
 		return true;
+	}
 	return NULL;
+}
-bool C_File::UncompressToFile ( CyString toFile, CBaseFile *spkfile, bool includedir, CProgressInfo *progress )
+bool C_File::uncompressToFile(const Utils::String &toFile, CBaseFile *spkfile, bool includedir, CProgressInfo *progress)
+{
 #ifdef _INCLUDE7ZIP
 	if ( (!m_sData) || (!m_lDataSize) )
 		return false;
 	// if theres a tmp file, open it and check it still exists
-	if ( !m_sTmpFile.Empty() )
+	if ( !m_sTmpFile.empty() )
+	{
 		if ( CFileIO::Exists(m_sTmpFile) ) return true;
 		m_sTmpFile = "";
+	}
 	// now uncompress to the file
-	CyString file = toFile;
+	Utils::String file = toFile;
-	if ( file.Empty() )
+	if (file.empty())
+	{
 		m_iTempNum++;
-		file = CyString("uncompr") + (long)m_iTempNum + ".tmp";
+		file = "uncompr" + (long)m_iTempNum + ".tmp";
+	}
 	else
-		file = _getFullFileToDir(file.ToString(), includedir, spkfile);
+		file = _getFullFileToDir(file, includedir, spkfile);
 	CFileIO File("compr.tmp");
 	if ( !File.startWrite() ) return false;
 	if ( !File.write(m_sData, m_lDataSize) ) return false;
 	File.close();
 	if ( LZMADecodeFile ( "compr.tmp", file.c_str(), (CProgressInfo7Zip *)progress ) )
+	{
 		ret = true;
-		if ( toFile.Empty() )
+		if ( toFile.empty() )
 			m_sTmpFile = file;
+	}
 	CFileIO::Remove("compr.tmp");
 Utils::String C_File::dataSizeString() const
+{
 	return SPK::GetSizeString(m_lDataSize);
+}
-CyString C_File::GetUncompressedSizeString ()
+Utils::String C_File::uncompressedSizeString() const
+{
-	return SPK::GetSizeString ( GetUncompressedDataSize() );
+	return SPK::GetSizeString(uncompressedDataSize());
+}
-CyString C_File::GetCreationTimeString ()
+Utils::String C_File::creationTimeString() const
+{
 	if ( !m_tTime )
-		return NullString;
+		return Utils::String::Null();
 	struct tm   *currDate;
 	char    dateString[100];
 	time_t n = m_tTime;
 	currDate = localtime(&n);
 	strftime(dateString, sizeof dateString, "(%d/%m/%Y) %H:%M", currDate);
-	return CyString(dateString);
+	return Utils::String(dateString);
+}
 bool C_File::CompareNew ( C_File *file )
+{
 	if ( !m_iVersion )
 		case SPKINSTALL_SHARED_FAIL:
 			errorStr = "Unable to remove Unused Shared file: %1";
 			break;
 		case SPKINSTALL_ORIGINAL_BACKUP:
 			errorStr = "Backing up original file: %1";
 			break;
 		case SPKINSTALL_ORIGINAL_BACKUP_FAIL:
 			errorStr = "Unable to back up original file: %1";
 			break;
 		case SPKINSTALL_ORIGINAL_RESTORE:
 			errorStr = "Restoring original file: %1";
 			unsigned char data[4];
 			if ( File.read(data, 3) ) return IsDataPCK ( data, 3 );
+		}
+	}
-	if ( CheckFileExt("pck") || CheckFileExt("pbb") || CheckFileExt("pbd") ) return true;
+	if (checkFileExt("pck") || checkFileExt("pbb") || checkFileExt("pbd")) return true;
 	return false;
+}
 bool C_File::PCKFile()
+{
 	// remove any directory
 	Utils::String file = _sName.token("/", -1);
 	// remove file extension
 	return file.remToken(".", -1);
-}
-CyString C_File::GetBaseName()
-{
-	return baseName();
+}
 void C_File::CopyData(C_File *oldFile, bool includeData)
+{
-	SetFilename(oldFile->GetFullFilename());
+	setFilename(oldFile->fullFilename());
 	_sDir = oldFile->dir();
 	m_tTime = oldFile->GetCreationTime();
 	m_bShared = oldFile->IsShared();
 	m_bSigned = oldFile->IsSigned();
 	m_iFileType = oldFile->fileType();
+		{
 			m_sData = new unsigned char[m_lDataSize];
 			m_bUsedMalloc = false;
 			memcpy((char *)m_sData, (char *)oldFile->GetData(), m_lDataSize);
+		}
-		m_lUncomprDataSize = oldFile->GetUncompressedDataSize();
+		m_lUncomprDataSize = oldFile->uncompressedDataSize();
+	}
 	m_iDataCompression = oldFile->GetCompressionType();
+}
 float GetLibraryVersion() { return (float)LIBRARYVERSION; }
 float GetFileFormatVersion() { return (float)FILEVERSION; }
-CyString C_File::ChangeFileExt(CyString ext)
-{
-	_sName = CFileIO(_sName).changeFileExtension(ext.ToString());
-	return _sName;
-}
 Utils::String C_File::fileExt() const
+{
 	return _sName.token(".", -1);
+}
+bool C_File::checkFileExt(const Utils::String& ext)
+{
+	if (fileExt().Compare(ext)) return true; return false;
+}
 const Utils::String &C_File::changeFileExt(const Utils::String &ext)
+{
 	_sName = CFileIO(_sName).changeFileExtension(ext);
 	return _sName;
+}
 bool C_File::CheckPackedExtension()
+{
-	CyString ext = this->GetFileExt();
+	Utils::String ext = this->fileExt();
 	if ( ext == "pck" )
 		return true;
 	else if ( ext == "pbb" )
 		return true;
 	else if ( ext == "pbd" )
 bool C_File::BobDecompile()
+{
 	bool bRes=false;
-	CyStringList outData;
+	Utils::CStringList outData;
-	outData.PushBack("// Converted by SPK Libraries\n");
+	outData.pushBack("// Converted by SPK Libraries\n");
 	/*
 	bob_with_errors *e=0;
 	char *pszTime;
 	char *name="";
 bool C_File::BodCompile()
+{
 	return true;
+}
-bool C_File::RenameScript(CyString baseName)
+bool C_File::renameScript(const Utils::String &baseName)
+{
 	if ( !m_sData || !m_lDataSize )
+	{
 		if ( !this->ReadFromFile() )
 			return false;
 	// uncompress the file
 	if ( !this->UncompressData() )
 		return false;
 	// un pck the file
-	if ( this->CheckFileExt("pck") )
+	if (this->checkFileExt("pck"))
+	{
 		if ( !this->UnPCKFile() )
 			return false;
+	}
 	// now we should have the raw data
-	CyString data((const char *)m_sData);
+	Utils::String data((const char *)m_sData);
-	data.Truncate(m_lDataSize);
+	data.truncate(m_lDataSize);
-	data = data.FindReplace(this->GetBaseName(), baseName);
+	data = data.findReplace(this->baseName(), baseName);
 	this->DeleteData();
-	m_sData = new unsigned char[data.Length()];
+	m_sData = new unsigned char[data.length()];
-	memcpy(m_sData, data.c_str(), data.Length());
+	memcpy(m_sData, data.c_str(), data.length());
-	m_lDataSize = (long)data.Length();
+	m_lDataSize = (long)data.length();
 	// repck the file
-	if ( this->CheckFileExt("pck") )
+	if (this->checkFileExt("pck"))
+	{
 		if ( !this->PCKFile() )
 			return false;
+	}

Subversion Repositories spk

(root)//libspk/src/File.cpp – Rev 160 → 178