io.hpp

Go to the documentation of this file.

 
#ifndef _POWERDXX_SYS_IO_HPP_
#define _POWERDXX_SYS_IO_HPP_
 
#include <cstdio>       /* fopen(), fprintf() etc. */
#include <utility>      /* std::swap() */
 
namespace sys {
 
namespace io {
 
enum class feature {
    read,
 
    write,
 
    seek,
};
 
static constexpr auto const read = feature::read;
static constexpr auto const write = feature::write;
static constexpr auto const seek = feature::seek;
 
enum class ownership {
    own,
 
    link,
};
 
static constexpr auto const own = ownership::own;
static constexpr auto const link = ownership::link;
 
template <ownership Ownership, feature ... Features> class file;
 
template <bool, class T = void> struct enable_if {
    using type = T;
 
    static constexpr bool const value{true};
};
 
template <class T> struct enable_if<false, T> {
    static constexpr bool const value{false};
};
 
template <auto ... Set> struct set {};
 
template <class SetT, auto Value> struct contains;
 
template <auto ... Set, auto Value>
struct contains<set<Set ...>, Value> : enable_if<((Set == Value) || ...)> {};
 
template <class SetT, auto Value>
constexpr auto const contains_v = contains<SetT, Value>::value;
 
template <class SetT, auto Value>
using contains_t = typename contains<SetT, Value>::type;
 
template <class LSetT, class RSetT> struct is_superset_of;
 
template <class LSetT, auto ... RSet>
struct is_superset_of<LSetT, set<RSet ...>> :
    enable_if<(contains_v<LSetT, RSet> && ...)> {};
 
template <class LSetT, class RSetT>
constexpr auto const is_superset_of_v = is_superset_of<LSetT, RSetT>::value;
 
template <class LSetT, class RSetT>
using is_superset_of_t = typename is_superset_of<LSetT, RSetT>::type;
 
struct query {
    struct contains_ftor {
        char const * const str;
 
        constexpr bool operator ()(char const ch) const {
            for (auto it = str; it && *it; ++it) {
                if (*it == ch) {
                    return true;
                }
            }
            return false;
        }
 
        template <typename ... CharTs>
        constexpr bool any(CharTs const ... chars) const {
            for (auto it = str; it && *it; ++it) {
                if (((*it == chars) || ...)) {
                    return true;
                }
            }
            return false;
        }
 
        template <typename ... CharTs>
        constexpr bool all(CharTs const ... chars) const {
            for (auto ch : {chars ...}) {
                bool match{false};
                for (auto it = str; it && *it && !match; ++it) {
                    match = (ch == *it);
                }
                if (!match) {
                    return false;
                }
            }
            return true;
        }
    } const contains; 
};
 
template <class FileT, feature ...>
class file_feature {
    protected:
    FILE * handle;
 
    operator FileT &() {
        return *static_cast<FileT *>(this);
    }
 
    file_feature(FILE * const handle) : handle{handle} {}
 
    public:
    explicit operator bool() const {
        return this->handle && !feof(this->handle) &&
               !ferror(this->handle);
    }
 
    bool eof() const {
        return this->handle && feof(this->handle);
    }
 
    bool error() const {
        return this->handle && ferror(this->handle);
    }
};
 
template <class FileT, feature ... Tail>
class file_feature<FileT, read, Tail ...> :
    public file_feature<FileT, Tail ...> {
    public:
    using file_feature<FileT, Tail ...>::file_feature;
 
    int getc() {
        if (this->handle) {
            return fgetc(this->handle);
        }
        return EOF;
    }
 
    template <typename T>
    std::size_t read(T & dst) {
        if (this->handle) {
            return fread(&dst, sizeof(T), 1, this->handle);
        }
        return 0;
    }
 
    template <typename T, std::size_t Count>
    std::size_t read(T (& dst)[Count], std::size_t const count) {
        if (this->handle) {
            return fread(&dst, sizeof(T),
                         (count <= Count ? count : Count),
                         this->handle);
        }
        return 0;
    }
 
    template <auto CountFmt, typename ... RefTs>
    int scanf(char const (& fmt)[CountFmt], RefTs & ... refs) {
        if (this->handle) {
            return fscanf(this->handle, fmt, &refs ...);
        }
        return EOF;
    }
 
    template <auto Count>
    bool gets(char (& dst)[Count]) {
        return this->handle && fgets(dst, Count, this->handle);
    }
};
 
template <class FileT, feature ... Tail>
class file_feature<FileT, write, Tail ...> :
    public file_feature<FileT, Tail ...> {
    public:
    using file_feature<FileT, Tail ...>::file_feature;
 
    template <auto CountFmt, typename ... ArgTs>
    FileT & printf(char const (& fmt)[CountFmt], ArgTs const & ... args) {
        if (this->handle) {
            fprintf(this->handle, fmt, args ...);
        }
        return *this;
    }
 
    template <auto CountFmt>
    FileT & printf(char const (& fmt)[CountFmt]) {
        if (this->handle) {
            fprintf(this->handle, fmt, 0);
        }
        return *this;
    }
 
    template <std::size_t Count>
    FileT & print(char const (& msg)[Count]) {
        if (this->handle) {
            fwrite(msg, sizeof(char), Count - 1, this->handle);
        }
        return *this;
    }
 
    FileT & putc(int const character) {
        if (this->handle) {
            fputc(character, this->handle);
        }
        return *this;
    }
 
    template <typename T>
    FileT & write(T const & src) {
        if (this->handle) {
            fwrite(&src, sizeof(T), 1, this->handle);
        }
        return *this;
    }
 
    template <typename T, std::size_t Count>
    FileT & write(T const (& src)[Count], std::size_t const count) {
        if (this->handle) {
            fwrite(&src, sizeof(T),
                   (count <= Count ? count : Count),
                   this->handle);
        }
        return *this;
    }
 
    FileT & flush() {
        if (this->handle) {
            fflush(this->handle);
        }
        return *this;
    }
};
 
template <class FileT, feature ... Tail>
class file_feature<FileT, seek, Tail ...> :
    public file_feature<FileT, Tail ...> {
    public:
    using file_feature<FileT, Tail ...>::file_feature;
 
    FileT & seek(long int const offset, int const origin) {
        if (this->handle) {
            fseek(this->handle, offset, origin);
        }
        return *this;
    }
 
    FileT & rewind() {
        if (this->handle) {
            frewind(this->handle);
        }
        return *this;
    }
 
    long int tell() {
        if (this->handle) {
            return ftell(this->handle);
        }
        return -1;
    }
};
 
template <feature ... Features>
class file<own, Features ...> final :
    public file_feature<file<own, Features ...>, Features ...> {
    template <ownership, feature ...> friend class file;
 
    public:
    file(file const &) = delete;
 
    file(file && move) : file{move.release()} {}
 
    explicit file(FILE * const handle) :
        file_feature<file, Features ...>{handle} {}
 
    file() : file{nullptr} {}
 
    template <feature ... Superset,
              class = is_superset_of_t<set<Superset ...>,
                                       set<Features ...>>>
    file(file<own, Superset ...> && move) :
        file{move.release()} {}
 
    file(char const * const filename, char const * const mode) :
        file{(!filename || !mode ||
              (contains_v<set<Features ...>, write> &&
           !query{mode}.contains.any('w', '+')) ||
          (contains_v<set<Features ...>, read> &&
           !query{mode}.contains.any('r', '+')) ||
          (contains_v<set<Features ...>, seek> &&
           query{mode}.contains('a') && !query{mode}.contains('+')))
             ? nullptr : fopen(filename, mode)} {}
 
    ~file() {
        close();
    }
 
    file & operator =(file && move) {
        std::swap(this->handle, move.handle);
        return *this;
    }
 
    template <feature ... Superset,
              class = is_superset_of_t<set<Superset ...>, set<Features ...>>>
    file & operator =(file<own, Superset ...> && move) {
        std::swap(this->handle, move.handle);
        return *this;
    }
 
    FILE * get() const {
        return this->handle;
    }
 
    FILE * release() {
        auto const handle = this->handle;
        this->handle = nullptr;
        return handle;
    }
 
    file & close() {
        if (this->handle) {
            fclose(this->handle);
            this->handle = nullptr;
        }
        return *this;
    }
 
};
 
template <feature ... Features>
class file<link, Features ...> final :
    public file_feature<file<link, Features ...>, Features ...> {
    public:
    explicit file(FILE * const handle) :
        file_feature<file, Features ...>{handle} {}
 
    file() : file{nullptr} {}
 
    template <ownership Ownership, feature ... Superset,
              class = is_superset_of_t<set<Superset ...>, set<Features ...>>>
    file(file<Ownership, Superset ...> const & copy) : file{copy.get()} {}
 
    template <feature ... Superset,
              class = is_superset_of_t<set<Superset ...>, set<Features ...>>>
    file(file<own, Superset ...> &&) = delete;
 
    template <ownership Ownership, feature ... Superset,
              class = is_superset_of_t<set<Superset ...>, set<Features ...>>>
    file & operator =(file<Ownership, Superset ...> const & copy) {
        this->handle = copy.get();
        return *this;
    }
 
    template <feature ... Superset,
              class = is_superset_of_t<set<Superset ...>, set<Features ...>>>
    file & operator =(file<own, Superset ...> &&) = delete;
 
    FILE * get() const {
        return this->handle;
    }
};
 
inline file<link, write> ferr{stderr};
 
inline file<link, write> fout{stdout};
 
inline file<link, read> fin{stdin};
 
} /* namespace io */
 
} /* namespace sys */
 
#endif /* _POWERDXX_SYS_IO_HPP_ */