dnf-utils/sgutil/sgu_lua_npk_file.cpp

#include "sgu_lua_npk_file.h"
#include "libNPK_Utils.h"

extern "C"
{
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
};

#include "lua_tinker.h"

////////////////////////////////////////////////////////////////////////////////////
void registerNPKLuaLibs(lua_State* L)
{
	//register global functions
	lua_tinker::def(L, "getLastErrorCode", &NPK::getLastErrorCode);
	lua_tinker::def(L, "getLastErrorMessage", &NPK::getLastErrorMessage);

	lua_tinker::def(L, "createNPKFile", &LuaNPKFile::create);
	lua_tinker::def(L, "destroyNPKFile", &LuaNPKFile::destroy);

	lua_tinker::def(L, "createEmptyFileList", &LuaNPKFileList::createEmpty);
	lua_tinker::def(L, "destroyFileList", &LuaNPKFileList::destroy);

	lua_tinker::class_add<LuaNPKFile>(L, "NPKFile");
	lua_tinker::class_def<LuaNPKFile>(L, "openPakFile", &LuaNPKFile::openPakFile);
	lua_tinker::class_def<LuaNPKFile>(L, "closePakFile", &LuaNPKFile::closePakFile);
	lua_tinker::class_def<LuaNPKFile>(L, "getFileCounts", &LuaNPKFile::getFileCounts);
	lua_tinker::class_def<LuaNPKFile>(L, "getFileNode", &LuaNPKFile::getFileNode);
	lua_tinker::class_def<LuaNPKFile>(L, "openFileStream", &LuaNPKFile::openFileStream);
	lua_tinker::class_def<LuaNPKFile>(L, "closeFileStream", &LuaNPKFile::closeFileStream);
	lua_tinker::class_def<LuaNPKFile>(L, "generateFullInfoList", &LuaNPKFile::generateFullInfoList);

	lua_tinker::class_add<LuaNPKFileItemBaseInfo>(L, "NPKFileItemBaseInfo");
	lua_tinker::class_def<LuaNPKFileItemBaseInfo>(L, "keyName", &LuaNPKFileItemBaseInfo::c_keyName);
	lua_tinker::class_mem<LuaNPKFileItemBaseInfo>(L, "fileOffset", &LuaNPKFileItemBaseInfo::fileOffset);
	lua_tinker::class_mem<LuaNPKFileItemBaseInfo>(L, "fileSize", &LuaNPKFileItemBaseInfo::fileSize);

	lua_tinker::class_add<LuaNPKFileItemFullInfo>(L, "LuaNPKFileItemFullInfo");
	lua_tinker::class_def<LuaNPKFileItemFullInfo>(L, "npkName", &LuaNPKFileItemFullInfo::c_npkName);
	lua_tinker::class_def<LuaNPKFileItemFullInfo>(L, "npkBase", &LuaNPKFileItemFullInfo::c_npkBase);
	lua_tinker::class_def<LuaNPKFileItemFullInfo>(L, "keyName", &LuaNPKFileItemFullInfo::c_keyName);
	lua_tinker::class_mem<LuaNPKFileItemFullInfo>(L, "fileOffset", &LuaNPKFileItemFullInfo::fileOffset);
	lua_tinker::class_mem<LuaNPKFileItemFullInfo>(L, "fileSize", &LuaNPKFileItemFullInfo::fileSize);
	lua_tinker::class_mem<LuaNPKFileItemFullInfo>(L, "fileCRC", &LuaNPKFileItemFullInfo::fileCRC);

	lua_tinker::class_add<LuaNPKFileList>(L, "LuaNPKFileList");
	lua_tinker::class_def<LuaNPKFileList>(L, "loadListFromFile", &LuaNPKFileList::loadListFromFile);
	lua_tinker::class_def<LuaNPKFileList>(L, "dumpToLocalFile", &LuaNPKFileList::dumpToLocalFile);
	lua_tinker::class_def<LuaNPKFileList>(L, "mergeOtherListInto", &LuaNPKFileList::mergeOtherListInto);
	lua_tinker::class_def<LuaNPKFileList>(L, "applyToLocalNPKFiles", &LuaNPKFileList::applyToLocalNPKFiles);
	lua_tinker::class_def<LuaNPKFileList>(L, "getFileCounts", &LuaNPKFileList::getFileCounts);
	lua_tinker::class_def<LuaNPKFileList>(L, "getFileItemFromIndex", &LuaNPKFileList::getFileItemFromIndex);
	lua_tinker::class_def<LuaNPKFileList>(L, "getFileItemFromName", &LuaNPKFileList::getFileItemFromName);

	lua_tinker::class_add<LuaNPKFileStream>(L, "NPKFileStream");
	lua_tinker::class_def<LuaNPKFileStream>(L, "name", &LuaNPKFileStream::name);
	lua_tinker::class_def<LuaNPKFileStream>(L, "size", &LuaNPKFileStream::size);
	lua_tinker::class_def<LuaNPKFileStream>(L, "read", &LuaNPKFileStream::read);
	lua_tinker::class_def<LuaNPKFileStream>(L, "seek", &LuaNPKFileStream::seek);
	lua_tinker::class_def<LuaNPKFileStream>(L, "tell", &LuaNPKFileStream::tell);
	lua_tinker::class_def<LuaNPKFileStream>(L, "crc32", &LuaNPKFileStream::crc32);
	lua_tinker::class_def<LuaNPKFileStream>(L, "isEOF", &LuaNPKFileStream::isEOF);
	lua_tinker::class_def<LuaNPKFileStream>(L, "writeToDiskFile", &LuaNPKFileStream::writeToDiskFile);
}

LuaNPKFile* LuaNPKFile::create()
{
	return new LuaNPKFile();
}

void LuaNPKFile::destroy(LuaNPKFile* instance)
{
	delete instance;
}

LuaNPKFile::LuaNPKFile()
{
	m_pNPKFile = NPK::createNPKFile();
}

LuaNPKFile::~LuaNPKFile()
{
	closeNPKFile(m_pNPKFile);
	m_pNPKFile = nullptr;
}

bool LuaNPKFile::openPakFile(const char* szPackFileName)
{
	std::wstring strFullName = convertUtf8StringToWide(szPackFileName);

	return m_pNPKFile && m_pNPKFile->openPakFile(strFullName.c_str());
}

bool LuaNPKFile::closePakFile(void)
{
	return m_pNPKFile && m_pNPKFile->closePakFile();
}

int32_t LuaNPKFile::getFileCounts(void) const
{
	return m_pNPKFile ? m_pNPKFile->getFileCounts() : 0;
}

LuaNPKFileItemBaseInfo LuaNPKFile::getFileNode(int32_t index) const
{
	LuaNPKFileItemBaseInfo baseInfo;
	m_pNPKFile->getFileItemBaseInfo(index, &baseInfo);
	return baseInfo;
}

LuaNPKFileList* LuaNPKFile::generateFullInfoList()
{
	LuaNPKFileList* fileList = new LuaNPKFileList(); 
	fileList->m_pFileList = m_pNPKFile->generateFullInfoList();
	return fileList;
}

LuaNPKFileStream* LuaNPKFile::openFileStream(const char* szFileName)
{
	if(m_pNPKFile)
	{
		LuaNPKFileStream* fileStream = new LuaNPKFileStream();
		fileStream->m_pFileStream = m_pNPKFile->openFileStream(szFileName);
		if (fileStream->m_pFileStream)
		{
			return fileStream;
		}
		delete fileStream;
	}
	return nullptr;
}

void LuaNPKFile::closeFileStream(LuaNPKFileStream* fileStream)
{
	if (m_pNPKFile && fileStream)
	{
		m_pNPKFile->closeFileStream(fileStream->m_pFileStream);
		fileStream->m_pFileStream = nullptr;
	}
	delete fileStream;
}

////////////////////////////////////////////////////////////////////////////////////
const char* LuaNPKFileStream::name(void) const
{
	return m_pFileStream ? m_pFileStream->name() : nullptr;
}

uint32_t LuaNPKFileStream::size(void) const
{
	return m_pFileStream ? m_pFileStream->size() : 0;
}

uint32_t LuaNPKFileStream::read(void* buffer, uint32_t size)
{
	return m_pFileStream ? m_pFileStream->read(buffer, size) : 0;
}

bool LuaNPKFileStream::seek(uint32_t offset)
{
	return m_pFileStream ? m_pFileStream->seek(offset) : false;
}

uint32_t LuaNPKFileStream::tell(void) const
{
	return m_pFileStream ? m_pFileStream->tell() : 0;
}

uint32_t LuaNPKFileStream::crc32(void)
{
	return m_pFileStream ? m_pFileStream->crc32() : 0;
}

bool LuaNPKFileStream::isEOF(void) const
{
	return m_pFileStream ? m_pFileStream->isEOF() : true;
}

bool LuaNPKFileStream::writeToDiskFile(const char* wszFileName)
{
	std::wstring wstrLocalDiskFile = convertUtf8StringToWide(wszFileName);
	return m_pFileStream ? m_pFileStream->writeToDiskFile(wstrLocalDiskFile.c_str()) : false;
}

/// /////////////////////////////////////////////////////////////////////////////////
LuaNPKFileList* LuaNPKFileList::createEmpty()
{
	LuaNPKFileList* pNewLuaFileList = new LuaNPKFileList();
	pNewLuaFileList->m_pFileList = NPK::createEmptyFileList();
	return pNewLuaFileList;
}

void LuaNPKFileList::destroy(LuaNPKFileList* instance)
{
	NPK::destoryFileList(instance->m_pFileList);
	delete instance;
}

bool LuaNPKFileList::loadListFromFile(const char* wszListFile/*utf8*/, const char* prefix, uint32_t flags, bool bEnableDuplicate)
{
	bool bNpkBase = (flags >> 4) & 1;
	bool bNpkName = (flags >> 3) & 1;
	bool bFileOffset = (flags >> 2) & 1;
	bool bFileSize = (flags >> 1) & 1;
	bool bFileCRC = flags & 1;

	if (m_pFileList)
	{
		std::wstring wstrListFile = convertUtf8StringToWide(wszListFile);
		return m_pFileList->loadListFromFile(wstrListFile.c_str(), prefix,
			bNpkBase, bNpkName, bFileOffset, bFileSize, bFileCRC, 
			bEnableDuplicate);
	}
	return false;
}

bool LuaNPKFileList::dumpToLocalFile(const char* wszListFile/*utf8*/, uint32_t flags)
{
	bool bNpkBase = (flags >> 4) & 1;
	bool bNpkName = (flags >> 3) & 1;
	bool bFileOffset = (flags >> 2) & 1;
	bool bFileSize = (flags >> 1) & 1;
	bool bFileCRC = flags & 1;
	if (m_pFileList)
	{
		std::wstring wstrListFile = convertUtf8StringToWide(wszListFile);
		return m_pFileList->dumpToLocalFile(wstrListFile.c_str(), 
			bNpkBase, bNpkName, bFileOffset, bFileSize, bFileCRC
		);
	}
	return false;
}

bool LuaNPKFileList::mergeOtherListInto(const LuaNPKFileList* sourceFileList, bool bEnableDuplicate)
{
	if (m_pFileList)
	{
		return m_pFileList->mergeOtherListInto(sourceFileList->m_pFileList, bEnableDuplicate);
	}
	return false;
}

bool LuaNPKFileList::applyToLocalNPKFiles(const char* wszNPKBase/*utf8*/)
{
	if (m_pFileList)
	{
		std::wstring strNPKBase = convertUtf8StringToWide(wszNPKBase);
		return m_pFileList->applyToLocalNPKFiles(strNPKBase.c_str());
	}
	return false;
}

int32_t LuaNPKFileList::getFileCounts(void) const
{
	return m_pFileList ? m_pFileList->getFileCounts() : 0;
}


LuaNPKFileItemFullInfo LuaNPKFileList::getFileItemFromIndex(int32_t index) const
{
	LuaNPKFileItemFullInfo fullInfo;
	if (m_pFileList)
	{
		m_pFileList->getFileItem(index, &fullInfo);
	}
	return fullInfo;
}

LuaNPKFileItemFullInfo LuaNPKFileList::getFileItemFromName(const char* szKeyName) const
{
	LuaNPKFileItemFullInfo fullInfo;
	if (m_pFileList)
	{
		m_pFileList->getFileItem(szKeyName, &fullInfo);
	}
	return fullInfo;
}