configuration/include/resource.h

/********************************************************************************
 *  FARSA Experiments Library                                                   *
 *  Copyright (C) 2007-2012                                                     *
 *  Gianluca Massera <emmegian@yahoo.it>                                        *
 *  Stefano Nolfi <stefano.nolfi@istc.cnr.it>                                   *
 *  Onofrio Gigliotta <onofrio.gigliotta@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 RESOURCE_H
#define RESOURCE_H

#include "parametersettable.h"
#include "configurationconfig.h"
#include "configurationexceptions.h"
#include <QMap>
#include <QString>
#include <QMutex>
#include <QSet>

class QObject;

namespace farsa {

class ResourceHandler;
class ResourceCollection;
class ResourcesUser;

class FARSA_CONF_TEMPLATE Resource
{
public:
    enum ResourceChangeType {
        Created,
        Modified,
        Deleted
    };

public:
    virtual ~Resource()
    {
    }
};

class FARSA_CONF_API ResourceMutexHolder
{
public:
    ResourceMutexHolder();

    ResourceMutexHolder(const ResourceMutexHolder& other) throw();

    ResourceMutexHolder& operator=(const ResourceMutexHolder& other) throw();

    ~ResourceMutexHolder() throw();

    bool operator==(const ResourceMutexHolder& other) const throw()
    {
        return (m_shared == other.m_shared);
    }

    QMutex& operator*() const throw()
    {
        return m_shared->resourceLock;
    }

    QMutex* operator->() const throw()
    {
        return &(m_shared->resourceLock);
    }

private:
    struct MutexAndRefCounter
    {
        MutexAndRefCounter() :
            resourceLock(QMutex::Recursive),
            referenceCounter(0)
        {
        }

        QMutex resourceLock;

        int referenceCounter;
    };

    MutexAndRefCounter* m_shared;
};

class FARSA_CONF_API ResourceHandler
{
public:
    ResourceHandler(QString name);

    ~ResourceHandler();

    QString name() const
    {
        return m_name;
    }

    void shareLockWith(ResourceHandler* other);

    void set(int* res);

    void set(float* res);

    void set(double* res);

    void set(bool* res);

    void set(Resource* res);

    void set(ParameterSettable* res);

    void set(QObject* res);

    void unset();

    template<class T>
    T* get() const
    {
        switch(m_type) {
            case t_resource:
                return dynamic_cast<T*>(m_pointers.res);
            case t_paramSettable:
                return dynamic_cast<T*>(m_pointers.par);
            case t_qObject:
                return dynamic_cast<T*>(m_pointers.obj);
            default:
                return NULL;
        }
    }

    QMutex& getLock()
    {
        return *m_lock;
    }

    bool exists() const
    {
        return (m_type != t_nonExistent);
    }

    void addNotifee(ResourcesUser *n);

    void removeNotifee(ResourcesUser *n);

    bool isNotifee(ResourcesUser *n) const;

private:
    void notifyAll(Resource::ResourceChangeType changeType);

    const QString m_name;

    enum Type
    {
        t_resource,
        t_paramSettable,
        t_qObject,
        t_int,
        t_float,
        t_double,
        t_bool,
        t_nonExistent
    } m_type;

    union Pointers
    {
        Resource* res;
        ParameterSettable* par;
        QObject* obj;
        int* intp;
        float* floatp;
        double* doublep;
        bool* boolp;
    } m_pointers;

    ResourceMutexHolder m_lock;

    QSet<ResourcesUser *> m_notifees;

    ResourceHandler(const ResourceHandler&);

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

template<>
inline int* ResourceHandler::get<int>() const
{
    if (m_type == t_int) {
        return m_pointers.intp;
    } else {
        return NULL;
    }
}

template<>
inline float* ResourceHandler::get<float>() const
{
    if (m_type == t_float) {
        return m_pointers.floatp;
    } else {
        return NULL;
    }
}

template<>
inline double* ResourceHandler::get<double>() const
{
    if (m_type == t_double) {
        return m_pointers.doublep;
    } else {
        return NULL;
    }
}

template<>
inline bool* ResourceHandler::get<bool>() const
{
    if (m_type == t_bool) {
        return m_pointers.boolp;
    } else {
        return NULL;
    }
}


class FARSA_CONF_API ResourceCollection
{
public:
    ResourceCollection();

    ~ResourceCollection();

    QMutex& getLock()
    {
        return m_lock;
    }

    QWaitCondition& getWaitCondition()
    {
        return m_waitCondition;
    }

    int incrementReferenceCounter() throw()
    {
        return ++m_referenceCounter;
    }

    int decrementReferenceCounter() throw()
    {
        return --m_referenceCounter;
    }

    int getReferenceCounter() throw()
    {
        return m_referenceCounter;
    }

    ResourceHandler* getResource(QString name, bool create = false);

    bool hasResource(QString name) const
    {
        return (m_resources.contains(name) && m_resources[name]->exists());
    }

private:
    QMap<QString, ResourceHandler*> m_resources;

    QMutex m_lock;

    QWaitCondition m_waitCondition;

    int m_referenceCounter;

    ResourceCollection(const ResourceCollection&);

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

class FARSA_CONF_API ResourceCollectionHolder
{
public:
    ResourceCollectionHolder();

    ResourceCollectionHolder(const ResourceCollectionHolder& other) throw();

    ResourceCollectionHolder& operator=(const ResourceCollectionHolder& other) throw();

    ~ResourceCollectionHolder() throw();

    void setUseLock(bool useLock) throw()
    {
        m_useLocks = useLock;
    }

    bool operator==(const ResourceCollectionHolder& other) const throw()
    {
        return (m_resourceCollection == other.m_resourceCollection);
    }

    ResourceCollection& operator*() const throw()
    {
        return *m_resourceCollection;
    }

    ResourceCollection* operator->() const throw()
    {
        return m_resourceCollection;
    }

private:
    ResourceCollection* m_resourceCollection;

    bool m_useLocks;
};

} // end namespace farsa

#endif