simmer: Discrete-Event Simulation for R

# Generated by using Rcpp::compileAttributes() -> do not edit by hand
# Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393

Seize__new <- function(resource, amount, cont, trj, mask) {
    .Call(`_simmer_Seize__new`, resource, amount, cont, trj, mask)
}

Seize__new_func <- function(resource, amount, cont, trj, mask) {
    .Call(`_simmer_Seize__new_func`, resource, amount, cont, trj, mask)
}

SeizeSelected__new <- function(id, amount, cont, trj, mask) {
    .Call(`_simmer_SeizeSelected__new`, id, amount, cont, trj, mask)
}

SeizeSelected__new_func <- function(id, amount, cont, trj, mask) {
    .Call(`_simmer_SeizeSelected__new_func`, id, amount, cont, trj, mask)
}

Release__new <- function(resource, amount) {
    .Call(`_simmer_Release__new`, resource, amount)
}

Release__new_func <- function(resource, amount) {
    .Call(`_simmer_Release__new_func`, resource, amount)
}

ReleaseAll__new <- function(resource) {
    .Call(`_simmer_ReleaseAll__new`, resource)
}

ReleaseAll__new_void <- function() {
    .Call(`_simmer_ReleaseAll__new_void`)
}

ReleaseSelected__new <- function(id, amount) {
    .Call(`_simmer_ReleaseSelected__new`, id, amount)
}

ReleaseSelected__new_func <- function(id, amount) {
    .Call(`_simmer_ReleaseSelected__new_func`, id, amount)
}

ReleaseSelectedAll__new <- function(id) {
    .Call(`_simmer_ReleaseSelectedAll__new`, id)
}

SetCapacity__new <- function(resource, value, mod) {
    .Call(`_simmer_SetCapacity__new`, resource, value, mod)
}

SetCapacity__new_func <- function(resource, value, mod) {
    .Call(`_simmer_SetCapacity__new_func`, resource, value, mod)
}

SetCapacitySelected__new <- function(id, value, mod) {
    .Call(`_simmer_SetCapacitySelected__new`, id, value, mod)
}

SetCapacitySelected__new_func <- function(id, value, mod) {
    .Call(`_simmer_SetCapacitySelected__new_func`, id, value, mod)
}

SetQueue__new <- function(resource, value, mod) {
    .Call(`_simmer_SetQueue__new`, resource, value, mod)
}

SetQueue__new_func <- function(resource, value, mod) {
    .Call(`_simmer_SetQueue__new_func`, resource, value, mod)
}

SetQueueSelected__new <- function(id, value, mod) {
    .Call(`_simmer_SetQueueSelected__new`, id, value, mod)
}

SetQueueSelected__new_func <- function(id, value, mod) {
    .Call(`_simmer_SetQueueSelected__new_func`, id, value, mod)
}

Select__new <- function(resources, policy, id) {
    .Call(`_simmer_Select__new`, resources, policy, id)
}

Select__new_func <- function(resources, policy, id) {
    .Call(`_simmer_Select__new_func`, resources, policy, id)
}

SetAttribute__new <- function(keys, values, global, mod, init) {
    .Call(`_simmer_SetAttribute__new`, keys, values, global, mod, init)
}

SetAttribute__new_func1 <- function(keys, values, global, mod, init) {
    .Call(`_simmer_SetAttribute__new_func1`, keys, values, global, mod, init)
}

SetAttribute__new_func2 <- function(keys, values, global, mod, init) {
    .Call(`_simmer_SetAttribute__new_func2`, keys, values, global, mod, init)
}

SetAttribute__new_func3 <- function(keys, values, global, mod, init) {
    .Call(`_simmer_SetAttribute__new_func3`, keys, values, global, mod, init)
}

Activate__new <- function(sources) {
    .Call(`_simmer_Activate__new`, sources)
}

Activate__new_func <- function(sources) {
    .Call(`_simmer_Activate__new_func`, sources)
}

Deactivate__new <- function(sources) {
    .Call(`_simmer_Deactivate__new`, sources)
}

Deactivate__new_func <- function(sources) {
    .Call(`_simmer_Deactivate__new_func`, sources)
}

SetTraj__new <- function(sources, trj) {
    .Call(`_simmer_SetTraj__new`, sources, trj)
}

SetTraj__new_func <- function(sources, trj) {
    .Call(`_simmer_SetTraj__new_func`, sources, trj)
}

SetSourceFn__new <- function(sources, dist) {
    .Call(`_simmer_SetSourceFn__new`, sources, dist)
}

SetSourceFn__new_func <- function(sources, dist) {
    .Call(`_simmer_SetSourceFn__new_func`, sources, dist)
}

SetSourceDF__new <- function(sources, data) {
    .Call(`_simmer_SetSourceDF__new`, sources, data)
}

SetSourceDF__new_func <- function(sources, data) {
    .Call(`_simmer_SetSourceDF__new_func`, sources, data)
}

SetPrior__new <- function(values, mod) {
    .Call(`_simmer_SetPrior__new`, values, mod)
}

SetPrior__new_func <- function(values, mod) {
    .Call(`_simmer_SetPrior__new_func`, values, mod)
}

Timeout__new <- function(delay) {
    .Call(`_simmer_Timeout__new`, delay)
}

Timeout__new_func <- function(task) {
    .Call(`_simmer_Timeout__new_func`, task)
}

Timeout__new_attr <- function(key, global) {
    .Call(`_simmer_Timeout__new_attr`, key, global)
}

Branch__new <- function(option, cont, trj) {
    .Call(`_simmer_Branch__new`, option, cont, trj)
}

Rollback__new1 <- function(target, times) {
    .Call(`_simmer_Rollback__new1`, target, times)
}

Rollback__new2 <- function(target, times) {
    .Call(`_simmer_Rollback__new2`, target, times)
}

Rollback__new_func1 <- function(target, check) {
    .Call(`_simmer_Rollback__new_func1`, target, check)
}

Rollback__new_func2 <- function(target, check) {
    .Call(`_simmer_Rollback__new_func2`, target, check)
}

Leave__new <- function(prob, trj, keep_seized) {
    .Call(`_simmer_Leave__new`, prob, trj, keep_seized)
}

HandleUnfinished__new <- function(trj) {
    .Call(`_simmer_HandleUnfinished__new`, trj)
}

Leave__new_func <- function(prob, trj, keep_seized) {
    .Call(`_simmer_Leave__new_func`, prob, trj, keep_seized)
}

Clone__new <- function(n, trj) {
    .Call(`_simmer_Clone__new`, n, trj)
}

Clone__new_func <- function(n, trj) {
    .Call(`_simmer_Clone__new_func`, n, trj)
}

Synchronize__new <- function(wait, terminate) {
    .Call(`_simmer_Synchronize__new`, wait, terminate)
}

Batch__new <- function(n, timeout, permanent, name) {
    .Call(`_simmer_Batch__new`, n, timeout, permanent, name)
}

Batch__new_func1 <- function(n, timeout, permanent, name) {
    .Call(`_simmer_Batch__new_func1`, n, timeout, permanent, name)
}

Batch__new_func2 <- function(n, timeout, permanent, name) {
    .Call(`_simmer_Batch__new_func2`, n, timeout, permanent, name)
}

Batch__new_func3 <- function(n, timeout, permanent, name) {
    .Call(`_simmer_Batch__new_func3`, n, timeout, permanent, name)
}

Batch__new_func4 <- function(n, timeout, permanent, name, rule) {
    .Call(`_simmer_Batch__new_func4`, n, timeout, permanent, name, rule)
}

Batch__new_func5 <- function(n, timeout, permanent, name, rule) {
    .Call(`_simmer_Batch__new_func5`, n, timeout, permanent, name, rule)
}

Batch__new_func6 <- function(n, timeout, permanent, name, rule) {
    .Call(`_simmer_Batch__new_func6`, n, timeout, permanent, name, rule)
}

Batch__new_func7 <- function(n, timeout, permanent, name, rule) {
    .Call(`_simmer_Batch__new_func7`, n, timeout, permanent, name, rule)
}

Separate__new <- function() {
    .Call(`_simmer_Separate__new`)
}

RenegeIn__new <- function(t, trj, keep_seized) {
    .Call(`_simmer_RenegeIn__new`, t, trj, keep_seized)
}

RenegeIn__new_func <- function(t, trj, keep_seized) {
    .Call(`_simmer_RenegeIn__new_func`, t, trj, keep_seized)
}

RenegeIf__new <- function(signal, trj, keep_seized) {
    .Call(`_simmer_RenegeIf__new`, signal, trj, keep_seized)
}

RenegeIf__new_func <- function(signal, trj, keep_seized) {
    .Call(`_simmer_RenegeIf__new_func`, signal, trj, keep_seized)
}

RenegeAbort__new <- function() {
    .Call(`_simmer_RenegeAbort__new`)
}

Send__new <- function(signals, delay) {
    .Call(`_simmer_Send__new`, signals, delay)
}

Send__new_func1 <- function(signals, delay) {
    .Call(`_simmer_Send__new_func1`, signals, delay)
}

Send__new_func2 <- function(signals, delay) {
    .Call(`_simmer_Send__new_func2`, signals, delay)
}

Send__new_func3 <- function(signals, delay) {
    .Call(`_simmer_Send__new_func3`, signals, delay)
}

Trap__new <- function(signals, trj, interruptible) {
    .Call(`_simmer_Trap__new`, signals, trj, interruptible)
}

Trap__new_func <- function(signals, trj, interruptible) {
    .Call(`_simmer_Trap__new_func`, signals, trj, interruptible)
}

UnTrap__new <- function(signals) {
    .Call(`_simmer_UnTrap__new`, signals)
}

UnTrap__new_func <- function(signals) {
    .Call(`_simmer_UnTrap__new_func`, signals)
}

Wait__new <- function() {
    .Call(`_simmer_Wait__new`)
}

Log__new <- function(message, level) {
    .Call(`_simmer_Log__new`, message, level)
}

Log__new_func <- function(message, level) {
    .Call(`_simmer_Log__new_func`, message, level)
}

StopIf__new <- function(condition) {
    .Call(`_simmer_StopIf__new`, condition)
}

StopIf__new_func <- function(condition) {
    .Call(`_simmer_StopIf__new_func`, condition)
}

activity_get_count_ <- function(activity_) {
    .Call(`_simmer_activity_get_count_`, activity_)
}

activity_print_ <- function(activity_, indent, verbose) {
    invisible(.Call(`_simmer_activity_print_`, activity_, indent, verbose))
}

activity_get_next_ <- function(activity_) {
    .Call(`_simmer_activity_get_next_`, activity_)
}

activity_get_prev_ <- function(activity_) {
    .Call(`_simmer_activity_get_prev_`, activity_)
}

activity_chain_ <- function(first_, second_) {
    invisible(.Call(`_simmer_activity_chain_`, first_, second_))
}

activity_clone_ <- function(activity_) {
    .Call(`_simmer_activity_clone_`, activity_)
}

activity_set_tag_ <- function(activity_, tag) {
    invisible(.Call(`_simmer_activity_set_tag_`, activity_, tag))
}

MemMonitor__new <- function() {
    .Call(`_simmer_MemMonitor__new`)
}

CsvMonitor__new <- function(ends_path, releases_path, attributes_path, resources_path, sep) {
    .Call(`_simmer_CsvMonitor__new`, ends_path, releases_path, attributes_path, resources_path, sep)
}

close_files_ <- function(mon_) {
    invisible(.Call(`_simmer_close_files_`, mon_))
}

get_arrivals_ <- function(mon_, per_resource) {
    .Call(`_simmer_get_arrivals_`, mon_, per_resource)
}

get_attributes_ <- function(mon_) {
    .Call(`_simmer_get_attributes_`, mon_)
}

get_resources_ <- function(mon_) {
    .Call(`_simmer_get_resources_`, mon_)
}

get_n_generated_ <- function(sim_, names) {
    .Call(`_simmer_get_n_generated_`, sim_, names)
}

get_trajectory_ <- function(sim_, names) {
    .Call(`_simmer_get_trajectory_`, sim_, names)
}

get_name_ <- function(sim_) {
    .Call(`_simmer_get_name_`, sim_)
}

get_attribute_ <- function(sim_, keys, global) {
    .Call(`_simmer_get_attribute_`, sim_, keys, global)
}

get_prioritization_ <- function(sim_) {
    .Call(`_simmer_get_prioritization_`, sim_)
}

get_batch_size_ <- function(sim_) {
    .Call(`_simmer_get_batch_size_`, sim_)
}

get_capacity_ <- function(sim_, names) {
    .Call(`_simmer_get_capacity_`, sim_, names)
}

get_capacity_selected_ <- function(sim_, id) {
    .Call(`_simmer_get_capacity_selected_`, sim_, id)
}

get_queue_size_ <- function(sim_, names) {
    .Call(`_simmer_get_queue_size_`, sim_, names)
}

get_queue_size_selected_ <- function(sim_, id) {
    .Call(`_simmer_get_queue_size_selected_`, sim_, id)
}

get_server_count_ <- function(sim_, names) {
    .Call(`_simmer_get_server_count_`, sim_, names)
}

get_server_count_selected_ <- function(sim_, id) {
    .Call(`_simmer_get_server_count_selected_`, sim_, id)
}

get_queue_count_ <- function(sim_, names) {
    .Call(`_simmer_get_queue_count_`, sim_, names)
}

get_queue_count_selected_ <- function(sim_, id) {
    .Call(`_simmer_get_queue_count_selected_`, sim_, id)
}

get_seized_ <- function(sim_, names) {
    .Call(`_simmer_get_seized_`, sim_, names)
}

get_seized_selected_ <- function(sim_, id) {
    .Call(`_simmer_get_seized_selected_`, sim_, id)
}

get_selected_ <- function(sim_, id) {
    .Call(`_simmer_get_selected_`, sim_, id)
}

get_activity_time_ <- function(sim_, names) {
    .Call(`_simmer_get_activity_time_`, sim_, names)
}

get_activity_time_selected_ <- function(sim_, id) {
    .Call(`_simmer_get_activity_time_selected_`, sim_, id)
}

Simulator__new <- function(name, verbose, mon, log_level) {
    .Call(`_simmer_Simulator__new`, name, verbose, mon, log_level)
}

reset_ <- function(sim_) {
    invisible(.Call(`_simmer_reset_`, sim_))
}

now_ <- function(sim_) {
    .Call(`_simmer_now_`, sim_)
}

peek_ <- function(sim_, steps) {
    .Call(`_simmer_peek_`, sim_, steps)
}

stepn_ <- function(sim_, n) {
    invisible(.Call(`_simmer_stepn_`, sim_, n))
}

run_ <- function(sim_, until) {
    invisible(.Call(`_simmer_run_`, sim_, until))
}

add_generator_ <- function(sim_, name_prefix, trj, dist, mon, priority, preemptible, restart) {
    .Call(`_simmer_add_generator_`, sim_, name_prefix, trj, dist, mon, priority, preemptible, restart)
}

add_dataframe_ <- function(sim_, name_prefix, trj, data, mon, batch, time, attrs, priority, preemptible, restart) {
    .Call(`_simmer_add_dataframe_`, sim_, name_prefix, trj, data, mon, batch, time, attrs, priority, preemptible, restart)
}

add_resource_ <- function(sim_, name, capacity, queue_size, mon, preemptive, preempt_order, queue_size_strict, queue_priority_min, queue_priority_max) {
    .Call(`_simmer_add_resource_`, sim_, name, capacity, queue_size, mon, preemptive, preempt_order, queue_size_strict, queue_priority_min, queue_priority_max)
}

add_resource_manager_ <- function(sim_, name, param, init, intervals, values, period) {
    .Call(`_simmer_add_resource_manager_`, sim_, name, param, init, intervals, values, period)
}

add_global_manager_ <- function(sim_, key, init, intervals, values, period) {
    .Call(`_simmer_add_global_manager_`, sim_, key, init, intervals, values, period)
}

get_ongoing_ <- function(sim_, per_resource) {
    .Call(`_simmer_get_ongoing_`, sim_, per_resource)
}