implementing Quantity further

src/Base/Quantity.h

@@ -53,11 +53,12 @@ public:
     Quantity pow(const Quantity&)const;
     //@}
 
+    static Quantity parse(const char* buffer);
+
 protected:
     double _Value;
     Unit   _Unit;
 
-    static Quantity parse(const char* buffer);
 };
 
 } // namespace Base

src/Base/QuantityPy.xml

@@ -8,6 +8,7 @@
 		Include="Base/Quantity.h"
 		FatherInclude="Base/PyObjectBase.h"
 		Namespace="Base"
+		NumberProtocol="true"
 		Constructor="true"
 		Delete="true"
 		FatherNamespace="Base">
@@ -25,22 +26,22 @@ Quantity(string) -- arbitrary mixture of numbers and chars defining a Quantity
 		</UserDocu>
 		<DeveloperDocu>Quantity</DeveloperDocu>
 	</Documentation>
-		<Methode Name="multiply">
+		<Methode Name="pow">
 			<Documentation>
 				<UserDocu>
-					multiply two quantities
+					sets the quantity to the power
 				</UserDocu>
 			</Documentation>
 		</Methode>
 		<Attribute Name="Value" ReadOnly="false">
 			<Documentation>
-				<UserDocu>Vector to the Base position of the Quantity</UserDocu>
+				<UserDocu>Numeric Value of the Quantity (in internal system mm,kg,s)</UserDocu>
 			</Documentation>
 			<Parameter Name="Value" Type="Float" />
 		</Attribute>
 		<Attribute Name="Unit" ReadOnly="false">
 			<Documentation>
-				<UserDocu>Direction vector of the Quantity</UserDocu>
+				<UserDocu>Unit of the Quantity</UserDocu>
 			</Documentation>
 			<Parameter Name="Unit" Type="Object" />
 		</Attribute>

src/Base/QuantityPyImp.cpp

@@ -2,6 +2,7 @@
 #include "PreCompiled.h"
 
 #include "Base/Quantity.h"
+#include "Base/Vector3D.h"
 
 // inclusion of the generated files (generated out of QuantityPy.xml)
 #include "QuantityPy.h"
@@ -22,20 +23,101 @@ PyObject *QuantityPy::PyMake(struct _typeobject *, PyObject *, PyObject *)  // P
 }
 
 // constructor method
-int QuantityPy::PyInit(PyObject* /*args*/, PyObject* /*kwd*/)
+int QuantityPy::PyInit(PyObject* args, PyObject* kwd)
 {
-    return 0;
+    Quantity *self = getQuantityPtr();
+
+    double f = DOUBLE_MAX;
+
+    if (PyArg_ParseTuple(args, "|d", &f)) {
+        if(f!=DOUBLE_MAX)
+            *self = Quantity(f);
+        return 0;
+    }
+    PyErr_Clear(); // set by PyArg_ParseTuple()
+
+    PyObject *object;
+
+    if (PyArg_ParseTuple(args,"O!",&(Base::QuantityPy::Type), &object)) {
+        // Note: must be static_cast, not reinterpret_cast
+        *self = *(static_cast<Base::QuantityPy*>(object)->getQuantityPtr());
+        return 0;
+    }
+    PyErr_Clear(); // set by PyArg_ParseTuple()
+    const char* string;
+    if (PyArg_ParseTuple(args,"s", &string)) {
+            
+
+        
+        return -1;
+        
+    }
+
+    PyErr_SetString(PyExc_TypeError, "Either three floats, tuple or Vector expected");
+    return -1;
 }
 
 
-PyObject* QuantityPy::multiply(PyObject * /*args*/)
+PyObject* QuantityPy::pow(PyObject * args)
 {
     PyErr_SetString(PyExc_NotImplementedError, "Not yet implemented");
     return 0;
 }
 
 
+PyObject* QuantityPy::number_add_handler(PyObject *self, PyObject *other)
+{
+    if (!PyObject_TypeCheck(self, &(QuantityPy::Type))) {
+        PyErr_SetString(PyExc_TypeError, "First arg must be Quantity");
+        return 0;
+    }
+    if (!PyObject_TypeCheck(other, &(QuantityPy::Type))) {
+        PyErr_SetString(PyExc_TypeError, "Second arg must be Quantity");
+        return 0;
+    }
+    Base::Quantity *a = static_cast<QuantityPy*>(self)->getQuantityPtr();
+    Base::Quantity *b = static_cast<QuantityPy*>(other)->getQuantityPtr();
+    return new QuantityPy(new Quantity(*a+*b) );
+}
 
+PyObject* QuantityPy::number_subtract_handler(PyObject *self, PyObject *other)
+{
+    if (!PyObject_TypeCheck(self, &(QuantityPy::Type))) {
+        PyErr_SetString(PyExc_TypeError, "First arg must be Quantity");
+        return 0;
+    }
+    if (!PyObject_TypeCheck(other, &(QuantityPy::Type))) {
+        PyErr_SetString(PyExc_TypeError, "Second arg must be Quantity");
+        return 0;
+    }
+    Base::Quantity *a = static_cast<QuantityPy*>(self)->getQuantityPtr();
+    Base::Quantity *b = static_cast<QuantityPy*>(other)->getQuantityPtr();
+    return new QuantityPy(new Quantity(*a-*b) );
+}
+
+PyObject* QuantityPy::number_multiply_handler(PyObject *self, PyObject *other)
+{
+    if (!PyObject_TypeCheck(self, &(QuantityPy::Type))) {
+        PyErr_SetString(PyExc_TypeError, "First arg must be Quantity");
+        return 0;
+    }
+
+    if (PyObject_TypeCheck(other, &(QuantityPy::Type))) {
+        Base::Quantity *a = static_cast<QuantityPy*>(self) ->getQuantityPtr();
+        Base::Quantity *b = static_cast<QuantityPy*>(other)->getQuantityPtr();
+        
+        return new QuantityPy(new Quantity(*a * *b) );
+    }
+    else if (PyFloat_Check(other)) {
+        Base::Quantity *a = static_cast<QuantityPy*>(self) ->getQuantityPtr();
+        double b = PyFloat_AsDouble(other);
+        return new QuantityPy(new Quantity(*a*b) );
+    }
+    else {
+        PyErr_SetString(PyExc_TypeError, "A Quantity can only be multiplied by Quantity or number");
+        return 0;
+    }
+}
 
 
 Py::Float QuantityPy::getValue(void) const

src/Base/UnitPy.xml

@@ -8,6 +8,7 @@
 		Include="Base/Unit.h"
 		FatherInclude="Base/PyObjectBase.h"
 		Namespace="Base"
+		NumberProtocol="true"
 		Constructor="true"
 		Delete="true"
 		FatherNamespace="Base">

src/Base/UnitPyImp.cpp

@@ -41,7 +41,66 @@ PyObject* UnitPy::getType(PyObject * /*args*/)
 }
 
 
+PyObject* UnitPy::number_add_handler(PyObject *self, PyObject *other)
+{
+    if (!PyObject_TypeCheck(self, &(UnitPy::Type))) {
+        PyErr_SetString(PyExc_TypeError, "First arg must be Unit");
+        return 0;
+    }
+    if (!PyObject_TypeCheck(other, &(UnitPy::Type))) {
+        PyErr_SetString(PyExc_TypeError, "Second arg must be Unit");
+        return 0;
+    }
+    Base::Unit *a = static_cast<UnitPy*>(self)->getUnitPtr();
+    Base::Unit *b = static_cast<UnitPy*>(other)->getUnitPtr();
 
+    if (*a != *b) {
+        PyErr_SetString(PyExc_TypeError, "Units not matching!");
+        return 0;
+    }
+
+    return new UnitPy(new Unit(*a));
+}
+
+PyObject* UnitPy::number_subtract_handler(PyObject *self, PyObject *other)
+{
+    if (!PyObject_TypeCheck(self, &(UnitPy::Type))) {
+        PyErr_SetString(PyExc_TypeError, "First arg must be Unit");
+        return 0;
+    }
+    if (!PyObject_TypeCheck(other, &(UnitPy::Type))) {
+        PyErr_SetString(PyExc_TypeError, "Second arg must be Unit");
+        return 0;
+    }
+    Base::Unit *a = static_cast<UnitPy*>(self)->getUnitPtr();
+    Base::Unit *b = static_cast<UnitPy*>(other)->getUnitPtr();
+
+    if (*a != *b) {
+        PyErr_SetString(PyExc_TypeError, "Units not matching!");
+        return 0;
+    }
+
+    return new UnitPy(new Unit(*a));
+}
+
+PyObject* UnitPy::number_multiply_handler(PyObject *self, PyObject *other)
+{
+    if (!PyObject_TypeCheck(self, &(UnitPy::Type))) {
+        PyErr_SetString(PyExc_TypeError, "First arg must be Unit");
+        return 0;
+    }
+
+    if (PyObject_TypeCheck(other, &(UnitPy::Type))) {
+        Base::Unit *a = static_cast<UnitPy*>(self) ->getUnitPtr();
+        Base::Unit *b = static_cast<UnitPy*>(other)->getUnitPtr();
+        
+        return new UnitPy(new Unit( (*a) * (*b) ) );
+    }
+    else {
+        PyErr_SetString(PyExc_TypeError, "A Unit can only be multiplied by a Unit");
+        return 0;
+    }
+}
 
 
 Py::Object UnitPy::getDimensions(void) const