void register_Process_class(){ { //::SireBase::Process typedef bp::class_< SireBase::Process > Process_exposer_t; Process_exposer_t Process_exposer = Process_exposer_t( "Process", bp::init< >() ); bp::scope Process_scope( Process_exposer ); Process_exposer.def( bp::init< SireBase::Process const & >(( bp::arg("other") )) ); { //::SireBase::Process::hasFinished typedef bool ( ::SireBase::Process::*hasFinished_function_type )( ) ; hasFinished_function_type hasFinished_function_value( &::SireBase::Process::hasFinished ); Process_exposer.def( "hasFinished" , hasFinished_function_value ); } { //::SireBase::Process::isError typedef bool ( ::SireBase::Process::*isError_function_type )( ) ; isError_function_type isError_function_value( &::SireBase::Process::isError ); Process_exposer.def( "isError" , isError_function_value ); } { //::SireBase::Process::isRunning typedef bool ( ::SireBase::Process::*isRunning_function_type )( ) ; isRunning_function_type isRunning_function_value( &::SireBase::Process::isRunning ); Process_exposer.def( "isRunning" , isRunning_function_value ); } { //::SireBase::Process::kill typedef void ( ::SireBase::Process::*kill_function_type )( ) ; kill_function_type kill_function_value( &::SireBase::Process::kill ); Process_exposer.def( "kill" , kill_function_value ); } { //::SireBase::Process::killAll typedef void ( *killAll_function_type )( ); killAll_function_type killAll_function_value( &::SireBase::Process::killAll ); Process_exposer.def( "killAll" , killAll_function_value ); } Process_exposer.def( bp::self != bp::self ); { //::SireBase::Process::operator= typedef ::SireBase::Process & ( ::SireBase::Process::*assign_function_type )( ::SireBase::Process const & ) ; assign_function_type assign_function_value( &::SireBase::Process::operator= ); Process_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } Process_exposer.def( bp::self == bp::self ); { //::SireBase::Process::run typedef ::SireBase::Process ( *run_function_type )( ::QString const & ); run_function_type run_function_value( &::SireBase::Process::run ); Process_exposer.def( "run" , run_function_value , ( bp::arg("command") ) ); } { //::SireBase::Process::run typedef ::SireBase::Process ( *run_function_type )( ::QString const &,::QString const & ); run_function_type run_function_value( &::SireBase::Process::run ); Process_exposer.def( "run" , run_function_value , ( bp::arg("command"), bp::arg("arg") ) ); } { //::SireBase::Process::run typedef ::SireBase::Process ( *run_function_type )( ::QString const &,::QStringList const & ); run_function_type run_function_value( &::SireBase::Process::run ); Process_exposer.def( "run" , run_function_value , ( bp::arg("command"), bp::arg("arguments") ) ); } { //::SireBase::Process::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireBase::Process::typeName ); Process_exposer.def( "typeName" , typeName_function_value ); } { //::SireBase::Process::wait typedef void ( ::SireBase::Process::*wait_function_type )( ) ; wait_function_type wait_function_value( &::SireBase::Process::wait ); Process_exposer.def( "wait" , wait_function_value ); } { //::SireBase::Process::wait typedef bool ( ::SireBase::Process::*wait_function_type )( int ) ; wait_function_type wait_function_value( &::SireBase::Process::wait ); Process_exposer.def( "wait" , wait_function_value , ( bp::arg("ms") ) ); } { //::SireBase::Process::wasKilled typedef bool ( ::SireBase::Process::*wasKilled_function_type )( ) ; wasKilled_function_type wasKilled_function_value( &::SireBase::Process::wasKilled ); Process_exposer.def( "wasKilled" , wasKilled_function_value ); } { //::SireBase::Process::what typedef char const * ( ::SireBase::Process::*what_function_type )( ) const; what_function_type what_function_value( &::SireBase::Process::what ); Process_exposer.def( "what" , what_function_value ); } Process_exposer.staticmethod( "killAll" ); Process_exposer.staticmethod( "run" ); Process_exposer.staticmethod( "typeName" ); Process_exposer.def( "__copy__", &__copy__); Process_exposer.def( "__deepcopy__", &__copy__); Process_exposer.def( "clone", &__copy__); Process_exposer.def( "__str__", &pvt_get_name); Process_exposer.def( "__repr__", &pvt_get_name); } }
void register_Process_class(){ { //::SireBase::Process typedef bp::class_< SireBase::Process > Process_exposer_t; Process_exposer_t Process_exposer = Process_exposer_t( "Process", "This class provides a means to run an external process\n(executable). This provides the equivalent of\nstd::system, but with added error handling and\nsignal handling (which ensures that any child processes\nare killed when Sire exits)\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") ); bp::scope Process_scope( Process_exposer ); Process_exposer.def( bp::init< SireBase::Process const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireBase::Process::hasFinished typedef bool ( ::SireBase::Process::*hasFinished_function_type)( ) ; hasFinished_function_type hasFinished_function_value( &::SireBase::Process::hasFinished ); Process_exposer.def( "hasFinished" , hasFinished_function_value , "Return whether or not this process has finished running" ); } { //::SireBase::Process::isError typedef bool ( ::SireBase::Process::*isError_function_type)( ) ; isError_function_type isError_function_value( &::SireBase::Process::isError ); Process_exposer.def( "isError" , isError_function_value , "Return whether or not the process exited in error" ); } { //::SireBase::Process::isRunning typedef bool ( ::SireBase::Process::*isRunning_function_type)( ) ; isRunning_function_type isRunning_function_value( &::SireBase::Process::isRunning ); Process_exposer.def( "isRunning" , isRunning_function_value , "Return whether or not the job is running" ); } { //::SireBase::Process::kill typedef void ( ::SireBase::Process::*kill_function_type)( ) ; kill_function_type kill_function_value( &::SireBase::Process::kill ); Process_exposer.def( "kill" , kill_function_value , "Kill this process" ); } { //::SireBase::Process::killAll typedef void ( *killAll_function_type )( ); killAll_function_type killAll_function_value( &::SireBase::Process::killAll ); Process_exposer.def( "killAll" , killAll_function_value , "Use this function to kill all of the jobs that are currently running" ); } Process_exposer.def( bp::self != bp::self ); { //::SireBase::Process::operator= typedef ::SireBase::Process & ( ::SireBase::Process::*assign_function_type)( ::SireBase::Process const & ) ; assign_function_type assign_function_value( &::SireBase::Process::operator= ); Process_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } Process_exposer.def( bp::self == bp::self ); { //::SireBase::Process::run typedef ::SireBase::Process ( *run_function_type )( ::QString const & ); run_function_type run_function_value( &::SireBase::Process::run ); Process_exposer.def( "run" , run_function_value , ( bp::arg("command") ) , "Run the command command and return a Process object that can be\nused to monitor the command" ); } { //::SireBase::Process::run typedef ::SireBase::Process ( *run_function_type )( ::QString const &,::QString const & ); run_function_type run_function_value( &::SireBase::Process::run ); Process_exposer.def( "run" , run_function_value , ( bp::arg("command"), bp::arg("arg") ) , "Run the command command with the solitary argument arg" ); } { //::SireBase::Process::run typedef ::SireBase::Process ( *run_function_type )( ::QString const &,::QStringList const & ); run_function_type run_function_value( &::SireBase::Process::run ); Process_exposer.def( "run" , run_function_value , ( bp::arg("command"), bp::arg("arguments") ) , "Run the command command with the arguments arguments, and\nreturn a Process object that can be used to query and control the\njob" ); } { //::SireBase::Process::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireBase::Process::typeName ); Process_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireBase::Process::wait typedef void ( ::SireBase::Process::*wait_function_type)( ) ; wait_function_type wait_function_value( &::SireBase::Process::wait ); Process_exposer.def( "wait" , wait_function_value , "Wait until the process has finished" ); } { //::SireBase::Process::wait typedef bool ( ::SireBase::Process::*wait_function_type)( int ) ; wait_function_type wait_function_value( &::SireBase::Process::wait ); Process_exposer.def( "wait" , wait_function_value , ( bp::arg("ms") ) , "Wait until the process has finished, or until ms milliseconds have passed.\nThis returns whether or not the process has finished" ); } { //::SireBase::Process::wasKilled typedef bool ( ::SireBase::Process::*wasKilled_function_type)( ) ; wasKilled_function_type wasKilled_function_value( &::SireBase::Process::wasKilled ); Process_exposer.def( "wasKilled" , wasKilled_function_value , "Return whether or not the process was killed" ); } { //::SireBase::Process::what typedef char const * ( ::SireBase::Process::*what_function_type)( ) const; what_function_type what_function_value( &::SireBase::Process::what ); Process_exposer.def( "what" , what_function_value , "" ); } Process_exposer.staticmethod( "killAll" ); Process_exposer.staticmethod( "run" ); Process_exposer.staticmethod( "typeName" ); Process_exposer.def( "__copy__", &__copy__); Process_exposer.def( "__deepcopy__", &__copy__); Process_exposer.def( "clone", &__copy__); Process_exposer.def( "__str__", &pvt_get_name); Process_exposer.def( "__repr__", &pvt_get_name); } }
void register_Simulation_class(){ { //::SireMove::Simulation typedef bp::class_< SireMove::Simulation > Simulation_exposer_t; Simulation_exposer_t Simulation_exposer = Simulation_exposer_t( "Simulation", "This class is used start and manage an active\nsimulation. A simulation consists of a collection\nof moves that are being applied to a System\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") ); bp::scope Simulation_scope( Simulation_exposer ); Simulation_exposer.def( bp::init< SireMove::Simulation const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMove::Simulation::abort typedef void ( ::SireMove::Simulation::*abort_function_type)( ) ; abort_function_type abort_function_value( &::SireMove::Simulation::abort ); Simulation_exposer.def( "abort" , abort_function_value , "Abort the simulation" ); } { //::SireMove::Simulation::hasFinished typedef bool ( ::SireMove::Simulation::*hasFinished_function_type)( ) ; hasFinished_function_type hasFinished_function_value( &::SireMove::Simulation::hasFinished ); Simulation_exposer.def( "hasFinished" , hasFinished_function_value , "Return whether or not the simulation has finished\n(completed all of the moves)" ); } { //::SireMove::Simulation::initialMoves typedef ::SireMove::MovesPtr ( ::SireMove::Simulation::*initialMoves_function_type)( ) ; initialMoves_function_type initialMoves_function_value( &::SireMove::Simulation::initialMoves ); Simulation_exposer.def( "initialMoves" , initialMoves_function_value , "Return the Moves in the state they were in before the simulation started" ); } { //::SireMove::Simulation::initialSystem typedef ::SireSystem::System ( ::SireMove::Simulation::*initialSystem_function_type)( ) ; initialSystem_function_type initialSystem_function_value( &::SireMove::Simulation::initialSystem ); Simulation_exposer.def( "initialSystem" , initialSystem_function_value , "Return the System in the state it was in before the simulation started" ); } { //::SireMove::Simulation::input typedef ::SireMove::SimPacket ( ::SireMove::Simulation::*input_function_type)( ) ; input_function_type input_function_value( &::SireMove::Simulation::input ); Simulation_exposer.def( "input" , input_function_value , "Return the initial input simulation WorkPacket" ); } { //::SireMove::Simulation::interimMoves typedef ::SireMove::MovesPtr ( ::SireMove::Simulation::*interimMoves_function_type)( ) ; interimMoves_function_type interimMoves_function_value( &::SireMove::Simulation::interimMoves ); Simulation_exposer.def( "interimMoves" , interimMoves_function_value , "Return the current state of the moves (updated while the simulation\nis running). This will throw an exception if the system hits an\nerror state" ); } { //::SireMove::Simulation::interimResult typedef ::SireMove::SimPacket ( ::SireMove::Simulation::*interimResult_function_type)( ) ; interimResult_function_type interimResult_function_value( &::SireMove::Simulation::interimResult ); Simulation_exposer.def( "interimResult" , interimResult_function_value , "Return the simulation WorkPacket from an intermediate point along\nthe simulation. This will throw an error if the simulation is in an\nerror state, and the initial packet if the simulation\nwas aborted" ); } { //::SireMove::Simulation::interimSystem typedef ::SireSystem::System ( ::SireMove::Simulation::*interimSystem_function_type)( ) ; interimSystem_function_type interimSystem_function_value( &::SireMove::Simulation::interimSystem ); Simulation_exposer.def( "interimSystem" , interimSystem_function_value , "Return the current state of the System (updated while the simulation\nis running). This will throw an exception if the system hits an\nerror state" ); } { //::SireMove::Simulation::isError typedef bool ( ::SireMove::Simulation::*isError_function_type)( ) ; isError_function_type isError_function_value( &::SireMove::Simulation::isError ); Simulation_exposer.def( "isError" , isError_function_value , "Return whether or not this simulation is in an error state" ); } { //::SireMove::Simulation::isRunning typedef bool ( ::SireMove::Simulation::*isRunning_function_type)( ) ; isRunning_function_type isRunning_function_value( &::SireMove::Simulation::isRunning ); Simulation_exposer.def( "isRunning" , isRunning_function_value , "Return whether or not this simulation is running" ); } { //::SireMove::Simulation::moves typedef ::SireMove::MovesPtr ( ::SireMove::Simulation::*moves_function_type)( ) ; moves_function_type moves_function_value( &::SireMove::Simulation::moves ); Simulation_exposer.def( "moves" , moves_function_value , "Return the final state of the moves after the simulation. This\nblocks until the simulation has finished and will throw an\nexception if the system hits an error state" ); } Simulation_exposer.def( bp::self != bp::self ); { //::SireMove::Simulation::operator= typedef ::SireMove::Simulation & ( ::SireMove::Simulation::*assign_function_type)( ::SireMove::Simulation const & ) ; assign_function_type assign_function_value( &::SireMove::Simulation::operator= ); Simulation_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } Simulation_exposer.def( bp::self == bp::self ); { //::SireMove::Simulation::progress typedef float ( ::SireMove::Simulation::*progress_function_type)( ) ; progress_function_type progress_function_value( &::SireMove::Simulation::progress ); Simulation_exposer.def( "progress" , progress_function_value , "Return the progress of the simulation (as a percentage)" ); } { //::SireMove::Simulation::result typedef ::SireMove::SimPacket ( ::SireMove::Simulation::*result_function_type)( ) ; result_function_type result_function_value( &::SireMove::Simulation::result ); Simulation_exposer.def( "result" , result_function_value , "Return the final result of the simulation. This blocks until\nthe simulation has stopped, and will throw an exception if the\nsimulation is in an error state. This returns the initial\nsimulation WorkPacket if the simulation was aborted" ); } { //::SireMove::Simulation::run typedef ::SireMove::Simulation ( *run_function_type )( ::SireSystem::System const &,::SireMove::Moves const &,int,bool ); run_function_type run_function_value( &::SireMove::Simulation::run ); Simulation_exposer.def( "run" , run_function_value , ( bp::arg("system"), bp::arg("moves"), bp::arg("nmoves"), bp::arg("record_stats")=(bool)(true) ) , "Run a simulation consisting of nmoves moves (in moves)\nof the System system, optionally recording simulation\nstatistics if record_stats is true. This runs the\nsimulation in the current thread" ); } { //::SireMove::Simulation::run typedef ::SireMove::Simulation ( *run_function_type )( ::SireSystem::System const &,::SireMove::Moves const &,int,int,bool ); run_function_type run_function_value( &::SireMove::Simulation::run ); Simulation_exposer.def( "run" , run_function_value , ( bp::arg("system"), bp::arg("moves"), bp::arg("nmoves"), bp::arg("nmoves_per_chunk"), bp::arg("record_stats")=(bool)(true) ) , "Run a simulation consisting of nmoves moves (in moves)\nof the System system, optionally recording simulation\nstatistics if record_stats is true. This runs the\nsimulation in the current thread. This runs nmoves_per_chunk\nmoves in every chunk of the simulation." ); } { //::SireMove::Simulation::run typedef ::SireMove::Simulation ( *run_function_type )( ::SireSystem::System const &,::SireMove::Move const &,int,bool ); run_function_type run_function_value( &::SireMove::Simulation::run ); Simulation_exposer.def( "run" , run_function_value , ( bp::arg("system"), bp::arg("move"), bp::arg("nmoves"), bp::arg("record_stats")=(bool)(true) ) , "Run a simulation consisting of nmoves moves (in move)\nof the System system, optionally recording simulation\nstatistics if record_stats is true. This runs the\nsimulation in the current thread" ); } { //::SireMove::Simulation::run typedef ::SireMove::Simulation ( *run_function_type )( ::SireSystem::System const &,::SireMove::Move const &,int,int,bool ); run_function_type run_function_value( &::SireMove::Simulation::run ); Simulation_exposer.def( "run" , run_function_value , ( bp::arg("system"), bp::arg("move"), bp::arg("nmoves"), bp::arg("nmoves_per_chunk"), bp::arg("record_stats")=(bool)(true) ) , "Run a simulation consisting of nmoves moves (in move)\nof the System system, optionally recording simulation\nstatistics if record_stats is true. This runs the\nsimulation in the current thread. This runs nmoves_per_chunk\nmoves in every chunk of the simulation." ); } { //::SireMove::Simulation::run typedef ::SireMove::Simulation ( *run_function_type )( ::SireMove::SimStore const &,int,bool ); run_function_type run_function_value( &::SireMove::Simulation::run ); Simulation_exposer.def( "run" , run_function_value , ( bp::arg("simstore"), bp::arg("nmoves"), bp::arg("record_stats")=(bool)(true) ) , "Run a simulation consisting of nmoves moves of the system\nin simstore (which also contains the moves) optionally recording simulation\nstatistics if record_stats is true. This runs the\nsimulation in the current thread" ); } { //::SireMove::Simulation::run typedef ::SireMove::Simulation ( *run_function_type )( ::SireMove::SimStore const &,int,int,bool ); run_function_type run_function_value( &::SireMove::Simulation::run ); Simulation_exposer.def( "run" , run_function_value , ( bp::arg("simstore"), bp::arg("nmoves"), bp::arg("nmoves_per_chunk"), bp::arg("record_stats")=(bool)(true) ) , "Run a simulation consisting of nmoves moves of the system\nin simstore (which also contains the moves) optionally recording simulation\nstatistics if record_stats is true. This runs the\nsimulation in the current thread. This runs nmoves_per_chunk\nmoves in every chunk of the simulation." ); } { //::SireMove::Simulation::run typedef ::SireMove::Simulation ( *run_function_type )( ::SireMove::SimPacket const & ); run_function_type run_function_value( &::SireMove::Simulation::run ); Simulation_exposer.def( "run" , run_function_value , ( bp::arg("simpacket") ) , "Run the simulation contained in the simulation WorkPacket simpacket\nin the current thread" ); } { //::SireMove::Simulation::run typedef ::SireMove::Simulation ( *run_function_type )( ::SireCluster::Node &,::SireSystem::System const &,::SireMove::Moves const &,int,bool ); run_function_type run_function_value( &::SireMove::Simulation::run ); Simulation_exposer.def( "run" , run_function_value , ( bp::arg("node"), bp::arg("system"), bp::arg("moves"), bp::arg("nmoves"), bp::arg("record_stats")=(bool)(true) ) , "Run a simulation consisting of nmoves moves (in moves)\nof the System system, optionally recording simulation\nstatistics if record_stats is true. This runs the\nsimulation on the node node. This runs nmoves_per_chunk\nmoves in every chunk of the simulation." ); } { //::SireMove::Simulation::run typedef ::SireMove::Simulation ( *run_function_type )( ::SireCluster::Node &,::SireSystem::System const &,::SireMove::Moves const &,int,int,bool ); run_function_type run_function_value( &::SireMove::Simulation::run ); Simulation_exposer.def( "run" , run_function_value , ( bp::arg("node"), bp::arg("system"), bp::arg("moves"), bp::arg("nmoves"), bp::arg("nmoves_per_chunk"), bp::arg("record_stats")=(bool)(true) ) , "Run a simulation consisting of nmoves moves (in moves)\nof the System system, optionally recording simulation\nstatistics if record_stats is true. This runs the\nsimulation on the node node. This runs nmoves_per_chunk\nmoves in every chunk of the simulation." ); } { //::SireMove::Simulation::run typedef ::SireMove::Simulation ( *run_function_type )( ::SireCluster::Node &,::SireSystem::System const &,::SireMove::Move const &,int,bool ); run_function_type run_function_value( &::SireMove::Simulation::run ); Simulation_exposer.def( "run" , run_function_value , ( bp::arg("node"), bp::arg("system"), bp::arg("move"), bp::arg("nmoves"), bp::arg("record_stats")=(bool)(true) ) , "Run a simulation consisting of nmoves moves (in move)\nof the System system, optionally recording simulation\nstatistics if record_stats is true. This runs the\nsimulation on the node node. This runs nmoves_per_chunk\nmoves in every chunk of the simulation." ); } { //::SireMove::Simulation::run typedef ::SireMove::Simulation ( *run_function_type )( ::SireCluster::Node &,::SireSystem::System const &,::SireMove::Move const &,int,int,bool ); run_function_type run_function_value( &::SireMove::Simulation::run ); Simulation_exposer.def( "run" , run_function_value , ( bp::arg("node"), bp::arg("system"), bp::arg("move"), bp::arg("nmoves"), bp::arg("nmoves_per_chunk"), bp::arg("record_stats")=(bool)(true) ) , "Run a simulation consisting of nmoves moves (in move)\nof the System system, optionally recording simulation\nstatistics if record_stats is true. This runs the\nsimulation on the node node. This runs nmoves_per_chunk\nmoves in every chunk of the simulation." ); } { //::SireMove::Simulation::run typedef ::SireMove::Simulation ( *run_function_type )( ::SireCluster::Node &,::SireMove::SimStore const &,int,bool ); run_function_type run_function_value( &::SireMove::Simulation::run ); Simulation_exposer.def( "run" , run_function_value , ( bp::arg("node"), bp::arg("simstore"), bp::arg("nmoves"), bp::arg("record_stats")=(bool)(true) ) , "Run a simulation consisting of nmoves moves of the system\nin simstore (which also contains the moves) optionally recording simulation\nstatistics if record_stats is true. This runs the\nsimulation on the node node. This runs nmoves_per_chunk\nmoves in every chunk of the simulation." ); } { //::SireMove::Simulation::run typedef ::SireMove::Simulation ( *run_function_type )( ::SireCluster::Node &,::SireMove::SimStore const &,int,int,bool ); run_function_type run_function_value( &::SireMove::Simulation::run ); Simulation_exposer.def( "run" , run_function_value , ( bp::arg("node"), bp::arg("simstore"), bp::arg("nmoves"), bp::arg("nmoves_per_chunk"), bp::arg("record_stats")=(bool)(true) ) , "Run a simulation consisting of nmoves moves of the system\nin simstore (which also contains the moves) optionally recording simulation\nstatistics if record_stats is true. This runs the\nsimulation on the node node. This runs nmoves_per_chunk\nmoves in every chunk of the simulation." ); } { //::SireMove::Simulation::run typedef ::SireMove::Simulation ( *run_function_type )( ::SireCluster::Node &,::SireMove::SimPacket const & ); run_function_type run_function_value( &::SireMove::Simulation::run ); Simulation_exposer.def( "run" , run_function_value , ( bp::arg("node"), bp::arg("simpacket") ) , "Run the simulation contained in the simulation WorkPacket simpacket\non the node node" ); } { //::SireMove::Simulation::stop typedef void ( ::SireMove::Simulation::*stop_function_type)( ) ; stop_function_type stop_function_value( &::SireMove::Simulation::stop ); Simulation_exposer.def( "stop" , stop_function_value , "Stop the simulation" ); } { //::SireMove::Simulation::system typedef ::SireSystem::System ( ::SireMove::Simulation::*system_function_type)( ) ; system_function_type system_function_value( &::SireMove::Simulation::system ); Simulation_exposer.def( "system" , system_function_value , "Return the final state of the system after the simulation. This\nblocks until the simulation has finished and will throw an\nexception if the system hits an error state" ); } { //::SireMove::Simulation::throwError typedef void ( ::SireMove::Simulation::*throwError_function_type)( ) ; throwError_function_type throwError_function_value( &::SireMove::Simulation::throwError ); Simulation_exposer.def( "throwError" , throwError_function_value , "Throw any error associated with this simulation - this does\nnothing if we are not in an error state" ); } { //::SireMove::Simulation::wait typedef void ( ::SireMove::Simulation::*wait_function_type)( ) ; wait_function_type wait_function_value( &::SireMove::Simulation::wait ); Simulation_exposer.def( "wait" , wait_function_value , "Wait for the simulation to stop running\n(which can be either because it finished, was stopped,\nwas aborted or ended in error)" ); } { //::SireMove::Simulation::wait typedef bool ( ::SireMove::Simulation::*wait_function_type)( int ) ; wait_function_type wait_function_value( &::SireMove::Simulation::wait ); Simulation_exposer.def( "wait" , wait_function_value , ( bp::arg("timeout") ) , "Wait for the simulation to stop running, or for timeout\nmilliseconds to pass, whichever comes soonest. This returns\nwhether or not the simulation has stopped" ); } { //::SireMove::Simulation::wasAborted typedef bool ( ::SireMove::Simulation::*wasAborted_function_type)( ) ; wasAborted_function_type wasAborted_function_value( &::SireMove::Simulation::wasAborted ); Simulation_exposer.def( "wasAborted" , wasAborted_function_value , "Return whether or not the simulation was aborted" ); } { //::SireMove::Simulation::wasStopped typedef bool ( ::SireMove::Simulation::*wasStopped_function_type)( ) ; wasStopped_function_type wasStopped_function_value( &::SireMove::Simulation::wasStopped ); Simulation_exposer.def( "wasStopped" , wasStopped_function_value , "Return whether or not the simulation was stopped" ); } Simulation_exposer.staticmethod( "run" ); Simulation_exposer.def( "__copy__", &__copy__); Simulation_exposer.def( "__deepcopy__", &__copy__); Simulation_exposer.def( "clone", &__copy__); Simulation_exposer.def( "__str__", &pvt_get_name); Simulation_exposer.def( "__repr__", &pvt_get_name); } }