ios.h

Go to the documentation of this file.

//   Copyright 2016-2023 Jean-Francois Poilpret
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.
 
 
#ifndef IOS_H
#define IOS_H
 
#include <math.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include "streambuf.h"
#include "flash.h"
 
namespace streams
{
    class ios_base
    {
    public:
        using iostate = uint8_t;
 
        static constexpr iostate eofbit = 0x01;
        static constexpr iostate failbit = 0x02;
        static constexpr iostate badbit = 0x04;
        static constexpr iostate goodbit = 0;
 
        iostate rdstate() const
        {
            return state_;
        }
 
        void setstate(iostate state)
        {
            clear(rdstate() | state);
        }
 
        void clear(iostate state = goodbit)
        {
            state_ = state;
        }
 
        bool good() const
        {
            return rdstate() == goodbit;
        }
 
        bool eof() const
        {
            return rdstate() & eofbit;
        }
 
        bool fail() const
        {
            return rdstate() & (failbit | badbit);
        }
 
        bool bad() const
        {
            return rdstate() & badbit;
        }
 
        bool operator!() const
        {
            return fail();
        }
 
        explicit operator bool() const
        {
            return !fail();
        }
 
        using fmtflags = uint16_t;
 
        static constexpr fmtflags dec = 0x0001;
        static constexpr fmtflags bin = 0x0002;
        static constexpr fmtflags oct = 0x0004;
        static constexpr fmtflags hex = 0x0008;
        static constexpr fmtflags basefield = dec | bin | oct | hex;
 
        static constexpr fmtflags left = 0x0010;
        static constexpr fmtflags right = 0x0020;
        static constexpr fmtflags adjustfield = left | right;
 
        static constexpr fmtflags scientific = 0x0040;
        static constexpr fmtflags fixed = 0x0080;
        static constexpr fmtflags floatfield = scientific | fixed;
 
        static constexpr fmtflags boolalpha = 0x0200;
        static constexpr fmtflags showbase = 0x0400;
        static constexpr fmtflags showpos = 0x1000;
        static constexpr fmtflags skipws = 0x2000;
        static constexpr fmtflags unitbuf = 0x4000;
        static constexpr fmtflags uppercase = 0x8000U;
 
        void flags(fmtflags flags)
        {
            flags_ = flags;
        }
 
        fmtflags flags() const
        {
            return flags_;
        }
 
        void setf(fmtflags flags)
        {
            flags_ |= flags;
        }
 
        void setf(fmtflags flags, fmtflags mask)
        {
            flags_ = (flags_ & ~mask) | (flags & mask);
        }
 
        void unsetf(fmtflags flags)
        {
            flags_ &= ~flags;
        }
 
        char fill() const
        {
            return fill_;
        }
 
        void fill(char fill)
        {
            fill_ = fill;
        }
 
        void width(uint8_t width)
        {
            width_ = width;
        }
 
        uint8_t width() const
        {
            return width_;
        }
 
        void precision(uint8_t precision)
        {
            precision_ = (precision < MAX_PRECISION ? precision : MAX_PRECISION);
        }
 
        uint8_t precision() const
        {
            return precision_;
        }
 
        ios_base& copyfmt(const ios_base& rhs)
        {
            flags_ = rhs.flags_;
            width_ = rhs.width_;
            precision_ = rhs.precision_;
            fill_ = rhs.fill_;
            return *this;
        }
 
        static constexpr uint8_t MAX_PRECISION = 16;
 
    protected:
        ios_base() = default;
        ios_base(const ios_base&) = delete;
        ios_base& operator=(const ios_base&) = delete;
 
        static constexpr uint8_t DOUBLE_BUFFER_SIZE = MAX_PRECISION + 7 + 1;
 
        void init()
        {
            width_ = 0;
            precision_ = 6;
            flags_ = skipws | dec;
            fill_ = ' ';
        }
        // Conversions from string
        void convert(const char* token, bool& value)
        {
            if (flags() & boolalpha)
                value = (strcmp(token, "true") == 0);
            else
                value = (atol(token) != 0);
        }
        void convert(const char* token, double& value)
        {
            char* endptr;
            double val = strtod(token, &endptr);
            if (endptr != token)
                value = val;
            else
                setstate(failbit);
        }
        const char* binary_token(const char* token) const
        {
            if ((base() == 2) && ((strncmp(token, "0b0", 3) == 0) || (strncmp(token, "0b1", 3) == 0))) return token + 2;
            return token;
        }
        bool convert(const char* token, long& value)
        {
            char* endptr;
            long val = strtol(binary_token(token), &endptr, base());
            if (endptr != token)
                value = val;
            else
                setstate(failbit);
            return (endptr != token);
        }
        bool convert(const char* token, unsigned long& value)
        {
            char* endptr;
            unsigned long val = strtoul(binary_token(token), &endptr, base());
            if (endptr != token)
                value = val;
            else
                setstate(failbit);
            return (endptr != token);
        }
        void convert(const char* token, int& value)
        {
            long val;
            if (convert(token, val)) value = (int) val;
        }
        void convert(const char* token, unsigned int& value)
        {
            unsigned long val;
            if (convert(token, val)) value = (unsigned int) val;
        }
 
        // Conversions to string
        void convert(ostreambuf& out, int value) const
        {
            // Allocate sufficient size for bin representation
            char buffer[sizeof(int) * 8 + 1];
            format_number(out, itoa(value, buffer, base()));
        }
        void convert(ostreambuf& out, unsigned int value) const
        {
            // Allocate sufficient size for bin representation
            char buffer[sizeof(unsigned int) * 8 + 1];
            format_number(out, utoa(value, buffer, base()));
        }
        void convert(ostreambuf& out, long value) const
        {
            // Allocate sufficient size for bin representation
            char buffer[sizeof(long) * 8 + 1];
            format_number(out, ltoa(value, buffer, base()));
        }
        void convert(ostreambuf& out, unsigned long value) const
        {
            // Allocate sufficient size for bin representation
            char buffer[sizeof(unsigned long) * 8 + 1];
            format_number(out, ultoa(value, buffer, base()));
        }
        static size_t double_digits(double value)
        {
            int digits = int(log10(fabs(value)));
            if (digits < 0)
                return 1;
            else
                return size_t(digits + 1);
        }
        bool is_too_large(double value) const
        {
            // Number of chars = sign + digits before DP + DP + precision + \0
            return (1 + double_digits(value) + 1 + precision() + 1) > DOUBLE_BUFFER_SIZE;
        }
        void convert(ostreambuf& out, double value) const
        {
            // Allocate sufficient size for fixed/scientific representation with precision max = 16
            // Need 1 more for sign, 1 for DP, 1 for first digit, 4 for e+00
            char buffer[DOUBLE_BUFFER_SIZE];
            // If value is too large, force scientific anyway
            if ((flags() & scientific) || is_too_large(value))
            {
                const uint8_t DTOSTRE_MAX_PRECISION = 7;
                dtostre(value, buffer, precision(), 0);
                if (precision() > DTOSTRE_MAX_PRECISION)
                {
                    // If precision() > 7, then it is limited to 7 by dtostre(), add 0 manually then
                    // Size of the exponent part, always e+00 or e-00
                    const uint8_t EXPONENT_SIZE = 1 + 1 + 2;
                    // Find exponent marker 'e' and move exponent part right (including null)
                    char* exponent = strchr(buffer, 'e');
                    uint8_t added_zeros = precision() - DTOSTRE_MAX_PRECISION;
                    memmove(exponent + added_zeros, exponent, EXPONENT_SIZE + 1);
                    // Add '0' in the added space before exponent
                    memset(exponent, '0', added_zeros);
                }
            }
            else if (flags() & fixed)
                dtostrf(value, 0, precision(), buffer);
            else
            {
                // In this mode any trailing 0 after DP is discarded
                // DP is also discarded if there are only 0 after it
                dtostrf(value, 0, precision(), buffer);
                char* dp = strchr(buffer, '.');
                if (dp)
                {
                    // Number has a decimal point, remove all trailing zeros
                    char* reverse = buffer + strlen(buffer) - 1;
                    while ((reverse != dp) && (*reverse == '0')) *reverse-- = 0;
                    // If there is no significant digit after DP, remove DP
                    if (reverse == dp) *reverse = 0;
                }
            }
            upper(buffer, true);
            justify(out, buffer, add_sign(buffer, true), nullptr);
        }
        void convert(ostreambuf& out, char value) const
        {
            char buffer[1 + 1];
            buffer[0] = value;
            buffer[1] = 0;
            justify(out, buffer, false, nullptr);
        }
        void convert(ostreambuf& out, bool value) const
        {
            if (flags() & boolalpha)
                justify(out, (value ? F("true") : F("false")));
            else
                convert(out, (value ? 1 : 0));
        }
 
        void upper(char* input, bool is_float = false) const
        {
            if ((flags() & uppercase) && ((flags() & hex) || is_float)) strupr(input);
        }
 
        const char* prefix_base() const
        {
            if (flags() & showbase)
            {
                if (flags() & bin)
                    return "0b";
                if (flags() & oct)
                    return "0";
                if (flags() & hex)
                    return "0x";
            }
            return nullptr;
        }
 
        bool add_sign(const char* input, bool is_float = false) const
        {
            return (flags() & showpos) && ((flags() & dec) || is_float) && (input[0] != '+') && (input[0] != '-');
        }
 
        void format_number(ostreambuf& out, char* input) const
        {
            upper(input);
            justify(out, input, add_sign(input), prefix_base());
        }
 
        void output_number(ostreambuf& out, const char* input, bool add_sign, const char* prefix) const
        {
            if (add_sign) out.put_('+', false);
            if (prefix) out.sputn(prefix);
            out.sputn(input);
        }
 
        void output_filler(ostreambuf& out, char filler, uint8_t size) const
        {
            while (size--) out.put_(filler, false);
        }
 
        void justify(ostreambuf& out, const char* input, bool add_sign, const char* prefix) const
        {
            // Handle case where padding must be added
            // Speed optimization: handle padding situation ONLY if width is != 0
            if (width())
            {
                size_t len = strlen(input) + (prefix ? strlen(prefix) : 0) + (add_sign ? 1 : 0);
                if (len < width())
                {
                    uint8_t add = width() - len;
                    if (flags() & left)
                    {
                        output_number(out, input, add_sign, prefix);
                        output_filler(out, fill(), add);
                        out.on_put();
                    }
                    else
                    {
                        output_filler(out, fill(), add);
                        output_number(out, input, add_sign, prefix);
                    }
                    return;
                }
            }
            // Handle case where no padding is needed
            output_number(out, input, add_sign, prefix);
        }
 
        void justify(ostreambuf& out, const flash::FlashStorage* input) const
        {
            size_t len = strlen_P((const char*) input);
            if (len < width())
            {
                uint8_t add = width() - len;
                if (flags() & left)
                {
                    out.sputn(input);
                    output_filler(out, fill(), add);
                    out.on_put();
                }
                else
                {
                    output_filler(out, fill(), add);
                    out.sputn(input);
                }
            }
            else
                out.sputn(input);
        }
 
        int base() const
        {
            if (flags() & bin) return 2;
            if (flags() & oct) return 8;
            if (flags() & hex) return 16;
            return 10;
        }
 
    private:
        iostate state_ = 0;
        fmtflags flags_ = skipws | dec;
        uint8_t width_ = 0;
        uint8_t precision_ = 6;
        char fill_ = ' ';
    };
 
    using ios = ios_base;
 
    template<typename FSTREAM> inline void skipws(FSTREAM& stream)
    {
        stream.setf(ios::skipws);
    }
 
    template<typename FSTREAM> inline void noskipws(FSTREAM& stream)
    {
        stream.unsetf(ios::skipws);
    }
 
    template<typename FSTREAM> inline void bin(FSTREAM& stream)
    {
        stream.setf(ios::bin, ios::basefield);
    }
 
    template<typename FSTREAM> inline void oct(FSTREAM& stream)
    {
        stream.setf(ios::oct, ios::basefield);
    }
 
    template<typename FSTREAM> inline void dec(FSTREAM& stream)
    {
        stream.setf(ios::dec, ios::basefield);
    }
 
    template<typename FSTREAM> inline void hex(FSTREAM& stream)
    {
        stream.setf(ios::hex, ios::basefield);
    }
 
    template<typename FSTREAM> inline void boolalpha(FSTREAM& stream)
    {
        stream.setf(ios::boolalpha);
    }
 
    template<typename FSTREAM> inline void noboolalpha(FSTREAM& stream)
    {
        stream.unsetf(ios::boolalpha);
    }
 
    template<typename FSTREAM> inline void showbase(FSTREAM& stream)
    {
        stream.setf(ios::showbase);
    }
 
    template<typename FSTREAM> inline void noshowbase(FSTREAM& stream)
    {
        stream.unsetf(ios::showbase);
    }
 
    template<typename FSTREAM> inline void showpos(FSTREAM& stream)
    {
        stream.setf(ios::showpos);
    }
 
    template<typename FSTREAM> inline void noshowpos(FSTREAM& stream)
    {
        stream.unsetf(ios::showpos);
    }
 
    template<typename FSTREAM> inline void uppercase(FSTREAM& stream)
    {
        stream.setf(ios::uppercase);
    }
 
    template<typename FSTREAM> inline void nouppercase(FSTREAM& stream)
    {
        stream.unsetf(ios::uppercase);
    }
 
    template<typename FSTREAM> inline void unitbuf(FSTREAM& stream)
    {
        stream.setf(ios::unitbuf);
    }
 
    template<typename FSTREAM> inline void nounitbuf(FSTREAM& stream)
    {
        stream.unsetf(ios::unitbuf);
    }
 
    template<typename FSTREAM> inline void left(FSTREAM& stream)
    {
        stream.setf(ios::left, ios::adjustfield);
    }
 
    template<typename FSTREAM> inline void right(FSTREAM& stream)
    {
        stream.setf(ios::right, ios::adjustfield);
    }
 
    template<typename FSTREAM> inline void defaultfloat(FSTREAM& stream)
    {
        stream.unsetf(ios::floatfield);
    }
 
    template<typename FSTREAM> inline void fixed(FSTREAM& stream)
    {
        stream.setf(ios::fixed, ios::floatfield);
    }
 
    template<typename FSTREAM> inline void scientific(FSTREAM& stream)
    {
        stream.setf(ios::scientific, ios::floatfield);
    }
}
 
#endif /* IOS_H */