configuration/src/resourcesuser.cpp

/***************************************************************************
 *   Copyright (C) 2008 by Tomassino Ferrauto                              *
 *   t_ferrauto@yahoo.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.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "resourcesuser.h"
#include <memory>

namespace farsa {

namespace {
    // This class is needed so that the status of m_beingNotified is exception safe  (i.e. it is reset
    // to false if an exception gets thrown inside the handler for resource change). This is used both
    // by SimpleResourcesUser and ConcurrentResourcesUser
    class BeingNotifiedRAII
    {
    public:
        BeingNotifiedRAII(bool* beingNotified) :
            m_beingNotified(beingNotified)
        {
            *m_beingNotified = true;
        }

        ~BeingNotifiedRAII()
        {
            *m_beingNotified = false;
        }

    private:
        bool* const m_beingNotified;
    };
}

void ResourcesUser::shareResourcesWith(ResourcesUser* other)
{
    if (other != NULL) {
        m_resources = other->m_resources;
    } else {
        // This is exception safe (the assignment operator doesn't throw and if the constructor
        // throws m_resources doesn't change)
        m_resources = ResourceCollectionHolder();
    }
}

ResourcesUser::ResourcesUser() :
    m_resources()
{
}

ResourcesUser::ResourcesUser(const ResourcesUser& other) throw() :
    m_resources(other.m_resources)
{
}

ResourcesUser& ResourcesUser::operator=(const ResourcesUser& other) throw()
{
    if (&other == this) {
        return *this;
    }

    m_resources = other.m_resources;

    return *this;
}

ResourcesUser::~ResourcesUser()
{
    // Nothing to do here
}

SimpleResourcesUser::SimpleResourcesUser() :
    ResourcesUser(),
    m_beingNotified(false),
    m_notifiedResourceHandler(NULL),
    m_observedResources()
{
}

SimpleResourcesUser::SimpleResourcesUser(const SimpleResourcesUser& other) :
    ResourcesUser(other),
    m_beingNotified(false), // When we are created we can't be in the resource change handler
    m_notifiedResourceHandler(NULL),
    m_observedResources(other.m_observedResources)
{
    // This is not exception safe. It is difficult to make this exception safe because QT aren't (and here we
    // have to deal with QT containers)
    
    // We have to be notified of changes in the same set of resources as other.
    forceBeingNotified();
}

SimpleResourcesUser& SimpleResourcesUser::operator=(const SimpleResourcesUser& other)
{
    // This is not exception safe. It is difficult to make this exception safe because QT aren't (and here we
    // have to deal with QT containers)

    if (&other == this) {
        return *this;
    }

    // First of all we have to stop being notified for old resources
    removeAllNotifications();

    // Calling parent function
    ResourcesUser::operator=(other);

    // Now we can copy the set of resources for which notification is reuested. m_beingNotified and
    // m_notifiedResourceHandler are not changed as we could be inside the notification handler
    // (that would be weird, though)
    m_observedResources = other.m_observedResources;

    // We have to be notified of changes in the same same set of resources as other
    forceBeingNotified();

    return *this;
}

SimpleResourcesUser::~SimpleResourcesUser()
{
    removeAllNotifications();
}

void SimpleResourcesUser::shareResourcesWith(ResourcesUser* other)
{
    // Now we have to stop being notified for old resources
    removeAllNotifications();

    // Calling parent function
    ResourcesUser::shareResourcesWith(other);
}

void SimpleResourcesUser::deleteResource(QString name)
{
    // Trying to retrieve the resource
    ResourceHandler* h = m_resources->getResource(name, false);

    if ((h == NULL) || (!h->exists())){
        throw ResourceNotDeclaredException(name.toAscii().data());
    }

    // Removing the resource
    h->unset();
}

void SimpleResourcesUser::resourceChanged(QString, ResourceChangeType)
{
    // The default implementation does nothing
}

void SimpleResourcesUser::notifyResourceChange(ResourceHandler* resource, ResourceChangeType changeType)
{
    BeingNotifiedRAII beingNotifiedRAII(&m_beingNotified);
    m_notifiedResourceHandler = resource;

    resourceChanged(m_notifiedResourceHandler->name(), changeType);
}

void SimpleResourcesUser::removeAllNotifications()
{
    // Functions using this are not exception safe and its hard to make them exception-safe
    // because QT aren't...
    foreach (ResourceHandler* h, m_observedResources) {
        h->removeNotifee(this);
    }

    m_observedResources.clear();
}

void SimpleResourcesUser::forceBeingNotified()
{
    // Functions using this are not exception safe and its hard to make them exception-safe
    // because QT aren't...
    foreach (ResourceHandler* h, m_observedResources) {
        h->addNotifee(this);
    }
}

ConcurrentResourcesUser::ConcurrentResourcesUser() :
    ResourcesUser(),
    m_lockAcquired(0),
    m_beingNotified(false),
    m_notifiedResourceHandler(NULL),
    m_usableResources()
{
    // Here we need the ResourceCollectionHolder object to use locks
    m_resources.setUseLock(true);
}

ConcurrentResourcesUser::~ConcurrentResourcesUser()
{
    // Removing from the notification list of all resources we were observing
    removeAllNotifications();

    m_usableResources.clear();
}

void ConcurrentResourcesUser::shareResourcesWith(ResourcesUser* other)
{
    if ((m_lockAcquired > 0) || m_beingNotified) {
        throw WrongResourceLockStatusForOperation("shareResourcesWith", true);
    }

    // If other is NULL we do not get any lock on other resources, otherwise we have to. The two
    // parts of the if are similar but trying to merge them creates quite some problems (with locks and
    // exception safety), so I leave them separated
    if (other == NULL) {
        // Acquiring the lock on old resources to remove notifications, then we can release it. I'm doing
        // it like this because I'm not sure deleting the mutex before destroying the QMutexLocker is
        // ok (even if the mutex is unlocked). The mutex could be destroyed together with the corresponding
        // ResourceCollection in ResourcesUser::shareResourcesWith(). Here we also get the list of name of
        // existing resource that we use
        QSet<QString> m_existingResourcesInOldCollection;
        {
            QMutexLocker oldCollectionLocker(&(m_resources->getLock()));

            // Removing all notifications on old resources
            removeAllNotifications();

            for (QMap<QString, ResourceHandler*>::const_iterator it = m_usableResources.constBegin(); it != m_usableResources.constEnd(); ++it) {
                if (it.value()->exists()) {
                    m_existingResourcesInOldCollection.insert(it.key());
                }
            }
        }

        // Calling parent function.
        ResourcesUser::shareResourcesWith(other);

        // Taking the lock on the newly created resource collection
        QMutexLocker newCollectionLocker(&(m_resources->getLock()));

        // Now we have to update the m_usableResources map to point the the new resource handlers. No resource
        // still esists, we create empty resourced here
        for (QMap<QString, ResourceHandler*>::iterator it = m_usableResources.begin(); it != m_usableResources.end(); ++it) {
            it.value() = m_resources->getResource(it.key(), true);
            it.value()->addNotifee(this);
        }

        // Before sending notifications, we have to get the lock on all resources and to release the lock on the
        // resource collection
        ResourcesMutexesLocker resourcesLocker(this, m_usableResources.values());

        // Now we can unlock the mutex on the Resource Manager
        newCollectionLocker.unlock();

        // Now we can send all notifications. All previously existing resources have been deleted
        foreach (QString name, m_existingResourcesInOldCollection) {
            notifyResourceChange(m_usableResources[name], Deleted);
        }
    } else {
        // Acquiring lock on new resources
        QMutexLocker newCollectionLocker(&(other->m_resources->getLock()));

        // Acquiring the lock on old resources to remove notifications, then we can release it. I'm doing
        // it like this because I'm not sure deleting the mutex before destroying the QMutexLocker is
        // ok (even if the mutex is unlocked). The mutex could be destroyed together with the corresponding
        // ResourceCollection in ResourcesUser::shareResourcesWith(). Here we also get the list of name of
        // existing resource that we use
        QSet<QString> m_existingResourcesInOldCollection;
        {
            QMutexLocker oldCollectionLocker(&(m_resources->getLock()));

            // Removing all notifications on old resources
            removeAllNotifications();

            for (QMap<QString, ResourceHandler*>::const_iterator it = m_usableResources.constBegin(); it != m_usableResources.constEnd(); ++it) {
                if (it.value()->exists()) {
                    m_existingResourcesInOldCollection.insert(it.key());
                }
            }
        }

        // Calling parent function to actually share resources. Here the lock on new resources would be taken
        // again (but the mutex is not recursive), so we have to temporarly prevent m_resources from locking
        m_resources.setUseLock(false);
        ResourcesUser::shareResourcesWith(other);
        m_resources.setUseLock(true);

        // Now we have to update the m_usableResources map to point the the new resource handlers. We also create
        // the set of names of resources that exists in the new collection
        QSet<QString> m_existingResourcesInNewCollection;
        for (QMap<QString, ResourceHandler*>::iterator it = m_usableResources.begin(); it != m_usableResources.end(); ++it) {
            it.value() = m_resources->getResource(it.key(), true);
            it.value()->addNotifee(this);

            if (it.value()->exists()) {
                m_existingResourcesInNewCollection.insert(it.key());
            }
        }

        // Before sending notifications, we have to get the lock on all resources and to release the lock on the
        // resource collection
        ResourcesMutexesLocker resourcesLocker(this, m_usableResources.values());

        // Now we can unlock the mutex on the Resource Manager
        newCollectionLocker.unlock();

        // Now we can send all notifications. The changeType to use depends on the status of the resource with a given
        // name in the new and old set: if a resource existed in the old set and not in the new one, changeType will be
        // Deleted, if it existed in the old set and is also present in the new one, changeType will be Modified, if it
        // didn't exist in the old set but is present in the new one, changeType will be Created.
        const QSet<QString> deletedResources = m_existingResourcesInOldCollection - m_existingResourcesInNewCollection;
        const QSet<QString> modifiedResources = m_existingResourcesInOldCollection & m_existingResourcesInNewCollection;
        const QSet<QString> createdResources = m_existingResourcesInNewCollection - m_existingResourcesInOldCollection;

        // Actually sending all notifications
        foreach (QString name, deletedResources) {
            notifyResourceChange(m_usableResources[name], Deleted);
        }
        foreach (QString name, modifiedResources) {
            notifyResourceChange(m_usableResources[name], Modified);
        }
        foreach (QString name, createdResources) {
            notifyResourceChange(m_usableResources[name], Created);
        }
    }
}

void ConcurrentResourcesUser::usableResources(QStringList resources)
{
    if ((m_lockAcquired > 0) || m_beingNotified) {
        throw WrongResourceLockStatusForOperation("usableResources", true);
    }

    // First of all we have to acquire the lock on the Resource Manager (because we need to call getResource)
    QMutexLocker collectionLocker(&(m_resources->getLock()));

    // Removing old resources
    m_usableResources.clear();

    foreach (QString resource, resources) {
        // Here we create a Resource Handler if the resource doesn't exists
        ResourceHandler* h = m_resources->getResource(resource, true);

        h->addNotifee(this);
        m_usableResources[resource] = h;
    }

    // Getting the lock on all new resources to send notifications. There is a little overhead, here,
    // because we get the lock also for non-existing resources (that are not notified, though)
    ResourcesMutexesLocker resourcesLocker(this, m_usableResources.values());

    // Now we can unlock the mutex on the Resource Manager
    collectionLocker.unlock();

    // Notifying that all the new resources exist
    foreach (ResourceHandler* h, m_usableResources) {
        if (h->exists()) {
            notifyResourceChange(h, Created);
        }
    }
}

void ConcurrentResourcesUser::addUsableResource(QString resource)
{
    if ((m_lockAcquired > 0) || m_beingNotified) {
        throw WrongResourceLockStatusForOperation("addUsableResource", true);
    }

    // First of all we have to acquire the lock on the Resource Manager (because we need to call getResource)
    QMutexLocker collectionLocker(&(m_resources->getLock()));

    // Here we create a Resource Handler if the resource doesn't exists
    ResourceHandler* h = m_resources->getResource(resource, true);

    h->addNotifee(this);
    m_usableResources[resource] = h;

    // If the resource exists, sending notification
    if (h->exists()) {
        // Taking the lock on the resource because we have to send a notification
        ResourcesMutexesLocker resourceLocker(this, h);

        // Now we can unlock the mutex on the Resource Manager
        collectionLocker.unlock();

        // Notifying that the resource exists
        notifyResourceChange(h, Created);
    }
}

void ConcurrentResourcesUser::addUsableResources(QStringList resources)
{
    if ((m_lockAcquired > 0) || m_beingNotified) {
        throw WrongResourceLockStatusForOperation("addUsableResources", true);
    }

    // First of all we have to acquire the lock on the Resource Manager (because we need to call getResource)
    QMutexLocker collectionLocker(&(m_resources->getLock()));

    // Adding all new resources
    QList<ResourceHandler *> newResources;
    foreach (QString resource, resources) {
        // Here we create a Resource Handler if the resource doesn't exists
        ResourceHandler* h = m_resources->getResource(resource, true);

        h->addNotifee(this);
        m_usableResources[resource] = h;

        // Saving the list of the new resources handlers for notifications
        newResources.append(h);
    }

    // Getting the lock on all new resources to send notifications. There is a little overhead, here,
    // because we get the lock also for non-existing resources (that are not notified, though)
    ResourcesMutexesLocker resourcesLocker(this, newResources);

    // Now we can unlock the mutex on the Resource Manager
    collectionLocker.unlock();

    // Notifying that all the new resources exist
    foreach (ResourceHandler* h, newResources) {
        if (h->exists()) {
            notifyResourceChange(h, Created);
        }
    }
}

void ConcurrentResourcesUser::removeUsableResource(QString resource)
{
    if ((m_lockAcquired > 0) || m_beingNotified) {
        throw WrongResourceLockStatusForOperation("removeUsableResource", true);
    }

    if (m_usableResources.contains(resource)) {
        // First of all we have to acquire the lock on the Resource Manager (because we need to call getResource)
        QMutexLocker collectionLocker(&(m_resources->getLock()));

        // The ResourceHandler should exist, if not there is a bug and this function will crash
        ResourceHandler* h = m_resources->getResource(resource, false);
        h->removeNotifee(this);

        m_usableResources.remove(resource);

        // Now notifying the resource is no longer available. First taking the lock on the resource
        ResourcesMutexesLocker resourceLocker(this, h);

        // Now we can unlock the mutex on the Resource Manager
        collectionLocker.unlock();

        // Notifying that the resource exists
        notifyResourceChange(h, Deleted);
    }
}

void ConcurrentResourcesUser::removeUsableResources(QStringList resources)
{
    if ((m_lockAcquired > 0) || m_beingNotified) {
        throw WrongResourceLockStatusForOperation("removeUsableResources", true);
    }

    // First of all we have to acquire the lock on the Resource Manager (because we need to call getResource)
    QMutexLocker collectionLocker(&(m_resources->getLock()));

    // Deleting all resources
    QList<ResourceHandler *> deletedResources;
    foreach (QString resource, resources) {
        if (!m_usableResources.contains(resource)) {
            continue;
        }

        // Taking the resource handler and then removing the resource (the resource must exist, otherwise there is a
        // bug and this will crash)
        ResourceHandler* h = m_resources->getResource(resource, false);
        h->removeNotifee(this);

        m_usableResources.remove(resource);

        // Saving the list of the deleted resources handlers for notifications
        deletedResources.append(h);
    }

    // Getting the lock on all deleted resources to send notifications. There is a little overhead, here,
    // because we get the lock also for non-existing resources (that are not notified, though)
    ResourcesMutexesLocker resourcesLocker(this, deletedResources);

    // Now we can unlock the mutex on the Resource Manager
    collectionLocker.unlock();

    // Notifying that all the resources that exist
    foreach (ResourceHandler* h, deletedResources) {
        if (h->exists()) {
            notifyResourceChange(h, Deleted);
        }
    }
}

void ConcurrentResourcesUser::removeAllUsableResources()
{
    if ((m_lockAcquired > 0) || m_beingNotified) {
        throw WrongResourceLockStatusForOperation("removeAllUsableResources", true);
    }

    // First of all we have to acquire the lock on the Resource Manager (because we need to call getResource)
    QMutexLocker collectionLocker(&(m_resources->getLock()));

    // Deleting all resources
    foreach (ResourceHandler* h, m_usableResources) {
        h->removeNotifee(this);
    }

    QList<ResourceHandler *> deletedResources = m_usableResources.values();
    // Clearing the list of resources we use
    m_usableResources.clear();

    // Getting the lock on all deleted resources to send notifications. There is a little overhead, here,
    // because we get the lock also for non-existing resources (that are not notified, though)
    ResourcesMutexesLocker resourcesLocker(this, deletedResources);

    // Now we can unlock the mutex on the Resource Manager
    collectionLocker.unlock();

    // Notifying that all the resources that exist
    foreach (ResourceHandler* h, deletedResources) {
        if (h->exists()) {
            notifyResourceChange(h, Deleted);
        }
    }
}

void ConcurrentResourcesUser::deleteResource(QString name)
{
    if ((m_lockAcquired > 0) || m_beingNotified) {
        throw WrongResourceLockStatusForOperation("deleteResource", true);
    }

    // Getting the lock on the resource collection
    QMutexLocker collectionLocker(&(m_resources->getLock()));

    // Now we have to get the resource and then acquire the lock on the resource if it exists
    ResourceHandler* h = m_resources->getResource(name, false);
    if ((h == NULL) || (!h->exists())) {
        throw ResourceNotDeclaredException(name.toAscii().data());
    }
    ResourcesMutexesLocker resourceLocker(this, h);

    // Before setting the resource, we can release the lock on Resource Manager
    collectionLocker.unlock();

    // Now removing the resource
    h->unset();
}

bool ConcurrentResourcesUser::hasResource(QString name) const
{
    if ((m_lockAcquired > 0) || m_beingNotified) {
        throw WrongResourceLockStatusForOperation("hasResource", true);
    }

    QMutexLocker locker(&(m_resources->getLock()));

    return m_resources->hasResource(name);
}

bool ConcurrentResourcesUser::usedResourcesExist(QStringList* nonExistingResources) const
{
    if ((m_lockAcquired > 0) || m_beingNotified) {
        throw WrongResourceLockStatusForOperation("usedResourcesExist", true);
    }

    QMutexLocker locker(&(m_resources->getLock()));

    bool allExist = true;

    foreach (ResourceHandler* h, m_usableResources) {
        if (!h->exists()) {
            allExist = false;
            if (nonExistingResources != NULL) {
                nonExistingResources->append(h->name());
            } else {
                // If we don't have to return the list of non-existing resource, we can exit
                // from the cicle as soon as we find a resource that doesn't exists
                break;
            }
        }
    }

    return allExist;
}

void ConcurrentResourcesUser::resourceChanged(QString, ResourceChangeType)
{
    // The default implementation of this function does nothing
}

void ConcurrentResourcesUser::lockAll()
{
    // Locking all resources. To avoid deadlocks here we first acquire the lock on the Resource Manager
    QMutexLocker locker(&(m_resources->getLock()));

    // Locking all resources
    lockResources(m_usableResources.values());

    ++m_lockAcquired;
}

void ConcurrentResourcesUser::unlockAll()
{
    // Unlocking all resources. Here we have to take the mutex because the unlock of resources must be
    // atomic (otherwise a lockAll() call can find a resource locked even if we are here because we haven't
    // unlocked a certain resource yet and he could then miss the wake of the wait condition)
    QMutexLocker locker(&(m_resources->getLock()));

    // Unlocking all resources and signalling threads on the wait condition
    unlockResources(m_usableResources.values());

    --m_lockAcquired;

    // The mutex will be unlocked here
}

void ConcurrentResourcesUser::notifyResourceChange(ResourceHandler* resource, ResourceChangeType changeType)
{
    BeingNotifiedRAII beingNotifiedRAII(&m_beingNotified);
    m_notifiedResourceHandler = resource;

    resourceChanged(m_notifiedResourceHandler->name(), changeType);
}

void ConcurrentResourcesUser::removeAllNotifications()
{
    // Functions using this are not exception safe and its hard to make them exception-safe
    // because QT aren't...
    foreach (ResourceHandler* h, m_usableResources) {
        h->removeNotifee(this);
    }
}

void ConcurrentResourcesUser::forceBeingNotified()
{
    // Functions using this are not exception safe and its hard to make them exception-safe
    // because QT aren't...
    foreach (ResourceHandler* h, m_usableResources) {
        h->addNotifee(this);
    }
}

void ConcurrentResourcesUser::lockResources(const QList<ResourceHandler*>& resources)
{
    // We have to cycle until getting resources is successful
    bool oneLockFailed;
    do {
        // Resetting the status of the flag for failed locks
        oneLockFailed = false;

        // Now locking all our resources. The mutexes for resources are recursive, so they will not fail
        // if this function is called recursively. Here I assume that locking a mutex never throws... If
        // this is not the case, an exception during the lock of one mutex will leave some mutex locked
        // indefinitely and some other unlocked.
        QList<ResourceHandler*> lockedResources;
        foreach (ResourceHandler* resource, resources) {
            const bool locked = resource->getLock().tryLock();
            if (!locked) {
                oneLockFailed = true;
                break;
            } else {
                lockedResources.append(resource);
            }
        }

        // If one lock failed, we can't acquire all resources here, so we unlock what we have
        // locked and wait
        if (oneLockFailed) {
            foreach (ResourceHandler* resource, lockedResources) {
                resource->getLock().unlock();
            }

            // Waiting
            m_resources->getWaitCondition().wait(&(m_resources->getLock()));
        }
    } while (oneLockFailed);
}

void ConcurrentResourcesUser::unlockResources(const QList<ResourceHandler*>& resources)
{
    // Unlocking all resources. Here I assume that unlocking a mutex never throws... If
    // this is not the case, an exception during the unlock of one mutex will leave some
    // mutex locked indefinitely and some other unlocked.
    foreach (ResourceHandler* resource, resources) {
        resource->getLock().unlock();
    }

    // Waking threads that are waiting
    m_resources->getWaitCondition().wakeAll();
}

ResourcesLocker::ResourcesLocker(ConcurrentResourcesUser *resourcesUser, bool acquireLock):
    m_resourcesUser(resourcesUser),
    m_lockedByUs(false)
{
    if (acquireLock) {
        lock();
    }
}

ResourcesLocker::~ResourcesLocker()
{
    unlock();
}

void ResourcesLocker::lock()
{
    if (m_lockedByUs) {
        return;
    }

    m_resourcesUser->lockAll();

    m_lockedByUs = true;
}

void ResourcesLocker::unlock()
{
    if (!m_lockedByUs) {
        return;
    }

    m_resourcesUser->unlockAll();

    m_lockedByUs = false;
}

} // end namspace farsa