PyDefaultArguments.h

Go to the documentation of this file.

#pragma once
// QPy - Copyright (c) 2012,2013 Ugo Varetto
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the author and copyright holder nor the
//       names of contributors to the project may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL UGO VARETTO BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


#include <Python.h>
#include <stdexcept>
#include <QString>
#include <QVariantMap>
#include <QVariantList>
#include <QString>
#include <QList>
#include <QGenericArgument>
#include <QGenericReturnArgument>
#include <QVector>
#include <QVariant>

#include "../PyQArgConstructor.h"
#include "../PyArgConstructor.h"

namespace qpy {


class IntQArgConstructor : public QArgConstructor {
public:
    QGenericArgument Create( PyObject* pyobj ) const {
        i_ = PyInt_AsLong( pyobj );
        return Q_ARG( int, i_ );
    }
    IntQArgConstructor* Clone() const {
        return new IntQArgConstructor( *this );
    }
private:
    mutable int i_;
};
class StringQArgConstructor : public QArgConstructor {
public:
    QGenericArgument Create( PyObject* pyobj ) const {
        s_ = PyString_AsString( pyobj );
        return Q_ARG( QString, s_ );
    }
    StringQArgConstructor* Clone() const {
        return new StringQArgConstructor( *this );
    }
private:
    mutable QString s_;
};
class DoubleQArgConstructor : public QArgConstructor {
public:
    QGenericArgument Create( PyObject* pyobj ) const {
        d_ = PyFloat_AsDouble( pyobj );
        return Q_ARG( double, d_ );
    }
    DoubleQArgConstructor* Clone() const {
        return new DoubleQArgConstructor( *this );
    }
private:
    mutable double d_;
};
class FloatQArgConstructor : public QArgConstructor {
public:
    QGenericArgument Create( PyObject* pyobj ) const {
        f_ = float( PyFloat_AsDouble( pyobj ) );
        return Q_ARG( float, f_ );
    }
    FloatQArgConstructor* Clone() const {
        return new FloatQArgConstructor( *this );
    }
private:
    mutable float f_;
};
class VoidStarQArgConstructor : public QArgConstructor {
public:
    QGenericArgument Create( PyObject* pyobj ) const {
        i_ = PyLong_AsVoidPtr( pyobj );
        return Q_ARG( void*, i_ );
    }
    VoidStarQArgConstructor* Clone() const {
        return new VoidStarQArgConstructor( *this );
    }
private:
    mutable void* i_;
};
class ObjectStarQArgConstructor : public QArgConstructor {
public:
    QGenericArgument Create( PyObject* pyobj ) const;

    ObjectStarQArgConstructor* Clone() const {
        return new ObjectStarQArgConstructor( *this );
    }
private:
    mutable QObject* obj_;
};

class IntPyArgConstructor : public PyArgConstructor {
public:
    IntPyArgConstructor() {
        SetArg( i_ );
    }
    IntPyArgConstructor( const IntPyArgConstructor& other ) : i_( other.i_ ) {
        SetArg( i_ );
    }
    PyObject* Create( void* p ) const {
        int i = *reinterpret_cast< int* >( p );
        return PyInt_FromLong( i );
    }
    PyObject* Create() const {
        return PyInt_FromLong( i_ );
    }
    IntPyArgConstructor* Clone() const {
        return new IntPyArgConstructor( *this );
    }
    bool IsQObjectPtr() const { return false; }
    QMetaType::Type Type() const { return QMetaType::Int; }
private:
    int i_; 
};
class StringPyArgConstructor : public PyArgConstructor {
public:
    StringPyArgConstructor() {
        SetArg( s_ );
    }
    StringPyArgConstructor( const StringPyArgConstructor& other ) : s_( other.s_ ) {
        SetArg( s_ );
    }
    PyObject* Create( void* p ) const {
        QString s = *reinterpret_cast< QString* >( p );
        return PyString_FromString( s.toAscii().constData() );
    }
    PyObject* Create() const {
        return PyString_FromString( s_.toAscii().constData() );
    }
    StringPyArgConstructor* Clone() const {
        return new StringPyArgConstructor( *this );
    }
    bool IsQObjectPtr() const { return false; }
    QMetaType::Type Type() const { return QMetaType::QString; }
private:
    QString s_; 
};
class DoublePyArgConstructor : public PyArgConstructor {
public:
    DoublePyArgConstructor() {
        SetArg( d_ );
    }
    DoublePyArgConstructor( const DoublePyArgConstructor& other ) : d_( other.d_ ) {
        SetArg( d_ );
    }
    PyObject* Create( void* p ) const {
        double d = *reinterpret_cast< double* >( p );
        return PyFloat_FromDouble( d );
    }
    PyObject* Create() const {
        return PyFloat_FromDouble( d_ );
    }
    DoublePyArgConstructor* Clone() const {
        return new DoublePyArgConstructor( *this );
    }
    bool IsQObjectPtr() const { return false; }
    QMetaType::Type Type() const { return QMetaType::Double; }
private:
    double d_; 
};
class FloatPyArgConstructor : public PyArgConstructor {
public:
    FloatPyArgConstructor() {
        SetArg( f_ );
    }
    FloatPyArgConstructor( const FloatPyArgConstructor& other ) : f_( other.f_ ) {
        SetArg( f_ );
    }
    PyObject* Create( void* p ) const {
        float f = *reinterpret_cast< float* >( p );
        return PyFloat_FromDouble( f );
    }
    PyObject* Create() const {
        return PyFloat_FromDouble( f_ );
    }
    FloatPyArgConstructor* Clone() const {
        return new FloatPyArgConstructor( *this );
    }
    bool IsQObjectPtr() const { return false; }
    QMetaType::Type Type() const { return QMetaType::Float; }
private:
    float f_; 
};

class VoidPyArgConstructor : public PyArgConstructor {
public:
    PyObject* Create() const { 
        Py_RETURN_NONE;
    } 
    PyObject* Create( void* ) const { return 0; }
    VoidPyArgConstructor* Clone() const {
        return new VoidPyArgConstructor( *this );
    }
    bool IsQObjectPtr() const { return false; }
    QMetaType::Type Type() const { return QMetaType::Void; }
};

class ObjectStarPyArgConstructor : public PyArgConstructor {
public:
    ObjectStarPyArgConstructor() {
        SetArg( obj_ );   
    }
    ObjectStarPyArgConstructor( const ObjectStarPyArgConstructor& other ) : obj_( other.obj_ ) {
        SetArg( obj_ );   
    }
    PyObject* Create() const {
        Py_RETURN_NONE;
    }
    PyObject* Create( void* ) const {
        Py_RETURN_NONE;
    }
    ObjectStarPyArgConstructor* Clone() const {
        return new ObjectStarPyArgConstructor( *this );
    }
    bool IsQObjectPtr() const { return true; }
    QMetaType::Type Type() const { return QMetaType::QObjectStar; }
private:
    QObject* obj_;
};

}