CircularLineBuffer.hh

#ifndef VTESTBED_GUI_CIRCULARLINEBUFFER_HH
#define VTESTBED_GUI_CIRCULARLINEBUFFER_HH

#include <mutex>
#include <string>
#include <vector>

#include <vtestbed/core/circular_buffer.hh>

namespace vtb {

    namespace gui {

        enum class LogLineMarker {Output, Error, Log};

        class LogLine {

        private:
            std::string _string;
            LogLineMarker _marker = static_cast<LogLineMarker>(0);

        public:

            LogLine() { this->_string.reserve(512); }

            inline
            LogLine(std::string s, LogLineMarker m):
            _string(s), _marker(m) {}

            inline void
            append(char ch) {
                this->_string += ch;
            }

            inline void
            marker(LogLineMarker m) {
                this->_marker = m;
            }

            inline LogLineMarker
            marker() const {
                return this->_marker;
            }

            inline bool
            hasMarker() const {
                return this->_marker != LogLineMarker(0);
            }

            inline bool
            isError() const {
                return this->_marker == LogLineMarker::Error;
            }

            inline const std::string&
            string() const {
                return this->_string;
            }

            inline bool
            matches(const char* keyword) const {
                return this->_string.find(keyword) != std::string::npos;
            }

            inline void
            clear() {
                this->_string.clear();
                this->_marker = static_cast<LogLineMarker>(0);
            }

            friend class CircularLineBuffer;

        };

        template <class T>
        struct pointer_pair {

            typedef const T* const_pointer;

            const_pointer first, last;

            inline const_pointer begin() const { return first; }
            inline const_pointer end() const { return last; }
            inline size_t size() const { return last-first; }

        };

        class CircularLineBuffer {

        public:
            typedef std::recursive_mutex mutex_t;
            typedef std::lock_guard<CircularLineBuffer> lock_guard_t;
            typedef std::char_traits<char> traits_type;
            typedef vtb::core::Circular_buffer<LogLine> line_array;
            typedef LogLine* pointer;
            typedef const LogLine* const_pointer;
            typedef pointer_pair<LogLine> view_type;

        private:
            static constexpr const size_t max_lines = 500;
            mutex_t _mutex;
            line_array _lines{max_lines};
            LogLine _currentLine;
            bool _dirty = false;

        public:

            void
            put(const char* s, LogLineMarker marker, std::streamsize n=1);

            void
            clear();

            inline void
            lock() {
                this->_mutex.lock();
            }

            inline void
            unlock() {
                this->_mutex.unlock();
            }

            inline const line_array&
            lines() const {
                return this->_lines;
            }

            inline bool
            sync() {
                bool old = this->_dirty;
                this->_dirty = false;
                return old;
            }

        private:

            void newLine();

        };

    }

}

#endif // vim:filetype=cpp