PyOpalObject.h

Go to the documentation of this file.

#ifndef PyOpalObject_H
 
#include <Python.h>
#include <structmember.h>
 
#include <memory>
#include <exception>
#include <iostream>
#include <boost/python.hpp>
#include <boost/noncopyable.hpp>
#include <boost/mpl/front.hpp>
 
#include "Utilities/OpalException.h"
#include "Elements/OpalElement.h"
#include "AbstractObjects/OpalData.h"
#include "AbstractObjects/Object.h"
#include "AbsBeamline/Component.h"
#include "Attributes/Attributes.h"
#include "OpalConfigure/Configure.h"
 
namespace PyOpal {
 
namespace PyOpalObjectNS {
 
// forward declarations
template <class C> class PyOpalObject;
template <class C> struct PyOpalObjectGetProperty;
template <class C> struct PyOpalObjectSetProperty;
 
enum AttributeType {DOUBLE, STRING, BOOL, INT, FLOATLIST};
 
extern std::map<AttributeType, std::string> attributeName; // defined in PyOpalObject.cpp
 
struct AttributeDef {
    std::string opalName_m;
    std::string pyName_m;
    std::string docString_m;
    AttributeType type_m;
    // could also add a "read only" flag as some attributes are read only
};
 
template <class C>
class PyOpalObject {
public:
    typedef PyOpalObject<C> PyC; // for convenience
    inline PyOpalObject();
    PyOpalObject(std::shared_ptr<C> object) : object_m(object) {}
    PyOpalObject(const PyOpalObject<C>& rhs);
    ~PyOpalObject() {}
 
    inline boost::python::class_<PyC> make_class(const char* className);
 
    template <class PYCLASS>
    void addAttributes(PYCLASS& pyclass);
 
    template <class PYCLASS>
    void addExecute(PYCLASS& pyclass);
 
    template <class PYCLASS>
    void addRegister(PYCLASS& pyclass);
 
    template <class PYCLASS>
    void addGetOpalElement(PYCLASS& pyclass);
 
    template <class ValueType>
    ValueType dummyGet() const {PyOpalObjectGetProperty<C>::setObject(this); return ValueType();}
 
    template <class ValueType>
    void dummySet(ValueType test) {PyOpalObjectSetProperty<C>::setObject(this);}
 
    PyObject* getAttribute(AttributeType type, std::string opalName) const;
 
    void setAttribute(AttributeType type, std::string opalName, PyObject* value);
 
    std::shared_ptr<C> getOpalShared() {return object_m;}
 
protected:
    static std::vector<AttributeDef> attributes; 
    static std::string classDocstring; 
    static bool converterRegistered; 
    std::shared_ptr<C> object_m; 
    std::string getDocString(AttributeDef& def);
    static void execute(PyOpalObject<C>& pyobject);
    static void registerObject(PyOpalObject<C>& pyobject);
    static boost::python::object getPyOpalElement(PyOpalObject<C>& pyobject);
};
 
template <class C>
boost::python::object getFieldValue(PyOpalObjectNS::PyOpalObject<C>& pyobject, double x, double y, double z, double t) {
    std::shared_ptr<C> objectPtr = pyobject.getOpalShared();
    objectPtr->update();
    ElementBase* element = objectPtr->getElement()->removeWrappers();
    Component* component = dynamic_cast<Component*>(element);
    if (component == NULL) {
        throw OpalException("PyElement<C>::getFieldValue",
                            "Failed to deduce Component from ElementBase.");
    }
 
    Vector_t R(x, y, z);
    Vector_t P(0.0, 0.0, 0.0);
    Vector_t B;
    Vector_t E;
    bool outOfBounds = component->apply(R, P, t, E, B);
    return boost::python::make_tuple(outOfBounds,
                                     B[0], B[1], B[2],
                                     E[0], E[1], E[2]);
}
 
 
 
 
 
template <class C>
struct PyOpalObjectGetProperty : boost::python::default_call_policies {
public:
    PyOpalObjectGetProperty(AttributeType type, std::string opalName): type_m(type), opalName_m(opalName) {}
    ~PyOpalObjectGetProperty() {;}
 
    template <class ArgumentPackage>
    PyObject* postcall(ArgumentPackage const&, PyObject* result);
 
    static void setObject(const PyOpalObject<C>* object) {object_m = object;}
 
private:
    AttributeType type_m;
    std::string opalName_m;
    static const PyOpalObject<C>* object_m;
};
 
template <class C>
struct PyOpalObjectSetProperty : boost::python::default_call_policies {
public:
    PyOpalObjectSetProperty(AttributeType type, std::string opalName): type_m(type), opalName_m(opalName) {}
    ~PyOpalObjectSetProperty() {;}
 
    template <class ArgumentPackage>
    PyObject* postcall(ArgumentPackage const& args, PyObject* result);
 
    static void setObject(PyOpalObject<C>* object) {object_m = object;}
 
private:
    AttributeType type_m;
    std::string opalName_m;
    static PyOpalObject<C>* object_m;
};
 
 
 
template <class C>
void PyOpalObject<C>::execute(PyOpalObject<C>& pyobject) {
    std::shared_ptr<C> objectPtr = pyobject.getOpalShared();
    objectPtr->execute();
}
 
template <class C>
void PyOpalObject<C>::registerObject(PyOpalObjectNS::PyOpalObject<C>& pyobject) {
    C* wrappedC = pyobject.getOpalShared().get();
    Object* objectPtr = dynamic_cast<Object*>(wrappedC);
    if (objectPtr == NULL) {
        throw OpalException("PyOpalObject<C>::registerObject",
                            "Trying to register something that was not a Opal Object");
    }
    //Object* objectPtr = &(*pyobject.getOpalShared());
    OpalData::getInstance()->define(objectPtr);
}
 
 
template <class C>
boost::python::object PyOpalObject<C>::getPyOpalElement(PyOpalObjectNS::PyOpalObject<C>& pyobject) {
    std::shared_ptr<OpalElement> elementPtr =
            std::dynamic_pointer_cast<OpalElement, C>(pyobject.getOpalShared());
    if (elementPtr.get() == NULL) {
        throw OpalException("PyOpalObject<C>::getPyOpalElement",
                            "Wrapped object was not an OpalElement");
    }
    PyOpalObject<OpalElement> element(elementPtr);
    boost::python::object pyelement(element);
    return pyelement;
}
 
 
// defined in PyOpalElement
template <>
PyOpalObject<OpalElement>::PyOpalObject();
 
template <class C>
PyOpalObject<C>::PyOpalObject() : object_m(new C) {}
 
template <class C>
PyObject* PyOpalObject<C>::getAttribute(AttributeType type, std::string opalName) const {
    if (!object_m) {
        throw OpalException("PyOpalObject<C>::getRealAttribute",
                            "Object was not initialised");       
    }
    Attribute* attribute = object_m->findAttribute(opalName);
    if (attribute == NULL) {
        throw OpalException("PyOpalObject<C>::getRealAttribute",
                            "Failed to parse attribute "+opalName);
    }
    PyObject* pyvalue;
    // I spent quite a bit of time trying to get this type unwinding to work
    // using templates (so it is done at compile time). In the end I couldn't
    // fight the template syntax and had to do it at runtime using an enum; it's
    // not so bad - the memory footprint is smaller and, tbh, template syntax is
    // horrible so might be easier to use.
    if (type == DOUBLE) {
        double value = Attributes::getReal(*attribute);
        pyvalue = PyFloat_FromDouble(value);
    } else if (type == INT) {
        double value = Attributes::getReal(*attribute);
        pyvalue = PyLong_FromDouble(value);
    } else if (type == STRING) {
        std::string value = Attributes::getString(*attribute);
        pyvalue = PyUnicode_FromString(value.c_str());
    } else if (type == BOOL) {
        bool value = Attributes::getBool(*attribute);
        if (value) {
            pyvalue = Py_True;
        } else {
            pyvalue = Py_False;        
        }
    } else if (type == FLOATLIST) {
        std::vector<double> value = Attributes::getRealArray(*attribute);
        pyvalue = PyList_New(value.size());
        for (size_t i = 0; i < value.size(); ++i) {
            PyList_SetItem(pyvalue, i, PyFloat_FromDouble(value[i])); // WARNING check memory...
        }
    } else {
        throw OpalException("PyOpalObject<C>::getAttribute",
                            "Attribute type "+attributeName[type]+" not implemented");
    }
    Py_INCREF(pyvalue);
    return pyvalue;
}
 
 
template <class C>
void PyOpalObject<C>::setAttribute(AttributeType type, std::string opalName, PyObject* pyvalue) {
    if (!object_m) {
        throw OpalException("PyOpalObject<C>::setAttribute",
                            "Element was not initialised");       
    }
    Attribute* attribute = object_m->findAttribute(opalName);
    if (attribute == NULL) {
        throw OpalException("PyOpalObject<C>::setAttribute",
                            "Failed to parse attribute "+opalName);
    }
    if (type == DOUBLE) {
        double value = PyFloat_AsDouble(pyvalue);
        Attributes::setReal(*attribute, value);
    } else if (type == INT) {
        double value = PyLong_AsDouble(pyvalue);
        Attributes::setReal(*attribute, value);
    } else if (type == STRING) {
        std::string value = PyUnicode_AsUTF8(pyvalue);
        Attributes::setString(*attribute, value);
    } else if (type == BOOL) {
        bool value = PyObject_IsTrue(pyvalue);
        Attributes::setBool(*attribute, value);
    } else if (type == FLOATLIST) {
        Py_ssize_t listSize = PyList_Size(pyvalue);
        std::vector<double> value(listSize);
        for (Py_ssize_t i = 0; i < listSize; ++i) {
            double value_i = PyFloat_AsDouble(PyList_GetItem(pyvalue, i));
            value[i] = value_i;
        }
        Attributes::setRealArray(*attribute, value);
    } else {
        throw OpalException("PyOpalObject<C>::setAttribute",
                            "Attribute type "+attributeName[type]+" not implemented");
    }
}
 
template <class C>
PyOpalObject<C>::PyOpalObject(const PyOpalObject<C>& rhs) : object_m(rhs.object_m) { 
}
 
template <class C>
std::string PyOpalObject<C>::getDocString(AttributeDef& def) {
    Attribute* attribute = object_m->findAttribute(def.opalName_m);
    if (attribute == NULL) {
        throw OpalException("PyOpalObject<C>::getRealAttribute",
                            "Failed to parse attribute "+def.opalName_m);
    }
    std::string docString = def.pyName_m+" ("+attributeName[def.type_m]+"): "+attribute->getHelp();
    if (def.docString_m != "") {
        docString = def.pyName_m+" ("+attributeName[def.type_m]+"): "+def.docString_m;
    }
    return docString;
}
 
template <class C>
boost::python::class_<PyOpalObject<C> > PyOpalObject<C>::make_class(const char* className) {
    typedef boost::python::class_<PyOpalObject<C> > PyClass;
    boost::python::docstring_options docop(true, true, false); // user_def, py_sig, cpp_sig
    PyClass pyclass = PyClass(className);
    addAttributes(pyclass);
    return pyclass;
}
 
 
template <class C>
template <class PYCLASS>
void PyOpalObject<C>::addExecute(PYCLASS& pyclass) {
    pyclass.def("execute", &PyOpalObject<C>::execute);
}
 
template <class C>
template <class PYCLASS>
void PyOpalObject<C>::addRegister(PYCLASS& pyclass) {
    pyclass.def("register", &PyOpalObject<C>::registerObject);
}
 
template <class C>
template <class PYCLASS>
void PyOpalObject<C>::addGetOpalElement(PYCLASS& pyclass) {
    pyclass.def("get_opal_element", &PyOpalObject<C>::getPyOpalElement);
}
 
 
 
template <class C>
template <class PYCLASS>
void PyOpalObject<C>::addAttributes(PYCLASS& pyclass) {
    for (std::vector<AttributeDef>::iterator iter = attributes.begin(); iter != attributes.end(); ++iter) {
        PyOpalObjectGetProperty<C> getProp(iter->type_m, iter->opalName_m);
        PyOpalObjectSetProperty<C> setProp(iter->type_m, iter->opalName_m);
        std::string docString = getDocString(*iter);
        std::string pyname = iter->pyName_m.c_str();
        if (iter->type_m == DOUBLE) {
            pyclass.add_property(pyname.c_str(),
                                 boost::python::make_function(&PyC::dummyGet<double>, getProp),
                                 boost::python::make_function(&PyC::dummySet<double>, setProp),
                                 docString.c_str()
            );
        } else if (iter->type_m == INT) {
            pyclass.add_property(pyname.c_str(),
                                 boost::python::make_function(&PyC::dummyGet<int>, getProp),
                                 boost::python::make_function(&PyC::dummySet<int>, setProp),
                                 docString.c_str()
            );
         }  else if (iter->type_m == STRING) {
            pyclass.add_property(pyname.c_str(),
                                 boost::python::make_function(&PyC::dummyGet<std::string>, getProp),
                                 boost::python::make_function(&PyC::dummySet<std::string>, setProp),
                                 docString.c_str()
            );
        }  else if (iter->type_m == BOOL) {
            pyclass.add_property(pyname.c_str(),
                                 boost::python::make_function(&PyC::dummyGet<bool>, getProp),
                                 boost::python::make_function(&PyC::dummySet<bool>, setProp),
                                 docString.c_str()
            );
        }  else if (iter->type_m == FLOATLIST) {
            pyclass.add_property(pyname.c_str(),
                                 boost::python::make_function(&PyC::dummyGet<boost::python::list>, getProp),
                                 boost::python::make_function(&PyC::dummySet<boost::python::list>, setProp),
                                 docString.c_str()
            );
        } else {
            // Looks like exception handling doesn't work properly at module
            // import time so this may not be handled politely - thrown as an 
            // unrecognised SystemError
            throw OpalException("PyOpalObject<C>::addAttributes", "Type not implemented");
        }
    }
}
 
 
 
template <class C>
template <class ArgumentPackage>
PyObject* PyOpalObjectGetProperty<C>::postcall(ArgumentPackage const&, PyObject* result) {
        Py_DECREF(result);
        result = object_m->getAttribute(type_m, opalName_m);
        return result;
}
 
template <class C>
const PyOpalObject<C>* PyOpalObjectGetProperty<C>::object_m = NULL;
 
 
template <class C>
template <class ArgumentPackage>
PyObject* PyOpalObjectSetProperty<C>::postcall(ArgumentPackage const& args, PyObject* result) {
    PyObject* value;
    PyObject* pyObject; // this is a direct pointer to the C but I don't know how to unwrap it...
    if (!PyArg_ParseTuple(args, "OO", &pyObject, &value)) {
        return NULL; // ParseTuple sets the error message
    }
    Py_DECREF(result);
    object_m->setAttribute(type_m, opalName_m, value);
    object_m = NULL;
    Py_RETURN_NONE;
}
 
template <class C>
PyOpalObject<C>* PyOpalObjectSetProperty<C>::object_m = NULL;
 
} // PyOpalObject
} // PyOpal
 
#endif // PyOpalObject_H