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