resource.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 "resource.h"
#include "resourcesuser.h"
#include <memory>

namespace farsa {

ResourceMutexHolder::ResourceMutexHolder() :
    m_shared(NULL)
{
    // Creating an instance of ResourceCollection in an exception-safe way
    m_shared = new MutexAndRefCounter();
    m_shared->referenceCounter++;
}

ResourceMutexHolder::ResourceMutexHolder(const ResourceMutexHolder& other) throw() :
    m_shared(other.m_shared)
{
    m_shared->referenceCounter++;
}

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

    // Sharing with other and decrementing our old one (possibly also deleting)
    m_shared->referenceCounter--;
    if (m_shared->referenceCounter == 0) {
        delete m_shared;
    }

    m_shared = other.m_shared;
    m_shared->referenceCounter++;

    return *this;
}

ResourceMutexHolder::~ResourceMutexHolder() throw()
{
    // Decrementing the reference counter and possibly deleting the mutex
    m_shared->referenceCounter--;
    if (m_shared->referenceCounter == 0) {
        delete m_shared;
    }
}

ResourceHandler::ResourceHandler(QString name) :
    m_name(name),
    m_type(t_nonExistent),
    m_lock(),
    m_notifees()
{
}

ResourceHandler::~ResourceHandler()
{
}

void ResourceHandler::shareLockWith(ResourceHandler* other)
{
    m_lock = other->m_lock;
}

void ResourceHandler::set(int* res)
{
    const Resource::ResourceChangeType changeType = (m_type == t_nonExistent) ? Resource::Created : Resource::Modified;
    m_type = t_int;
    m_pointers.intp = res;
    notifyAll(changeType);
}

void ResourceHandler::set(float* res)
{
    const Resource::ResourceChangeType changeType = (m_type == t_nonExistent) ? Resource::Created : Resource::Modified;
    m_type = t_float;
    m_pointers.floatp = res;
    notifyAll(changeType);
}

void ResourceHandler::set(double* res)
{
    const Resource::ResourceChangeType changeType = (m_type == t_nonExistent) ? Resource::Created : Resource::Modified;
    m_type = t_double;
    m_pointers.doublep = res;
    notifyAll(changeType);
}

void ResourceHandler::set(bool* res)
{
    const Resource::ResourceChangeType changeType = (m_type == t_nonExistent) ? Resource::Created : Resource::Modified;
    m_type = t_bool;
    m_pointers.boolp = res;
    notifyAll(changeType);
}

void ResourceHandler::set(Resource* res)
{
    const Resource::ResourceChangeType changeType = (m_type == t_nonExistent) ? Resource::Created : Resource::Modified;
    m_type = t_resource;
    m_pointers.res = res;
    notifyAll(changeType);
}

void ResourceHandler::set(ParameterSettable* res)
{
    const Resource::ResourceChangeType changeType = (m_type == t_nonExistent) ? Resource::Created : Resource::Modified;
    m_type = t_paramSettable;
    m_pointers.par = res;
    notifyAll(changeType);
}

void ResourceHandler::set(QObject* res)
{
    const Resource::ResourceChangeType changeType = (m_type == t_nonExistent) ? Resource::Created : Resource::Modified;
    m_type = t_qObject;
    m_pointers.obj = res;
    notifyAll(changeType);
}

void ResourceHandler::unset()
{
    m_type = t_nonExistent;
    // Note: if getResource is called in the callback, an exception will be thrown!
    notifyAll(Resource::Deleted);
}

void ResourceHandler::addNotifee(ResourcesUser *n)
{
    m_notifees.insert(n);
}

void ResourceHandler::removeNotifee(ResourcesUser *n)
{
    m_notifees.remove(n);
}

bool ResourceHandler::isNotifee(ResourcesUser *n) const
{
    return m_notifees.contains(n);
}

void ResourceHandler::notifyAll(Resource::ResourceChangeType changeType)
{
    foreach (ResourcesUser *n, m_notifees) {
        n->notifyResourceChange(this, changeType);
    }
}

ResourceCollection::ResourceCollection() :
    m_resources(),
    m_lock(QMutex::NonRecursive),
    m_referenceCounter(0)
{
}

ResourceCollection::~ResourceCollection()
{
    // Deleting all resources still in the map
    foreach (ResourceHandler *r, m_resources) {
        delete r;
    }
}

ResourceHandler* ResourceCollection::getResource(QString name, bool create)
{
    ResourceHandler *h = NULL;

    if (!m_resources.contains(name)) {
        if (create) {
            // Adding an non-existant resource (in an exception-safe way)
            std::auto_ptr<ResourceHandler> hp(new ResourceHandler(name));
            m_resources[name] = hp.get();
            h = hp.release();
        }
    } else {
        h = m_resources[name];
    }

    return h;
}

ResourceCollectionHolder::ResourceCollectionHolder() :
    m_resourceCollection(NULL),
    m_useLocks(false)
{
    // Creating an instance of ResourceCollection in an exception-safe way
    std::auto_ptr<ResourceCollection> c(new ResourceCollection());
    c->incrementReferenceCounter();
    m_resourceCollection = c.release();
}

ResourceCollectionHolder::ResourceCollectionHolder(const ResourceCollectionHolder& other) throw() :
    m_resourceCollection(other.m_resourceCollection),
    m_useLocks(false)
{
    if (other.m_useLocks) {
        m_resourceCollection->getLock().lock();
    }

    // Incrementing the counter of the ResourceCollection object
    m_resourceCollection->incrementReferenceCounter();

    if (other.m_useLocks) {
        m_resourceCollection->getLock().unlock();
    }
}

ResourceCollectionHolder& ResourceCollectionHolder::operator=(const ResourceCollectionHolder& other) throw()
{
    // Comparing for equality of objects (not pointers) because we must not do anything
    // if this and other already point to the same ResourceCollection object
    if (other == *this) {
        return *this;
    }

    // Acquiring locks if we have to
    if (m_useLocks) {
        m_resourceCollection->getLock().lock();
        other.m_resourceCollection->getLock().lock();
    }

    // First of all releasing the current resource manager (and destroying it if we have to)
    const int refCounter = m_resourceCollection->decrementReferenceCounter();
    if (m_useLocks) {
        m_resourceCollection->getLock().unlock();
    }
    if (refCounter == 0) {
        delete m_resourceCollection;
    }

    // Now we can use the ResourceCollection of other
    m_resourceCollection = other.m_resourceCollection;
    m_resourceCollection->incrementReferenceCounter();

    if (m_useLocks) {
        // m_resourceCollection is now the same as other.m_resourceCollection, so here
        // we are unlocking the mutex on the new collection
        m_resourceCollection->getLock().unlock();
    }

    return *this;
}

ResourceCollectionHolder::~ResourceCollectionHolder() throw()
{
    if (m_useLocks) {
        m_resourceCollection->getLock().lock();
    }

    const int refCounter = m_resourceCollection->decrementReferenceCounter();

    if (m_useLocks) {
        m_resourceCollection->getLock().unlock();
    }

    if (refCounter == 0) {
        delete m_resourceCollection;
    }
}

} // end namspace farsa