Python_Obj.cpp

Go to the documentation of this file.

#include <vector>
#include <map>
#include <list>

#include "Attrib.h"
#include "Computer.h"
#include "Hierarchy.h"
#include "Application.h"

#include "DLL.h"
#include "DLLMgr.h"
#include "ProcDataBase.h"

#include <boost/python.hpp>
#include <boost/python/suite/indexing/vector_indexing_suite.hpp>

using namespace boost::python;

struct ElementWrap : Element, wrapper<Element>
{
  void help(){this->get_override("help")();};
  StatusCode init(){return this->get_override("init")();};
  void reset(){this->get_override("reset")();};
  void update(){this->get_override("update")();};
};

void export_obj()
{
  class_<Attrib>("Attrib")
    .def("is",     &Attrib::is)
    .def("add",    &Attrib::add)
    .def("remove", &Attrib::remove)
    .def("attributs", &Attrib::attributs)
    ;

  void (Object::*msgx1)(std::string)                = (&Object::msg);
  void (Object::*msgx2)(std::string, std::string)   = (&Object::msg);
  void (Object::*verbosex1)(std::string)                = (&Object::verbose);
  void (Object::*verbosex2)(std::string, std::string)   = (&Object::verbose);
  void (Object::*debugx1)(std::string)                = (&Object::debug);
  void (Object::*debugx2)(std::string, std::string)   = (&Object::debug);
  void (Object::*infox1)(std::string)                = (&Object::info);
  void (Object::*infox2)(std::string, std::string)   = (&Object::info);
  void (Object::*warningx1)(std::string)                = (&Object::warning);
  void (Object::*warningx2)(std::string, std::string)   = (&Object::warning);
  void (Object::*errorx1)(std::string)                = (&Object::error);
  void (Object::*errorx2)(std::string, std::string)   = (&Object::error);
  void (Object::*fatalx1)(std::string)                = (&Object::fatal);
  void (Object::*fatalx2)(std::string, std::string)   = (&Object::fatal);
  
  class_<Object, bases <Attrib> >("Object")
    .def("name",  &Object::name)
    .def("type",  &Object::type)
    .def("id",    &Object::id)
    .def("title", &Object::title)
    .def("dllName",   &Object::dllName)
    .def("setName",  &Object::setName)
    .def("setType",  &Object::setType)
    .def("setId",    &Object::setId)
    .def("setTitle", &Object::setTitle)
    .def("msgSvc",&Object::msgSvc)
    .def("msg", msgx1)
    .def("msg", msgx2)
    .def("verbose", verbosex1)
    .def("verbose", verbosex2)
    .def("debug", debugx1)
    .def("debug", debugx2)
    .def("info", infox1)
    .def("info", infox2)
    .def("warning", warningx1)
    .def("warning", warningx2)
    .def("error", errorx1)
    .def("error", errorx2)
    .def("fatal", fatalx1)
    .def("fatal", fatalx2)
    ;

  class_<Application, bases <Object> >("Application")
    .def("initialize", &Application::initialize)
    .def("run",        &Application::run)
    .def("finalize",   &Application::finalize)
    .def("create",     &Application::create)
    .def("cd",         &Application::cd)
    .def("options",    &Application::options, 
         return_value_policy<reference_existing_object>())
    .def("hostname",   &Application::hostname)
    .def("setCurrent", &Application::setCurrent)
    .def("current",    &Application::current,
         return_value_policy<reference_existing_object>())
    .def("computer",   &Application::computer,
         return_value_policy<reference_existing_object>())
    .def("dllMgr",     &Application::dllMgr,
         return_value_policy<reference_existing_object>())
    .def("procDb",     &Application::procDb,
         return_value_policy<reference_existing_object>())
    .def("ctrl",       &Application::ctrl)
    .def("setCtrl",    &Application::setCtrl)
    .def("prepare",    &Application::prepare)
    .def("loop",       &Application::loop)
    .def("terminate",  &Application::terminate)
    ;    

  Hierarchy* (Hierarchy::*parentx0)()              = (&Hierarchy::parent);
  Hierarchy* (Hierarchy::*parentx1)(std::string)   = (&Hierarchy::parent);
  void       (Hierarchy::*delChildx0)(Hierarchy*)  = (&Hierarchy::delChild);
  void       (Hierarchy::*delChildx1)(std::string) = (&Hierarchy::delChild);  
  void       (Hierarchy::*treex0)()                = (&Hierarchy::tree);

  class_< std::vector<Hierarchy*> >("HierarchyPtrVec")
    .def(vector_indexing_suite< std::vector<Hierarchy*> >())
    ;

  class_<Hierarchy, bases<Object> >("Hierarchy")
    .def("clear", &Hierarchy::clear)
    .def("setParent", &Hierarchy::setParent)
    .def("parent", parentx0,return_value_policy<reference_existing_object>())
    .def("parent", parentx1,return_value_policy<reference_existing_object>())
    .def("origin", &Hierarchy::origin,return_value_policy<reference_existing_object>())
    .def("addChild", &Hierarchy::addChild)
    .def("children", &Hierarchy::children)
    .def("child", &Hierarchy::child,return_value_policy<reference_existing_object>())
    .def("childTyped", &Hierarchy::childTyped,return_value_policy<reference_existing_object>())
    .def("numberOfChildren", &Hierarchy::numberOfChildren)
    .def("hasChildren", &Hierarchy::hasChildren)
    .def("delChild", delChildx0)
    .def("delChild", delChildx1)
    .def("path", &Hierarchy::path)
    .def("pathTyped", &Hierarchy::pathTyped)
    .def("tree", treex0)
    ;  

  class_<ElementWrap, boost::noncopyable, bases<Hierarchy> >("Element")
    .def("help",pure_virtual(&Element::help))
    .def("init",pure_virtual(&Element::init))
    .def("reset",pure_virtual(&Element::reset))
    .def("update",pure_virtual(&Element::update))
    .def("recursiveInitElement",&Element::recursiveInitElement)
    .def("recursiveInitCommunications",&Element::recursiveInitCommunications)
    .def("setConnection",&Element::setConnection)
    .def("connection",&Element::connection,return_value_policy<reference_existing_object>())
    ;

  class_<Computer, bases<Element> >("Computer")
    .def("help",&Computer::help)
    .def("init",&Computer::init)
    .def("reset",&Computer::reset)
    .def("update",&Computer::update)
    ;  
}