BmnFileReaderXzLzma.h

Go to the documentation of this file.

#pragma once
#ifndef BmnFileReaderXzLzma_h
#define BmnFileReaderXzLzma_h
// headers from this target
#include "BmnIArchiveLibRead.h"
#include "BmnIFileReader.h"
#include "BmnReaderCacheManager.h"
 
// If one needs lzma_stream, just reinterpret_cast the variable from the struct below
struct LzmaContext;
 
/*
 * A class responsible for reading files compressed with XZ (LZMA2 algorithm). This algorithm allows
 * us to reach maximal compression ratios. Still, it comes with a cost - compression speeds are low,
 * while decompression speeds are decent, but still slow relative to many other libraries.
 * It's advisable to allocate this class on the heap as internally it uses big std::array
 * @warning Using this class directly can result in throws if the XZ-LZMA library is not found during compilation.
 *          Therefore, it's always advisable to obtain appropriate read objects through
 *          `BmnCompressionCreateNewSuitableReaderForAFile`
 */
class BmnFileReaderXzLzma
    : public BmnIFileReader
    , public BmnIArchiveLibRead
{
  public:
    /*
     * A standard constructor that sets a path to the input binary (XZ-LZMA) file
     * @note The constructor will not check whether the file actually exists
     * @param fileName A path (most likely relative) to the input binary (XZ-LZMA) file
     * @warning If using relative paths, be very careful about currently-working directory as it might
     *          be something unexpected based on the directory that initalized an application
     */
    explicit BmnFileReaderXzLzma(const std::string& fileName = "");
 
    /*
     * A standard constructor that sets a path to the input binary (XZ-LZMA) file
     * @note The constructor will not check whether the file actually exists
     * @param fileName A path (most likely relative) to the input binary (XZ-LZMA) file
     * @warning If using relative paths, be very careful about currently-working directory as it might
     *          be something unexpected based on the directory that initalized an application
     */
    explicit BmnFileReaderXzLzma(std::string&& fileName);
 
    /*
     * A standard constructor that sets a path to the input binary (XZ-LZMA) file
     * @note The constructor will not check whether the file actually exists
     * @param filePath A path to the input binary (XZ-LZMA) file
     * @warning If using relative paths, be very careful about currently-working directory as it might
     *          be something unexpected based on the directory that initalized an application
     */
    explicit BmnFileReaderXzLzma(const std::filesystem::path& filePath);
 
    /*
     * A standard constructor that sets a path to the input binary (XZ-LZMA) file
     * @note The constructor will not check whether the file actually exists
     * @param filePath A path to the input binary (XZ-LZMA) file
     * @warning If using relative paths, be very careful about currently-working directory as it might
     *          be something unexpected based on the directory that initalized an application
     */
    explicit BmnFileReaderXzLzma(std::filesystem::path&& filePath);
 
    // Closes the stream while destroying the instance
    virtual ~BmnFileReaderXzLzma() override;
    BmnFileReaderXzLzma(const BmnFileReaderXzLzma&) = delete;
    BmnFileReaderXzLzma& operator=(const BmnFileReaderXzLzma&) = delete;
    BmnFileReaderXzLzma(BmnFileReaderXzLzma&&) noexcept = delete;
    BmnFileReaderXzLzma& operator=(BmnFileReaderXzLzma&&) noexcept = delete;
 
    // ========== BmnIFileReaderInterface ==========
 
    /*
     * Opens a file for reading. The path of the file should be provided before calling this method
     * @param processingFlags A flag that tells us how to open the file for reading. This class only supports
     * `ReadBinary` flag
     */
    virtual void Open(
        const BmnBinaryFileProcessingOptions processingFlags = BmnBinaryFileProcessingOptions::ReadBinary) override;
 
    /*
     * Closes the stream and resets all internal data. After calling `Close`, it's safe to reopen using the same
     * instance of this class
     */
    virtual void Close() noexcept override;
 
    /*
     * Reads and decompresses the data while still managing caching for efficiency.
     * @param dataToFill A buffer that will be filled with uncompressed data
     * @param sizeToFill A number of bytes that will be filled in `dataToFill`
     * @return A number of bytes that were filled in `dataToFill`. This value should almost always be the same as
     *         `sizeToFill` except when the end of the stream is reached (only if the user asked for more data than
     * possible)
     */
    virtual int64_t Read(void* dataToFill, const int64_t sizeToFill) override;
 
    /*
     * A method that tells us what's the next byte to read
     * @return A position of the next byte that should be read
     */
    [[nodiscard]] virtual int64_t Tell() const noexcept override;
 
    /*
     * A method that allows us to go to another place in the file (uncompressed data) and read from that place.
     * This method is NOT EFFICIENT as it still needs to uncompress data to reach the needed place!
     * @param value A position in uncompressed data to which one wants to move before the next read
     */
    virtual void Seek(int64_t value) override;
 
    /*
     * Check whether the reading stream is good
     * @return 'true' if no decompression error has occurred and the input-file stream is good, or 'false' otherwise
     */
    [[nodiscard]] virtual bool IsGood() const noexcept override;
 
    /*
     * Check if we have reached the file. This will tell us if we have reached EOF in the uncompressed data, not
     * in the file itself. That is, the file might be at EOF, while this method returns will return true as cache
     * still has some data
     * @return 'true' if both file and internal cache are completely read, 'false' otherwise
     */
    [[nodiscard]] virtual bool IsEOF() const noexcept override;
 
    /*
     * A method that clears bad flags after an error has occurred. Just calling this error will most likely
     * not solve the problem, and you will get an error again in the next read. That is, before calling `Read`,
     * remove the previous error source
     */
    virtual void ClearStateFlags() override;
 
    /*
     * @return 'true' if the input stream is open, or 'false' if not
     */
    [[nodiscard]] virtual bool IsOpen() const noexcept override;
 
    // ========== BmnIArchiveLib Interface ==========
 
    /*
     * A method that is called to uncompress XZ-LZMA data
     * @param source A pointer to a buffer with the subsequent compressed data that should be uncompressed
     * @param sourceTotalSize A number of bytes available in the source buffer. If one has reached the EOF, it's ok to
     * pass a 0 here
     * @param numberOfReadBytes A number of bytes that were consumed by XZ-LZMA while decompressing. This value will be
     * set.
     * @param output A pointer to a buffer that will be filled with uncompressed data
     * @param outputTotalSize A number of bytes that may be filled in the output buffer
     * @param numberOfSetOutputBytes A number of bytes that were set while decompressing. This value will be set.
     * @return There are a few options:
     *      1. `BmnFileStreamResults::FileNotOpen` if the stream is not open
     *      2. `BmnFileStreamResults::TryingToReadBadStream` if the stream previously hit an error while it wasn't
     * cleared later
     *      3. `BmnFileStreamResults::UnexpectedFail` XZ-LZMA failed while decompressing
     *      4. `BmnFileStreamResults::ReachedEOF` XZ-LZMA reached the end of frame (in our case file)
     *      5. `BmnFileStreamResults::Success` XZ-LZMA successfully uncompressed the package
     */
    virtual BmnFileStreamResults Uncompress(const void* source,
                                            const size_t sourceTotalSize,
                                            size_t& numberOfReadBytes,
                                            void* output,
                                            const size_t outputTotalSize,
                                            size_t& numberOfSetOutputBytes) override;
 
    /*
     * If an error occurred while decompressing, this method can be called to obtain a description of the error
     * @return A description of an error that occurred while decompressing, or an empty string if no such error happened
     */
    [[nodiscard]] virtual std::string GetLastUncompressErrorDescription() const noexcept override;
 
    /*
     * @return 'false' - this class doesn't allow jumping
     */
    [[nodiscard]] virtual bool JumpsAllowed() const noexcept override;
 
    /*
     * This method will do nothing but print an error. This class doesn't allow us to efficiently jump over the
     * compressed file
     */
    virtual void JumpTo(size_t) override;
 
    /*
     * A method that tells us how many uncompressed bytes were read from an input file
     * @return A number of uncompressed bytes that passed through the XZ-LZMA
     */
    [[nodiscard]] virtual size_t GetNumberOfDecompressedBytes() const noexcept override;
 
    /*
     * A method that can be used to check if the reading stream has ended
     * @return 'true' if we have reached EOF, 'false' otherwise
     */
    [[nodiscard]] virtual bool HasReachedTheEndOfStream() const noexcept override;
 
    /*
     * A method that checks whether the last read was good or not. If not, the stream is not good anymore
     * @return 'true' if the stream is in a good state, 'false' otherwise
     */
    [[nodiscard]] virtual bool IsStreamInGoodState() const noexcept override;
 
    // ========== BmnFileReaderXzLzma public methods ==========
 
    /*
     * A method that can be used to understand how much memory is used by LZMA
     * @return Amount of memory used by an internal LZMA stream
     */
    [[nodiscard]] size_t GetUsedMemoryByLZMA() const noexcept;
 
    // ========== BmnFileReaderXzLzma inlines ==========
 
    [[nodiscard]] inline LzmaContext* GetUnderlyingLibraryStream() const noexcept;
    // Get number of read bytes via `GetNumberOfDecompressedBytes`
    // No need to expose `fArchiveReadManager`
  public:
    static size_t sMaximalAllowedMemory;
 
  private:
    // We won't be sharing this instance so going with a raw pointer... it could've been a unique ptr as well, but
    // nothing too important
    LzmaContext* fLzmaStream;
    BmnReaderCacheManager<32ull * 1024ull, 64ull * 1024ull> fArchiveReadManager;
    size_t fNumberOfReadBytes;
    int32_t fLastReturnStatus;
    // 4 padding bytes
};
 
// o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
// ================== BmnFileReaderXzLzma inline methods ==================
// o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
 
LzmaContext* BmnFileReaderXzLzma::GetUnderlyingLibraryStream() const noexcept
{
    return fLzmaStream;
}
 
#endif   // BmnFileReaderXzLzma_h