PythonQtClassInfo.h

Go to the documentation of this file.

#ifndef _PYTHONQTCLASSINFO_H
#define _PYTHONQTCLASSINFO_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 "PythonQt.h"
#include <QMetaObject>
#include <QMetaMethod>
#include <QHash>
#include <QByteArray>
#include <QList>
 
class PythonQtSlotInfo;
class PythonQtClassInfo;
 
struct PythonQtDynamicClassInfo {
  PythonQtDynamicClassInfo()
  {
    _dynamicMetaObject = nullptr;
    _classInfo = nullptr;
  }
  ~PythonQtDynamicClassInfo();
 
  const QMetaObject* _dynamicMetaObject;
  PythonQtClassInfo* _classInfo;
};
 
struct PythonQtMemberInfo {
  enum Type { Invalid, Slot, Signal, EnumValue, EnumWrapper, Property, NestedClass, NotFound };
 
  PythonQtMemberInfo()
    : _type(Invalid)
    , _slot(nullptr)
    , _pythonType(nullptr)
    , _enumValue(nullptr)
  {
  }
 
  PythonQtMemberInfo(PythonQtSlotInfo* info);
 
  PythonQtMemberInfo(const PythonQtObjectPtr& enumValue);
 
  PythonQtMemberInfo(const QMetaProperty& prop);
 
  Type _type;
 
  // TODO: this could be a union...
  PythonQtSlotInfo* _slot;
  PyObject* _pythonType;
  PythonQtObjectPtr _enumValue;
  QMetaProperty _property;
};
 
 
class PYTHONQT_EXPORT PythonQtClassInfo
{
 
public:
  PythonQtClassInfo();
  ~PythonQtClassInfo();
 
  struct ParentClassInfo {
    ParentClassInfo(PythonQtClassInfo* parent, int upcastingOffset = 0)
      : _parent(parent)
      , _upcastingOffset(upcastingOffset) {};
 
    PythonQtClassInfo* _parent;
    int _upcastingOffset;
  };
 
  void setupQObject(const QMetaObject* meta);
 
  void setupCPPObject(const QByteArray& classname);
 
  void setTypeSlots(int typeSlots) { _typeSlots = typeSlots; }
  int typeSlots() const { return _typeSlots; }
 
  PythonQtMemberInfo member(const char* member);
 
  PythonQtSlotInfo* constructors();
 
  PythonQtSlotInfo* destructor();
 
  void addConstructor(PythonQtSlotInfo* info);
 
  void setDestructor(PythonQtSlotInfo* info);
 
  void addDecoratorSlot(PythonQtSlotInfo* info);
 
  void addNestedClass(PythonQtClassInfo* info);
 
  const QByteArray& className() const;
 
  QByteArray unscopedClassName() const;
 
  bool isQObject() { return _isQObject; }
 
  bool isCPPWrapper() { return !_isQObject; }
 
  const QMetaObject* metaObject() { return _meta; }
 
  void setMetaObject(const QMetaObject* meta);
 
  bool inherits(const char* classname);
 
  bool inherits(PythonQtClassInfo* info);
 
  void* castTo(void* ptr, const char* classname);
 
  QString help();
 
  QStringList propertyList();
 
  QStringList memberList();
 
  int metaTypeId() { return _metaTypeId; }
 
  void setDecoratorProvider(PythonQtQObjectCreatorFunctionCB* cb);
 
  QObject* decorator();
 
  void addParentClass(const ParentClassInfo& info) { _parentClasses.append(info); }
 
  void setPythonQtClassWrapper(PyObject* obj) { _pythonQtClassWrapper = obj; }
 
  PyObject* pythonQtClassWrapper() { return _pythonQtClassWrapper; }
 
  void setShellSetInstanceWrapperCB(PythonQtShellSetInstanceWrapperCB* cb) { _shellSetInstanceWrapperCB = cb; }
 
  PythonQtShellSetInstanceWrapperCB* shellSetInstanceWrapperCB() { return _shellSetInstanceWrapperCB; }
 
  void addPolymorphicHandler(PythonQtPolymorphicHandlerCB* cb) { _polymorphicHandlers.append(cb); }
 
  void* castDownIfPossible(void* ptr, PythonQtClassInfo** resultClassInfo);
 
  static PyObject* findEnumWrapper(const QByteArray& name, PythonQtClassInfo* localScope, bool* isLocalEnum = nullptr);
 
  void clearNotFoundCachedMembers();
 
  const QList<PythonQtClassInfo*>& nestedClasses() { return _nestedClasses; }
 
  PyObject* copyObject(void* cppObject);
 
  PythonQtSlotInfo* getCopyConstructor();
 
  void setReferenceCounting(PythonQtVoidPtrCB* refCB, PythonQtVoidPtrCB* unrefCB);
 
  PythonQtVoidPtrCB* referenceCountingRefCB();
  PythonQtVoidPtrCB* referenceCountingUnrefCB();
 
  PyObject* getPythonTypeForProperty(const QString& name);
 
  PythonQtClassInfo* getClassInfoForProperty(const QString& name);
 
  bool supportsRichCompare();
 
  static QByteArray escapeReservedNames(const QByteArray& name);
 
  static void addGlobalNamespaceWrapper(PythonQtClassInfo* namespaceWrapper);
 
  static void clearGlobalNamespaceWrappers();
 
private:
  void updateRefCountingCBs();
 
  void createEnumWrappers(const QObject* decoratorProvider);
  void createEnumWrappers(const QMetaObject* meta);
  PyObject* findEnumWrapper(const char* name);
 
  void clearCachedMembers();
 
  void* recursiveCastDownIfPossible(void* ptr, const char** resultClassName);
 
  PythonQtSlotInfo* findDecoratorSlotsFromDecoratorProvider(const char* memberName, PythonQtSlotInfo* inputInfo,
    bool& found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset);
  void listDecoratorSlotsFromDecoratorProvider(QStringList& list, bool metaOnly);
  PythonQtSlotInfo* recursiveFindDecoratorSlotsFromDecoratorProvider(const char* memberName,
    PythonQtSlotInfo* inputInfo, bool& found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset);
 
  void recursiveCollectClassInfos(QList<PythonQtClassInfo*>& classInfoObjects);
  void recursiveCollectDecoratorObjects(QList<QObject*>& decoratorObjects);
 
  bool lookForPropertyAndCache(const char* memberName);
  bool lookForMethodAndCache(const char* memberName);
  bool lookForEnumAndCache(const QMetaObject* m, const char* memberName);
 
  PythonQtSlotInfo* findDecoratorSlots(const char* memberName, PythonQtSlotInfo* tail, bool& found,
    QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset);
  int findCharOffset(const char* sigStart, char someChar);
 
  QHash<QByteArray, PythonQtMemberInfo> _cachedMembers;
 
  PythonQtSlotInfo* _constructors;
  PythonQtSlotInfo* _destructor;
 
  PythonQtVoidPtrCB* _refCallback;
  PythonQtVoidPtrCB* _unrefCallback;
 
  QList<PythonQtSlotInfo*> _decoratorSlots;
 
  QList<PythonQtObjectPtr> _enumWrappers;
 
  const QMetaObject* _meta;
 
  QByteArray _wrappedClassName;
  QList<ParentClassInfo> _parentClasses;
 
  QList<PythonQtPolymorphicHandlerCB*> _polymorphicHandlers;
 
  QList<PythonQtClassInfo*> _nestedClasses;
 
  QObject* _decoratorProvider;
  PythonQtQObjectCreatorFunctionCB* _decoratorProviderCB;
 
  PyObject* _pythonQtClassWrapper;
 
  PythonQtShellSetInstanceWrapperCB* _shellSetInstanceWrapperCB;
 
  int _metaTypeId;
  int _typeSlots;
 
  bool _isQObject;
  bool _enumsCreated;
  bool _richCompareDetectionDone;
  bool _searchPolymorphicHandlerOnParent;
  bool _searchRefCountCB;
 
  static QList<PythonQtClassInfo*> _globalNamespaceWrappers;
 
  static QSet<QByteArray> _reservedNames;
};
 
//---------------------------------------------------------------
 
#endif