scan-3.1/thread.cpp at master · RoepStoep/scan-3.1 · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

// includes

#include <iostream>
#include <string>

#include "libmy.hpp"
#include "thread.hpp"

// types

class Input : public Waitable {

private:

   std::atomic<bool> m_has_input {false};
   bool m_eof {false};
   std::string m_line;

public:

   bool peek_line (std::string & line);
   bool get_line  (std::string & line);

   void put_eof  ();
   void put_line (const std::string & line);

   bool has_input () const { return m_has_input; }
};

// variables

static Input G_Input;
static std::thread G_Thread;

// prototypes

static void input_program (Input * input);

// functions

void listen_input() {
   G_Thread = std::thread(input_program, &G_Input);
   G_Thread.detach();
}

static void input_program(Input * input) {

   std::string line;

   while (std::getline(std::cin, line)) {
      input->put_line(line);
   }

   input->put_eof();
}

bool has_input() {
   return G_Input.has_input();
}

bool peek_line(std::string & line) {
   return G_Input.peek_line(line);
}

bool get_line(std::string & line) {
   return G_Input.get_line(line);
}

bool Input::peek_line(std::string & line) {

   lock();

   assert(m_has_input);

   bool line_ok = !m_eof;
   if (line_ok) line = m_line;

   unlock();

   return line_ok;
}

bool Input::get_line(std::string & line) {

   lock();

   while (!m_has_input) {
      wait();
   }

   bool line_ok = !m_eof;
   if (line_ok) line = m_line;

   m_has_input = false;
   signal();

   unlock();

   return line_ok;
}

void Input::put_eof() {

   lock();

   while (m_has_input) {
      wait();
   }

   m_eof = true;

   m_has_input = true;
   signal();

   unlock();
}

void Input::put_line(const std::string & line) {

   lock();

   while (m_has_input) {
      wait();
   }

   m_line = line;

   m_has_input = true;
   signal();

   unlock();
}