/*
           UTF-8 encoded file !!!!
*/
#ifndef T_RETURNSYNCOBJECT_H
#define T_RETURNSYNCOBJECT_H

#include <QObject>
#include <QMutexLocker>
#include <QVariant>

/*
@Denjs 2010
Public Domain licensed ("Общественное достояние")
QT 4.6 tested
*/

/*
Класс презназначенный для реализации
синхронного взаимодействия
через сигнал-слоты.

Может использоваться для передачи параметров расчетов обратно к вызывающей стороне,
для подтверждения получения сигнала.
Может приостановить исходный поток до момента пока сигнал не будет обработан.


Экземпляр класса передается с сигналом,
а на приемной стороне вызывается метод
bool t_returnSyncObject::done()
для сигнализации того, что обработка закончена.
для отслеживания случая, когда сигнал подключен
к более чем 1 слоту, вызывается
bool t_returnSyncObject::done()


На исходной стороне, после испускания сигнала,
вызывается
bool t_returnSyncObject::waitForDone(int timeOut);
метод задерживает управление до момента,
пока не вызван .done() или истечения таймаута.

Для передачи параметров используется
t_returnSyncObject::set_result(QVariant retult)

*/


class t_returnSyncObject : public QObject
{
    Q_OBJECT

public:
    explicit t_returnSyncObject(QObject *parent = 0);

signals:

public slots:
    bool done();
    bool isDone();

    bool reset();
    bool waitForDone(int _timeOut);
    bool setResult(QVariant __result);
    QVariant result();

private:
    mutable QMutex mutex;
    bool    _done;
    QVariant _result;
};

//================================================================================
//--------------------------------------------------------------------------------
// Linux :
#if defined (Q_WS_X11)
        /* nothing needs to be included here yet...*/
// Win :
#elif defined (Q_WS_WIN)
        // for Sleep() :
        #include <windows.h>
// Mac:
#elif defined (Q_WS_MAC)
        /* NOT SUPPORTED THIS VERSION */
#else
        /* NOT SUPPORTED THIS VERSION */
#endif
//--------------------------------------------------------------------------------

static void SleepMS_qt( unsigned int time)
{
        // Linux:
        #if defined (Q_WS_X11)
                        usleep(time*1000);//sleep in millisecinds
        // Win:
        #elif defined (Q_WS_WIN)
                        Sleep(time);//WIN  2008.02.19
        // Mac:
        #elif defined (Q_WS_MAC)
                        // NOT SUPPORTED THIS VERSION
        #else
                        // NOT SUPPORTED THIS VERSION
        #endif
        return;
};


#endif // T_RETURNSYNCOBJECT_H

/*
           UTF-8 encoded file !!!!
*/
#include "t_returnSyncObject.h"

//============================================================================
t_returnSyncObject::t_returnSyncObject(QObject *parent) :
    QObject(parent)
 {
    reset();
 };

//============================================================================
bool t_returnSyncObject::done()
 {
    QMutexLocker locker(&mutex);
    _done=true;
    return _done;
 };

//============================================================================
bool t_returnSyncObject::isDone()
 {
    QMutexLocker locker(&mutex);
    return _done;
 };

//============================================================================
bool t_returnSyncObject::waitForDone(int _timeOut)
 {
    int timePassed=0;
    int stepTimeout=200;
    if ( (!isDone()) && (timePassed<_timeOut) )
        {
            SleepMS_qt(stepTimeout);
            //sleep
            timePassed += stepTimeout;
        };
    return isDone();
 };

//============================================================================
bool t_returnSyncObject::setResult(QVariant __result)
 {
    QMutexLocker locker(&mutex);
    _result = __result;
    return _done;
 };

//============================================================================
QVariant t_returnSyncObject::result()
 {
    return _result;
 };

//============================================================================
bool t_returnSyncObject::reset()
 {
    QMutexLocker locker(&mutex);
    _result = QVariant();
    _done = false;
    return true;
 };

            t_returnSyncObject *syncResultObject=new t_returnSyncObject(this);

            emit mySignal(syncResultObject);
            bool rez=syncResultObject->waitForDone(5000);// ждем не более 5 секунд
            if (rez==false) //таймаут...
                {
                    qDebug() << "Таймаут получения ответа от приемной стороны..";
                    return -1;
                };
            //теперь проверим что нам ответил слот-сервис 
            QString rezStr=syncResultObject->result().toString();

void myClass2::mySlot(t_returnSyncObject *syncResultObject)
{
    if (syncResultObject==0) return;
    if (syncResultObject->isDone()) return;

    QString rez="Обработано!";

    syncResultObject->setResult(QVariant(rez));
    syncResultObject->done();
    return;
}