NumberDumper.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_NUMBERDUMPER_HXX_
#define _UTILS_NUMBERDUMPER_HXX_
 
#include "executor/StateFlow.hxx"
#include "utils/Singleton.hxx"
#include "utils/logging.h"
 
class NumberDumper : public Singleton<NumberDumper>
{
public:
    NumberDumper(Service *s)
        : displayFlow_(s)
    {
    }
 
    void add(uint16_t data)
    {
        if (!nextChunk_)
        {
            nextChunk_ = displayFlow_.alloc();
            nextOfs_ = 0;
        }
        nextChunk_->data()->data[nextOfs_] = data;
        if (++nextOfs_ >= BUFSIZE)
        {
            displayFlow_.send(nextChunk_);
            nextChunk_ = nullptr;
        }
    }
 
    static constexpr uint16_t EOLN = 0xffffu;
 
private:
    static constexpr unsigned BUFSIZE = 128;
 
    struct Chunk
    {
        uint16_t data[BUFSIZE];
    };
 
    Buffer<Chunk> *nextChunk_ = nullptr;
    unsigned nextOfs_ = 0;
 
    class Displayer : public StateFlow<Buffer<Chunk>, QList<1>>
    {
    public:
        Displayer(Service *s)
            : StateFlow<Buffer<Chunk>, QList<1>>(s)
        {
            endp_ = output;
            thisLineLimit_ = endp_ + MIN_LINE;
        }
 
        Action entry() override
        {
            nextOfs_ = 0;
            return call_immediately(STATE(render));
        }
 
        Action render()
        {
            while (true)
            {
                bool send_off = false;
                if (nextOfs_ >= BUFSIZE)
                {
                    return release_and_exit();
                }
                auto d = message()->data()->data[nextOfs_];
                if (d == EOLN)
                {
                    if (!line_prefer_end())
                    {
                        *endp_++ = '|';
                    }
                    else if (fits_next_line())
                    {
                        *endp_++ = '\n';
                        thisLineLimit_ = endp_ + MIN_LINE;
                    }
                    else
                    {
                        send_off = true;
                    }
                }
                else if (!has_one_number())
                {
                    send_off = true;
                }
 
                if (send_off)
                {
                    GLOBAL_LOG_OUTPUT(output, endp_ - output);
                    endp_ = output;
                    thisLineLimit_ = endp_ + MIN_LINE;
                }
 
                if (d != EOLN)
                {
                    endp_ = unsigned_integer_to_buffer(d, endp_);
                    *endp_ = ' ';
                    endp_++;
                }
                if (++nextOfs_ % 30 == 0)
                    return yield();
            }
        }
 
    private:
        bool has_one_number()
        {
            return endp_ < (output_limit() - 12);
        }
 
        bool line_prefer_end()
        {
            return endp_ >= thisLineLimit_;
        }
 
        bool fits_next_line()
        {
            return endp_ + (MIN_LINE * 3) <= output_limit();
        }
 
        char *output_limit()
        {
            return output + sizeof(output);
        }
 
        char *endp_;
        char *thisLineLimit_;
        uint16_t nextOfs_;
        char output[320];
        static constexpr uint8_t MIN_LINE = 60;
    };
 
    Displayer displayFlow_;
};
 
#endif // _UTILS_NUMBERDUMPER_HXX_