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
 
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 bool fail(void) const { return m_fail_; }

    void set_fail(void) { m_fail_ = true; }

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

    void clear(void);

    hxattr_nodiscard 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;
 
#if (HX_USE_FILE_IO) != 2
    template<size_t buffer_size_>
    bool getline(char(&buffer_)[buffer_size_]) {
        return this->getline(buffer_, buffer_size_);
    }

    bool getline(char* buffer_, int buffer_size_) hxattr_nonnull(2) hxattr_hot ;
#endif // (HX_USE_FILE_IO) != 2

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

    int scan(const char* format_, ...) hxattr_scanf(2, 3) hxattr_hot ;

    template<typename T_>
    bool read1(T_& t_) { return this->read(&t_, sizeof t_, sizeof t_) == sizeof t_; }

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

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

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

    template<size_t string_length_>
    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