streambuf.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 STREAMBUF_H
#define STREAMBUF_H
 
#include "queue.h"
#include "flash.h"
#include "virtual.h"
 
namespace streams
{
    class ostreambuf : private containers::Queue<char, char>
    {
    private:
        using QUEUE = Queue<char, char>;
 
    public:
        ostreambuf(const ostreambuf&) = delete;
        ostreambuf& operator=(const ostreambuf&) = delete;
        
        using CALLBACK = virtual_support::VirtualMethod::METHOD;
 
        template<uint8_t SIZE>
        explicit ostreambuf(char (&buffer)[SIZE], CALLBACK callback = nullptr, void* arg = nullptr)
        : QUEUE{buffer, true}, on_put_callback_{callback, arg} {}
 
        void pubsync()
        {
            overflow_ = false;
            while (!empty()) time::yield();
        }
 
        void sputc(char c)
        {
            put_(c, true);
        }
 
        void sputn(const char* content, size_t size)
        {
            while (size--) put_(*content++, false);
            on_put();
        }
 
        void sputn(const char* str)
        {
            while (*str) put_(*str++, false);
            on_put();
        }
 
        void sputn(const flash::FlashStorage* str)
        {
            uint16_t address = (uint16_t) str;
            while (char value = pgm_read_byte(address++)) put_(value, false);
            on_put();
        }
 
        bool overflow() const
        {
            return overflow_;
        }
 
        QUEUE& queue()
        {
            return *this;
        }
 
    protected:
        void put_(char c, bool call_on_put = true)
        {
            if (!push(c)) overflow_ = true;
            if (call_on_put) on_put();
        }
 
        void reset_overflow()
        {
            overflow_ = false;
        }
 
    private:
        void on_put()
        {
            on_put_callback_();
        }
 
        bool overflow_ = false;
        const virtual_support::VirtualMethod on_put_callback_;
 
        friend class ios_base;
        friend class ostream;
    };
 
    class istreambuf : private containers::Queue<char, char>
    {
    private:
        using QUEUE = Queue<char, char>;
 
    public:
        istreambuf(const istreambuf&) = delete;
        istreambuf& operator=(const istreambuf&) = delete;
        
        static const int EOF = -1;
 
        template<uint8_t SIZE> explicit istreambuf(char (&buffer)[SIZE]) : QUEUE{buffer, false} {}
 
        int in_avail() const
        {
            return items();
        }
 
        int sbumpc()
        {
            char value;
            if (pull(value)) return value;
            return EOF;
        }
 
        int sgetc()
        {
            char value;
            if (peek(value)) return value;
            return EOF;
        }
 
        QUEUE& queue()
        {
            return *this;
        }
    };
}
 
#endif /* STREAMBUF_H */