Python_Obj.cpp File Reference

#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>

Go to the source code of this file.

Classes
struct	ElementWrap

Functions
void	export_obj ()

Function Documentation

export_obj()

void export_obj

(

)

Definition at line 27 of file Python_Obj.cpp.

References Attrib::add(), Hierarchy::addChild(), Attrib::attributs(), Application::cd(), Hierarchy::child(), Hierarchy::children(), Hierarchy::childTyped(), Hierarchy::clear(), Application::computer(), Element::connection(), Application::create(), Application::ctrl(), Application::current(), Object::debug(), Hierarchy::delChild(), Application::dllMgr(), Object::dllName(), Object::error(), Object::fatal(), Application::finalize(), Hierarchy::hasChildren(), Element::help(), Computer::help(), Application::hostname(), Object::id(), Object::info(), Element::init(), Computer::init(), Application::initialize(), Attrib::is(), Application::loop(), Object::msg(), Object::msgSvc(), Object::name(), Hierarchy::numberOfChildren(), Application::options(), Hierarchy::origin(), Hierarchy::parent(), Hierarchy::path(), Hierarchy::pathTyped(), Application::prepare(), Application::procDb(), Element::recursiveInitCommunications(), Element::recursiveInitElement(), Attrib::remove(), Element::reset(), Computer::reset(), Application::run(), Element::setConnection(), Application::setCtrl(), Application::setCurrent(), Object::setId(), Object::setName(), Hierarchy::setParent(), Object::setTitle(), Object::setType(), Application::terminate(), Object::title(), Hierarchy::tree(), Object::type(), Element::update(), Computer::update(), Object::verbose(), and Object::warning().

Referenced by BOOST_PYTHON_MODULE().

{
  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)
    ;  
}