dependencymanager.hpp

/* Copyright (c) 2014-2015, The Nuria Project
 * The NuriaProject Framework is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 3 of the License,
 * or (at your option) any later version.
 * 
 * The NuriaProject Framework 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 Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with The NuriaProject Framework.
 * If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef NURIA_DEPEDENCYMANAGER_HPP
#define NURIA_DEPEDENCYMANAGER_HPP

#include "essentials.hpp"
#include <functional>
#include <QObject>

namespace Nuria {
class DependencyManagerPrivate;

class NURIA_CORE_EXPORT DependencyManager : public QObject {
        Q_OBJECT
public:
        
        enum ThreadingPolicy {
                DefaultPolicy,
                
                ApplicationGlobal,
                
                SingleThread,
                
                ThreadLocal
        };
        
        ~DependencyManager ();
        
        static DependencyManager *instance ();
        
        ThreadingPolicy defaultThreadingPolicy () const;
        
        void setDefaultThreadingPolicy (ThreadingPolicy policy);
        
        void *objectByName (const QByteArray &name, int type = -1, ThreadingPolicy policy = DefaultPolicy);
        
        int objectType (const QByteArray &name, ThreadingPolicy policy = DefaultPolicy) const;
        
        inline bool hasObject (const QByteArray &name, ThreadingPolicy policy = DefaultPolicy) const
        { return objectType (name, policy) != -1; }
        
        void storeObject (const QByteArray &name, void *object, int type,
                          ThreadingPolicy policy = DefaultPolicy);
        
        template< typename T >
        void storeObject (const QByteArray &name, T *object)
        { storeObject (name, object, qMetaTypeId< T * > ()); }
        
        void setCreator (const QByteArray &name, const std::function< QObject *() > &creator);
        
        template< typename T >
        inline static T *get (const QByteArray &name, ThreadingPolicy policy = DefaultPolicy) {
                return static_cast< T * > (instance ()->objectByName (name, qMetaTypeId< T * > (), policy));
        }
        
private slots:
        
        void freeAllObjects ();
        
private:
        explicit DependencyManager (QObject *parent = 0);
        
        DependencyManagerPrivate *d_ptr;
};

template< typename T >
class Dependency {
        mutable T *m_obj = nullptr;
        QByteArray m_name;
public:
        
        Dependency (const QByteArray &objectName = QByteArray ())
                : m_name (objectName)
        {
                if (objectName.isEmpty ()) {
                        const char *name = QMetaType::typeName (qMetaTypeId< T * > ());
                        this->m_name.setRawData (name, ::qstrlen (name) - 1);
                }
                
        }
        
        bool operator== (const Dependency< T > &other) const
        { return (this->m_name == other.m_name); }
        
        bool operator!= (const Dependency< T > &other) const
        { return (this->m_name != other.m_name); }
        
        operator bool () const
        { return (get () != nullptr); }
        
        T *operator-> () const
        { return get (); }
        
        T *get () const {
                if (!this->m_obj) {
                        this->m_obj = DependencyManager::get< T > (this->m_name);
                }
                
                return this->m_obj;
        }
        
};

}

#endif // NURIA_DEPEDENCYMANAGER_HPP