Python_Base.cpp

Go to the documentation of this file.

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

#include "StatusCode.h"
#include "MsgSvc.h"
#include "Options.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;

void export_base()
{
  enum_<MsgSvc::MsgLevel>("MsgLevel")
    .value("VERBOSE", MsgSvc::VERBOSE)
    .value("DEBUG",   MsgSvc::DEBUG)
    .value("INFO",    MsgSvc::INFO)
    .value("WARNING", MsgSvc::WARNING)
    .value("ERROR",   MsgSvc::ERR)
    .value("FATAL",   MsgSvc::FATAL)
    .value("NONE",    MsgSvc::NONE)
    ;
  
  class_<MsgSvc>("MsgSvc")
    .def("msgSvc",&MsgSvc::msgSvc)
    .def("setLineLength",&MsgSvc::setLineLength)
    .def("setCallSize",&MsgSvc::setCallSize)
    ;
  
  enum_<StatusCode::Type>("Code")
    .value("FAILURE",StatusCode::FAILURE)
    .value("SUCCESS",StatusCode::SUCCESS)
    ;
  
  class_<StatusCode>("StatusCode")
    .def("isSuccess", &StatusCode::isSuccess)
    .def("isFailure", &StatusCode::isFailure)
    ;
  
  class_<Options>("Options")
    .def("setLogOutputLevel", &Options::setLogOutputLevel)
    .def("logOutputLevel",    &Options::logOutputLevel)
    .def("setPrintFreq",      &Options::setPrintFreq)
    .def("printFreq",         &Options::printFreq)
    .def("setRunNumber",      &Options::setRunNumber)
    .def("runNumber",         &Options::runNumber)
    .def("setNEvt",             &Options::setNEvt)
    .def("nEvt",                &Options::nEvt)
    .def("setNEvtMax",          &Options::setNEvtMax)
    .def("nEvtMax",             &Options::nEvtMax)
    .def("setPlotFreq",         &Options::setPlotFreq)
    .def("plotFreq",            &Options::plotFreq)
    .def("setNErrors",          &Options::setNErrors)
    .def("nErrors",             &Options::nErrors)
    .def("setRunNumberMgr",   &Options::setRunNumberManagement)
    .def("runNumberMgr",      &Options::runNumberManagement)
    .def("setCurrentPath",    &Options::setCurrentPath)
    .def("currentPath",       &Options::currentPath)
    .def("setStoragePath",    &Options::setStoragePath)
    .def("storagePath",       &Options::storagePath)
    .def("storageFullPath",   &Options::storageFullPath)
    .def("setStorageDir",     &Options::setStorageDir)
    .def("storageDir",          &Options::storageDir)
    .def("setStorageFile",    &Options::setStorageFile)
    .def("storageFile",         &Options::storageFile)
    .def("storageFileFullName",&Options::storageFileFullName)
    .def("dataFileFullName",  &Options::dataFileFullName)
    .def("dataFile",            &Options::dataFile)
    .def("logFile",             &Options::logFile)
    .def("setDataStorage",    &Options::setDataStorage)
    .def("dataStorage",         &Options::dataStorage)
    .def("setLogStorage",     &Options::setLogStorage)
    .def("logStorage",        &Options::logStorage)
    .def("setLogDefFile",     &Options::setLogDefFile)
    .def("logDefFile",        &Options::logDefFile)
    .def("setDefFile",        &Options::setDefFile)
    .def("defFile",             &Options::defFile)
    .def("incRunNumber",      &Options::incRunNumber)
    .def("incNEvt",             &Options::incNEvt)
    .def("incNErrors",          &Options::incNErrors)
    .def("setStream",         &Options::setStream)     
    .def("stopOnError",       &Options::stopOnError)
    .def("setStopOnError",    &Options::setStopOnError)
    .def("dump",              &Options::print)
    ;

  std::vector<Processus*> (ProcDataBase::*listElement)(Element*) = (&ProcDataBase::list);
  std::vector<Processus*> (ProcDataBase::*listFull)( )        = (&ProcDataBase::list);

  class_<ProcDataBase>("ProcDb")
    .def("list", listElement)
    .def("list", listFull   )
    ;

  class_<DLL>("DLL")
    .def("info",&DLL::print)
    ;

  class_< std::vector< DLL* > >("DLLPtrVec")
    .def(vector_indexing_suite< std::vector< DLL* > >())
    ;

  StatusCode (DLLMgr::*destroyElement)  (Element*)     = (&DLLMgr::destroy);
  StatusCode (DLLMgr::*destroyProcessus)(Processus*)   = (&DLLMgr::destroy);

  class_<DLLMgr>("DLLMgr")
    .def("load", &DLLMgr::load)
    .def("unload", &DLLMgr::unload)
    .def("info",&DLLMgr::print)
    .def("dll", &DLLMgr::dll,return_value_policy<reference_existing_object>())
    .def("dlls", &DLLMgr::dlls)
    .def("dllOfObject", &DLLMgr::libraryOfObject,return_value_policy<reference_existing_object>())
    .def("createElement", &DLLMgr::createElement,return_value_policy<reference_existing_object>())
    .def("createProcessus",&DLLMgr::createProcessus,return_value_policy<reference_existing_object>())
    .def("destroy",destroyElement)
    .def("destroy",destroyProcessus)
    ;
}