c@94: 
c@94: #ifndef PIPER_PROCESS_QT_TRANSPORT_H
c@94: #define PIPER_PROCESS_QT_TRANSPORT_H
c@94: 
c@94: #include "SynchronousTransport.h"
c@94: 
c@94: #include <QProcess>
c@94: #include <QString>
c@100: #include <QMutex>
c@94: 
c@94: #include <iostream>
c@94: 
c@97: namespace piper_vamp {
c@97: namespace client {
c@94: 
c@100: /**
c@100:  * A SynchronousTransport implementation that spawns a sub-process
c@100:  * using Qt's QProcess abstraction and talks to it via stdin/stdout
c@100:  * channels. Calls are completely serialized; the protocol only
c@100:  * supports one call in process at a time, and therefore the transport
c@100:  * only allows one at a time. This class is thread-safe because it
c@100:  * serializes explicitly using a mutex.
c@100:  */
c@94: class ProcessQtTransport : public SynchronousTransport
c@94: {
c@94: public:
c@101:     ProcessQtTransport(std::string processName) :
c@94:         m_completenessChecker(0) {
c@94:         m_process = new QProcess();
c@94:         m_process->setReadChannel(QProcess::StandardOutput);
c@94:         m_process->setProcessChannelMode(QProcess::ForwardedErrorChannel);
c@101:         m_process->start(QString::fromStdString(processName));
c@94:         if (!m_process->waitForStarted()) {
c@94:             std::cerr << "server failed to start" << std::endl;
c@94:             delete m_process;
c@94:             m_process = nullptr;
c@94:         }
c@94:     }
c@94: 
c@94:     ~ProcessQtTransport() {
c@94:         if (m_process) {
c@94:             if (m_process->state() != QProcess::NotRunning) {
c@94: 		m_process->closeWriteChannel();
c@94:                 m_process->waitForFinished(200);
c@94:                 m_process->close();
c@94:                 m_process->waitForFinished();
c@94:                 std::cerr << "server exited" << std::endl;
c@94:             }
c@94:             delete m_process;
c@94:         }
c@94:     }
c@94: 
c@94:     void
c@94:     setCompletenessChecker(MessageCompletenessChecker *checker) {
c@94:         //!!! ownership?
c@94:         m_completenessChecker = checker;
c@94:     }
c@94:     
c@94:     bool
c@94:     isOK() const override {
c@94:         return m_process != nullptr;
c@94:     }
c@94:     
c@94:     std::vector<char>
c@94:     call(const char *ptr, size_t size) override {
c@94: 
c@100: 	QMutexLocker locker(&m_mutex);
c@100: 	
c@94:         if (!m_completenessChecker) {
c@94:             throw std::logic_error("No completeness checker set on transport");
c@94:         }
c@94:         
c@94:         m_process->write(ptr, size);
c@94:         
c@94:         std::vector<char> buffer;
c@94:         bool complete = false;
c@94:         
c@94:         while (!complete) {
c@94: 
c@94:             qint64 byteCount = m_process->bytesAvailable();
c@94: 
c@101: 	    if (!byteCount) {
c@108: 		std::cerr << "waiting for data from server..." << std::endl;
c@101: 		m_process->waitForReadyRead(1000);
c@94:                 if (m_process->state() == QProcess::NotRunning) {
c@94:                     std::cerr << "ERROR: Subprocess exited: Load failed" << std::endl;
c@94:                     throw std::runtime_error("Piper server exited unexpectedly");
c@94:                 }
c@94:             } else {
c@94:                 size_t formerSize = buffer.size();
c@94:                 buffer.resize(formerSize + byteCount);
c@94:                 m_process->read(buffer.data() + formerSize, byteCount);
c@94:                 complete = m_completenessChecker->isComplete(buffer);
c@94:             }
c@94:         }
c@94: 
c@94:         return buffer;
c@94:     }
c@94:     
c@94: private:
c@94:     MessageCompletenessChecker *m_completenessChecker; //!!! I don't own this (currently)
c@94:     QProcess *m_process; // I own this
c@100:     QMutex m_mutex;
c@94: };
c@94: 
c@94: }
c@94: }
c@94: 
c@94: #endif