TextDisplayStream.hpp

Go to the documentation of this file.

/*
 * This file is part of the DUDS project. It is subject to the BSD-style
 * license terms in the LICENSE file found in the top-level directory of this
 * distribution and at https://github.com/jjackowski/duds/blob/master/LICENSE.
 * No part of DUDS, including this file, may be copied, modified, propagated,
 * or distributed except according to the terms contained in the LICENSE file.
 *
 * Copyright (C) 2017  Jeff Jackowski
 */
#include <duds/hardware/display/TextDisplay.hpp>
#include <duds/general/Spinlock.hpp>
#include <iostream>
#include <cstring>

namespace duds { namespace hardware { namespace display {

template <class Char, class Traits = std::char_traits<Char> >
class TextDisplayBasicStreambuf : public std::basic_streambuf<Char, Traits> {
    std::shared_ptr<TextDisplay> disp;
protected:
    virtual typename Traits::int_type overflow(
        typename Traits::int_type c = Traits::eof()
    ) {
        // nowhere to go; return an error
        if (!disp) {
            return Traits::eof();
        }
        // there is no end to the data the display can take
        if (c == Traits::eof()) {
            return Traits::not_eof(c);
        }
        switch (c) {
            // carriage return
            case '\r':
                disp->move(0, disp->rowPos());
                break;
            // new line
            case '\n':
                disp->clearTo(disp->columns() - 1, disp->rowPos());
                break;
            // something else
            default:
                // write out the character
                disp->write((int)c);
        }
        return c;
    }
public:
    TextDisplayBasicStreambuf(const std::shared_ptr<TextDisplay> &d) : disp(d) {
        assert(d);
    }
    const std::shared_ptr<TextDisplay> &display() const {
        return disp;
    }
    virtual unsigned int column() const {
        return disp->columnPos();
    }
    virtual unsigned int row() const {
        return disp->rowPos();
    }
    virtual void moveCursor(unsigned int c, unsigned int r) {
        disp->move(c, r);
    }
    virtual void clearDisplay() {
        disp->clear();
    }
    virtual void clearTo(unsigned int c, unsigned int r) {
        disp->clearTo(c, r);
    }
    virtual void startLine() {
        TextDisplay *td = disp.get();
        if (td) {
            if (td->columnPos() > 0) {
                td->clearTo(td->columns() - 1, td->rowPos());
            }
        }
    }
};

template <class Char, class Traits = std::char_traits<Char> >
class TextDisplayBasicBufferedStreambuf :
public TextDisplayBasicStreambuf<Char, Traits> {
    using base = TextDisplayBasicStreambuf<Char, Traits>;
    std::vector<Char> shown;
    std::vector<Char> update;
    std::vector<Char> working;
    duds::general::Spinlock wblock;
    std::uint8_t columnsize;
    std::uint8_t rowsize;
    std::uint8_t cpos;
    std::uint8_t rpos;
    void write(Char c) {
        // write out the character
        *base::pptr() = c;
        // advance to the next character
        if (++cpos >= columnsize) {
            cpos = 0;
            if (++rpos >= rowsize) {
                rpos = 0;
                // reposition to start of buffer
                base::setp(base::pbase(), base::epptr());
                return;
            }
        }
        base::pbump(1);
    }
    void clearToImpl(unsigned int c, unsigned int r) {
        while ((cpos != c) || (rpos != r)) {
            write(' ');
        }
        write(' ');
    }
    void bufWrite(Char c) {
        // no locking; must already be locked
        switch (c) {
            // carriage return
            case '\r':
                base::pbump(-(int)cpos);
                cpos = 0;
                break;
            // new line
            case '\n':
                clearToImpl(columnsize - 1, rpos);
                break;
            // something else
            default:
                // write out the character
                write((int)c);
        }
    }
protected:
    virtual typename Traits::int_type overflow(
        typename Traits::int_type c = Traits::eof()
    ) {
        // ignore EOF
        if (c != Traits::eof()) {
            duds::general::SpinLockGuard lock(wblock);
            bufWrite((Char)c);
        }
        return Traits::not_eof(c);
    }
    virtual std::streamsize xsputn(const Char* s, std::streamsize count) {
        duds::general::SpinLockGuard lock(wblock);
        for (std::streamsize cnt = count; cnt > 0; ++s, --cnt) {
            bufWrite(*s);
        }
        return count;
    }
    virtual int sync() {
        // copy data to write to the display; allows another thread to keep
        { // writing more text
            duds::general::SpinLockGuard lock(wblock);
            update = working;
        }
        // compare update and shown buffer to output what is needed
        typename std::vector<Char>::iterator siter = shown.begin();
        typename std::vector<Char>::iterator uiter = update.begin();
        bool cont = false; // contiguous flag
        for (int r = 0; r < rowsize; ++r) {
            for (int c = 0; c < columnsize; ++siter, ++uiter, ++c) {
                // difference?
                if (*siter != *uiter) {
                    // non-contiguous?
                    if (!cont) {
                        // reposition cursor
                        base::display()->move(c, r);
                        cont = true;
                    }
                    assert(base::display()->columnPos() == c);
                    assert(base::display()->rowPos() == r);
                    // write data
                    base::display()->write((int)*uiter);
                    // update shown buffer
                    *siter = *uiter;
                } else {
                    // no longer contiguos
                    cont = false;
                }
            }
        }
        return 0; // success code
    }
    virtual typename base::pos_type seekoff(
        typename base::off_type off,
        std::ios_base::seekdir dir,
        std::ios_base::openmode which = std::ios_base::out
    ) {
        // only output seeking is supported
        if (which & std::ios_base::out) {
            duds::general::SpinLockGuard lock(wblock);
            // figure out new absolute position
            typename base::pos_type cp = base::pptr() - base::pbase();
            typename base::pos_type op;
            switch (dir) {
                case std::ios_base::beg:
                    op = off;
                    break;
                case std::ios_base::cur:
                    op = cp + off;
                    break;
                case std::ios_base::end:
                    op = working.size() + off;
                    break;
                default:
                    return typename base::pos_type(-1);
            }
            // do not seek out of bounds
            if ((op > 0) && (op < working.size())) {
                // reposition to start
                base::setp(base::pbase(), base::epptr());
                // seek to requested position
                base::pbump(op);
                // compute row & column positions
                rpos = op / columnsize;
                cpos = op % columnsize;
                return op;
            }
        }
        return typename base::pos_type(-1);
    }
    virtual typename base::pos_type seekpos(
        typename base::pos_type pos,
        std::ios_base::openmode which = std::ios_base::out
    ) {
        return seekoff(typename base::off_type(pos), std::ios_base::beg, which);
    }
public:
    TextDisplayBasicBufferedStreambuf(const std::shared_ptr<TextDisplay> &d) :
    TextDisplayBasicStreambuf<Char, Traits>(d),
    columnsize(d->columns()),
    rowsize(d->rows()),
    cpos(0),
    rpos(0),
    shown(d->columns() * d->rows(), ' '),
    update(d->columns() * d->rows(), ' '),
    working(d->columns() * d->rows(), ' ') {
        base::setp(&(working[0]), &(working[0]) + (columnsize * rowsize));
    }
    virtual unsigned int column() const {
        return cpos;
    }
    virtual unsigned int row() const {
        return rpos;
    }
    virtual void moveCursor(unsigned int c, unsigned int r) {
        // range check
        if ((c >= columnsize) || (r >= rowsize)) {
            DUDS_THROW_EXCEPTION(DisplayBoundsError() <<
                TextDisplayPositionInfo(Info_DisplayColRow(c, r)) <<
                TextDisplaySizeInfo(Info_DisplayColRow(columnsize, rowsize))
            );
        }
        duds::general::SpinLockGuard lock(wblock);
        base::setp(base::pbase(), base::epptr());
        cpos = c;
        rpos = r;
        base::pbump(r * columnsize + c);
    }
    virtual void clearDisplay() {
        duds::general::SpinLockGuard lock(wblock);
        // make the work-in-progress all spaces
        std::memset(&(working[0]), ' ', working.size());
        // reposition to start of buffer
        base::setp(base::pbase(), base::epptr());
        cpos = rpos = 0;
    }
    virtual void clearTo(unsigned int c, unsigned int r) {
        // range check
        if ((c >= columnsize) || (r >= rowsize)) {
            DUDS_THROW_EXCEPTION(DisplayBoundsError() <<
                TextDisplayPositionInfo(Info_DisplayColRow(c, r)) <<
                TextDisplaySizeInfo(Info_DisplayColRow(columnsize, rowsize))
            );
        }
        duds::general::SpinLockGuard lock(wblock);
        clearToImpl(c, r);
    }
    virtual void startLine() {
        duds::general::SpinLockGuard lock(wblock);
        if (cpos > 0) {
            clearToImpl(columnsize - 1, rpos);
        }
    }
};

template <class Char = char, class Traits = std::char_traits<Char> >
class TextDisplayBaseStream : public std::basic_ostream<Char, Traits> {
    using base = std::basic_ostream<Char, Traits>;
    TextDisplayBasicStreambuf<Char, Traits> *tdbb;
    static const int xidx;
public:
    TextDisplayBaseStream(TextDisplayBasicStreambuf<Char, Traits> *tbuf) :
    tdbb(tbuf) {
        base::init(tdbb);
        this->pword(xidx) = this;
    }
    static int xallocIndex() {
        return xidx;
    }
    const std::shared_ptr<TextDisplay> &display() const {
        return tdbb->display();
    }
    void moveCursor(unsigned int c, unsigned int r) {
        tdbb->moveCursor(c, r);
    }
    void clearDisplay() {
        tdbb->clearDisplay();
    }
    void clearTo(unsigned int c, unsigned int r) {
        tdbb->clearTo(c, r);
    }
    void startLine() {
        tdbb->startLine();
    }
};


// convineince classes; could use TextDisplayBasicBuffer or
// TextDisplayStoredBuffer without them
template <class Char, class Traits = std::char_traits<Char> >
class TextDisplayBasicStream : public TextDisplayBaseStream<Char, Traits> {
    TextDisplayBasicStreambuf<Char, Traits> buff;
public:
    TextDisplayBasicStream(const std::shared_ptr<TextDisplay> &d) :
    buff(d), TextDisplayBaseStream<Char, Traits>(&buff) { }
};

template <class Char, class Traits = std::char_traits<Char> >
class TextDisplayBasicBufferedStream : public TextDisplayBaseStream<Char, Traits> {
    TextDisplayBasicBufferedStreambuf<Char, Traits> buff;
public:
    TextDisplayBasicBufferedStream(const std::shared_ptr<TextDisplay> &d) :
    buff(d), TextDisplayBaseStream<Char, Traits>(&buff) { }
};

template <class Char, class Traits>
const int TextDisplayBaseStream<Char, Traits>::xidx = std::ios_base::xalloc();

template <class Char, class Traits>
std::basic_ostream<Char, Traits> &clear(std::basic_ostream<Char, Traits> &os) {
    if (os.pword(TextDisplayBaseStream<Char, Traits>::xallocIndex()) == &os) {
        static_cast<TextDisplayBaseStream<Char, Traits>&>(os).clearDisplay();
    }
    return os;
}

template <class Char, class Traits>
std::basic_ostream<Char, Traits> &startLine(std::basic_ostream<Char, Traits> &os) {
    if (os.pword(TextDisplayBaseStream<Char, Traits>::xallocIndex()) == &os) {
        static_cast<TextDisplayBaseStream<Char, Traits>&>(os).startLine();
    }
    return os;
}

struct move_impl {
    unsigned int col;
    unsigned int row;
    move_impl(unsigned int c, unsigned int r) : col(c), row(r) { }
    template <class Char, class Traits>
    friend std::basic_ostream<Char, Traits> &operator << (
        std::basic_ostream<Char, Traits> &os, const move_impl &mi
    ) {
        if (os.pword(TextDisplayBaseStream<Char, Traits>::xallocIndex()) == &os) {
            static_cast<TextDisplayBaseStream<Char, Traits>&>(os).moveCursor(
                mi.col, mi.row
            );
        }
        return os;
    }
};

inline move_impl move(unsigned int c, unsigned int r) {
    return move_impl(c, r);
}

struct clearTo_impl {
    unsigned int col;
    unsigned int row;
    clearTo_impl(unsigned int c, unsigned int r) : col(c), row(r) { }
    template <class Char, class Traits>
    friend std::basic_ostream<Char, Traits> &operator << (
        std::basic_ostream<Char, Traits> &os, const clearTo_impl &mi
    ) {
        if (os.pword(TextDisplayBaseStream<Char, Traits>::xallocIndex()) == &os) {
            static_cast<TextDisplayBaseStream<Char, Traits>&>(os).clearTo(
                mi.col, mi.row
            );
        }
        return os;
    }
};

inline clearTo_impl clearTo(unsigned int c, unsigned int r) {
    return clearTo_impl(c, r);
}

typedef TextDisplayBasicStreambuf<char>  TextDisplayStreambuf;
typedef TextDisplayBasicBufferedStreambuf<char>  TextDisplayBufferedStreambuf;
typedef TextDisplayBasicStream<char>  TextDisplayStream;
typedef TextDisplayBasicBufferedStream<char>  TextDisplayBufferedStream;

} } }