synchronousprinter.h

Go to the documentation of this file.

 
#pragma once
 
#include <PropWare/hmi/output/printer.h>
 
namespace PropWare {
 
class SynchronousPrinter {
    public:
        SynchronousPrinter (const Printer &printer)
                : m_printer(&printer),
                  m_lock(locknew()),
                  m_borrowed(false) {
            lockclr(this->m_lock);
        }
 
        ~SynchronousPrinter () {
            lockclr(this->m_lock);
            lockret(this->m_lock);
        }
 
        bool has_lock () const {
            return -1 != this->m_lock;
        }
 
        bool refreshLock () {
            if (this->has_lock()) {
                // Wait for any other cogs using the lock to return
                while (lockset(this->m_lock));
                lockclr(this->m_lock);
                lockret(this->m_lock);
            }
 
            this->m_lock = locknew();
            return this->has_lock();
        }
 
        const Printer *borrow_printer () {
            while (lockset(this->m_lock));
            this->m_borrowed = true;
            return this->m_printer;
        }
 
        bool return_printer (const Printer *printer) {
            if (printer == this->m_printer) {
                lockclr(this->m_lock);
                this->m_borrowed = false;
                return true;
            } else
                return false;
        }
 
        template<typename T>
        void print (const T var) const {
            while (lockset(this->m_lock));
            this->m_printer->print(var);
            lockclr(this->m_lock);
        }
 
        void println (const char string[]) const {
            while (lockset(this->m_lock));
            this->m_printer->println(string);
            lockclr(this->m_lock);
        }
 
        void printf (const char fmt[]) const {
            while (lockset(this->m_lock));
            this->m_printer->puts(fmt);
            lockclr(this->m_lock);
        }
 
        template<typename T, typename... Targs>
        void printf (const char fmt[], const T first, const Targs... remaining) const {
            while (lockset(this->m_lock));
            this->m_printer->printf(fmt, first, remaining...);
            lockclr(this->m_lock);
        }
 
    protected:
        const Printer *m_printer;
        int           m_lock;
        bool          m_borrowed;
};
 
}
 
extern const PropWare::SynchronousPrinter pwSyncOut;