Спринт 12. Бинарные файлы: читаем и пишем байты.

-----------------------------------------------------------------------
compressor.h
-----------------------------------------------------------------------
#pragma once

#include <fstream>
#include <iostream>
#include <string>

class CompressorRLE {
public:
    static const int max_block_size = 128;
    static const int min_repeats_for_special_block = 3;

    CompressorRLE(std::ostream& dst) : dst_(dst) {}

    void PutChar(char c) {

        if (block_size_ > 0 && c == last_char_) {
            ++repeat_count_;

            if (repeat_count_ >= max_block_size - 1) {
                FinalizeRepeats();
            }
            return;
        }

        FinalizeRepeats();
        AddCharToBlock(c);
    }

    void Finalize() {
        FinalizeRepeats();
        WriteBlock0(block, block_size_);
    }

    size_t GetCompressedSize() const {
        return compressed_size_;
    }

private:
    void FinalizeRepeats() {
        if (repeat_count_ == 0) {
            return;
        }

        if (repeat_count_ < min_repeats_for_special_block) {
            for (; repeat_count_ > 0; --repeat_count_) {
                AddCharToBlock(last_char_);
            }
            return;
        }

        WriteBlock0(block, block_size_ - 1);
        WriteBlock1(last_char_, repeat_count_ + 1);
        block_size_ = 0;
        repeat_count_ = 0;
    };

    void AddCharToBlock(char c) {
        block[block_size_++] = c;

        if (block_size_ >= max_block_size) {
            WriteBlock0(block, block_size_);
            block_size_ = 0;
        }

        last_char_ = c;
    }

    void WriteBlock0(char* data, int size) {
        if (size == 0) {
            return;
        }

        unsigned char zero = static_cast<unsigned char>(((size - 1) << 1) + 0);
        dst_.put(zero);
        dst_.write(data, size);

        compressed_size_ += 1 + static_cast<size_t>(size);
    }

    void WriteBlock1(char data, int size) {
        if (size == 0) {
            return;
        }

        unsigned char zero = static_cast<unsigned char>(((size - 1) << 1) + 1);
        dst_.put(zero);
        dst_.put(data);

        compressed_size_ += 2;
    }

private:
    std::ostream& dst_;

    size_t compressed_size_ = 0;

    int block_size_ = 0;
    int repeat_count_ = 0;
    char last_char_;

    char block[max_block_size];
};

struct EncodingResult {
    bool opened;
    size_t src_size;
    size_t dst_size;
};

inline EncodingResult EncodeRLE(std::string src_name, std::string dst_name) {
    using namespace std;

    ifstream in(src_name, ios::binary);
    if (!in) {
        return {false, 0, 0};
    }

    ofstream out(dst_name, ios::binary);

    CompressorRLE compressor(out);
    size_t source_size = 0;

    do {
        char buff[1024];
        in.read(buff, sizeof buff);
        size_t read = in.gcount();
        source_size += read;

        for (size_t i = 0; i < read; ++i) {
            compressor.PutChar(buff[i]);
        }
    } while (in);

    compressor.Finalize();

    return {true, source_size, compressor.GetCompressedSize()};
}
-----------------------------------------------------------------------
decompressor.h
-----------------------------------------------------------------------
#pragma once

#include <fstream>
#include <iostream>
#include <string>

static const int BUFF_SIZE = 1024;
static const int MAX_BLOCK_SIZE = 128;

enum BlockType : int {
    Empty,
    Compression,
    NoCompression,
};

class DeCompressorRLE {
public:

    DeCompressorRLE(std::ostream& dst) : dst_(dst) {}

    BlockType get_block_type() {
        return block_type_;
    }

    void read_header(u_char header) {
        bool block_type = header & 1;
        data_size_ = (header >> 1) + 1 ;

        if (block_type) {
            block_type_= Compression;
        } else {
            block_type_ = NoCompression;
        }
    }

    void write(bool primary = 0) {
        write_data_ += data_size_;

        if (primary || BUFF_SIZE - MAX_BLOCK_SIZE <= write_data_) {
            dst_.write(block, write_data_);
            write_data_ = 0;
        }

        add_data_size_ = 0;
        data_size_ = 0;
        block_type_ = Empty;
    }

    void read_data(char data) {
        if (block_type_== Compression) {

            for (size_t i = 0; i < data_size_; ++i) {
                block[i + write_data_] = data;
            }
            write();

        } else if (block_type_ == NoCompression) {

            if (data_size_ > add_data_size_) {
                block[write_data_+add_data_size_++] = data;
            } else {
                write();
                read_header(data);
            }
        }
    }

private:
    std::ostream& dst_;
    char block[BUFF_SIZE] = {' '};

    int data_size_ = 0;
    int add_data_size_ = 0;
    int write_data_ = 0;

    BlockType block_type_ = Empty;
};

inline bool DecodeRLE(const std::string& src_name, const std::string& dst_name) {
    using namespace std;

    ifstream input(src_name, ios::in | ios::binary);

    if (!input) {
        return false;
    }

    ofstream output(dst_name, ios::out | ios::binary);

    DeCompressorRLE de_compressor_rle(output);

    do {
        char buff[BUFF_SIZE];
        input.read(buff, sizeof buff);
        size_t read = input.gcount();

        for (size_t i = 0; i < read; ++i) {

            if (de_compressor_rle.get_block_type() != Empty) {
                de_compressor_rle.read_data(buff[i]);
            } else {
                de_compressor_rle.read_header(buff[i]);
            }
        }

    } while (input);

    de_compressor_rle.write(true);
    return true;
}
-----------------------------------------------------------------------
main.cpp
-----------------------------------------------------------------------
#include "compressor.h"
#include "decompressor.h"

#include <cassert>
#include <fstream>
#include <string>
#include <string_view>

using namespace std;

string GetFileContents(string file) {
    ifstream stream(file, ios::binary);

    stream.seekg(0, ios::end);
    size_t sz = stream.tellg();

    stream.seekg(0, ios::beg);
    string res(sz, '\0');

    if (stream.read(res.data(), sz)) {
        return res;
    }

    return {};
}

void Test() {
    ofstream("test.txt") << "abcdaaaaaabbbcdedecdec"sv << string(1000, 'x')
                         << "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\xa0"
                            "decdecdecasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdassdasdassdas"
                            "dcdecasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdassdasdassdasdcde"
                            "casdasdasdasdasdasdasdasdasdasdasdasdasdasdasdassdasdassdasdcdecasd"
                            "asdasdasdasdasdasdasdasdasdasdasdasdasdasdassdasdassdasddeccccccccc"
                            "cccc"sv;
    EncodeRLE("test.txt"s, "test.rle"s);
    DecodeRLE("test.rle"s, "test2.txt"s);

    assert(GetFileContents("test.rle"s).size() < GetFileContents("test.txt"s).size() / 2);
    assert(GetFileContents("test.txt"s) == GetFileContents("test2.txt"s));
}

int main(int argc, const char** argv) {
    if (argc == 1) {
        Test();
        return 0;
    }

    if (argc != 4 || (argv[1] != "x"sv && argv[1] != "c"sv)) {
        cout << "Usage: "sv << argv[0] << " c|x <in file> <out file>"sv << endl;
        return 1;
    }

    if (argv[1] == "c"sv) {
        auto result = EncodeRLE(argv[2], argv[3]);
        if (!result.opened) {
            cout << "Error opening file"sv << endl;
            return 2;
        }

        cout << "Compressed "sv << result.src_size << " bytes => "sv << result.dst_size << " bytes"sv << endl;
    } else {
        if (!DecodeRLE(argv[2], argv[3])) {
            cout << "Error decoding file"sv << endl;
            return 3;
        }

        cout << "Successfully decoded"sv << endl;
    }

    return 0;
}