kindred/create
1
1
Fork 0
Code Issues 37 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity

Base: apply clang format

Browse Source
This commit is contained in:
wmayer
2023-11-10 18:27:44 +01:00
committed by WandererFan
parent bb333d9a74
commit 985def3416
154 changed files with 11874 additions and 9872 deletions
Download Patch File Download Diff File Expand all files Collapse all files

154
src/Base/GeometryPyCXX.h
View File

@@ -37,8 +37,9 @@
#include <Base/Vector3D.h>
namespace Base {
template <typename T>
namespace Base
{
template<typename T>
inline Vector3<T> getVectorFromTuple(PyObject* o)
{
Py::Sequence tuple(o);
@@ -50,32 +51,35 @@ inline Vector3<T> getVectorFromTuple(PyObject* o)
T y = static_cast<T>(Py::Float(tuple[1]));
T z = static_cast<T>(Py::Float(tuple[2]));
return Vector3<T>(x,y,z);
return Vector3<T>(x, y, z);
}
class BaseExport Vector2dPy : public Py::PythonClass<Vector2dPy>
class BaseExport Vector2dPy: public Py::PythonClass<Vector2dPy> // NOLINT
{
public:
static Py::PythonType &behaviors();
static PyTypeObject *type_object();
static bool check( PyObject *p );
static Py::PythonType& behaviors();
static PyTypeObject* type_object();
static bool check(PyObject* p);
static Py::PythonClassObject<Vector2dPy> create(const Vector2d&);
static Py::PythonClassObject<Vector2dPy> create(double x, double y);
Vector2dPy(Py::PythonClassInstance *self, Py::Tuple &args, Py::Dict &kwds);
Vector2dPy(Py::PythonClassInstance* self, Py::Tuple& args, Py::Dict& kwds);
~Vector2dPy() override;
static void init_type();
Py::Object getattro(const Py::String &name_) override;
int setattro(const Py::String &name_, const Py::Object &value) override;
Py::Object getattro(const Py::String& name_) override;
int setattro(const Py::String& name_, const Py::Object& value) override;
Py::Object repr() override;
inline const Vector2d& value() const {
inline const Vector2d& value() const
{
return v;
}
inline void setValue(const Vector2d& n) {
inline void setValue(const Vector2d& n)
{
v = n;
}
inline void setValue(double x, double y) {
inline void setValue(double x, double y)
{
v.x = x;
v.y = y;
}
@@ -88,17 +92,17 @@ public:
Py::Object number_invert() override;
Py::Object number_int() override;
Py::Object number_float() override;
Py::Object number_add( const Py::Object & ) override;
Py::Object number_subtract( const Py::Object & ) override;
Py::Object number_multiply( const Py::Object & ) override;
Py::Object number_remainder( const Py::Object & ) override;
Py::Object number_divmod( const Py::Object & ) override;
Py::Object number_lshift( const Py::Object & ) override;
Py::Object number_rshift( const Py::Object & ) override;
Py::Object number_and( const Py::Object & ) override;
Py::Object number_xor( const Py::Object & ) override;
Py::Object number_or( const Py::Object & ) override;
Py::Object number_power( const Py::Object &, const Py::Object & ) override;
Py::Object number_add(const Py::Object&) override;
Py::Object number_subtract(const Py::Object&) override;
Py::Object number_multiply(const Py::Object&) override;
Py::Object number_remainder(const Py::Object&) override;
Py::Object number_divmod(const Py::Object&) override;
Py::Object number_lshift(const Py::Object&) override;
Py::Object number_rshift(const Py::Object&) override;
Py::Object number_and(const Py::Object&) override;
Py::Object number_xor(const Py::Object&) override;
Py::Object number_or(const Py::Object&) override;
Py::Object number_power(const Py::Object&, const Py::Object&) override;
//@}
Py::Object isNull(const Py::Tuple&);
@@ -118,53 +122,62 @@ private:
Vector2d v;
};
}
} // namespace Base
namespace Py {
namespace Py
{
using Vector2d = PythonClassObject<Base::Vector2dPy>;
inline Base::Vector2d toVector2d(PyObject *py) {
inline Base::Vector2d toVector2d(PyObject* py)
{
Base::Vector2dPy* py2d = Py::Vector2d(py).getCxxObject();
return py2d ? py2d->value() : Base::Vector2d();
}
inline Base::Vector2d toVector2d(const Object& py) {
inline Base::Vector2d toVector2d(const Object& py)
{
Base::Vector2dPy* py2d = Py::Vector2d(py).getCxxObject();
return py2d ? py2d->value() : Base::Vector2d();
}
// Implementing the vector class in the fashion of the PyCXX library.
class BaseExport Vector : public Object
class BaseExport Vector: public Object // NOLINT
{
public:
explicit Vector (PyObject *pyob, bool owned): Object(pyob, owned) {
explicit Vector(PyObject* pyob, bool owned)
: Object(pyob, owned)
{
validate();
}
Vector (const Vector& ob): Object(*ob) {
Vector(const Vector& ob)
: Object(*ob)
{
validate();
}
explicit Vector (const Base::Vector3d&);
explicit Vector (const Base::Vector3f&);
bool accepts (PyObject *pyob) const override;
explicit Vector(const Base::Vector3d&);
explicit Vector(const Base::Vector3f&);
bool accepts(PyObject* pyob) const override;
Vector(const Object& other): Object(other.ptr()) {
Vector(const Object& other)
: Object(other.ptr())
{
validate();
}
Vector& operator= (const Object& rhs)
Vector& operator=(const Object& rhs)
{
return (*this = *rhs);
}
Vector& operator= (const Vector& rhs)
Vector& operator=(const Vector& rhs)
{
return (*this = *rhs);
}
Vector& operator= (PyObject* rhsp);
Vector& operator= (const Base::Vector3d&);
Vector& operator= (const Base::Vector3f&);
Vector& operator=(PyObject* rhsp);
Vector& operator=(const Base::Vector3d&);
Vector& operator=(const Base::Vector3f&);
operator Base::Vector3d() const
{
return toVector();
@@ -173,7 +186,7 @@ public:
Base::Vector3d toVector() const;
private:
static int Vector_TypeCheck(PyObject *);
static int Vector_TypeCheck(PyObject*);
};
/**
@@ -188,45 +201,54 @@ private:
// The third template parameter is the definition of a pointer to the method
// of the Python binding class to return the managed geometric instance. In our
// example this is the method RotationPy::getRotationPtr.
template <class T, class PyT, T* (PyT::*valuePtr)() const>
class GeometryT : public Object
template<class T, class PyT, T* (PyT::*valuePtr)() const>
class GeometryT: public Object // NOLINT
{
public:
explicit GeometryT (PyObject *pyob, bool owned): Object(pyob, owned) {
explicit GeometryT(PyObject* pyob, bool owned)
: Object(pyob, owned)
{
validate();
}
GeometryT (const GeometryT& ob): Object(*ob) {
GeometryT(const GeometryT& ob)
: Object(*ob)
{
validate();
}
explicit GeometryT ()
explicit GeometryT()
{
set(new PyT(new T()), true);
validate();
}
explicit GeometryT (const T& v)
explicit GeometryT(const T& v)
{
set(new PyT(new T(v)), true);
validate();
}
GeometryT(const Object& other): Object(other.ptr()) {
GeometryT(const Object& other)
: Object(other.ptr())
{
validate();
}
bool accepts (PyObject *pyob) const override {
return pyob && Geometry_TypeCheck (pyob);
bool accepts(PyObject* pyob) const override
{
return pyob && Geometry_TypeCheck(pyob);
}
GeometryT& operator= (const Object& rhs)
GeometryT& operator=(const Object& rhs)
{
return (*this = *rhs);
}
GeometryT& operator= (PyObject* rhsp)
GeometryT& operator=(PyObject* rhsp)
{
if(ptr() == rhsp) return *this;
set (rhsp, false);
if (ptr() == rhsp) {
return *this;
}
set(rhsp, false);
return *this;
}
GeometryT& operator= (const T& v)
GeometryT& operator=(const T& v)
{
set (new PyT(v), true);
set(new PyT(v), true);
return *this;
}
const T& getValue() const
@@ -248,22 +270,20 @@ public:
}
private:
static int Geometry_TypeCheck(PyObject * obj)
static int Geometry_TypeCheck(PyObject* obj)
{
return PyObject_TypeCheck(obj, &(PyT::Type));
}
};
// PyCXX wrapper classes Py::Matrix, Py::Rotation, Py::Placement, ...
using BoundingBox = GeometryT<Base::BoundBox3d, Base::BoundBoxPy,
&Base::BoundBoxPy::getBoundBoxPtr>;
using Matrix = GeometryT<Base::Matrix4D, Base::MatrixPy,
&Base::MatrixPy::getMatrixPtr>;
using Rotation = GeometryT<Base::Rotation, Base::RotationPy,
&Base::RotationPy::getRotationPtr>;
using Placement = GeometryT<Base::Placement, Base::PlacementPy,
&Base::PlacementPy::getPlacementPtr>;
using BoundingBox =
GeometryT<Base::BoundBox3d, Base::BoundBoxPy, &Base::BoundBoxPy::getBoundBoxPtr>;
using Matrix = GeometryT<Base::Matrix4D, Base::MatrixPy, &Base::MatrixPy::getMatrixPtr>;
using Rotation = GeometryT<Base::Rotation, Base::RotationPy, &Base::RotationPy::getRotationPtr>;
using Placement =
GeometryT<Base::Placement, Base::PlacementPy, &Base::PlacementPy::getPlacementPtr>;
}
} // namespace Py
#endif // PY_GEOMETRYPY_H
#endif // PY_GEOMETRYPY_H