PythonQtMethodInfo.h

Go to the documentation of this file.

#ifndef _PYTHONQTMETHODINFO_H
#define _PYTHONQTMETHODINFO_H
 
/*
 *
 *  Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
 *
 *  This library 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 2.1 of the License, or (at your option) any later version.
 *
 *  This library 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.
 *
 *  Further, this software is distributed without any warranty that it is
 *  free of the rightful claim of any third person regarding infringement
 *  or the like.  Any license provided herein, whether implied or
 *  otherwise, applies only to this software file.  Patent licenses, if
 *  any, provided herein do not apply to combinations of this program with
 *  other software, or any other product whatsoever.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *  Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
 *  28359 Bremen, Germany or:
 *
 *  http://www.mevis.de
 *
 */
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
 
#include "PythonQtPythonInclude.h"
#include "PythonQtSystem.h"
 
#include <QByteArray>
#include <QHash>
#include <QList>
#include <QMetaMethod>
 
class PythonQtClassInfo;
struct _object;
typedef struct _object PyObject;
 
class PYTHONQT_EXPORT PythonQtMethodInfo
{
public:
  enum ParameterType {
    Unknown = -1,
    Variant = -2
  };
 
  struct ParameterInfo {
    QByteArray name;
    QByteArray innerName; // if the type is a template, this stores the inner name
    PyObject*  enumWrapper; // if it is an enum, a pointer to the enum wrapper
    int  typeId; // a mixture from QMetaType and ParameterType
    char pointerCount; // the number of pointer indirections
    char innerNamePointerCount; // the number of pointer indirections in the inner name
    bool isConst;
    bool isReference;
    bool isQList;
    bool passOwnershipToCPP;
    bool passOwnershipToPython;
    bool newOwnerOfThis;
  };
 
  PythonQtMethodInfo() {
    _shouldAllowThreads = true;
  };
  ~PythonQtMethodInfo() {};
  PythonQtMethodInfo(const QMetaMethod& meta, PythonQtClassInfo* classInfo);
  PythonQtMethodInfo(const QByteArray& typeName, const QList<QByteArray>& args);
  PythonQtMethodInfo(const PythonQtMethodInfo& other) {
    _parameters = other._parameters;
    _shouldAllowThreads = other._shouldAllowThreads;
  }
 
  static const PythonQtMethodInfo* getCachedMethodInfo(const QMetaMethod& method, PythonQtClassInfo* classInfo);
 
  static const PythonQtMethodInfo* getCachedMethodInfoFromArgumentList(int numArgs, const char** args);
 
  static void cleanupCachedMethodInfos();
 
  int  parameterCount() const { return _parameters.size(); };
 
  static int nameToType(const char* name);
 
  const QList<ParameterInfo>& parameters() const { return _parameters; }
 
  static void addParameterTypeAlias(const QByteArray& alias, const QByteArray& name);
 
  static void fillParameterInfo(ParameterInfo& type, const QByteArray& name, PythonQtClassInfo* classInfo = nullptr);
 
  static const ParameterInfo& getParameterInfoForMetaType(int type);
 
  static int getInnerTemplateMetaType(const QByteArray& typeName);
 
  static QByteArray getInnerTemplateTypeName(const QByteArray& typeName);
 
  static QByteArray getInnerListTypeName(const QByteArray& typeName);
 
  bool shouldAllowThreads() const { return _shouldAllowThreads; }
 
protected:
  void setupAllowThreads();
 
  static QHash<QByteArray, int> _parameterTypeDict;
  static QHash<QByteArray, QByteArray> _parameterNameAliases;
 
  static QHash<QByteArray, PythonQtMethodInfo*> _cachedSignatures;
 
  static QHash<int, ParameterInfo> _cachedParameterInfos;
 
  QList<ParameterInfo> _parameters;
  bool _shouldAllowThreads;
 
};
 
class PYTHONQT_EXPORT PythonQtSlotInfo : public PythonQtMethodInfo
{
public:
  enum Type {
    MemberSlot, InstanceDecorator, ClassDecorator
  };
 
  PythonQtSlotInfo(const PythonQtSlotInfo& info):PythonQtMethodInfo() {
    _meta = info._meta;
    _parameters = info._parameters;
    _shouldAllowThreads = info._shouldAllowThreads;
    _slotIndex = info._slotIndex;
    _next = nullptr;
    _decorator = info._decorator;
    _type = info._type;
    _upcastingOffset = 0;
  }
 
  PythonQtSlotInfo(PythonQtClassInfo* classInfo, const QMetaMethod& meta, int slotIndex, QObject* decorator = nullptr, Type type = MemberSlot ):PythonQtMethodInfo()
  {
    const PythonQtMethodInfo* info = getCachedMethodInfo(meta, classInfo);
    _meta = meta;
    _parameters = info->parameters();
    _shouldAllowThreads = info->shouldAllowThreads();
    _slotIndex = slotIndex;
    _next = nullptr;
    _decorator = decorator;
    _type = type;
    _upcastingOffset = 0;
  }
 
 
public:
  QList<ParameterInfo> arguments() const;
 
  void deleteOverloadsAndThis();
 
  const QMetaMethod* metaMethod() const { return &_meta; }
 
  void setUpcastingOffset(int upcastingOffset) { _upcastingOffset = upcastingOffset; }
 
  int upcastingOffset() const { return _upcastingOffset; }
 
  int slotIndex() const { return _slotIndex; }
 
  PythonQtSlotInfo* nextInfo()  const { return _next; }
 
  void setNextInfo(PythonQtSlotInfo* next) { _next = next; }
 
  bool isInstanceDecorator() const { return _decorator!=nullptr && _type == InstanceDecorator; }
 
  bool isClassDecorator() const { return _decorator!=nullptr && _type == ClassDecorator; }
 
  QObject* decorator() const { return _decorator; }
 
  QString fullSignature(bool skipReturnValue = false, int optionalArgsIndex = -1) const;
 
  QByteArray signature() const;
 
  QByteArray slotName(bool removeDecorators = false) const;
 
  QStringList overloads(bool skipReturnValue = false) const;
 
  QByteArray getImplementingClassName() const;
 
  static void invokeQtMethod(QObject* obj, PythonQtSlotInfo* slot, void** argList);
 
  static void setGlobalShouldAllowThreads(bool flag);
 
  static bool getGlobalShouldAllowThreads();
 
private:
  int               _slotIndex;
  PythonQtSlotInfo* _next;
  QObject*          _decorator;
  Type              _type;
  QMetaMethod       _meta;
  int               _upcastingOffset;
 
  static bool _globalShouldAllowThreads;
};
 
 
#endif