pythonItomMetaObject.h

/* ********************************************************************
    itom software
    URL: http://www.uni-stuttgart.de/ito
    Copyright (C) 2020, Institut fuer Technische Optik (ITO),
    Universitaet 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] = NULL;
            m_argTypes[i] = -1;
        }
    };
    

    ~FctCallParamContainer()
    {
        for(int i=0;i<m_sizeArgs;i++) 
        {
            QMetaType::destroy(m_argTypes[i], 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::destroy(m_argTypes[0], m_args[0]);
        m_argTypes[0] = type; 
        m_args[0] = QMetaType::create(type, NULL);
    };


    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::destroy(m_argTypes[index+1], 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