From 7facc33a7e27fda3de587ba539ae3623da75e738 Mon Sep 17 00:00:00 2001 From: MihailRis Date: Wed, 26 Feb 2025 00:22:57 +0300 Subject: [PATCH] cleanup --- src/io/devices/ZipFileDevice.cpp | 147 +++++++++++++++---------------- src/io/memory_ostream.hpp | 2 +- 2 files changed, 74 insertions(+), 75 deletions(-) diff --git a/src/io/devices/ZipFileDevice.cpp b/src/io/devices/ZipFileDevice.cpp index 8fd2e977..15b8809c 100644 --- a/src/io/devices/ZipFileDevice.cpp +++ b/src/io/devices/ZipFileDevice.cpp @@ -81,19 +81,19 @@ ZipFileDevice::Entry ZipFileDevice::readEntry() { read_int(file, entry.crc32); read_int(file, entry.compressedSize); read_int(file, entry.uncompressedSize); - auto fileNameLength = read_int(file); - auto extraFieldLength = read_int(file); - auto fileCommentLength = read_int(file); + auto filename_len = read_int(file); + auto extra_field_len = read_int(file); + auto file_comment_len = read_int(file); read_int(file, entry.diskNumberStart); read_int(file, entry.internalAttributes); read_int(file, entry.externalAttributes); read_int(file, entry.localHeaderOffset); - entry.fileName.resize(fileNameLength, '\0'); - file->read(entry.fileName.data(), fileNameLength); + entry.fileName.resize(filename_len, '\0'); + file->read(entry.fileName.data(), filename_len); // Skip extra field and file comment - file->seekg(extraFieldLength + fileCommentLength, std::ios::cur); + file->seekg(extra_field_len + file_comment_len, std::ios::cur); if (entry.diskNumberStart == 0xFF) { throw std::runtime_error("zip64 is not supported"); @@ -124,11 +124,11 @@ void ZipFileDevice::findBlob(Entry& entry) { read_int(file); // crc32 read_int(file); // compressed size read_int(file); // uncompressed size - auto nameLength = read_int(file); - auto extraFieldLength = read_int(file); + auto name_len = read_int(file); + auto extra_field_len = read_int(file); // Skip extra field and file comment - file->seekg(nameLength + extraFieldLength, std::ios::cur); + file->seekg(name_len + extra_field_len, std::ios::cur); entry.blobOffset = file->tellg(); } @@ -138,10 +138,10 @@ ZipFileDevice::ZipFileDevice( : file(std::move(filePtr)), separateFunc(std::move(separateFunc)) { // Searching for EOCD file->seekg(0, std::ios::end); - std::streampos fileSize = file->tellg(); + std::streampos file_size = file->tellg(); bool foundEOCD = false; - for (int pos = static_cast(fileSize)-4; pos >= 0; --pos) { + for (int pos = static_cast(file_size)-4; pos >= 0; --pos) { file->seekg(pos); if (read_int(file) == EOCD_SIGNATURE) { foundEOCD = true; @@ -156,14 +156,14 @@ ZipFileDevice::ZipFileDevice( read_int(file); // diskNumber read_int(file); // centralDirDisk read_int(file); // numEntriesThisDisk - auto totalEntries = read_int(file); + auto total_entries = read_int(file); read_int(file); // centralDirSize - auto centralDirOffset = read_int(file); + auto central_dir_offset = read_int(file); read_int(file); // commentLength - file->seekg(centralDirOffset); + file->seekg(central_dir_offset); - for (uint16_t i = 0; i < totalEntries; i++) { + for (uint16_t i = 0; i < total_entries; i++) { if (read_int(file) != CENTRAL_DIR_SIGNATURE) { logger.error() << "invalid central directory entry"; break; @@ -198,22 +198,22 @@ std::unique_ptr ZipFileDevice::read(std::string_view path) { if (entry.blobOffset == 0) { findBlob(entry); } - std::unique_ptr srcStream; + std::unique_ptr src_stream; if (separateFunc) { // Create new istream for concurrent data reading - srcStream = separateFunc(); - srcStream->seekg(entry.blobOffset); + src_stream = separateFunc(); + src_stream->seekg(entry.blobOffset); } else { // Read compressed data to memory if istream cannot be separated file->seekg(entry.blobOffset); util::Buffer buffer(entry.compressedSize); file->read(buffer.data(), buffer.size()); - srcStream = std::make_unique(std::move(buffer)); + src_stream = std::make_unique(std::move(buffer)); } if (entry.compressionMethod == COMPRESSION_NONE) { - return srcStream; + return src_stream; } else if (entry.compressionMethod == COMPRESSION_DEFLATE) { - return std::make_unique(std::move(srcStream)); + return std::make_unique(std::move(src_stream)); } else { throw std::runtime_error( "unsupported compression method [" + @@ -301,17 +301,17 @@ std::unique_ptr ZipFileDevice::list(std::string_view path) { } } else { auto folder = std::string(path) + "/"; - size_t folderLen = folder.length(); + size_t folder_len = folder.length(); for (const auto& [name, entry] : entries) { if (name.find(folder) != 0) { continue; } - size_t pos = name.find('/', folderLen); + size_t pos = name.find('/', folder_len); if (pos == std::string::npos) { - names.push_back(name.substr(folderLen, pos - folderLen)); + names.push_back(name.substr(folder_len, pos - folder_len)); } if (pos == name.length() - 1) { - names.push_back(name.substr(folderLen, pos - folderLen)); + names.push_back(name.substr(folder_len, pos - folder_len)); } } } @@ -324,60 +324,59 @@ std::unique_ptr ZipFileDevice::list(std::string_view path) { static void write_headers( std::ostream& file, const std::string& name, - size_t srcSize, - size_t compressedSize, + size_t source_Size, + size_t compressed_size, uint32_t crc, - int compressionMethod, - const file_time_type& modificationTime, - ByteBuilder& centralDir + int compression_method, + const file_time_type& last_write_time, + ByteBuilder& central_dir ) { - auto timestamp = to_ms_dos_timestamp(modificationTime); + auto timestamp = to_ms_dos_timestamp(last_write_time); ByteBuilder header; header.putInt32(LOCAL_FILE_SIGNATURE); header.putInt16(10); // version header.putInt16(0); // flags - header.putInt16(compressionMethod); // compression method + header.putInt16(compression_method); // compression method header.putInt32(timestamp); // last modification datetime header.putInt32(crc); // crc32 - header.putInt32(compressedSize); - header.putInt32(srcSize); + header.putInt32(compressed_size); + header.putInt32(source_Size); header.putInt16(name.length()); header.putInt16(0); // extra field length header.put(reinterpret_cast(name.data()), name.length()); - size_t localHeaderOffset = file.tellp(); + size_t local_header_offset = file.tellp(); file.write(reinterpret_cast(header.data()), header.size()); - centralDir.putInt32(CENTRAL_DIR_SIGNATURE); - centralDir.putInt16(10); // version - centralDir.putInt16(0); // version - centralDir.putInt16(0); // flags - centralDir.putInt16(compressionMethod); // compression method - centralDir.putInt32(timestamp); // last modification datetime - centralDir.putInt32(crc); // crc32 - centralDir.putInt32(compressedSize); - centralDir.putInt32(srcSize); - centralDir.putInt16(name.length()); - centralDir.putInt16(0); // extra field length - centralDir.putInt16(0); // file comment length - centralDir.putInt16(0); // disk number start - centralDir.putInt16(0); // internal attributes - centralDir.putInt32(0); // external attributes - centralDir.putInt32(localHeaderOffset); // local header offset - centralDir.put(reinterpret_cast(name.data()), name.length()); + central_dir.putInt32(CENTRAL_DIR_SIGNATURE); + central_dir.putInt16(10); // version + central_dir.putInt16(0); // version + central_dir.putInt16(0); // flags + central_dir.putInt16(compression_method); // compression method + central_dir.putInt32(timestamp); // last modification datetime + central_dir.putInt32(crc); // crc32 + central_dir.putInt32(compressed_size); + central_dir.putInt32(source_Size); + central_dir.putInt16(name.length()); + central_dir.putInt16(0); // extra field length + central_dir.putInt16(0); // file comment length + central_dir.putInt16(0); // disk number start + central_dir.putInt16(0); // internal attributes + central_dir.putInt32(0); // external attributes + central_dir.putInt32(local_header_offset); // local header offset + central_dir.put(reinterpret_cast(name.data()), name.length()); } static size_t write_zip( const std::string& root, const path& folder, std::ostream& file, - ByteBuilder& centralDir + ByteBuilder& central_dir ) { size_t entries = 0; - ByteBuilder localHeader; for (const auto& entry : io::directory_iterator(folder)) { auto name = entry.pathPart().substr(root.length() + 1); - auto modificationTime = io::last_write_time(entry); + auto last_write_time = io::last_write_time(entry); if (io::is_directory(entry)) { name = name + "/"; write_headers( @@ -387,35 +386,35 @@ static size_t write_zip( 0, 0, COMPRESSION_NONE, - modificationTime, - centralDir + last_write_time, + central_dir ); - entries += write_zip(root, entry, file, centralDir) + 1; + entries += write_zip(root, entry, file, central_dir) + 1; } else { auto uncompressed = io::read_bytes_buffer(entry); uint32_t crc = crc32(0, uncompressed.data(), uncompressed.size()); - memory_ostream memoryStream; + memory_ostream memory_stream; { - deflate_ostream deflateStream(memoryStream); - deflateStream.write( + deflate_ostream deflate_stream(memory_stream); + deflate_stream.write( reinterpret_cast(uncompressed.data()), uncompressed.size() ); - deflateStream.flush(); + deflate_stream.flush(); } - auto data = memoryStream.release(); - size_t dataSize = data.size(); + auto data = memory_stream.release(); + size_t data_size = data.size(); write_headers( file, name, uncompressed.size(), - dataSize, + data_size, crc, COMPRESSION_DEFLATE, - modificationTime, - centralDir + last_write_time, + central_dir ); - file.write(reinterpret_cast(data.data()), dataSize); + file.write(reinterpret_cast(data.data()), data_size); entries++; } } @@ -423,12 +422,12 @@ static size_t write_zip( } void io::write_zip(const path& folder, const path& file) { - ByteBuilder centralDir; + ByteBuilder central_dir; auto out = io::write(file); - size_t entries = write_zip(folder.pathPart(), folder, *out, centralDir); + size_t entries = write_zip(folder.pathPart(), folder, *out, central_dir); - size_t centralDirOffset = out->tellp(); - out->write(reinterpret_cast(centralDir.data()), centralDir.size()); + size_t central_dir_offset = out->tellp(); + out->write(reinterpret_cast(central_dir.data()), central_dir.size()); ByteBuilder eocd; eocd.putInt32(EOCD_SIGNATURE); @@ -436,8 +435,8 @@ void io::write_zip(const path& folder, const path& file) { eocd.putInt16(0); // central dir disk eocd.putInt16(entries); // num entries eocd.putInt16(entries); // total entries - eocd.putInt32(centralDir.size()); // central dir size - eocd.putInt32(centralDirOffset); // central dir offset + eocd.putInt32(central_dir.size()); // central dir size + eocd.putInt32(central_dir_offset); // central dir offset eocd.putInt16(0); // comment length out->write(reinterpret_cast(eocd.data()), eocd.size()); } diff --git a/src/io/memory_ostream.hpp b/src/io/memory_ostream.hpp index 76ad8623..57034d72 100644 --- a/src/io/memory_ostream.hpp +++ b/src/io/memory_ostream.hpp @@ -23,7 +23,7 @@ public: } size_t size() const { - return pptr()-pbase(); + return pptr() - pbase(); } protected: int_type overflow(int_type c) override {