metaobject.hpp

/* Copyright (c) 2014, The Nuria Project
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *    1. The origin of this software must not be misrepresented; you must not
 *       claim that you wrote the original software. If you use this software
 *       in a product, an acknowledgment in the product documentation would be
 *       appreciated but is not required.
 *    2. Altered source versions must be plainly marked as such, and must not be
 *       misrepresented as being the original software.
 *    3. This notice may not be removed or altered from any source
 *       distribution.
 */

#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 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