streams.h

Go to the documentation of this file.

//   Copyright 2016-2021 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 STREAMS_HH
#define STREAMS_HH
 
#include <ctype.h>
#include "queue.h"
#include "flash.h"
#include "ios.h"
#include "streambuf.h"
#include "time.h"
 
namespace streams
{
    class ostream : public ios_base
    {
    public:
        explicit ostream(ostreambuf& streambuf) : streambuf_{streambuf} {}
 
        ostream& operator=(const ostream&) = delete;
 
        ostreambuf& rdbuf() const
        {
            return streambuf_;
        }
 
        void flush()
        {
            streambuf_.pubsync();
        }
 
        void put(char c)
        {
            streambuf_.sputc(c);
            check_overflow();
        }
 
        void write(const char* content, size_t size)
        {
            streambuf_.sputn(content, size);
            check_overflow();
        }
 
        void write(const char* str)
        {
            streambuf_.sputn(str);
            check_overflow();
        }
 
        void write(const flash::FlashStorage* str)
        {
            streambuf_.sputn(str);
            check_overflow();
        }
 
        ostream& operator<<(const void* ptr)
        {
            convert(streambuf_, uint16_t(ptr));
            after_insertion();
            return *this;
        }
 
        ostream& operator<<(bool value)
        {
            convert(streambuf_, value);
            after_insertion();
            return *this;
        }
 
        ostream& operator<<(char ch)
        {
            convert(streambuf_, ch);
            after_insertion();
            return *this;
        }
 
        ostream& operator<<(const char* str)
        {
            justify(streambuf_, str, false, nullptr);
            after_insertion();
            return *this;
        }
 
        ostream& operator<<(const flash::FlashStorage* str)
        {
            justify(streambuf_, str);
            after_insertion();
            return *this;
        }
 
        ostream& operator<<(int value)
        {
            convert(streambuf_, value);
            after_insertion();
            return *this;
        }
 
        ostream& operator<<(unsigned int value)
        {
            convert(streambuf_, value);
            after_insertion();
            return *this;
        }
 
        ostream& operator<<(long value)
        {
            convert(streambuf_, value);
            after_insertion();
            return *this;
        }
 
        ostream& operator<<(unsigned long value)
        {
            convert(streambuf_, value);
            after_insertion();
            return *this;
        }
 
        ostream& operator<<(double value)
        {
            convert(streambuf_, value);
            after_insertion();
            return *this;
        }
 
        using MANIPULATOR = void (*)(ostream&);
 
        ostream& operator<<(MANIPULATOR func)
        {
            func(*this);
            return *this;
        }
 
    private:
        void after_insertion()
        {
            check_overflow();
            if (flags() & unitbuf) streambuf_.pubsync();
            width(0);
        }
 
        void check_overflow()
        {
            if (streambuf_.overflow()) setstate(badbit);
        }
 
        ostreambuf& streambuf_;
    };
 
    // NOTE: istream API is blocking, while istreambuf is not
    class istream : public ios_base
    {
    public:
        explicit istream(istreambuf& streambuf) : streambuf_{streambuf} {}
 
        istream& operator=(const istream&) = delete;
 
        istreambuf& rdbuf() const
        {
            return streambuf_;
        }
 
        int peek()
        {
            int value;
            while ((value = streambuf_.sgetc()) == istreambuf::EOF) time::yield();
            return value;
        }
 
        int get()
        {
            int value;
            while ((value = streambuf_.sbumpc()) == istreambuf::EOF) time::yield();
            return value;
        }
 
        istream& get(char& ch)
        {
            ch = get();
            return *this;
        }
 
        istream& get(char* str, size_t n, char delim = '\n')
        {
            while (--n)
            {
                int ch = peek();
                if (ch == delim) break;
                *str++ = get();
            }
            *str = 0;
            return *this;
        }
 
        istream& getline(char* str, size_t n, char delim = '\n')
        {
            while (--n)
            {
                int ch = get();
                if (ch == delim) break;
                *str++ = ch;
            }
            *str = 0;
            return *this;
        }
 
        istream& ignore(size_t n = 1, int delim = istreambuf::EOF)
        {
            bool forever = (n == 0);
            while (forever || (n > 0))
            {
                --n;
                if (get() == delim) break;
            }
            return *this;
        }
 
        istream& read(char* str, size_t n)
        {
            while (n--) *str++ = get();
            return *this;
        }
 
        istream& operator>>(char* buf)
        {
            if (width() > 0)
            {
                skipws_if_needed();
                scan(buf, width());
                width(0);
            }
            return *this;
        }
 
        istream& operator>>(bool& value)
        {
            skipws_if_needed();
            char buffer[10 + 1];
            convert(scan(buffer, sizeof buffer), value);
            return *this;
        }
 
        istream& operator>>(char& value)
        {
            skipws_if_needed();
            value = containers::pull(streambuf_.queue());
            return *this;
        }
 
        istream& operator>>(int& value)
        {
            skipws_if_needed();
            char buffer[sizeof(int) * 8 + 1];
            convert(scan(buffer, sizeof buffer), value);
            return *this;
        }
 
        istream& operator>>(unsigned int& value)
        {
            skipws_if_needed();
            char buffer[sizeof(int) * 8 + 1];
            convert(scan(buffer, sizeof buffer), value);
            return *this;
        }
 
        istream& operator>>(long& value)
        {
            skipws_if_needed();
            char buffer[sizeof(long) * 8 + 1];
            convert(scan(buffer, sizeof buffer), value);
            return *this;
        }
 
        istream& operator>>(unsigned long& value)
        {
            skipws_if_needed();
            char buffer[sizeof(long) * 8 + 1];
            convert(scan(buffer, sizeof buffer), value);
            return *this;
        }
 
        istream& operator>>(double& value)
        {
            skipws_if_needed();
            // 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];
            convert(scan(buffer, sizeof buffer), value);
            return *this;
        }
 
        using MANIPULATOR = void (*)(istream&);
 
        istream& operator>>(MANIPULATOR func)
        {
            func(*this);
            return *this;
        }
 
    private:
        void skipws_if_needed()
        {
            if (flags() & skipws) skip_whitespace();
        }
 
        void skip_whitespace()
        {
            while (isspace(containers::peek(streambuf_.queue()))) containers::pull(streambuf_.queue());
        }
 
        char* scan(char* str, size_t max);
 
        istreambuf& streambuf_;
 
        template<typename FSTREAM> friend void ws(FSTREAM&);
    };
 
    template<typename FSTREAM> inline void ws(FSTREAM& stream)
    {
        stream.skip_whitespace();
    }
 
    template<typename FSTREAM> inline void flush(FSTREAM& stream)
    {
        stream.flush();
    }
 
    template<typename FSTREAM> inline void endl(FSTREAM& stream)
    {
        stream.put('\n');
        stream.flush();
    }
}
 
#endif /* STREAMS_HH */