BmnFileReaderRaw.h

Go to the documentation of this file.

#pragma once
#ifndef BmnFileReaderRaw_h
#define BmnFileReaderRaw_h
 
// headers from this target
#include "BmnIFileReader.h"
// std:: headers
#include <fstream>
 
/*
 * A class that allows one to read raw binary files. This class is very similar to `std::ifstream`
 * and only implements its methods. Still, APi of `BmnIFileReader` is used so one can use this class
 * along with other children classes based on needs
 */
class BmnFileReaderRaw : public BmnIFileReader
{
  public:
    /*
     * A standard constructor that sets a path to the input raw binary file
     * @note The constructor will not check whether the file actually exists
     * @param fileName A path (most likely relative) to the input raw binary 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 BmnFileReaderRaw(const std::string& fileName = "");
 
    /*
     * A standard constructor that sets a path to the input raw binary file
     * @note The constructor will not check whether the file actually exists
     * @param fileName A path (most likely relative) to the input raw binary 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 BmnFileReaderRaw(std::string&& fileName);
 
    /*
     * A standard constructor that sets a path to the input raw binary file
     * @note The constructor will not check whether the file actually exists
     * @param filePath A path to the input raw binary 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 BmnFileReaderRaw(const std::filesystem::path& filePath);
 
    /*
     * A standard constructor that sets a path to the input raw binary file
     * @note The constructor will not check whether the file actually exists
     * @param filePath A path to the input raw binary 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 BmnFileReaderRaw(std::filesystem::path&& filePath);
 
    virtual ~BmnFileReaderRaw() = default;
    BmnFileReaderRaw(const BmnFileReaderRaw&) = delete;
    BmnFileReaderRaw& operator=(const BmnFileReaderRaw&) = delete;
    BmnFileReaderRaw(BmnFileReaderRaw&&) noexcept = delete;
    BmnFileReaderRaw& operator=(BmnFileReaderRaw&&) noexcept = delete;
 
    // ========== BmnIFileReaderInterface ==========
 
    /*
     * Opens a raw 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 input stream. After calling `Close`, it's safe to reopen using the same instance of this class
     */
    virtual void Close() noexcept override;
 
    /*
     * Reads the binary-file data and writes them into the provided buffer.
     * @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 next to read
     * @return A position of the next byte that should be read
     */
    [[nodiscard]] virtual int64_t Tell() const noexcept override;
 
    /*
     * A method that sets a position for a next-byte read
     * @param value A position in the raw-data file to which one wants to move before the next read
     */
    virtual void Seek(int64_t value) override;
 
    /*
     * Checks whether the reading stream is good
     * @return 'true' if the underlying stream is good, or 'false' otherwise
     */
    [[nodiscard]] virtual bool IsGood() const noexcept override;
 
    /*
     * Check if we have reached the file.
     * @note This method will return 'true' ONLY IF one tries to a byte after the last one
     * @return 'true' if eof flag of the internal stream is set, '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;
 
  private:
    std::ifstream fInputStream;
    int64_t fNextByteToRead;
};
 
#endif   // BmnFileReaderRaw_h