#ifndef _PYTHONQTOBJECTPTR_H

#define _PYTHONQTOBJECTPTR_H

#include "PythonQtPythonInclude.h"

#include "PythonQtSystem.h"

#include "PythonQtThreadSupport.h"

#include <QVariant>

#include <QVariantList>

#include <QVariantMap>

class PythonQtSafeObjectPtr;

class PYTHONQT_EXPORT PythonQtObjectPtr

{

PythonQtObjectPtr():_object(nullptr) {}

PythonQtObjectPtr(const PythonQtObjectPtr &p)

:_object(nullptr) {

setObject(p.object());

}

//! rvalue copy constructor, does not need any incref/decref.

PythonQtObjectPtr(PythonQtObjectPtr &&p) noexcept

:_object(p.takeObject()) {

}

//! rvalue copy constructor, does not need any incref/decref.

PythonQtObjectPtr(PythonQtSafeObjectPtr &&p);

//! If the given variant holds a PythonQtObjectPtr, extract the value from it and hold onto the reference. This results in an increment of the reference count.

PythonQtObjectPtr(const QVariant& variant):_object(nullptr) {

fromVariant(variant);

}

PythonQtObjectPtr(PyObject* o);

~PythonQtObjectPtr();

//! If the given variant holds a PythonQtObjectPtr, extract the value from it and hold onto the reference. This results in an increment of the reference count.

bool fromVariant(const QVariant& variant);

//! Returns a PythonQtSafeObjectPtr as a QVariant. It does not return a PythonQtObjectPtr, because that would be unsafe regarding the GIL.

QVariant toVariant();

//! Returns a PythonQtObjectPtr as a QVariant. Only use this when you know that the variant is only used locally and not stored outside of the current GIL scope.

QVariant toLocalVariant();

PythonQtObjectPtr &operator=(const PythonQtObjectPtr &p) {

setObject(p.object());

return *this;

}

//! rvalue assignment operator that steals the reference from p

PythonQtObjectPtr &operator=(PythonQtObjectPtr &&p) noexcept {

if (_object) {

setObject(nullptr);

}

_object = p.takeObject();

return *this;

}

//! rvalue assignment operator that steals the reference from p

PythonQtObjectPtr &operator=(PythonQtSafeObjectPtr &&p);

PythonQtObjectPtr &operator=(PyObject* o) {

setObject(o);

return *this;

}

PythonQtObjectPtr &operator=(const QVariant& variant) {

fromVariant(variant);

return *this;

}

bool operator==( const PythonQtObjectPtr &p ) const {

return object() == p.object();

}

bool operator!= ( const PythonQtObjectPtr& p ) const {

return !( *this == p );

}

bool operator==( PyObject* p ) const {

return object() == p;

}

bool operator!= ( PyObject* p ) const {

return object() != p;

}

bool isNull() const { return !object(); }

PyObject* operator->() const { return object(); }

PyObject& operator*() const { return *( object() ); }

operator PyObject*() const { return object(); }

//! sets the object and passes the ownership (stealing the reference, in Python slang)

void setNewRef(PyObject* o);

PyObject* object() const {

return _object;

}

//! evaluates the given script code in the context of this object and returns the result value

QVariant evalScript(const QString& script, int start = Py_file_input);

//! evaluates the given code and returns the result value (use Py_Compile etc. to create pycode from string)

//! If pycode is NULL, a python error is printed.

QVariant evalCode(PyObject* pycode);

//! evaluates the given code in the context

void evalFile(const QString& filename);

//! add the given \c object to the \c module as a variable with \c name (it can be removed via clearVariable)

void addObject(const QString& name, QObject* object);

//! add the given variable to the module

void addVariable(const QString& name, const QVariant& v);

//! remove the given variable

void removeVariable(const QString& name);

//! get the variable with the \c name of the \c module, returns an invalid QVariant on error

QVariant getVariable(const QString& name);

//! call the given python object (in the scope of the current object), returns the result converted to a QVariant

QVariant call(const QString& callable, const QVariantList& args = QVariantList(), const QVariantMap& kwargs = QVariantMap());

//! call the contained python object directly, returns the result converted to a QVariant

QVariant call(const QVariantList& args = QVariantList(), const QVariantMap& kwargs = QVariantMap());

//! takes the object from the pointer, leaving the pointer empty.

//! the caller has to take care about the decref of the taken object!

PyObject* takeObject() {

PyObject* o = _object;

_object = nullptr;

return o;

}

void setObject(PyObject* o);

PyObject* _object;

};

class PYTHONQT_EXPORT PythonQtSafeObjectPtr

{

PythonQtSafeObjectPtr() :_object(nullptr) {}

PythonQtSafeObjectPtr(const PythonQtSafeObjectPtr &p)

:_object(nullptr) {

setObject(p.object());

}

PythonQtSafeObjectPtr(const PythonQtObjectPtr &p)

:_object(nullptr) {

setObject(p.object());

}

//! rvalue copy constructor, does not need any incref/decref.

PythonQtSafeObjectPtr(PythonQtSafeObjectPtr &&p) noexcept

:_object(p._object) {

p._object = nullptr;

}

//! rvalue copy constructor, does not need any incref/decref.

PythonQtSafeObjectPtr(PythonQtObjectPtr &&p)

:_object(p.takeObject()) {

}

PythonQtSafeObjectPtr(PyObject* o);

~PythonQtSafeObjectPtr();

PythonQtSafeObjectPtr &operator=(const PythonQtSafeObjectPtr &p) {

setObject(p.object());

return *this;

}

PythonQtSafeObjectPtr &operator=(const PythonQtObjectPtr &p) {

setObjectUnsafe(p.object());

return *this;

}

//! rvalue assignment operator that steals the reference from p

PythonQtSafeObjectPtr &operator=(PythonQtSafeObjectPtr &&p) noexcept {

if (_object) {

setObject(nullptr);

}

_object = p._object;

p._object = nullptr;

return *this;

}

//! rvalue assignment operator that steals the reference from p

PythonQtSafeObjectPtr &operator=(PythonQtObjectPtr &&p) {

if (_object) {

setObjectUnsafe(nullptr);

}

_object = p.takeObject();

return *this;

}

PythonQtSafeObjectPtr &operator=(PyObject* o) {

setObject(o);

return *this;

}

bool operator==(const PythonQtSafeObjectPtr &p) const {

return object() == p.object();

}

bool operator!= (const PythonQtSafeObjectPtr& p) const {

return !(*this == p);

}

bool operator==(PyObject* p) const {

return object() == p;

}

bool operator!= (PyObject* p) const {

return object() != p;

}

bool isNull() const { return !object(); }

PyObject* operator->() const { return object(); }

PyObject& operator*() const { return *(object()); }

operator PyObject*() const { return object(); }

PyObject* object() const {

return _object;

}

//! takes the object from the pointer, leaving the pointer empty.

//! the caller has to take care about the decref of the taken object!

PyObject* takeObject() {

PyObject* o = _object;

_object = nullptr;

return o;

}

void setObject(PyObject* o);

void setObjectUnsafe(PyObject* o);

PyObject* _object;

};

Q_DECLARE_METATYPE(PythonQtSafeObjectPtr)

#endif