hxfile.hpp

Go to the documentation of this file.

#pragma once
// SPDX-FileCopyrightText: © 2017-2026 Adrian Johnston.
// SPDX-License-Identifier: MIT
// This file is licensed under the MIT license found in the LICENSE.md file.

 
#include "libhatchet.h"
 
// HX_USE_MACROS_WITH_MODULE allows including macros alongside the module.
#if HX_USE_MACROS_WITH_MODULE
#error Header does not provide macros alone.
#endif
 
#if HX_USE_FILE_IO
 
#if HX_CPLUSPLUS >= 202302L
#include "hxexpected.hpp"
#endif
 
HX_NS_BEGIN_
 
class hxfile;

extern hxfile hxin;

extern hxfile hxout;

extern hxfile hxerr;

extern hxfile hxdev_null;

hxinline_constexpr char hxendl[] = "\n";

class hxfile {
public:
    enum open_mode : uint8_t {
        open_mode_none = 0u,
        open_mode_in = 1u,
        open_mode_out = 2u,
        open_mode_asserts = 4u
    };

    hxfile(void);

    hxfile(uint8_t mode_, const char* filename_, ...) hxattr_printf(3, 4);

    hxfile(uint8_t mode_, intptr_t file_);

    hxfile(const char* file_, uint8_t mode_=0) = delete;

    hxfile(hxfile&& file_) noexcept;

    ~hxfile();

    void operator=(hxfile&& file_) noexcept;

    operator bool(void) const;

    bool open(uint8_t mode_, const char* filename_, ...) hxattr_printf(3, 4);

    void close(void);

    hxattr_nodiscard bool is_open(void) const;

    hxattr_nodiscard hxinline bool fail(void) const { return m_fail_; }

    void set_fail(void) { m_fail_ = true; }

    hxattr_nodiscard hxinline bool eof(void) const { return m_eof_; }

    void clear(void);

    hxattr_nodiscard hxinline uint8_t mode(void) const { return m_open_mode_; }

    hxattr_nodiscard size_t get_pos(void) const;

    bool set_pos(size_t position_);

    size_t read(void* bytes_, size_t buffer_size_, size_t count_) hxattr_nonnull(2) hxattr_hot;

    size_t write(const void* bytes_, size_t count_) hxattr_nonnull(2) hxattr_hot;

    bool flush(void) hxattr_hot;

    bool print(const char* format_, ...) hxattr_printf(2, 3) hxattr_hot;

    template<typename T_>
    hxinline bool read1(T_& t_) { return this->read(&t_, sizeof t_, sizeof t_) == sizeof t_; }
 
#if HX_CPLUSPLUS >= 202302L
    template<typename T_>
    hxattr_nodiscard hxinline hxexpected<T_> expect(void) {
        T_ t_;
        const bool error_ = this->read(&t_, sizeof(T_), sizeof(T_)) != sizeof(T_);
        return hxexpected<T_>(error_, t_);
    }
#endif

    template<typename T_>
    hxinline bool write1(const T_& t_) { return this->write(&t_, sizeof t_) == sizeof t_; }

    template<typename T_>
    hxinline hxfile& operator>>(T_& t_) {
        this->read(&t_, sizeof t_, sizeof t_);
        return *this;
    }

    template<typename T_>
    hxinline hxfile& operator<<(const T_& t_) {
        this->write(&t_, sizeof t_);
        return *this;
    }

    template<size_t string_length_>
    hxinline hxfile& operator<<(const char(&str_)[string_length_]) {
        this->write(str_, string_length_-1);
        return *this;
    }
 
private:
    hxfile(const hxfile&) = delete;
    void operator=(const hxfile&) = delete;
    template<typename T_> hxfile& operator>>(const T_* t_) = delete;
 
    bool openv_(uint8_t mode_, const char* format_, va_list args_);
 
    intptr_t m_file_pimpl_;
    uint8_t  m_open_mode_;
    bool     m_owns_;
    bool     m_fail_;
    bool     m_eof_;
};
 
HX_NS_END_
#endif // HX_USE_FILE_IO