metaobject.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_METAOBJECT_HPP
#define NURIA_METAOBJECT_HPP

#include "essentials.hpp"
#include "callback.hpp"

#include <QVariant>
#include <QString>

namespace Nuria {

class MetaObject;
class MetaMethod;
class MetaField;
class MetaEnum;

class NURIA_CORE_EXPORT MetaAnnotation {
public:
        
        MetaAnnotation ();
        
        bool isValid () const;
        
        QByteArray name () const;
        
        QVariant value () const;
        
private:
        friend class MetaObject;
        friend class MetaMethod;
        friend class MetaField;
        friend class MetaEnum;
        
        inline MetaAnnotation (MetaObject *meta, short category, short index, short nth)
                : m_meta (meta), m_category (category), m_index (index), m_nth (nth)
        {}
        
        mutable MetaObject *m_meta;
        short m_category;
        short m_index;
        short m_nth;
};

class NURIA_CORE_EXPORT MetaMethod {
public:
        
        enum Type {
                
                Method = 0,
                
                Static = 1,
                
                Constructor = 2
        };
        
        MetaMethod ();
        
        bool isValid () const;
        
        QByteArray name () const;
        
        Type type () const;
        
        QByteArray returnType () const;
        
        QVector< QByteArray > argumentTypes () const;
        
        QVector< QByteArray > argumentNames () const;
        
        Callback callback (void *instance = nullptr) const;
        
        Callback unsafeCallback (void *instance = nullptr) const;
        
        Callback testCallback (void *instance = nullptr) const;
        
        int annotationCount () const;
        
        MetaAnnotation annotation (int idx) const;      
        
        int annotationLowerBound (const QByteArray &name) const;
        
        int annotationUpperBound (const QByteArray &name) const;
        
private:
        friend class MetaObject;
        
        inline MetaMethod (MetaObject *meta, int index)
                : m_meta (meta), m_index (index)
        {}
        
        mutable MetaObject *m_meta;
        int m_index;
        
};

class NURIA_CORE_EXPORT MetaField {
public:
        enum Access {
                NoAccess = 0x00,
                ReadOnly = 0x01,
                WriteOnly = 0x02,
                ReadWrite = ReadOnly | WriteOnly
        };
        
        MetaField ();
        
        bool isValid () const;
        
        QByteArray name () const;
        
        QByteArray typeName () const;
        
        Access access () const;
        
        QVariant read (void *instance) const;
        
        bool write (void *instance, const QVariant &value);
        
        int annotationCount () const;
        
        MetaAnnotation annotation (int idx) const;
        
        int annotationLowerBound (const QByteArray &name) const;
        
        int annotationUpperBound (const QByteArray &name) const;
        
private:
        friend class MetaObject;
        
        inline MetaField (MetaObject *meta, short index)
                : m_meta (meta), m_index (index)
        {}
        
        mutable MetaObject *m_meta;
        short m_index;
};

class NURIA_CORE_EXPORT MetaEnum {
public:
        
        MetaEnum ();
        
        bool isValid () const;
        
        QByteArray name () const;
        
        int elementCount () const;
        
        QByteArray key (int at) const;
        
        int value (int at) const;
        
        QByteArray valueToKey (int value) const;
        
        int keyToValue (const QByteArray &key) const;
        
        int annotationCount () const;
        
        MetaAnnotation annotation (int idx) const;
        
        int annotationLowerBound (const QByteArray &name) const;
        
        int annotationUpperBound (const QByteArray &name) const;
        
private:
        friend class MetaObject;
        
        inline MetaEnum (MetaObject *meta, int index)
                : m_meta (meta), m_index (index)
        {}
        
        mutable MetaObject *m_meta;
        int m_index;
        
};

typedef QMap< QByteArray, MetaObject * > MetaObjectMap;

class NURIA_CORE_EXPORT MetaObject {
public:
        
        enum class GateMethod {
                ClassName = 0, // QByteArray
                MetaTypeId = 1, // int
                PointerMetaTypeId = 2, // int
                BaseClasses = 3, // QVector< QByteArray >
                AnnotationCount = 4, // int
                MethodCount = 5, // int
                FieldCount = 6, // int
                EnumCount = 7, // int
                
                AnnotationName = 10, // QByteArray
                AnnotationValue = 11, // QVariant
                
                MethodName = 20, // QByteArray
                MethodType = 21, // Nuria::MetaMethod::Type
                MethodReturnType = 22, // QByteArray
                MethodArgumentNames = 23, // QVector< QByteArray >
                MethodArgumentTypes = 24, // QVector< QByteArray >
                MethodCallback = 25, // Nuria::Callback, additional = void *instance
                MethodUnsafeCallback = 26, // Nuria::Callback, additional = void *instance
                MethodArgumentTest = 27, // Nuria::Callback, additional = void *instance
                
                FieldName = 30, // QByteArray
                FieldType = 31, // QByteArray
                FieldRead = 32, // QVariant, additional = void *instance
                FieldWrite = 33, // bool, additional = void** = { instance, value }
                FieldAccess = 34, // MetaField::Access
                
                EnumName = 40, // QByteArray
                EnumElementCount = 41, // int
                EnumElementKey = 42, // QByteArray
                EnumElementValue = 43, // int
                
                DestroyInstance = 50 // void, additional = void *instance
        };
        
        template< typename T >
        static MetaObject *of () {
                int id = qMetaTypeId< T * > ();
                const char *typeName = QMetaType::typeName (id);
                return MetaObject::byName (QByteArray (typeName, ::strlen (typeName) - 1));
        }
        
        static MetaObject *byName (const QByteArray &type);
        
        static MetaObject *byTypeId (int typeId);
        
        static MetaObjectMap typesInheriting (const QByteArray &typeName);
        
        static MetaObjectMap typesWithAnnotation (const QByteArray &name);
        
        static MetaObjectMap allTypes ();
        
        static void registerMetaObject (MetaObject *object);
        
        inline MetaObject () {}
        
        virtual ~MetaObject () {}
        
        QByteArray className ();
        
        int metaTypeId ();
        
        int pointerMetaTypeId ();
        
        QVector< QByteArray > parents ();
        
        int annotationCount ();
        
        MetaAnnotation annotation (int idx) const;
        
        int annotationLowerBound (const QByteArray &name) const;
        
        int annotationUpperBound (const QByteArray &name) const;
        
        int methodCount ();
        
        MetaMethod method (int idx);
        
        int methodLowerBound (const QByteArray &name);
        
        int methodUpperBound (const QByteArray &name);
        
        MetaMethod method (const QVector< QByteArray > &prototype);
        
        void destroyInstance (void *instance);
        
        int fieldCount ();
        
        MetaField field (int idx);
        
        MetaField fieldByName (const QByteArray &name);
        
        int enumCount ();
        
        MetaEnum enumAt (int idx);
        
        MetaEnum enumByName (const QByteArray &name);
        
protected:
        
        virtual void gateCall (GateMethod method, int category, int index, int nth,
                               void *result, void *additional = 0) = 0;
        
private:
        friend class MetaAnnotation;
        friend class MetaMethod;
        friend class MetaField;
        friend class MetaEnum;
        
};

}

#endif // NURIA_METAOBJECT_HPP