ios.h

Go to the documentation of this file.

 
#ifndef ios_h
#define ios_h
#include "../FsLib/FsLib.h"
//==============================================================================
typedef fspos_t pos_t;
//==============================================================================
#if SDFAT_FILE_TYPE == 1
typedef FatFile StreamBaseFile;
#elif SDFAT_FILE_TYPE == 2
typedef ExFatFile StreamBaseFile;
#elif SDFAT_FILE_TYPE == 3
typedef FsBaseFile StreamBaseFile;
#else // SDFAT_FILE_TYPE
#error Invalid SDFAT_FILE_TYPE
#endif // SDFAT_FILE_TYPE
class ios_base
{
  public:
    typedef unsigned char iostate;
    // State flags.
    static const iostate goodbit = 0x00;
    static const iostate badbit = 0X01;
    static const iostate eofbit = 0x02;
    static const iostate failbit = 0X04;
#if SDFAT_FILE_TYPE == 1
    typedef uint32_t streamsize;
    typedef uint32_t pos_type;
    typedef int32_t off_type;
#else  // SDFAT_FILE_TYPE
    typedef uint64_t streamsize;
    typedef uint64_t pos_type;
    typedef int64_t off_type;
#endif // SDFAT_FILE_TYPE
    enum seekdir
    {
        beg,
        cur,
        end
    };
    typedef unsigned int fmtflags;
    static const fmtflags left = 0x0001;
    static const fmtflags right = 0x0002;
    static const fmtflags internal = 0x0004;
    static const fmtflags dec = 0x0008;
    static const fmtflags hex = 0x0010;
    static const fmtflags oct = 0x0020;
    // static const fmtflags fixed      = 0x0040;
    // static const fmtflags scientific = 0x0080;
    static const fmtflags boolalpha = 0x0100;
    static const fmtflags showbase = 0x0200;
    static const fmtflags showpoint = 0x0400;
    static const fmtflags showpos = 0x0800;
    static const fmtflags skipws = 0x1000;
    // static const fmtflags unitbuf    = 0x2000;
    static const fmtflags uppercase = 0x4000;
    static const fmtflags adjustfield = left | right | internal;
    static const fmtflags basefield = dec | hex | oct;
    // static const fmtflags floatfield  = scientific | fixed;
    //----------------------------------------------------------------------------
    typedef uint8_t openmode;
 
    // Openmode flags.
    static const openmode app = 0X4;
    static const openmode ate = 0X8;
    static const openmode binary = 0X10;
    static const openmode in = 0X20;
    static const openmode out = 0X40;
    static const openmode trunc = 0X80;
    //----------------------------------------------------------------------------
    ios_base() : m_fill(' '), m_fmtflags(dec | right | skipws), m_precision(2), m_width(0)
    {
    }
    char fill()
    {
        return m_fill;
    }
    char fill(char c)
    {
        char r = m_fill;
        m_fill = c;
        return r;
    }
    fmtflags flags() const
    {
        return m_fmtflags;
    }
    fmtflags flags(fmtflags fl)
    {
        fmtflags tmp = m_fmtflags;
        m_fmtflags = fl;
        return tmp;
    }
    int precision() const
    {
        return m_precision;
    }
    int precision(unsigned int n)
    {
        int r = m_precision;
        m_precision = n;
        return r;
    }
    fmtflags setf(fmtflags fl)
    {
        fmtflags r = m_fmtflags;
        m_fmtflags |= fl;
        return r;
    }
    fmtflags setf(fmtflags fl, fmtflags mask)
    {
        fmtflags r = m_fmtflags;
        m_fmtflags &= ~mask;
        m_fmtflags |= fl;
        return r;
    }
    void unsetf(fmtflags fl)
    {
        m_fmtflags &= ~fl;
    }
    unsigned width()
    {
        return m_width;
    }
    unsigned width(unsigned n)
    {
        unsigned r = m_width;
        m_width = n;
        return r;
    }
 
  protected:
    uint8_t flagsToBase()
    {
        uint8_t f = flags() & basefield;
        return f == oct ? 8 : f != hex ? 10 : 16;
    }
 
  private:
    char m_fill;
    fmtflags m_fmtflags;
    unsigned char m_precision;
    unsigned int m_width;
};
//------------------------------------------------------------------------------
inline ios_base &boolalpha(ios_base &str)
{
    str.setf(ios_base::boolalpha);
    return str;
}
inline ios_base &dec(ios_base &str)
{
    str.setf(ios_base::dec, ios_base::basefield);
    return str;
}
inline ios_base &hex(ios_base &str)
{
    str.setf(ios_base::hex, ios_base::basefield);
    return str;
}
inline ios_base &internal(ios_base &str)
{
    str.setf(ios_base::internal, ios_base::adjustfield);
    return str;
}
inline ios_base &left(ios_base &str)
{
    str.setf(ios_base::left, ios_base::adjustfield);
    return str;
}
inline ios_base &noboolalpha(ios_base &str)
{
    str.unsetf(ios_base::boolalpha);
    return str;
}
inline ios_base &noshowbase(ios_base &str)
{
    str.unsetf(ios_base::showbase);
    return str;
}
inline ios_base &noshowpoint(ios_base &str)
{
    str.unsetf(ios_base::showpoint);
    return str;
}
inline ios_base &noshowpos(ios_base &str)
{
    str.unsetf(ios_base::showpos);
    return str;
}
inline ios_base &noskipws(ios_base &str)
{
    str.unsetf(ios_base::skipws);
    return str;
}
inline ios_base &nouppercase(ios_base &str)
{
    str.unsetf(ios_base::uppercase);
    return str;
}
inline ios_base &oct(ios_base &str)
{
    str.setf(ios_base::oct, ios_base::basefield);
    return str;
}
inline ios_base &right(ios_base &str)
{
    str.setf(ios_base::right, ios_base::adjustfield);
    return str;
}
inline ios_base &showbase(ios_base &str)
{
    str.setf(ios_base::showbase);
    return str;
}
inline ios_base &showpos(ios_base &str)
{
    str.setf(ios_base::showpos);
    return str;
}
inline ios_base &showpoint(ios_base &str)
{
    str.setf(ios_base::showpoint);
    return str;
}
inline ios_base &skipws(ios_base &str)
{
    str.setf(ios_base::skipws);
    return str;
}
inline ios_base &uppercase(ios_base &str)
{
    str.setf(ios_base::uppercase);
    return str;
}
//==============================================================================
class ios : public ios_base
{
  public:
    ios()
    {
    }
 
    operator const void *() const
    {
        return !fail() ? reinterpret_cast<const void *>(this) : nullptr;
    }
    bool operator!() const
    {
        return fail();
    }
    explicit operator bool() const
    {
        return !fail();
    }
    iostate rdstate() const
    {
        return m_iostate;
    }
    bool good() const
    {
        return m_iostate == goodbit;
    }
    bool eof() const
    {
        return m_iostate & eofbit;
    }
    bool fail() const
    {
        return m_iostate & (failbit | badbit);
    }
    bool bad() const
    {
        return m_iostate & badbit;
    }
    void clear(iostate state = goodbit)
    {
        m_iostate = state;
    }
    void setstate(iostate state)
    {
        m_iostate |= state;
    }
 
  private:
    iostate m_iostate = 0;
};
#endif // ios_h