How to implement concurrent file/text edit with c++? - c++

Question

I'm working on a small project with Qt (for learning Qt and bit of c++ exercise) and what I want to achieve is a clone of "online coding editors" which multiple users can read and edit a document. Doesn't have to be online, main purpose is to handle concurrent file editing. I just don't know how to approach this task.
What I have done till now is to build a simple text editor. Program has two text areas. In text area 1 you write your code. In text area 2 it shows the output. When you run your code it saves the contents of the text area 1 to a file (Code.cpp for example) then compile the saved file. When it compiled, another function runs the exe and writes the output to another file(This done in powershell's Out-File command). text area 2 just reads the content of the output file.
For single user this works. The problem is I don't know how to handle when there are multiple users. Someone suggested me that I should use text editor program as a client and handle concurrent operations in a server. That seems like a nice approach. Does that mean I should also handle the save file and run code option on the server?
And how do I do let multiple users edit the same file? Obviously I'm not asking for a -real- code. I know mutexes and semaphores but never implemented one. Some pseudo code might help maybe? I don't know where to start to dig up so here I am. I would really appreciate if someone can point me a direction (any books to read or tutorials... etc)

Answer 1

Take a look at QThread and Qt Signals/Slots. Let's say you have a main program that has an editor and a save command. This is your main thread. Your save command is executed in a worker thread, an instance of QThread that can run next to your main thread. When the user clicks save, your worker thread will send a Qt Signal saying that the save command was executed. Your main thread can then refresh the file contents. Now because you use QThread and Qt Signals you will not need any mutex or semaphore or any kind of resource locking because that's already done for you. You can see this as thread safe.
The following example was directly taken from the Qt docs: https://doc.qt.io/qt-5/qthread.html
class Worker : public QObject
{
Q_OBJECT
public slots:
void doWork(const QString &parameter) {
QString result;
/* ... here is the expensive or blocking operation ... */
emit resultReady(result);
}
signals:
void resultReady(const QString &result);
};
class Controller : public QObject
{
Q_OBJECT
QThread workerThread;
public:
Controller() {
Worker *worker = new Worker;
worker->moveToThread(&workerThread);
connect(&workerThread, &QThread::finished, worker, &QObject::deleteLater);
connect(this, &Controller::operate, worker, &Worker::doWork);
connect(worker, &Worker::resultReady, this, &Controller::handleResults);
workerThread.start();
}
~Controller() {
workerThread.quit();
workerThread.wait();
}
public slots:
void handleResults(const QString &);
signals:
void operate(const QString &);
};