yanczi/VoidArchive
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Podmiana makr na globalne zmienne statyczne. Create cargo zmodyfikowane

Browse source
This commit is contained in:
yanczi 2025-12-21 11:49:30 +01:00
parent 022bc0d069
commit 608e382095
6 changed files with 63 additions and 72 deletions
Download patch file Download diff file Expand all files Collapse all files

74
CreateCargo.cpp
View file

@ -20,8 +20,8 @@
#include "CreateCargo.h"
CreateCargo::CreateCargo()
: signature(SIGNATURE)
, extension(EXTENSION)
: signature(fl::sigpak)
, extension(fl::extpak)
, version(VERSION)
, methodFlags(0)
, xxhState(XXH64_createState())
@ -42,7 +42,7 @@ CreateCargo::~CreateCargo() {
//-----------------------------------------------------------------------------
bool CreateCargo::Create(const std::string& path, const uint8_t& flag)
{
cargoFile = path + "." + extension;
cargoFile = path + "." + signature;
catalogPath = path;
methodFlags = flag;
@ -90,7 +90,7 @@ bool CreateCargo::Create(const std::string& path, const uint8_t& flag)
}
// Zapisywanie klucza szyfrującego
if (flag == FILE_FLAG_ENCRYPT || flag == FILE_FLAG_ZIPENC || encList.size() > 0)
if (flag == flag::enc || flag == flag::ezd || encList.size() > 0)
{
eman.saveKey(catalogPath, hppKey);
}
@ -185,42 +185,13 @@ CargoHead CreateCargo::CreateCargoHead(const uint32_t& filesLen, const uint64_t&
{
CargoHead ch;
ch.signature = signature;
ch.signature = fl::sigpak;
ch.table = table;
ch.files = filesLen;
return ch;
}
//-----------------------------------------------------------------------------
// Sprawdza czy plik znajduje siê na liœcie
//-----------------------------------------------------------------------------
void CreateCargo::computingBytes(const uint8_t& flag, std::vector<char>& input, std::vector<char>& output)
{
//Flaga aktywna sprawdza czy plik jest na liœcie. Jeœli jest to zwraca surowedane
//Przeciwnie kompresuje dane
ChunkManager cm(eman);
switch (flag)
{
case FILE_FLAG_COMPRESS:
output = cm.chunked(input, true, false);
break;
case FILE_FLAG_ENCRYPT:
output = cm.chunked(input, false, true);
break;
case FILE_FLAG_ZIPENC:
output = cm.chunked(input, true, true);
break;
default:
output = std::move(input);
break;
}
}
//-----------------------------------------------------------------------------
// Przygotowanie nagłówków i plików
//-----------------------------------------------------------------------------
@ -249,26 +220,26 @@ std::vector<FilesTable> CreateCargo::ComputingHeadFiles()
size_t size = f.tellg();
f.seekg(0, std::ios::beg);
if (size > MAX_FILE_SIZE)
if (size > ds::maxFileSize)
{
std::cerr << path << " is too large. It exceeds " << MAX_FILE_SIZE / 1024 / 1024 / 1024 << "GB!" << std::endl;
std::cerr << path << " is too large. It exceeds " << ds::maxFileSize / 1024 / 1024 / 1024 << "GB!" << std::endl;
}
else
{
XXH64_reset(xxhState, 0);
//Wczytanie pliku do pamięci
std::vector<char> buffer(CHUNK_STREAM_256MB);
std::vector<char> buffer(ds::chunk_stream);
uint64_t sizeFile = 0;
const uint32_t chunkBlockSize = CHUNK_BLOCK_SIZE;
const uint32_t chunkBlockSize = ds::block_size;
const uint32_t quantity = (size + chunkBlockSize) / chunkBlockSize;
const uint32_t lastChunkSize = size - (chunkBlockSize * (quantity - 1));
// Jeśli jest ustawiona flaga inna niż RAW
// Dodaj do kontenera konfigurację chunków
if (file.parameter != FILE_FLAG_RAW)
if (file.parameter != flag::raw)
{
std::cout << "CHUNK PARAM" << std::endl;
cargo.write(reinterpret_cast<const char*>(&quantity), sizeof(quantity));
@ -278,7 +249,7 @@ std::vector<FilesTable> CreateCargo::ComputingHeadFiles()
}
// Strumieniowanie danych
while (f.read(buffer.data(), CHUNK_STREAM_256MB) || f.gcount() > 0)
while (f.read(buffer.data(), ds::chunk_stream) || f.gcount() > 0)
{
const int bufferSize = f.gcount();
buffer.resize(bufferSize);
@ -286,7 +257,7 @@ std::vector<FilesTable> CreateCargo::ComputingHeadFiles()
// Aktualizacja XXH64
XXH64_update(xxhState, buffer.data(), buffer.size());
if (file.parameter == FILE_FLAG_RAW)
if (file.parameter == flag::raw)
{
// Zapisywanie strumienia do kontenera
cargo.write(reinterpret_cast<const char*>(buffer.data()), buffer.size());
@ -308,16 +279,16 @@ std::vector<FilesTable> CreateCargo::ComputingHeadFiles()
std::vector<char> outChunk;
// Przetwórz chunki i przetwórz
if ((file.parameter & FILE_FLAG_COMPRESS) == FILE_FLAG_COMPRESS)
if ((file.parameter & flag::zip) == flag::zip)
{
// Zaszyfruj i skompresuj lub tylko skompresuj
outChunk = (file.parameter & FILE_FLAG_ENCRYPT) == FILE_FLAG_ENCRYPT ?
outChunk = (file.parameter & flag::enc) == flag::enc ?
eman.encrypt(cman.compress(chunk)) : cman.compress(chunk);
}
else
{
// Zaszyfruj lub skopiuj
outChunk = (file.parameter & FILE_FLAG_ENCRYPT) == FILE_FLAG_ENCRYPT ?
outChunk = (file.parameter & flag::enc) == flag::enc ?
eman.encrypt(cman.compress(chunk)) : cman.compress(chunk);
}
@ -373,24 +344,25 @@ void CreateCargo::GetFilters(const std::string& filterFile)
file.close();
// Lista plików do skompresowania
if (jslist.contains(KEY_ZIP))
if (jslist.contains(key::zip))
{
zipList = jslist[KEY_ZIP].get<std::vector<std::string>>();
zipList = jslist[key::zip].get<std::vector<std::string>>();
}
// Lista plików do zaszyfrowania
if (jslist.contains(KEY_ENCRYPT))
if (jslist.contains(key::enc))
{
encList = jslist[KEY_ENCRYPT].get<std::vector<std::string>>();
encList = jslist[key::enc].get<std::vector<std::string>>();
}
// Lista plików do pominięcia
if (jslist.contains(KEY_IGNORE))
if (jslist.contains(key::ignore))
{
ignoreList = jslist[KEY_IGNORE].get<std::vector<std::string>>();
ignoreList = jslist[key::ignore].get<std::vector<std::string>>();
}
hppKey = jslist.value("keyhpp", false);
// Flaga tworzenia klucza jako plik nag³ówka c++
hppKey = jslist.value(key::hpp, false);
}
//-----------------------------------------------------------------------------