IOBase.h

 
#ifndef ACTIVE_FILE_IO_BASE
#define ACTIVE_FILE_IO_BASE
 
#include <ios>
 
namespace active::file {
    
    class IOBase {
    public:
 
        // MARK: - Types
            
        using flag_type = std::ios_base::iostate;
 
        // MARK: - Constructors
        
        IOBase() noexcept { m_stateFlags = std::ios_base::goodbit; }
        IOBase(const IOBase& source) noexcept { m_stateFlags = source.m_stateFlags; }
        virtual ~IOBase() noexcept = default;
 
        // MARK: - Operators
        
        bool operator! () const noexcept { return fail(); }
        operator void* () const noexcept { return fail() ? nullptr : (void*) 1; }
 
        // MARK: - Functions (const)
        
        virtual bool good() const noexcept { return (m_stateFlags == 0); }
        virtual bool eof() const noexcept { return ((m_stateFlags & std::ios_base::eofbit) != 0); }
        virtual bool fail() const noexcept { return ((m_stateFlags & (std::ios_base::failbit | std::ios_base::badbit)) != 0); }
        virtual bool bad() const noexcept { return ((m_stateFlags & std::ios_base::badbit) != 0); }
        virtual flag_type state() const noexcept { return m_stateFlags; }
 
        // MARK: - Functions (mutating)
        
        virtual void clear(flag_type f = std::ios_base::goodbit) { m_stateFlags = f; }
        virtual void setState(flag_type f) { clear(state() | f); }
        virtual void unsetState(flag_type f) { clear((state() | f) ^ f); }
        
    protected:
        void setCompleteState(flag_type state) { m_stateFlags = state; }
        void clear(flag_type f = std::ios_base::goodbit) const { m_stateFlags = f; }
        void setState(flag_type f) const { clear(state() | f); }
        virtual void unsetState(flag_type f) const { clear((state() | f) ^ f); }
        
    private:
        mutable flag_type m_stateFlags;
    };
    
}
 
#endif  //ACTIVE_FILE_IO_BASE