pythonItomMetaObject.h

/* ********************************************************************
    itom software
    URL: http://www.uni-stuttgart.de/ito
    Copyright (C) 2020, Institut für Technische Optik (ITO),
    Universität Stuttgart, Germany
 
    This file is part of itom.
 
    itom is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public Licence as published by
    the Free Software Foundation; either version 2 of the Licence, or (at
    your option) any later version.
 
    itom 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 Library
    General Public Licence for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with itom. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************** */
 
#ifndef PYTHONITOMMETAOBJECT_H
#define PYTHONITOMMETAOBJECT_H
 
#include "../global.h"
 
#include <qbytearray.h>
#include <qmetaobject.h>
 
namespace ito
{
 
    struct PythonQObjectMarshal
    {
        PythonQObjectMarshal() : m_objectID(0), m_object(NULL) {}
 
        PythonQObjectMarshal(QByteArray objName, const char* className, QObject *object) :
            m_objName(objName),
            m_objectID(0),
            m_object(object)
        {
            m_className = QByteArray(className);
        }
 
        PythonQObjectMarshal(QObject *obj) :
            m_objName(obj->objectName().toLatin1()),
            m_objectID(0),
            m_object(obj)
        {
            m_className = QByteArray(obj->metaObject()->className());
        }
 
        QByteArray m_objName;
        QByteArray m_className;
        unsigned int m_objectID;
        QObject *m_object; //casted from QObject
    };
 
 
 
// MethodDescription
class MethodDescription
{
public:
    MethodDescription();
    MethodDescription(
        QByteArray &name,
        QByteArray &signature,
        QMetaMethod::MethodType type,
        QMetaMethod::Access access,
        int methodIndex,
        int retType,
        int nrOfArgs,
        int *argTypes
    );
    MethodDescription(QMetaMethod &method);
    MethodDescription(const MethodDescription &copy);
    ~MethodDescription();
 
    MethodDescription &operator=(const MethodDescription &other);
 
    inline bool isValid() const { return (m_methodIndex >= 0); }    
    inline QMetaMethod::MethodType type() const { return m_type; }  
    inline QMetaMethod::Access access() const { return m_access; }  
    inline int methodIndex() const { return m_methodIndex; }        
    inline QByteArray name() const { return m_name; }               
    inline int retType() const { return m_retType; }                
    inline int nrOfArgs() const { return m_nrOfArgs; }              
    inline int* argTypes() const { return m_argTypes; }             
    inline QByteArray signature() const { return m_signature; }     
    inline bool checkMethod(QByteArray &name, int nrOfArgs) const { return (name == m_name && nrOfArgs == m_nrOfArgs); }
 
private:
    QByteArray m_name;               
    int m_methodIndex;               
    QByteArray m_signature;          
    QMetaMethod::MethodType m_type;  
    QMetaMethod::Access m_access;    
    int m_retType;                   
    int m_nrOfArgs;                  
    int *m_argTypes;                 
};
 
typedef QList<MethodDescription> MethodDescriptionList;
 
class FctCallParamContainer
{
public:
 
    FctCallParamContainer(int nrOfParams) :
      m_nrOfParams(nrOfParams),
      m_sizeArgs(nrOfParams+1)
    {
        m_args = new void*[m_sizeArgs];
        m_argTypes = new int[m_sizeArgs];
 
        for (int i = 0; i < m_sizeArgs; i++)
        {
            m_args[i] = nullptr;
            m_argTypes[i] = -1;
        }
    };
 
 
    ~FctCallParamContainer()
    {
        for (int i = 0; i < m_sizeArgs; i++)
        {
            QMetaType(m_argTypes[i]).destroy(m_args[i]);
        }
 
        DELETE_AND_SET_NULL_ARRAY(m_argTypes);
        DELETE_AND_SET_NULL_ARRAY(m_args);
    }
 
    inline void** args() { return m_args; };                 
    inline int* argTypes() { return m_argTypes; };           
    inline int getRetType() const { return m_argTypes[0]; }; 
 
    inline void initRetArg(int type)  //reference of ptr is stolen and will be deleted by this class
    {
        if (m_args[0])
        {
            QMetaType(m_argTypes[0]).destroy(m_args[0]);
        }
 
        m_argTypes[0] = type;
        m_args[0] = QMetaType(type).create(nullptr);
    };
 
 
    inline void setParamArg(unsigned int index, void* ptr, int type)  //reference of ptr is stolen and will be deleted by this class
    {
        if ((int)index < 0 || (int)index >= m_nrOfParams)
        {
            return;
        }
 
        if (m_args[index + 1])
        {
            QMetaType(m_argTypes[index + 1]).destroy(m_args[index + 1]);
        }
 
        m_args[index+1] = ptr;
        m_argTypes[index+1] = type;
    };
 
private:
    FctCallParamContainer( const FctCallParamContainer & /*copy*/ ) = delete;
    int m_nrOfParams;  
    int m_sizeArgs;  
    void** m_args;   
    int* m_argTypes; 
};
 
} //end namespace ito
 
#endif // PYTHONITOMMETAOBJECT_H