src/shell/KeyboardReader.cpp

/*
 * LSCP Shell
 *
 * Copyright (c) 2014 - 2020 Christian Schoenebeck
 *
 * This program is part of LinuxSampler and released under the same terms.
 */

#include "KeyboardReader.h"

static KeyboardReader* g_singleton = NULL;
static int g_instanceCount = 0;

KeyboardReader::KeyboardReader() : Thread(false, false, 1, -1),
    m_originalTerminalSetting(TerminalCtrl::now()),
    m_callback(NULL), m_doCallback(true)
{
    if (!g_instanceCount) g_singleton = this;
    g_instanceCount++;
    TerminalCtrl::echoInput(false);
}

KeyboardReader::~KeyboardReader() {
    StopThread();
    TerminalCtrl::restore(m_originalTerminalSetting);
    // ensures that no temporary copy objects delete the global reference
    g_instanceCount--;
    if (!g_instanceCount) g_singleton = NULL;
}

void KeyboardReader::setCallback(Callback_t fn) {
    m_callback = fn;
}

void KeyboardReader::callback(bool b) {
    m_doCallback = b;
}

int KeyboardReader::Main() {
    #if DEBUG
    Thread::setNameOfCaller("KeyboardReader");
    #endif

    while (true) {
        std::vector<char> v = TerminalCtrl::getChars(1, 1);
        if (!v.empty()) {
            // prevent thread from being cancelled
            // (e.g. to prevent deadlocks while holding mutex lock(s))
            pushCancelable(false);

            m_fifoMutex.Lock();
            m_fifo.push_back(v[0]);
            if (m_sync.GetUnsafe()) {
                bool delimiterReceived = false;
                for (std::list<char>::iterator it = m_fifo.begin(); it != m_fifo.end(); ++it) {
                    if ((*it) == m_syncDelimiter) {
                        delimiterReceived = true;
                        break;
                    }
                }
                m_fifoMutex.Unlock();
                if (delimiterReceived) m_sync.Set(false);
            } else {
                m_fifoMutex.Unlock();
                if (m_callback && m_doCallback) (*m_callback)(this);
            }

            // now allow thread being cancelled again
            // (since all mutexes are now unlocked)
            popCancelable();
        }
        TestCancel();
    }
    return 0; // just to avoid a warning with some old compilers
}

bool KeyboardReader::charAvailable() const {
    return !m_fifo.empty(); // is thread safe
}

char KeyboardReader::popChar() {
    LockGuard lock(m_fifoMutex);
    if (m_fifo.empty()) return 0;
    char c = m_fifo.front();
    m_fifo.pop_front();
    return c;
}

std::string KeyboardReader::popStringToDelimiterSync(char delimiter, bool includeDelimiter) {
    m_syncDelimiter = delimiter;
    
    bool alreadyReceived = false;
    m_fifoMutex.Lock();
    for (std::list<char>::iterator it = m_fifo.begin(); it != m_fifo.end(); ++it) {
        if ((*it)== delimiter) {
            alreadyReceived = true;
            break;
        }
    }
    if (!alreadyReceived) m_sync.Set(true);
    m_fifoMutex.Unlock();
    if (!alreadyReceived) m_sync.WaitAndUnlockIf(true);

    // if we are here, then there is now a string with the requested delimiter
    // in the FIFO
    std::string s;
    while (charAvailable()) {
        char c = popChar();
        if (includeDelimiter || c != delimiter) s += c;
        if (c == delimiter) return s;
    }
    return s;
}

void KeyboardReader::startReading() {
    StartThread();
}

void KeyboardReader::stopReading() {
    StopThread();
}

KeyboardReader* KeyboardReader::singleton() {
    return g_singleton;
}
1	schoenebeck	2515	/*
2			* LSCP Shell
3			*
4	schoenebeck	3766	* Copyright (c) 2014 - 2020 Christian Schoenebeck
5	schoenebeck	2515	*
6			* This program is part of LinuxSampler and released under the same terms.
7			*/
8
9			#include "KeyboardReader.h"
10
11			static KeyboardReader* g_singleton = NULL;
12			static int g_instanceCount = 0;
13
14			KeyboardReader::KeyboardReader() : Thread(false, false, 1, -1),
15			m_originalTerminalSetting(TerminalCtrl::now()),
16			m_callback(NULL), m_doCallback(true)
17			{
18			if (!g_instanceCount) g_singleton = this;
19			g_instanceCount++;
20			TerminalCtrl::echoInput(false);
21			}
22
23			KeyboardReader::~KeyboardReader() {
24	schoenebeck	3290	StopThread();
25	schoenebeck	2515	TerminalCtrl::restore(m_originalTerminalSetting);
26			// ensures that no temporary copy objects delete the global reference
27			g_instanceCount--;
28			if (!g_instanceCount) g_singleton = NULL;
29			}
30
31			void KeyboardReader::setCallback(Callback_t fn) {
32			m_callback = fn;
33			}
34
35			void KeyboardReader::callback(bool b) {
36			m_doCallback = b;
37			}
38
39			int KeyboardReader::Main() {
40	schoenebeck	3766	#if DEBUG
41			Thread::setNameOfCaller("KeyboardReader");
42			#endif
43
44	schoenebeck	2515	while (true) {
45			std::vector<char> v = TerminalCtrl::getChars(1, 1);
46			if (!v.empty()) {
47	schoenebeck	3766	// prevent thread from being cancelled
48			// (e.g. to prevent deadlocks while holding mutex lock(s))
49			pushCancelable(false);
50
51	schoenebeck	2515	m_fifoMutex.Lock();
52			m_fifo.push_back(v[0]);
53			if (m_sync.GetUnsafe()) {
54			bool delimiterReceived = false;
55			for (std::list<char>::iterator it = m_fifo.begin(); it != m_fifo.end(); ++it) {
56			if ((*it) == m_syncDelimiter) {
57			delimiterReceived = true;
58			break;
59			}
60			}
61			m_fifoMutex.Unlock();
62			if (delimiterReceived) m_sync.Set(false);
63			} else {
64			m_fifoMutex.Unlock();
65			if (m_callback && m_doCallback) (*m_callback)(this);
66			}
67	schoenebeck	3766
68			// now allow thread being cancelled again
69			// (since all mutexes are now unlocked)
70			popCancelable();
71	schoenebeck	2515	}
72			TestCancel();
73			}
74			return 0; // just to avoid a warning with some old compilers
75			}
76
77			bool KeyboardReader::charAvailable() const {
78			return !m_fifo.empty(); // is thread safe
79			}
80
81			char KeyboardReader::popChar() {
82			LockGuard lock(m_fifoMutex);
83			if (m_fifo.empty()) return 0;
84			char c = m_fifo.front();
85			m_fifo.pop_front();
86			return c;
87			}
88
89			std::string KeyboardReader::popStringToDelimiterSync(char delimiter, bool includeDelimiter) {
90			m_syncDelimiter = delimiter;
91
92			bool alreadyReceived = false;
93			m_fifoMutex.Lock();
94			for (std::list<char>::iterator it = m_fifo.begin(); it != m_fifo.end(); ++it) {
95			if ((*it)== delimiter) {
96			alreadyReceived = true;
97			break;
98			}
99			}
100			if (!alreadyReceived) m_sync.Set(true);
101			m_fifoMutex.Unlock();
102			if (!alreadyReceived) m_sync.WaitAndUnlockIf(true);
103
104			// if we are here, then there is now a string with the requested delimiter
105			// in the FIFO
106			std::string s;
107			while (charAvailable()) {
108			char c = popChar();
109			if (includeDelimiter \|\| c != delimiter) s += c;
110			if (c == delimiter) return s;
111			}
112			return s;
113			}
114
115			void KeyboardReader::startReading() {
116			StartThread();
117			}
118
119			void KeyboardReader::stopReading() {
120			StopThread();
121			}
122
123			KeyboardReader* KeyboardReader::singleton() {
124			return g_singleton;
125			}