dataexchange.h

Go to the documentation of this file.

/********************************************************************************
 *  FARSA                                                                       *
 *  Copyright (C) 2007-2012                                                     *
 *  Gianluca Massera <emmegian@yahoo.it>                                        *
 *  Stefano Nolfi <stefano.nolfi@istc.cnr.it>                                   *
 *  Tomassino Ferrauto <tomassino.ferrauto@istc.cnr.it>                         *
 *                                                                              *
 *  This program is free software; you can redistribute it and/or modify        *
 *  it under the terms of the GNU General Public License as published by        *
 *  the Free Software Foundation; either version 2 of the License, or           *
 *  (at your option) any later version.                                         *
 *                                                                              *
 *  This program is distributed in the hope that it will be useful,             *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of              *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               *
 *  GNU General Public License for more details.                                *
 *                                                                              *
 *  You should have received a copy of the GNU General Public License           *
 *  along with this program; if not, write to the Free Software                 *
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA  *
 ********************************************************************************/

#ifndef DATAEXCHANGE_H
#define DATAEXCHANGE_H

#include <QEvent>
#include <QObject>
#include <QSet>
#include <QMutex>
#include <QMutexLocker>
#include <QWaitCondition>
#include <memory>
#include "baseexception.h"
#include "utilitiesexceptions.h"

namespace farsa {

namespace __DataExchange_internal {
    class QueueHolderBase;
    template <class DataType_t>
    class QueueHolder;
}
template <class DataType_t>
class DatumToUpload;
template <class DataType_t>
class DataDownloader;
template <class C>
class Downloader;

template <class DataType_t>
class FARSA_UTIL_TEMPLATE DataUploader
{
public:
    typedef DataType_t DataType;

    typedef farsa::DatumToUpload<DataType> DatumToUpload;

    enum FullQueueBehavior {
        OverrideOlder, 
        BlockUploader, 
        IncreaseQueueSize, 
        SignalUploader 
    };

public:
    DataUploader(unsigned int queueSize, FullQueueBehavior b, DataDownloader<DataType>* downloader = NULL);

    ~DataUploader();

    unsigned int getQueueSize() const
    {
        return m_queueSize;
    }

    FullQueueBehavior getFullQueueBehavior() const
    {
        return m_fullQueueBehavior;
    }

    const DataDownloader<DataType>* getDownloader() const
    {
        return m_queue->downloader;
    }

    unsigned int getAvailableSpace() const;

    unsigned int getNumDataInQueue() const;

    DataType* createDatum();

    void uploadDatum();

    bool datumCreatedNotUploaded() const
    {
        return m_datumCreatedNotUploaded;
    }

    void checkAssociationBeforeUpload(bool v)
    {
        m_checkAssociationBeforeUpload = v;
    }

    bool associationBeforeUploadChecked() const
    {
        return m_checkAssociationBeforeUpload;
    }

private:
        void setDownloader(DataDownloader<DataType>* downloader);

    bool associationPresent() const;

    const unsigned int m_queueSize;

    const FullQueueBehavior m_fullQueueBehavior;

    std::auto_ptr<__DataExchange_internal::QueueHolder<DataType> > m_queue;

    bool m_datumCreatedNotUploaded;

    bool m_checkAssociationBeforeUpload;

    friend class DataDownloader<DataType>;

    DataUploader(const DataUploader<DataType>& other);

    DataUploader& operator=(const DataUploader<DataType>& other);
};

template <class DataType_t>
class FARSA_UTIL_TEMPLATE DatumToUpload
{
public:

    typedef DataType_t DataType;

public:
    DatumToUpload(DataUploader<DataType>& uploader) :
        m_uploader(uploader),
        m_datum(m_uploader.createDatum()),
        m_datumUploaded(false)
    {
    }

    ~DatumToUpload()
    {
        uploadDatum();
    }

    void uploadDatum()
    {
        if (!m_datumUploaded) {
            m_uploader.uploadDatum();
            m_datum = NULL;
            m_datumUploaded = true;
        }
    }

    const DataType* operator->() const
    {
        return m_datum;
    }

    DataType* operator->()
    {
        return m_datum;
    }

    bool operator==(const DataType* other) const
    {
        return (m_datum == other);
    }

    operator bool() const
    {
        return (m_datum != NULL);
    }

private:
    DataUploader<DataType>& m_uploader;

    DataType* m_datum;

    bool m_datumUploaded;

    DatumToUpload(const DatumToUpload<DataType>& other);

    DatumToUpload& operator=(const DatumToUpload<DataType>& other);
};

template<class DataType_t>
class FARSA_UTIL_TEMPLATE NewDatumEvent : public QEvent
{
public:
    static const QEvent::Type newDatumEventType = static_cast<QEvent::Type>(QEvent::User + 1);

    typedef DataType_t DataType;

public:
    NewDatumEvent(DataDownloader<DataType>* downloader) :
        QEvent(newDatumEventType),
        m_downloader(downloader)
    {
    }

    virtual ~NewDatumEvent()
    {
    }

    const DataDownloader<DataType>* getDownloader() const
    {
        return m_downloader;
    }

    DataDownloader<DataType>* getDownloader()
    {
        return m_downloader;
    }

private:
    DataDownloader<DataType>* const m_downloader;
};

template <class DataType_t>
class FARSA_UTIL_TEMPLATE NewDatumNotifiable
{
public:
    typedef DataType_t DataType;

public:
    virtual ~NewDatumNotifiable()
    {
    }

    virtual void newDatumAvailable(DataDownloader<DataType>* downloader) = 0;
};

template <class DataType_t>
class FARSA_UTIL_TEMPLATE DataDownloader
{
public:
    typedef DataType_t DataType;

    enum NewDatumAvailableBehavior {
        NoNotification, 
        NoNotificationBlocking, 
        QtEvent, 
        Callback 
    };

public:
    DataDownloader(NewDatumAvailableBehavior b, DataUploader<DataType>* uploader = NULL);

    DataDownloader(QObject* o, DataUploader<DataType>* uploader = NULL);

    DataDownloader(NewDatumNotifiable<DataType>* o, DataUploader<DataType>* uploader = NULL);

    ~DataDownloader();

    NewDatumAvailableBehavior getNewDatumAvailableBehavior() const
    {
        return m_newDatumAvailableBehavior;
    }

    const DataUploader<DataType>* getUploader() const
    {
        return (m_queue == NULL) ? NULL : m_queue->uploader;
    }

    unsigned int getNumAvailableData() const;

    const DataType* downloadDatum();

private:
    void sendNotification();

    const NewDatumAvailableBehavior m_newDatumAvailableBehavior;

    QObject* const m_qoject;

    NewDatumNotifiable<DataType>* const m_newDatumNotifiable;

    __DataExchange_internal::QueueHolder<DataType>* m_queue;

    friend class DataUploader<DataType>;

    DataDownloader(const DataDownloader<DataType>& other);

    DataDownloader& operator=(const DataDownloader<DataType>& other);
};

template <class UploadedData_t, class DownloadedData_t>
class FARSA_UTIL_TEMPLATE DataUploaderDownloader : public DataUploader<UploadedData_t>, public DataDownloader<DownloadedData_t>
{
public:
    typedef UploadedData_t UploadedData;

    typedef DownloadedData_t DownloadedData;

    typedef typename DataUploader<UploadedData>::FullQueueBehavior FullQueueBehavior;

    typedef typename DataDownloader<DownloadedData>::NewDatumAvailableBehavior NewDatumAvailableBehavior;

public:
    DataUploaderDownloader(unsigned int uploadQueueSize, FullQueueBehavior fullQueueBehavior, NewDatumAvailableBehavior newDatumAvailableBehavior, DataUploaderDownloader<DownloadedData, UploadedData>* other = NULL) :
        DataUploader<UploadedData>(uploadQueueSize, fullQueueBehavior, other),
        DataDownloader<DownloadedData>(newDatumAvailableBehavior, other)
    {
    }

    DataUploaderDownloader(unsigned int uploadQueueSize, FullQueueBehavior fullQueueBehavior, QObject* o, DataUploaderDownloader<DownloadedData, UploadedData>* other = NULL) :
        DataUploader<UploadedData>(uploadQueueSize, fullQueueBehavior, other),
        DataDownloader<DownloadedData>(o, other)
    {
    }

    DataUploaderDownloader(unsigned int uploadQueueSize, FullQueueBehavior fullQueueBehavior, NewDatumNotifiable<DownloadedData>* o, DataUploaderDownloader<DownloadedData, UploadedData>* other = NULL) :
        DataUploader<UploadedData>(uploadQueueSize, fullQueueBehavior, other),
        DataDownloader<DownloadedData>(o, other)
    {
    }

    ~DataUploaderDownloader()
    {
        // Nothing to do here
    }
};

class FARSA_UTIL_API GlobalUploaderDownloader
{
public:
    static void stopAllDataExchanges();

private:
    GlobalUploaderDownloader();

    static GlobalUploaderDownloader& getInstance();

    void internalStopAllDataExchanges();

    void addQueueHolder(__DataExchange_internal::QueueHolderBase* queueHolder);

    void removeQueueHolder(__DataExchange_internal::QueueHolderBase* queueHolder);

    QSet<__DataExchange_internal::QueueHolderBase*> m_queueHolders;

    QMutex m_mutex;

    template <class DataType_t>
    friend class __DataExchange_internal::QueueHolder;

private:
    GlobalUploaderDownloader(const GlobalUploaderDownloader&);

    GlobalUploaderDownloader& operator=(const GlobalUploaderDownloader&);
};

}  // end namespace farsa

// Implementation of all template members
#include <QCoreApplication>
#include <QMutex>
#include <QLinkedList>
#include <QWaitCondition>
#include <QMutexLocker>
#include <QtGlobal>

namespace farsa {

namespace __DataExchange_internal {
    class QueueHolderBase
    {
    public:
        QueueHolderBase()
            : mutex()
            , waitCondition()
            , dataExchangeStopped(false)
        {
        }

    public:
        QMutex mutex;

        QWaitCondition waitCondition;

        bool dataExchangeStopped;
    };

    template <class DataType_t>
    class QueueHolder : public QueueHolderBase
    {
    public:
        typedef DataType_t DataType;

    public:
        QueueHolder(unsigned int queueSize, DataUploader<DataType>* u)
            : QueueHolderBase()
            , queue()
            , availableSpace(queueSize)
            , numDataInQueue(0)
            , queueFullLastDatumCreation(false)
            , nextUploaderDatum(NULL)
            , currentDownloaderDatum(NULL)
            , nextUploadIt()
            , nextDownloadIt()
            , uploader(u)
            , downloader(NULL)
        {
            // Allocating all memory. We use auto_ptr to ensure exception safety
            std::auto_ptr<DataType> uploaderDatum(new DataType());
            std::auto_ptr<DataType> downloaderDatum(new DataType());

            // Explicitly using a try-catch block to be exception-safe
            try {
                for (unsigned int i = 0; i < queueSize; i++) {
                    queue.push_back(new DataType());
                }
            } catch (...) {
                // If an exception is thrown, deleting all objects allocated so far
                foreach(DataType* d, queue) {
                    delete d;
                }

                // Propagating exception
                throw;
            }

            // Now initializing the iterators for the uploader and the downloader
            nextUploadIt = queue.begin();
            nextDownloadIt = queue.begin();

            // Now releasing the auto_ptrs
            nextUploaderDatum = uploaderDatum.release();
            currentDownloaderDatum = downloaderDatum.release();

            // Adding ourself to the list of queue holders
            GlobalUploaderDownloader::getInstance().addQueueHolder(this);
        }

        ~QueueHolder()
        {
            // Removing ourself from the list of queue holders
            GlobalUploaderDownloader::getInstance().removeQueueHolder(this);

            foreach(DataType* d, queue) {
                delete d;
            }
            queue.clear();

            delete nextUploaderDatum;
            delete currentDownloaderDatum;
        }

    public:
        QLinkedList<DataType*> queue;

        unsigned int availableSpace;

        unsigned int numDataInQueue;

        bool queueFullLastDatumCreation;

        DataType* nextUploaderDatum;

        DataType* currentDownloaderDatum;

        typename QLinkedList<DataType*>::iterator nextUploadIt;

        typename QLinkedList<DataType*>::iterator nextDownloadIt;

        DataUploader<DataType>* uploader;

        DataDownloader<DataType>* downloader;
    };
}

template <class DataType_t>
DataUploader<DataType_t>::DataUploader(unsigned int queueSize, FullQueueBehavior b, DataDownloader<DataType>* downloader) :
    m_queueSize((queueSize == 0) ? 1 : queueSize),
    m_fullQueueBehavior(b),
    m_queue(new __DataExchange_internal::QueueHolder<DataType>(m_queueSize, this)),
    m_datumCreatedNotUploaded(false),
    m_checkAssociationBeforeUpload(true)
{
    setDownloader(downloader);
}

template <class DataType_t>
DataUploader<DataType_t>::~DataUploader()
{
    // If we are associated with a downloader, we must not delete the queue, the downloader will take care of it
    if (associationPresent()) {
        QMutexLocker locker(&m_queue->mutex);

        m_queue->uploader = NULL;
        m_queue.release();
    }
}

template <class DataType_t>
unsigned int DataUploader<DataType_t>::getAvailableSpace() const
{
    QMutexLocker locker(&m_queue->mutex);

    if (m_fullQueueBehavior == IncreaseQueueSize) {
        return (m_queue->availableSpace == 0) ? 1 : m_queue->availableSpace;
    } else {
        return m_queue->availableSpace;
    }
}

template <class DataType_t>
unsigned int DataUploader<DataType_t>::getNumDataInQueue() const
{
    QMutexLocker locker(&m_queue->mutex);

    return m_queue->numDataInQueue;
}

template <class DataType_t>
DataType_t* DataUploader<DataType_t>::createDatum()
{
    QMutexLocker locker(&m_queue->mutex);

    // If the datum has already been created, returning the same datum again
    if (m_datumCreatedNotUploaded) {
        return m_queue->nextUploaderDatum;
    }

    // Checking whether data exchange has been stopped
    if (m_queue->dataExchangeStopped) {
        return NULL;
    }

    // Checking if we are associated with a downloader if we have to
    if (m_checkAssociationBeforeUpload && !associationPresent()) {
        throw UploaderDownloaderAssociationNotPresentException(UploaderDownloaderAssociationNotPresentException::DownloaderNotPresent);
    }

    // Resetting the flag signalling whether the queue was full
    m_queue->queueFullLastDatumCreation = false;

    // Checking if the queue is full
    if (m_queue->availableSpace == 0) {
        // Checking that uploader and downloader iterators point to the same location (this must
        // always happend if we get here)
        Q_ASSERT(m_queue->nextUploadIt == m_queue->nextDownloadIt);

        // The queue is full, setting the flag
        m_queue->queueFullLastDatumCreation = true;

        // What to do depends on the FullQueueBehavior
        switch (m_fullQueueBehavior) {
            case OverrideOlder:
                // The next datum would go where the downloader is going to take the element, so
                // we have to move the downloader forward
                ++m_queue->nextDownloadIt;
                if (m_queue->nextDownloadIt == m_queue->queue.end()) {
                    m_queue->nextDownloadIt = m_queue->queue.begin();
                }
                break;
            case BlockUploader:
                // Waiting on the wait condition, we will be woke up when the downloader downloads
                // an element. In that case the nextDownloadIt has been moved forward, so we can safely
                // use nextUploadIt
                m_queue->waitCondition.wait(&m_queue->mutex);

                // If we were woken up because data exchange has been stopped, simply returning NULL
                if (m_queue->dataExchangeStopped) {
                    return NULL;
                }
                break;
            case IncreaseQueueSize: {
                    // We have to add a datum to the queue at the current location. After the current
                    // datum has been uploaded, this element will be the nextUploaderDatum
                    std::auto_ptr<DataType> d(new DataType());
                    m_queue->nextUploadIt = m_queue->queue.insert(m_queue->nextDownloadIt, d.get());
                    d.release();
                } break;
            case SignalUploader:
                // Returning NULL to tell the uploader that there is no space
                return NULL;
                break;
        }
    }

    m_datumCreatedNotUploaded = true;

    // Returning the datum to modify
    return m_queue->nextUploaderDatum;
}

template <class DataType_t>
void DataUploader<DataType_t>::uploadDatum()
{
    // If the datum hasn't been created, doing nothing
    if (!m_datumCreatedNotUploaded) {
        return;
    }

    QMutexLocker locker(&m_queue->mutex);

    // Checking whether data exchange has been stopped
    if (m_queue->dataExchangeStopped) {
        return;
    }

    // Putting the new datum in the queue, extracting the next element and moving the uploader iterator forward
    DataType* tmp = *m_queue->nextUploadIt;
    *m_queue->nextUploadIt = m_queue->nextUploaderDatum;
    m_queue->nextUploaderDatum = tmp;
    ++m_queue->nextUploadIt;
    if (m_queue->nextUploadIt == m_queue->queue.end()) {
        m_queue->nextUploadIt = m_queue->queue.begin();
    }

    // To update the variables with available space and data in queue, we have to check if the queue was full
    // and then check which is the FullQueueBehavior, to undestand what has been done in createDatum()
    if (m_queue->queueFullLastDatumCreation) {
        switch (m_fullQueueBehavior) {
            case OverrideOlder:
                // Nothing has changed, the queue is still full
                break;
            case BlockUploader:
                // The downloader has downloaded one datum before we could add the new one, so we have to update the counters
                --m_queue->availableSpace;
                ++m_queue->numDataInQueue;
                break;
            case IncreaseQueueSize:
                // The queue has grown, but still there is no space left. We only have to increase numDataInQueue
                ++m_queue->numDataInQueue;
                break;
            case SignalUploader:
                // Nothing has been done (we should never get here)
                Q_ASSERT(false);
                break;
        }
    } else {
        --m_queue->availableSpace;
        ++m_queue->numDataInQueue;
    }

    m_datumCreatedNotUploaded = false;

    // Waking up the downloader, in case it was sleeping. This doesn't conflict with sendNotification() because if the
    // downloader is sleeping it is not expecting any notification
    m_queue->waitCondition.wakeAll();

    // Now we have to notify the downloader
    if (m_queue->downloader != NULL) {
        // If the downloader expects a callback to be called, we have to release the lock, otherwise a deadlock
        // is possible if the downloader tries to get the datum from inside the callback
        if (m_queue->downloader->m_newDatumAvailableBehavior == DataDownloader<DataType>::Callback) {
            locker.unlock();
        }

        // Notifying the downloader
        m_queue->downloader->sendNotification();
    }
}

template <class DataType_t>
void DataUploader<DataType_t>::setDownloader(DataDownloader<DataType>* downloader)
{
    // Remeber that this function is not thread-safe and that the downloader must not be accessed concurrently to a
    // call to this function

    // If downloader is NULL, doing nothing
    if (downloader == NULL) {
        return;
    }

    // Checking that no association is present
    if ((m_queue->downloader != NULL) && (m_queue->downloader != downloader)) {
        throw UploaderDownloaderAssociationNotUniqueException(UploaderDownloaderAssociationNotUniqueException::UploaderAlreadyAssociated);
    } else if ((downloader->m_queue != NULL) && (downloader->m_queue->uploader != NULL) && (downloader->m_queue->uploader != this)) {
        throw UploaderDownloaderAssociationNotUniqueException(UploaderDownloaderAssociationNotUniqueException::DownloaderAlreadyAssociated);
    }

    // Setting the correct values of m_downloader and downloader->m_uploader
    m_queue->downloader = downloader;
    m_queue->uploader = this;
    downloader->m_queue = m_queue.get();

    // If there are data available, we must notify the downloader
    if (m_queue->numDataInQueue != 0) {
        m_queue->downloader->sendNotification();
    }
}

template <class DataType_t>
bool DataUploader<DataType_t>::associationPresent() const
{
    return (m_queue->downloader != NULL);
}

template <class DataType_t>
DataDownloader<DataType_t>::DataDownloader(NewDatumAvailableBehavior b, DataUploader<DataType>* uploader) :
    m_newDatumAvailableBehavior(b),
    m_qoject(NULL),
    m_newDatumNotifiable(NULL),
    m_queue(NULL)
{
    if ((m_newDatumAvailableBehavior != NoNotification) && (m_newDatumAvailableBehavior != NoNotificationBlocking)) {
        if (m_newDatumAvailableBehavior == QtEvent) {
            throw InvalidNewDatumAvailableBehaviorException("when the NewDatumAvailableBehavior is \"QtEvent\" you must specify the QObject that receives the event");
        } else if (m_newDatumAvailableBehavior == Callback) {
            throw InvalidNewDatumAvailableBehaviorException("when the NewDatumAvailableBehavior is \"Callback\" you must specify the NewDatumNotifiable object whose callback is called");
        }
    }

    if (uploader != NULL) {
        uploader->setDownloader(this);
    }
}

template <class DataType_t>
DataDownloader<DataType_t>::DataDownloader(QObject* o, DataUploader<DataType>* uploader) :
    m_newDatumAvailableBehavior(QtEvent),
    m_qoject(o),
    m_newDatumNotifiable(NULL),
    m_queue(NULL)
{
    if (m_qoject == NULL) {
        throw InvalidNewDatumAvailableBehaviorException("when the NewDatumAvailableBehavior is \"QtEvent\" you must specify a valid (i.e. not NULL) QObject");
    }

    if (uploader != NULL) {
        uploader->setDownloader(this);
    }
}

template <class DataType_t>
DataDownloader<DataType_t>::DataDownloader(NewDatumNotifiable<DataType>* o, DataUploader<DataType>* uploader) :
    m_newDatumAvailableBehavior(Callback),
    m_qoject(NULL),
    m_newDatumNotifiable(o),
    m_queue(NULL)
{
    if (m_newDatumNotifiable == NULL) {
        throw InvalidNewDatumAvailableBehaviorException("when the NewDatumAvailableBehavior is \"Callback\" you must specify a valid (i.e. not NULL) NewDatumNotifiable");
    }

    if (uploader != NULL) {
        uploader->setDownloader(this);
    }
}

template <class DataType_t>
DataDownloader<DataType_t>::~DataDownloader()
{
    if (m_queue != NULL) {
        QMutexLocker locker(&m_queue->mutex);

        // Setting the downloader to NULL
        m_queue->downloader = NULL;

        // If the uploader associated with us has been deleted, we have to free memory for the queue
        if (m_queue->uploader == NULL) {
            locker.unlock();

            delete m_queue;
        }
    }
}

template <class DataType_t>
unsigned int DataDownloader<DataType_t>::getNumAvailableData() const
{
    if (m_queue == NULL) {
        throw UploaderDownloaderAssociationNotPresentException(UploaderDownloaderAssociationNotPresentException::UploaderNotPresent);
    }

    QMutexLocker locker(&m_queue->mutex);

    return m_queue->numDataInQueue;
}

template <class DataType_t>
const DataType_t* DataDownloader<DataType_t>::downloadDatum()
{
    // Checking if the queue is there, We allow to download even if no uploader is present to
    // be able to remove the last data from the queue
    if (m_queue == NULL) {
        throw UploaderDownloaderAssociationNotPresentException(UploaderDownloaderAssociationNotPresentException::UploaderNotPresent);
    }

    QMutexLocker locker(&m_queue->mutex);

    // Checking whether data exchange has been stopped
    if (m_queue->dataExchangeStopped) {
        return NULL;
    }

    // Checking if the queue is empty
    if (m_queue->numDataInQueue == 0) {
        // Checking that uploader and downloader iterators point to the same location (this must
        // always happend if we get here)
        Q_ASSERT(m_queue->nextUploadIt == m_queue->nextDownloadIt);

        // What to do depends on the NewDatumAvailableBehavior
        switch (m_newDatumAvailableBehavior) {
            case NoNotificationBlocking:
                // Waiting on the wait condition, we will be woke up when the uploader has uploaded something
                m_queue->waitCondition.wait(&m_queue->mutex);

                // If we were woken up because data exchange has been stopped, simply returning NULL
                if (m_queue->dataExchangeStopped) {
                    return NULL;
                }
                break;
            default:
                // In all the other cases we return NULL to tell that no datum is available
                return NULL;
                break;
        }
    }

    // We can return the current datum. We have to put back in the queue the datum that was downloaded before and move
    // the iterator forward
    DataType* oldDatum = m_queue->currentDownloaderDatum;
    m_queue->currentDownloaderDatum = *m_queue->nextDownloadIt;
    *m_queue->nextDownloadIt = oldDatum;
    ++m_queue->nextDownloadIt;
    if (m_queue->nextDownloadIt == m_queue->queue.end()) {
        m_queue->nextDownloadIt = m_queue->queue.begin();
    }

    // Incrementing the available space and decrementing the number of data in the queue
    ++m_queue->availableSpace;
    --m_queue->numDataInQueue;

    // Waking up the uploader, in case it was sleeping
    m_queue->waitCondition.wakeAll();

    return m_queue->currentDownloaderDatum;
}

template <class DataType_t>
void DataDownloader<DataType_t>::sendNotification()
{
    // What we do here depends on the NewDatumAvailableBehavior
    switch (m_newDatumAvailableBehavior) {
        case NoNotification:
        case NoNotificationBlocking:
            // Nothing to do
            break;
        case QtEvent:
            // Posting a QT event
            Q_ASSERT(m_qoject != NULL);
            QCoreApplication::postEvent(m_qoject, new NewDatumEvent<DataType>(this));
            break;
        case Callback:
            // Calling the callback
            Q_ASSERT(m_newDatumNotifiable != NULL);
            m_newDatumNotifiable->newDatumAvailable(this);
            break;
    }
}

} // end namespace farsa

#endif