BOOL SApplication::_LoadXmlDocment( LPCTSTR pszXmlName ,LPCTSTR pszType ,pugi::xml_document & xmlDoc,IResProvider *pResProvider/* = NULL*/)
{
if(!pResProvider)
{
if(IsFileType(pszType))
{
pugi::xml_parse_result result= xmlDoc.load_file(pszXmlName,pugi::parse_default,pugi::encoding_utf8);
SASSERT_FMTW(result,L"parse xml error! xmlName=%s,desc=%s,offset=%d",pszXmlName,result.description(),result.offset);
return result;
}else
{
pResProvider = GetMatchResProvider(pszType,pszXmlName);
}
}
if(!pResProvider) return FALSE;
DWORD dwSize=pResProvider->GetRawBufferSize(pszType,pszXmlName);
if(dwSize==0) return FALSE;
CMyBuffer<char> strXml;
strXml.Allocate(dwSize);
pResProvider->GetRawBuffer(pszType,pszXmlName,strXml,dwSize);
pugi::xml_parse_result result= xmlDoc.load_buffer(strXml,strXml.size(),pugi::parse_default,pugi::encoding_utf8);
SASSERT_FMTW(result,L"parse xml error! xmlName=%s,desc=%s,offset=%d",pszXmlName,result.description(),result.offset);
return result;
}
HRESULT CThreadCombine::ProcessVirt()
{
NFile::NIO::COutFile outFile;
if (!outFile.Create(OutputPath, false))
{
HRESULT res = GetLastError();
ErrorPath1 = OutputPath;
return res;
}
CProgressSync &sync = ProgressDialog.Sync;
sync.SetProgress(TotalSize, 0);
CMyBuffer bufferObject;
if (!bufferObject.Allocate(kBufSize))
return E_OUTOFMEMORY;
Byte *buffer = (Byte *)(void *)bufferObject;
UInt64 pos = 0;
for (int i = 0; i < Names.Size(); i++)
{
NFile::NIO::CInFile inFile;
const UString nextName = InputDirPrefix + Names[i];
if (!inFile.Open(nextName))
{
HRESULT res = GetLastError();
ErrorPath1 = nextName;
return res;
}
sync.SetCurrentFileName(nextName);
for (;;)
{
UInt32 processedSize;
if (!inFile.Read(buffer, kBufSize, processedSize))
{
HRESULT res = GetLastError();
ErrorPath1 = nextName;
return res;
}
if (processedSize == 0)
break;
UInt32 needSize = processedSize;
if (!outFile.Write(buffer, needSize, processedSize))
{
HRESULT res = GetLastError();
ErrorPath1 = OutputPath;
return res;
}
if (needSize != processedSize)
throw g_Message_FileWriteError;
pos += processedSize;
RINOK(sync.SetPosAndCheckPaused(pos));
}
}
return S_OK;
}
HRESULT CThreadCombine::ProcessVirt()
{
NIO::COutFile outFile;
if (!outFile.Create(OutputPath, false))
{
HRESULT res = GetLastError();
AddErrorPath(OutputPath);
return res;
}
CProgressSync &sync = Sync;
sync.Set_NumBytesTotal(TotalSize);
CMyBuffer bufferObject;
if (!bufferObject.Allocate(kBufSize))
return E_OUTOFMEMORY;
Byte *buffer = (Byte *)(void *)bufferObject;
UInt64 pos = 0;
FOR_VECTOR (i, Names)
{
NIO::CInFile inFile;
const FString nextName = InputDirPrefix + Names[i];
if (!inFile.Open(nextName))
{
HRESULT res = GetLastError();
AddErrorPath(nextName);
return res;
}
sync.Set_FilePath(fs2us(nextName));
for (;;)
{
UInt32 processedSize;
if (!inFile.Read(buffer, kBufSize, processedSize))
{
HRESULT res = GetLastError();
AddErrorPath(nextName);
return res;
}
if (processedSize == 0)
break;
UInt32 needSize = processedSize;
if (!outFile.Write(buffer, needSize, processedSize))
{
HRESULT res = GetLastError();
AddErrorPath(OutputPath);
return res;
}
if (needSize != processedSize)
throw g_Message_FileWriteError;
pos += processedSize;
RINOK(sync.Set_NumBytesCur(pos));
}
}
BOOL SApplication::_LoadXmlDocment( LPCTSTR pszXmlName ,LPCTSTR pszType ,pugi::xml_document & xmlDoc)
{
DWORD dwSize=GetRawBufferSize(pszType,pszXmlName);
if(dwSize==0) return FALSE;
CMyBuffer<char> strXml;
strXml.Allocate(dwSize);
GetRawBuffer(pszType,pszXmlName,strXml,dwSize);
pugi::xml_parse_result result= xmlDoc.load_buffer(strXml,strXml.size(),pugi::parse_default,pugi::encoding_utf8);
SASSERT_FMTW(result,L"parse xml error! xmlName=%s,desc=%s,offset=%d",pszXmlName,result.description(),result.offset);
return result;
}
BOOL DuiResProviderFiles::Init( LPCTSTR pszPath )
{
CMyBuffer<char> xmlBuf;
CDuiStringT strPathIndex=pszPath;
strPathIndex+=_T("\\");
strPathIndex+=INDEX_XML;
FILE *f=_tfopen(strPathIndex,_T("rb"));
if(!f) return(FALSE);
int nLen=_filelength(_fileno(f));
if(nLen>100*1024)
{
fclose(f);
return FALSE;
}
xmlBuf.Allocate(nLen);
if(nLen!=fread(xmlBuf,1,nLen,f))
{
fclose(f);
return FALSE;
}
fclose(f);
pugi::xml_document xmlDoc;
CDuiStringT strFileName;
if(!xmlDoc.load_buffer(xmlBuf,xmlBuf.size(),pugi::parse_default,pugi::encoding_utf8)) return FALSE;
pugi::xml_node xmlNode=xmlDoc.child("resid");
while(xmlNode)
{
DuiResID id(DUI_CA2T(xmlNode.attribute("type").value(),CP_UTF8),xmlNode.attribute("id").as_int(0));
CDuiStringT strFile=DUI_CA2T(xmlNode.attribute("file").value(),CP_UTF8);
if(!m_strPath.IsEmpty()) strFile.Format(_T("%s\\%s"),(LPCTSTR)m_strPath,(LPCTSTR)strFile);
m_mapFiles[id]=strFile;
xmlNode=xmlNode.next_sibling("resid");
}
m_strPath=pszPath;
return TRUE;
}
HRESULT CThreadCrc::ProcessVirt()
{
Hash.Init();
CMyBuffer buf;
if (!buf.Allocate(kBufSize))
return E_OUTOFMEMORY;
CProgressSync &sync = ProgressDialog.Sync;
SetStatus(LangString(IDS_SCANNING));
Enumerator.Init();
FString path;
NFind::CFileInfo fi;
UInt64 numFiles = 0;
UInt64 numItems = 0, numItems_Prev = 0;
UInt64 totalSize = 0;
for (;;)
{
bool filled;
DWORD error = Enumerator.GetNextFile(fi, filled, path);
if (error != 0)
{
AddErrorMessage(error, path);
continue;
}
if (!filled)
break;
if (!fi.IsDir())
{
totalSize += fi.Size;
numFiles++;
}
numItems++;
bool needPrint = false;
// if (fi.IsDir())
{
if (numItems - numItems_Prev >= 100)
{
needPrint = true;
numItems_Prev = numItems;
}
}
/*
else if (numFiles - numFiles_Prev >= 200)
{
needPrint = true;
numFiles_Prev = numFiles;
}
*/
if (needPrint)
{
RINOK(sync.ScanProgress(numFiles, totalSize, path, fi.IsDir()));
}
}
RINOK(sync.ScanProgress(numFiles, totalSize, FString(), false));
// sync.SetNumFilesTotal(numFiles);
// sync.SetProgress(totalSize, 0);
// SetStatus(LangString(IDS_CHECKSUM_CALCULATING));
// sync.SetCurFilePath(L"");
SetStatus(L"");
Enumerator.Init();
FString tempPath;
FString firstFilePath;
bool isFirstFile = true;
UInt64 errorsFilesSize = 0;
for (;;)
{
bool filled;
DWORD error = Enumerator.GetNextFile(fi, filled, path);
if (error != 0)
{
AddErrorMessage(error, path);
continue;
}
if (!filled)
break;
error = 0;
Hash.InitForNewFile();
if (!fi.IsDir())
{
NIO::CInFile inFile;
tempPath = Enumerator.BasePrefix_for_Open;
tempPath += path;
if (!inFile.Open(tempPath))
{
error = GetNormalizedError();
AddErrorMessage(error, path);
continue;
}
if (isFirstFile)
{
firstFilePath = path;
isFirstFile = false;
}
sync.Set_FilePath(fs2us(path));
sync.Set_NumFilesCur(Hash.NumFiles);
UInt64 progress_Prev = 0;
for (;;)
{
UInt32 size;
if (!inFile.Read(buf, kBufSize, size))
{
error = GetNormalizedError();
AddErrorMessage(error, path);
UInt64 errorSize = 0;
if (inFile.GetLength(errorSize))
errorsFilesSize += errorSize;
break;
}
if (size == 0)
break;
Hash.Update(buf, size);
if (Hash.CurSize - progress_Prev >= ((UInt32)1 << 21))
{
RINOK(sync.Set_NumBytesCur(errorsFilesSize + Hash.FilesSize + Hash.CurSize));
progress_Prev = Hash.CurSize;
}
}
}
if (error == 0)
Hash.Final(fi.IsDir(), false, fs2us(path));
RINOK(sync.Set_NumBytesCur(errorsFilesSize + Hash.FilesSize));
}
RINOK(sync.Set_NumBytesCur(errorsFilesSize + Hash.FilesSize));
sync.Set_NumFilesCur(Hash.NumFiles);
if (Hash.NumFiles != 1)
sync.Set_FilePath(L"");
SetStatus(L"");
CProgressMessageBoxPair &pair = GetMessagePair(Hash.NumErrors != 0);
AddHashBundleRes(pair.Message, Hash, fs2us(firstFilePath));
LangString(IDS_CHECKSUM_INFORMATION, pair.Title);
return S_OK;
}
HRESULT CThreadSplit::ProcessVirt()
{
NFile::NIO::CInFile inFile;
if (!inFile.Open(FilePath))
return GetLastError();
NFile::NIO::COutFile outFile;
CMyBuffer bufferObject;
if (!bufferObject.Allocate(kBufSize))
return E_OUTOFMEMORY;
Byte *buffer = (Byte *)(void *)bufferObject;
UInt64 curVolSize = 0;
CVolSeqName seqName;
seqName.SetNumDigits(NumVolumes);
UInt64 length;
if (!inFile.GetLength(length))
return GetLastError();
CProgressSync &sync = ProgressDialog.Sync;
sync.SetProgress(length, 0);
UInt64 pos = 0;
UInt64 numFiles = 0;
int volIndex = 0;
for (;;)
{
UInt64 volSize;
if (volIndex < VolumeSizes.Size())
volSize = VolumeSizes[volIndex];
else
volSize = VolumeSizes.Back();
UInt32 needSize = (UInt32)(MyMin((UInt64)kBufSize, volSize - curVolSize));
UInt32 processedSize;
if (!inFile.Read(buffer, needSize, processedSize))
return GetLastError();
if (processedSize == 0)
break;
needSize = processedSize;
if (curVolSize == 0)
{
UString name = VolBasePath;
name += L'.';
name += seqName.GetNextName();
sync.SetCurrentFileName(name);
sync.SetNumFilesCur(numFiles++);
if (!outFile.Create(name, false))
{
HRESULT res = GetLastError();
ErrorPath1 = name;
return res;
}
}
if (!outFile.Write(buffer, needSize, processedSize))
return GetLastError();
if (needSize != processedSize)
throw g_Message_FileWriteError;
curVolSize += processedSize;
if (curVolSize == volSize)
{
outFile.Close();
if (volIndex < VolumeSizes.Size())
volIndex++;
curVolSize = 0;
}
pos += processedSize;
RINOK(sync.SetPosAndCheckPaused(pos));
}
sync.SetNumFilesCur(numFiles);
return S_OK;
}
HRESULT CThreadCrc::ProcessVirt()
{
DataSize = NumFolders = NumFiles = NumFilesScan = DataCrcSum = DataNameCrcSum = 0;
memset(Sha256Sum, 0, SHA256_DIGEST_SIZE);
// ProgressDialog.WaitCreating();
CMyBuffer bufferObject;
if (!bufferObject.Allocate(kBufSize))
return E_OUTOFMEMORY;
Byte *buffer = (Byte *)(void *)bufferObject;
UInt64 totalSize = 0;
Enumerator.Init();
UString scanningStr = LangString(IDS_SCANNING, 0x03020800);
scanningStr += L' ';
CProgressSync &sync = ProgressDialog.Sync;
for (;;)
{
NFind::CFileInfo fileInfo;
bool filled;
FString resPath;
HRESULT errorCode = Enumerator.GetNextFile(fileInfo, filled, resPath);
if (errorCode != 0)
{
SetErrorPath1(resPath);
return errorCode;
}
if (!filled)
break;
if (!fileInfo.IsDir())
{
totalSize += fileInfo.Size;
NumFilesScan++;
}
sync.SetCurrentFileName(scanningStr + fs2us(resPath));
sync.SetProgress(totalSize, 0);
RINOK(sync.SetPosAndCheckPaused(0));
}
sync.SetNumFilesTotal(NumFilesScan);
sync.SetProgress(totalSize, 0);
Enumerator.Init();
for (;;)
{
NFind::CFileInfo fileInfo;
bool filled;
FString resPath;
HRESULT errorCode = Enumerator.GetNextFile(fileInfo, filled, resPath);
if (errorCode != 0)
{
SetErrorPath1(resPath);
return errorCode;
}
if (!filled)
break;
UInt32 crc = CRC_INIT_VAL;
CSha256 sha256;
Sha256_Init(&sha256);
if (fileInfo.IsDir())
NumFolders++;
else
{
NIO::CInFile inFile;
if (!inFile.Open(Enumerator.BasePrefix + resPath))
{
errorCode = GetNormalizedError();
SetErrorPath1(resPath);
return errorCode;
}
sync.SetCurrentFileName(fs2us(resPath));
sync.SetNumFilesCur(NumFiles);
NumFiles++;
for (;;)
{
UInt32 processedSize;
if (!inFile.Read(buffer, kBufSize, processedSize))
{
errorCode = GetNormalizedError();
SetErrorPath1(resPath);
return errorCode;
}
if (processedSize == 0)
break;
crc = CrcUpdate(crc, buffer, processedSize);
if (NumFilesScan == 1)
Sha256_Update(&sha256, buffer, processedSize);
DataSize += processedSize;
RINOK(sync.SetPosAndCheckPaused(DataSize));
}
DataCrcSum += CRC_GET_DIGEST(crc);
if (NumFilesScan == 1)
Sha256_Final(&sha256, Sha256Sum);
}
for (int i = 0; i < resPath.Length(); i++)
{
wchar_t c = resPath[i];
crc = CRC_UPDATE_BYTE(crc, ((Byte)(c & 0xFF)));
crc = CRC_UPDATE_BYTE(crc, ((Byte)((c >> 8) & 0xFF)));
}
DataNameCrcSum += CRC_GET_DIGEST(crc);
RINOK(sync.SetPosAndCheckPaused(DataSize));
}
sync.SetNumFilesCur(NumFiles);
OkMessage = GetResultMessage();
OkMessageTitle = LangString(IDS_CHECKSUM_INFORMATION, 0x03020720);
return S_OK;
}
HRESULT CThreadSplit::ProcessVirt()
{
NIO::CInFile inFile;
if (!inFile.Open(FilePath))
return GetLastError();
CPreAllocOutFile outFile;
CMyBuffer buffer;
if (!buffer.Allocate(kBufSize))
return E_OUTOFMEMORY;
CVolSeqName seqName;
seqName.SetNumDigits(NumVolumes);
UInt64 length;
if (!inFile.GetLength(length))
return GetLastError();
CProgressSync &sync = Sync;
sync.Set_NumBytesTotal(length);
UInt64 pos = 0;
UInt64 prev = 0;
UInt64 numFiles = 0;
unsigned volIndex = 0;
for (;;)
{
UInt64 volSize;
if (volIndex < VolumeSizes.Size())
volSize = VolumeSizes[volIndex];
else
volSize = VolumeSizes.Back();
UInt32 needSize = kBufSize;
{
const UInt64 rem = volSize - outFile.Written;
if (needSize > rem)
needSize = (UInt32)rem;
}
UInt32 processedSize;
if (!inFile.Read(buffer, needSize, processedSize))
return GetLastError();
if (processedSize == 0)
return S_OK;
needSize = processedSize;
if (outFile.Written == 0)
{
FString name = VolBasePath;
name += '.';
name += us2fs(seqName.GetNextName());
sync.Set_FilePath(fs2us(name));
if (!outFile.File.Create(name, false))
{
HRESULT res = GetLastError();
AddErrorPath(name);
return res;
}
UInt64 expectSize = volSize;
if (pos < length)
{
const UInt64 rem = length - pos;
if (expectSize > rem)
expectSize = rem;
}
outFile.PreAlloc(expectSize);
}
if (!outFile.Write(buffer, needSize, processedSize))
return GetLastError();
if (needSize != processedSize)
throw g_Message_FileWriteError;
pos += processedSize;
if (outFile.Written == volSize)
{
outFile.Close();
sync.Set_NumFilesCur(++numFiles);
if (volIndex < VolumeSizes.Size())
volIndex++;
}
if (pos - prev >= ((UInt32)1 << 22) || outFile.Written == 0)
{
RINOK(sync.Set_NumBytesCur(pos));
prev = pos;
}
}
}
void Process2()
{
// NCOM::CComInitializer comInitializer;
ProgressDialog->WaitCreating();
CVolSeqName volSeqName;
if (!volSeqName.ParseName(FirstVolumeName))
throw L"Can not detect file as splitted file";
UString nextName = InputDirPrefix + FirstVolumeName;
UInt64 totalSize = 0;
for (;;)
{
NFile::NFind::CFileInfoW fileInfo;
if (!NFile::NFind::FindFile(nextName, fileInfo))
break;
if (fileInfo.IsDirectory())
break;
totalSize += fileInfo.Size;
nextName = InputDirPrefix + volSeqName.GetNextName();
}
if (totalSize == 0)
throw L"no data";
ProgressDialog->ProgressSynch.SetProgress(totalSize, 0);
if (!volSeqName.ParseName(FirstVolumeName))
throw L"Can not detect file as splitted file";
UString outName = volSeqName.UnchangedPart;
while(!outName.IsEmpty())
{
int lastIndex = outName.Length() - 1;
if (outName[lastIndex] != L'.')
break;
outName.Delete(lastIndex);
}
if (outName.IsEmpty())
outName = L"file";
NFile::NIO::COutFile outFile;
if (!outFile.Create(OutputDirPrefix + outName, false))
throw L"Can create open output file";
NFile::NIO::CInFile inFile;
CMyBuffer bufferObject;
if (!bufferObject.Allocate(kBufSize))
throw L"Can not allocate buffer";
Byte *buffer = (Byte *)(void *)bufferObject;
UInt64 pos = 0;
nextName = InputDirPrefix + FirstVolumeName;
bool needOpen = true;
for (;;)
{
if (needOpen)
{
NFile::NFind::CFileInfoW fileInfo;
if (!NFile::NFind::FindFile(nextName, fileInfo))
break;
if (fileInfo.IsDirectory())
break;
if (!inFile.Open(nextName))
throw L"Can not open file";
ProgressDialog->ProgressSynch.SetCurrentFileName(fileInfo.Name);
nextName = InputDirPrefix + volSeqName.GetNextName();
needOpen = false;
}
UInt32 processedSize;
if (!inFile.Read(buffer, kBufSize, processedSize))
throw L"Can not read input file";
if (processedSize == 0)
{
needOpen = true;
continue;
}
UInt32 needSize = processedSize;
if (!outFile.Write(buffer, needSize, processedSize))
throw L"Can not write output file";
if (needSize != processedSize)
throw L"Can not write output file";
pos += processedSize;
HRESULT res = ProgressDialog->ProgressSynch.SetPosAndCheckPaused(pos);
if (res != S_OK)
return;
}
}
void Process2()
{
// NCOM::CComInitializer comInitializer;
ProgressDialog->WaitCreating();
NFile::NIO::CInFile inFile;
if (!inFile.Open(FilePath))
throw L"Can not open file";
NFile::NIO::COutFile outFile;
CMyBuffer bufferObject;
if (!bufferObject.Allocate(kBufSize))
throw L"Can not allocate buffer";
Byte *buffer = (Byte *)(void *)bufferObject;
UInt64 curVolSize = 0;
CVolSeqName seqName;
UInt64 length;
if (!inFile.GetLength(length))
throw "error";
ProgressDialog->ProgressSynch.SetProgress(length, 0);
UInt64 pos = 0;
int volIndex = 0;
for (;;)
{
UInt64 volSize;
if (volIndex < VolumeSizes.Size())
volSize = VolumeSizes[volIndex];
else
volSize = VolumeSizes.Back();
UInt32 needSize = (UInt32)(MyMin((UInt64)kBufSize, volSize - curVolSize));
UInt32 processedSize;
if (!inFile.Read(buffer, needSize, processedSize))
throw L"Can not read input file";
if (processedSize == 0)
break;
needSize = processedSize;
if (curVolSize == 0)
{
UString name = VolBasePath;
name += L".";
name += seqName.GetNextName();
if (!outFile.Create(name, false))
throw L"Can not create output file";
ProgressDialog->ProgressSynch.SetCurrentFileName(name);
}
if (!outFile.Write(buffer, needSize, processedSize))
throw L"Can not write output file";
if (needSize != processedSize)
throw L"Can not write output file";
curVolSize += processedSize;
if (curVolSize == volSize)
{
outFile.Close();
if (volIndex < VolumeSizes.Size())
volIndex++;
curVolSize = 0;
}
pos += processedSize;
HRESULT res = ProgressDialog->ProgressSynch.SetPosAndCheckPaused(pos);
if (res != S_OK)
return;
}
}
