streambuf.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 STREAMBUF_H
#define STREAMBUF_H
 
#include "flash.h"
#include "interrupts.h"
#include "queue.h"
 
#define REGISTER_OSTREAMBUF_LISTENERS(HANDLER1, ...)                                \
    void streams::ostreambuf_on_put_dispatch(ostreambuf& obuf)                      \
    {                                                                               \
        streams::dispatch_handler::ostreambuf_on_put<HANDLER1, ##__VA_ARGS__>(obuf);\
    }
 
#define REGISTER_OSTREAMBUF_NO_LISTENERS()                          \
    void streams::ostreambuf_on_put_dispatch(ostreambuf&) {}
 
#define DECL_OSTREAMBUF_LISTENERS_FRIEND         \
    friend struct streams::dispatch_handler;
 
namespace streams
{
    class ostreambuf;
    extern void ostreambuf_on_put_dispatch(ostreambuf&);
 
    class ostreambuf : private containers::Queue<char, char>
    {
    private:
        using QUEUE = Queue<char, char>;
 
    public:
        ostreambuf(const ostreambuf&) = delete;
        ostreambuf& operator=(const ostreambuf&) = delete;
 
        template<uint8_t SIZE>
        explicit ostreambuf(char (&buffer)[SIZE]) : QUEUE{buffer, true} {}
 
        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()
        {
            ostreambuf_on_put_dispatch(*this);
        }
 
        bool overflow_ = false;
 
        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;
        }
    };
 
    struct dispatch_handler
    {
        template<bool DUMMY_> static bool ostreambuf_on_put_helper(ostreambuf& obuf UNUSED)
        {
            return false;
        }
 
        template<bool DUMMY_, typename HANDLER1_, typename... HANDLERS_> 
        static bool ostreambuf_on_put_helper(ostreambuf& obuf)
        {
            bool result = interrupt::HandlerHolder<HANDLER1_>::handler()->on_put(obuf);
            // handle other handlers if needed
            return result || ostreambuf_on_put_helper<DUMMY_, HANDLERS_...>(obuf);
        }
 
        template<typename... HANDLERS_> static void ostreambuf_on_put(ostreambuf& obuf)
        {
            // Ask each registered listener tohandle obuf on_put() if concerned
            ostreambuf_on_put_helper<false, HANDLERS_...>(obuf);
        }
    };
}
 
#endif /* STREAMBUF_H */