OpenABMCovid19
Agent-Based Model for Modelling the COVID-19

Package index
Search the OpenABMCovid19 package
Functions
1362
Source code
15
Man pages
27
Home
/
CRAN
/
OpenABMCovid19
/
R/OpenABMCovid19.R

R/OpenABMCovid19.R
In OpenABMCovid19: Agent-Based Model for Modelling the COVID-19

Defines functions `strain_transmission_multiplier` `strain_idx` `vaccine_n_strains` `vaccine_name` `vaccine_vaccine_protection_period` `vaccine_time_to_protect` `vaccine_severe_efficacy` `vaccine_symptoms_efficacy` `vaccine_full_efficacy` `vaccine_idx` `get_network` `set_network_transmission_multiplier` `network_transmission_multiplier` `network_daily_fraction` `network_type` `network_skip_quarantined` `network_skip_hospitalised` `network_name` `network_n_vertices` `network_n_edges` `set_param_array_location_death_icu` `set_param_array_app_users_fraction` `set_param_array_mild_fraction` `set_param_array_fraction_asymptomatic` `set_param_array_population` `set_param_array_household_size` `set_param_array_fatality_fraction` `set_param_array_critical_fraction` `set_param_array_hospitalised_fraction` `set_param_array_relative_transmission_used` `set_param_array_relative_transmission` `set_param_array_adjusted_susceptibility` `set_param_array_relative_susceptibility` `set_param_array_mean_work_interactions` `set_param_array_sd_random_interactions` `set_param_array_mean_random_interactions` `get_param_array_app_users_fraction` `get_param_array_location_death_icu` `get_param_array_mild_fraction` `get_param_array_fraction_asymptomatic` `get_param_array_population` `get_param_array_household_size` `get_param_array_fatality_fraction` `get_param_array_critical_fraction` `get_param_array_hospitalised_fraction` `get_param_array_relative_transmission_used` `get_param_array_relative_transmission` `get_param_array_adjusted_susceptibility` `get_param_array_relative_susceptibility` `get_param_array_mean_work_interactions` `get_param_array_sd_random_interactions` `get_param_array_mean_random_interactions` CopyToC_floatArray CopyToR_floatArray `floatArray_frompointer` `floatArray_cast` `floatArray_setitem` `floatArray_getitem` `delete_floatArray` `floatArray` CopyToC_shortArray CopyToR_shortArray `shortArray_frompointer` `shortArray_cast` `shortArray_setitem` `shortArray_getitem` `delete_shortArray` `shortArray` CopyToC_longArray CopyToR_longArray `longArray_frompointer` `longArray_cast` `longArray_setitem` `longArray_getitem` `delete_longArray` `longArray` CopyToC_intArray CopyToR_intArray `intArray_frompointer` `intArray_cast` `intArray_setitem` `intArray_getitem` `delete_intArray` `intArray` CopyToC_doubleArray CopyToR_doubleArray `doubleArray_frompointer` `doubleArray_cast` `doubleArray_setitem` `doubleArray_getitem` `delete_doubleArray` `doubleArray` `get_household_value` `add_household_to_ref_households` `set_param_location_death_icu` `set_param_mild_fraction` `set_param_testing_symptoms_time_off` `set_param_testing_symptoms_time_on` `set_param_lockdown_elderly_on` `set_param_lockdown_elderly_time_off` `set_param_lockdown_elderly_time_on` `set_param_lockdown_on` `set_param_lockdown_time_off` `set_param_lockdown_time_on` `set_param_lockdown_house_interaction_multiplier` `set_param_random_network_multiplier` `set_param_lockdown_occupation_multiplier` `set_param_daily_non_cov_symptoms_rate` `set_param_app_turned_on` `set_param_app_turn_on_time` `set_param_app_users_fraction` `set_param_priority_test_contacts` `set_param_test_result_wait_priority` `set_param_test_order_wait_priority` `set_param_test_order_wait` `set_param_test_result_wait` `set_param_test_specificity` `set_param_test_sensitivity` `set_param_test_sensitive_period` `set_param_test_insensitive_period` `set_param_test_release_on_negative` `set_param_test_on_traced` `set_param_test_on_symptoms` `set_param_quarantine_household_contacts_on_positive` `set_param_quarantine_household_on_traced_symptoms` `set_param_quarantine_household_on_traced_positive` `set_param_quarantine_household_on_positive` `set_param_quarantine_household_on_symptoms` `set_param_allow_clinical_diagnosis` `set_param_tracing_network_depth` `set_param_traceable_interaction_fraction` `set_param_quarantine_on_traced` `set_param_quarantine_compliance_traced_positive` `set_param_quarantine_compliance_traced_symptoms` `set_param_quarantine_dropout_positive` `set_param_quarantine_dropout_traced_symptoms` `set_param_quarantine_dropout_traced_positive` `set_param_quarantine_dropout_self` `set_param_quarantine_length_positive` `set_param_quarantine_length_traced_positive` `set_param_quarantine_length_traced_symptoms` `set_param_quarantine_length_self` `set_param_trace_on_positive` `set_param_trace_on_symptoms` `set_param_self_quarantine_fraction` `set_param_quarantine_days` `set_param_hospitalised_daily_interactions` `set_param_quarantined_daily_interactions` `set_param_sd_asymptomatic_to_recovery` `set_param_mean_asymptomatic_to_recovery` `set_param_asymptomatic_infectious_factor` `set_param_fraction_asymptomatic` `set_param_population` `set_param_household_size` `set_param_mean_time_to_death` `set_param_sd_time_to_recover` `set_param_mean_time_to_recover` `set_param_sd_time_to_critical` `set_param_mean_time_to_critical` `set_param_mean_time_to_hospital` `set_param_fatality_fraction` `set_param_critical_fraction` `set_param_hospitalised_fraction` `set_param_sd_time_to_symptoms` `set_param_mean_time_to_symptoms` `set_param_manual_traceable_fraction` `add_contact` `remove_contact` `check_member_or_self` `build_watts_strogatz_network` `create_network` CopyToC_network CopyToR_network `network` `network_next_network_get` `network_next_network_set` `network_opt_long_array_get` `network_opt_long_array_set` `network_opt_long_get` `network_opt_long_set` `network_opt_int_array_get` `network_opt_int_array_set` `network_opt_pdx_array_get` `network_opt_pdx_array_set` `network_opt_n_indiv_get` `network_opt_n_indiv_set` `network_construction_get` `network_construction_set` `network_transmission_multiplier_get` `network_transmission_multiplier_set` `network_name_get` `network_name_set` `network_network_id_get` `network_network_id_set` `network_daily_fraction_get` `network_daily_fraction_set` `network_skip_quarantined_get` `network_skip_quarantined_set` `network_skip_hospitalised_get` `network_skip_hospitalised_set` `network_type_get` `network_type_set` `network_n_vertices_get` `network_n_vertices_set` `network_n_edges_get` `network_n_edges_set` `network_edges_get` `network_edges_set` CopyToC_edge CopyToR_edge `edge_id2_get` `edge_id2_set` `edge_id1_get` `edge_id1_set` `set_cross_immunity_probability` `calculate_R_instanteous` `n_newly_infected` `apply_cross_immunity` `transition_one_disese_event` `transition_to_death` `transition_to_susceptible` `transition_to_recovered` `transition_to_critical` `transition_to_hospitalised_recovering` `transition_to_hospitalised` `transition_to_symptomatic_mild` `transition_to_symptomatic` `seed_infect_by_idx` `new_infection` `transmit_virus_by_type` `transmit_virus` `estimate_mean_interactions_by_age` `set_up_infectious_curves` `set_up_transition_times` `inv_incomplete_gamma_p` `incomplete_gamma_p` CopyToC_incomplete_gamma_p_params CopyToR_incomplete_gamma_p_params `incomplete_gamma_p_params_percentile_get` `incomplete_gamma_p_params_percentile_set` `incomplete_gamma_p_params_n_get` `incomplete_gamma_p_params_n_set` `free_gsl_rng` `setup_gsl_rng` `n_unique_elements` `sum_square_diff_array` `copy_normalize_array` `copy_array` `normalize_array` `discrete_draw` `negative_binomial_draw` `gamma_rate_curve` `geometric_draw_list` `shifted_geometric_draw_list` `geometric_max_draw_list` `bernoulli_draw_list` `gamma_draw_list` `fflush_stdout` `print_exit` `print_now` `printf_w` `resolve_quarantine_reasons` `intervention_smart_release` `intervention_on_traced` `intervention_on_positive_result` `intervention_on_critical` `intervention_on_hospitalised` `intervention_on_symptoms` `intervention_vaccine_wane` `intervention_vaccine_protect` `intervention_vaccinate_age_group` `intervention_vaccinate_by_idx` `intervention_vaccinate` `get_vaccine_by_id` `add_vaccine` `intervention_index_case_symptoms_to_positive` `intervention_notify_contacts` `intervention_manual_trace` `intervention_test_result` `intervention_test_take` `intervention_quarantine_household` `intervention_quarantine_release` `intervention_quarantine_until` `intervention_trace_token_release` `remove_traces_on_individual` `remove_traced_on_this_trace` `remove_one_trace_token` `index_trace_token` `create_trace_token` `add_trace_tokens` `set_up_trace_tokens` `update_intervention_policy` `destroy_risk_scores` `set_up_risk_scores` `set_up_app_users` `set_up_transition_times_intervention` CopyToC_vaccine CopyToR_vaccine `vaccine__next_get` `vaccine__next_set` `vaccine_name_get` `vaccine_name_set` `vaccine_n_strains_get` `vaccine_n_strains_set` `vaccine_is_severe_get` `vaccine_is_severe_set` `vaccine_is_symptoms_get` `vaccine_is_symptoms_set` `vaccine_is_full_get` `vaccine_is_full_set` `vaccine_vaccine_protection_period_get` `vaccine_vaccine_protection_period_set` `vaccine_time_to_protect_get` `vaccine_time_to_protect_set` `vaccine_severe_efficacy_get` `vaccine_severe_efficacy_set` `vaccine_symptoms_efficacy_get` `vaccine_symptoms_efficacy_set` `vaccine_full_efficacy_get` `vaccine_full_efficacy_set` `vaccine_idx_get` `vaccine_idx_set` CopyToC_trace_token CopyToR_trace_token `trace_token_index_status_get` `trace_token_index_status_set` `trace_token_contact_time_get` `trace_token_contact_time_set` `trace_token_last_get` `trace_token_last_set` `trace_token__next_get` `trace_token__next_set` `trace_token_last_index_get` `trace_token_last_index_set` `trace_token_next_index_get` `trace_token_next_index_set` `trace_token_traced_from_get` `trace_token_traced_from_set` `trace_token_individual_get` `trace_token_individual_set` CopyToC_trace_token_block CopyToR_trace_token_block `trace_token_block__next_get` `trace_token_block__next_set` `trace_token_block_trace_tokens_get` `trace_token_block_trace_tokens_set` `print_individual` `destroy_individual` `count_infection_events` `update_random_interactions` `set_vaccine_status` `wane_immunity` `set_immune` `set_discharged` `set_mortuary_admission` `set_icu_admission` `set_general_admission` `set_waiting` `set_case` `set_dead` `set_critical` `set_hospitalised_recovering` `set_hospitalised` `set_susceptible` `set_recovered` `set_quarantine_status` `set_house_no` `set_age_group` `add_infection_event` `initialize_hazard` `initialize_individual` CopyToC_infection_event CopyToR_infection_event `infection_event_strain_get` `infection_event_strain_set` `infection_event_expected_hospitalisation_get` `infection_event_expected_hospitalisation_set` `infection_event_network_id_get` `infection_event_network_id_set` `infection_event_is_case_get` `infection_event_is_case_set` `infection_event__next_get` `individual_index_trace_token_set` `individual_trace_tokens_get` `individual_trace_tokens_set` `individual_quarantine_test_result_get` `individual_quarantine_test_result_set` `individual_quarantine_release_event_get` `individual_quarantine_release_event_set` `individual_quarantine_event_get` `individual_quarantine_event_set` `individual_quarantined_get` `individual_quarantined_set` `individual_infection_events_get` `individual_infection_events_set` `individual_next_disease_event_get` `individual_next_disease_event_set` `individual_current_disease_event_get` `individual_current_disease_event_set` `individual_infectiousness_multiplier_get` `individual_infectiousness_multiplier_set` `individual_hazard_get` `individual_hazard_set` `individual_status_get` `individual_status_set` `individual_interactions_get` `individual_interactions_set` `individual_n_interactions_get` `individual_n_interactions_set` `individual_random_interactions_get` `individual_random_interactions_set` `individual_base_random_interactions_get` `individual_base_random_interactions_set` `individual_occupation_network_get` `individual_occupation_network_set` `individual_age_type_get` `individual_age_type_set` `individual_age_group_get` `individual_age_group_set` `individual_house_no_get` `individual_house_no_set` `individual_idx_get` `individual_idx_set` `get_transmissions` `get_n_transmissions` `print_interactions_averages` `write_network` `write_random_network` `write_household_network` `write_occupation_network` `write_hospital_interactions` `write_time_step_hospital_data` `get_worker_ward_type` `write_ward_data` `write_quarantine_reasons` `write_trace_tokens_ts` `write_trace_tokens` `write_transmissions` `write_interactions` `write_individual_file` `write_output_files` `set_up_reference_household_memory` `read_hospital_param_file` `read_household_demographics_file` `read_param_file` `read_command_line_args` rng `rng_get` `rng_set` NEWLY_INFECTED_STATES `NEWLY_INFECTED_STATES_get` DEFAULT_NETWORKS_NAMES `DEFAULT_NETWORKS_NAMES_get` `DEFAULT_NETWORKS_NAMES_set` EVENT_TYPE_TO_WARD_MAP `EVENT_TYPE_TO_WARD_MAP_get` AGE_TEXT_MAP `AGE_TEXT_MAP_get` `AGE_TEXT_MAP_set` AGE_TYPE_MAP `AGE_TYPE_MAP_get` OCCUPATION_DEFAULT_MAP `OCCUPATION_DEFAULT_MAP_get` NETWORK_TYPE_MAP `NETWORK_TYPE_MAP_get` AGE_OCCUPATION_MAP `AGE_OCCUPATION_MAP_get` `destroy_occupation_network_table` `destroy_params` `initialize_params` `check_hospital_params` `check_params` `update_household_intervention_state` `update_work_intervention_state` `get_individuals` `get_app_user_by_index` `get_app_users` `set_app_users` `set_up_default_occupation_network_table` `set_indiv_occupation_network` `set_indiv_occupation_network_property` `set_occupation_network_table` `set_demographic_house_table` `set_model_param_fatality_fraction` `set_model_param_risk_score_household` `set_model_param_risk_score` `set_model_param_manual_traceable_fraction` `set_model_param_manual_trace_notifications_per_worker_day` `set_model_param_manual_trace_interviews_per_worker_day` `set_model_param_manual_trace_n_workers` `set_model_param_manual_trace_exclude_app_users` `set_model_param_manual_trace_delay` `set_model_param_manual_trace_on` `set_model_param_manual_trace_on_positive` `set_model_param_manual_trace_on_hospitalization` `set_model_param_lockdown_elderly_on` `set_model_param_lockdown_occupation_multiplier` `set_model_param_lockdown_random_network_multiplier` `set_model_param_lockdown_house_interaction_multiplier` `set_model_param_lockdown_on` `set_model_param_app_turned_on` `set_model_param_app_users_fraction` `set_model_param_priority_test_contacts` `set_model_param_test_order_wait_priority` `set_model_param_test_result_wait_priority` `set_model_param_test_order_wait` `set_model_param_test_result_wait` `set_model_param_test_on_traced` `set_model_param_test_release_on_negative` `set_model_param_test_on_symptoms` `set_model_param_quarantine_household_contacts_on_symptoms` `set_model_param_quarantine_household_contacts_on_positive` `set_model_param_quarantine_household_on_traced_positive` `set_model_param_quarantine_household_on_traced_symptoms` `set_model_param_quarantine_household_on_positive` `set_model_param_quarantine_household_on_symptoms` `set_model_param_allow_clinical_diagnosis` `set_model_param_tracing_network_depth` `set_model_param_traceable_interaction_fraction` `set_model_param_quarantine_on_traced` `set_model_param_trace_on_positive` `set_model_param_trace_on_symptoms` `set_model_param_self_quarantine_fraction` `set_model_param_quarantine_days` `get_model_param_fatality_fraction` `get_model_param_manual_traceable_fraction` `get_model_param_manual_trace_notifications_per_worker_day` `get_model_param_manual_trace_interviews_per_worker_day` `get_model_param_manual_trace_n_workers` `get_model_param_manual_trace_exclude_app_users` `get_model_param_manual_trace_delay` `get_model_param_manual_trace_on` `get_model_param_manual_trace_on_positive` `get_model_param_manual_trace_on_hospitalization` `get_model_param_lockdown_occupation_multiplier` `get_model_param_lockdown_random_network_multiplier` `get_model_param_lockdown_house_interaction_multiplier` `get_model_param_risk_score_household` `get_model_param_risk_score` `get_model_param_lockdown_on` `get_model_param_app_turned_on` `get_model_param_app_users_fraction` `get_model_param_priority_test_contacts` `get_model_param_test_order_wait_priority` `get_model_param_test_result_wait_priority` `get_model_param_test_order_wait` `get_model_param_test_result_wait` `get_model_param_test_on_traced` `get_model_param_test_release_on_negative` `get_model_param_test_on_symptoms` `get_model_param_quarantine_household_contacts_on_symptoms` `set_model_param_relative_transmission` `get_model_param_quarantine_household_contacts_on_positive` `get_model_param_quarantine_household_on_traced_positive` `get_model_param_quarantine_household_on_traced_symptoms` `get_model_param_quarantine_household_on_positive` `get_model_param_quarantine_household_on_symptoms` `get_model_param_allow_clinical_diagnosis` `get_model_param_tracing_network_depth` `get_model_param_traceable_interaction_fraction` `get_model_param_quarantine_on_traced` `get_model_param_trace_on_positive` `set_param_relative_transmission` `set_param_adjusted_susceptibility` `set_param_relative_susceptibility` `set_param_sd_infectiousness_multiplier` `set_param_max_n_strains` `set_param_rebuild_networks` `set_param_infectious_rate` `set_param_sd_infectious_period` `set_param_mean_infectious_period` `set_param_elderly_network_adults` `set_param_child_network_adults` `set_param_daily_fraction_work` `set_param_mean_work_interactions` `set_param_random_interaction_distribution` `set_param_sd_random_interactions` `set_param_mean_random_interactions` `set_param_days_of_interactions` `set_param_n_total` `set_param_param_id` `set_param_rng_seed` `get_param_location_death_icu` `get_param_testing_symptoms_time_off` `get_param_symptoms_time_on` `get_param_lockdown_elderly_on` `get_param_lockdown_elderly_time_off` `get_param_lockdown_elderly_time_on` `get_param_lockdown_on` `get_param_lockdown_time_off` `get_param_lockdown_time_on` `get_param_lockdown_house_interaction_multiplier` `get_param_lockdown_random_network_multiplier` `get_param_lockdown_occupation_multiplier` `get_param_daily_non_cov_symptoms_rate` `get_param_app_turn_on_time` `get_param_app_turned_on` `get_param_app_users_fraction` `get_param_priority_test_contacts` `get_param_test_result_wait_priority` `get_param_test_order_wait_priority` `get_param_test_order_wait` `get_param_test_result_wait` `get_param_test_specificity` `get_param_test_sensitivity` `get_param_test_sensitive_period` `get_param_test_insensitive_period` `get_param_test_release_on_negative` `get_param_test_on_traced` `get_param_test_on_symptoms` `get_param_quarantine_household_contacts_on_positive` `get_param_quarantine_household_on_traced_symptoms` `get_param_quarantine_household_on_traced_positive` `get_param_quarantine_household_on_positive` `get_param_quarantine_household_on_symptoms` `get_param_allow_clinical_diagnosis` `get_param_tracing_network_depth` `get_param_traceable_interaction_fraction` `get_param_quarantine_on_traced` `get_param_quarantine_compliance_traced_positive` `get_param_quarantine_compliance_traced_symptoms` `get_param_quarantine_dropout_positive` `get_param_quarantine_dropout_traced_symptoms` `get_param_quarantine_dropout_traced_positive` `get_param_quarantine_dropout_self` `get_param_quarantine_length_positive` `get_param_quarantine_length_traced_positive` `get_param_quarantine_length_traced_symptoms` `get_param_quarantine_length_self` `get_param_trace_on_positive` `get_param_trace_on_symptoms` `get_param_self_quarantine_fraction` `get_param_hospitalised_daily_interactions` `get_param_quarantine_daily_interactions` `get_param_sd_asymptomatic_to_recover` `get_param_mild_fraction` `get_param_mean_asymptomatic_to_recover` `get_param_asymptomatic_infectious_factor` `get_param_fraction_asymptomatic` `get_param_population` `get_param_household_size` `get_param_mean_sd_to_death` `get_param_mean_time_to_death` `get_param_mean_sd_to_recover` `get_param_mean_time_to_recover` `get_param_sd_time_to_critical` `get_param_mean_time_to_critical` `get_param_mean_time_to_hospital` `get_param_fatality_fraction` `get_param_critical_fraction` `get_param_hospitalised_fraction` `get_param_sd_time_to_symptoms` `get_param_mean_time_to_symptoms` `get_param_manual_traceable_fraction` `get_param_relative_transmission_used` `get_param_relative_transmission` `get_param_adjusted_susceptibility` `get_param_relative_susceptibility` `get_param_sd_infectiousness_multiplier` `get_param_max_n_strains` `get_param_rebuild_networks` `get_param_infectious_rate` `get_param_sd_infectious_period` `get_param_mean_infectious_period` `get_param_elderly_network_adults` `get_param_child_network_adults` `get_param_daily_fraction_work` `get_param_mean_work_interactions` `get_param_random_interaction_distribution` `get_param_sd_random_interactions` `get_param_mean_random_interactions` `get_param_days_of_interactions` `get_param_n_total` `get_param_param_id` `get_param_rng_seed` `get_param_hospital_on` `get_param_quarantine_days` `utils_n_daily_age` `utils_n_daily` `utils_n_total_age` `utils_n_total_by_day` `utils_n_total` `utils_n_current` `get_strain_by_id` `add_new_strain` CopyToC_strain CopyToR_strain `strain_hospitalised_fraction_get` `strain_hospitalised_fraction_set` `strain_transmission_multiplier_get` `strain_transmission_multiplier_set` `strain_idx_get` `strain_idx_set` `update_daily_fraction` `destroy_network` `relabel_network` `get_model_param_trace_on_symptoms` `get_model_param_self_quarantine_fraction` `get_model_param_quarantine_days` `get_model_param_daily_fraction_work_used` `get_model_param_hospital_on` CopyToC_parameters CopyToR_parameters `parameters` `delete_parameters` `parameters_max_n_strains_get` `parameters_max_n_strains_set` `parameters_hcw_mean_work_interactions_get` `parameters_hcw_mean_work_interactions_set` `parameters_critical_waiting_mod_get` `parameters_critical_waiting_mod_set` `parameters_hospitalised_waiting_mod_get` `parameters_hospitalised_waiting_mod_set` `parameters_max_hcw_daily_interactions_get` `parameters_max_hcw_daily_interactions_set` `parameters_n_patient_required_interactions_get` `parameters_n_patient_required_interactions_set` `parameters_n_hcw_per_ward_get` `parameters_n_hcw_per_ward_set` `parameters_n_ward_beds_get` `parameters_n_ward_beds_set` `parameters_n_wards_get` `parameters_n_wards_set` `parameters_n_hospitals_get` `parameters_n_hospitals_set` `parameters_hospital_on_get` `parameters_hospital_on_set` `parameters_risk_score_household_get` `parameters_risk_score_household_set` `parameters_risk_score_get` `parameters_risk_score_set` `parameters_occupation_network_table_get` `parameters_interventions_on_get` `parameters_interventions_on_set` `parameters_testing_symptoms_time_off_get` `parameters_testing_symptoms_time_off_set` `parameters_testing_symptoms_time_on_get` `parameters_testing_symptoms_time_on_set` `parameters_lockdown_elderly_on_get` `parameters_lockdown_elderly_on_set` `parameters_lockdown_elderly_time_off_get` `parameters_lockdown_elderly_time_off_set` `parameters_lockdown_elderly_time_on_get` `parameters_lockdown_elderly_time_on_set` `parameters_lockdown_on_get` `parameters_lockdown_on_set` `parameters_lockdown_time_off_get` `parameters_lockdown_time_off_set` `parameters_lockdown_time_on_get` `parameters_lockdown_time_on_set` `parameters_lockdown_house_interaction_multiplier_get` `parameters_lockdown_house_interaction_multiplier_set` `parameters_lockdown_random_network_multiplier_get` `parameters_lockdown_random_network_multiplier_set` `parameters_lockdown_occupation_multiplier_get` `parameters_lockdown_occupation_multiplier_set` `parameters_daily_non_cov_symptoms_rate_get` `parameters_daily_non_cov_symptoms_rate_set` `parameters_app_turn_on_time_get` `parameters_app_turn_on_time_set` `parameters_app_turned_on_get` `parameters_app_turned_on_set` `parameters_app_users_fraction_get` `parameters_app_users_fraction_set` `parameters_test_specificity_get` `parameters_test_specificity_set` `parameters_test_sensitivity_get` `parameters_test_sensitivity_set` `parameters_test_sensitive_period_get` `parameters_test_sensitive_period_set` `parameters_test_insensitive_period_get` `parameters_test_insensitive_period_set` `parameters_priority_test_contacts_get` `parameters_priority_test_contacts_set` `parameters_test_release_on_negative_get` `parameters_test_release_on_negative_set` `parameters_test_order_wait_priority_get` `parameters_test_order_wait_priority_set` `parameters_test_result_wait_priority_get` `parameters_test_result_wait_priority_set` `parameters_test_order_wait_get` `parameters_test_order_wait_set` `parameters_test_result_wait_get` `parameters_test_result_wait_set` `parameters_test_on_traced_get` `parameters_test_on_traced_set` `parameters_test_on_symptoms_get` `parameters_test_on_symptoms_set` `parameters_quarantine_household_contacts_on_symptoms_get` `parameters_quarantine_household_contacts_on_symptoms_set` `parameters_quarantine_household_contacts_on_positive_get` `parameters_quarantine_household_contacts_on_positive_set` `parameters_quarantine_household_on_traced_positive_get` `parameters_quarantine_household_on_traced_positive_set` `parameters_quarantine_household_on_traced_symptoms_get` `parameters_quarantine_household_on_traced_symptoms_set` `parameters_quarantine_household_on_positive_get` `parameters_quarantine_household_on_positive_set` `parameters_quarantine_household_on_symptoms_get` `parameters_quarantine_household_on_symptoms_set` `parameters_allow_clinical_diagnosis_get` `parameters_allow_clinical_diagnosis_set` `parameters_tracing_network_depth_get` `parameters_tracing_network_depth_set` `parameters_traceable_interaction_fraction_get` `parameters_traceable_interaction_fraction_set` `parameters_quarantine_smart_release_day_get` `parameters_quarantine_smart_release_day_set` `parameters_quarantine_on_traced_get` `parameters_quarantine_on_traced_set` `parameters_quarantine_compliance_traced_positive_get` `parameters_quarantine_compliance_traced_positive_set` `parameters_quarantine_compliance_traced_symptoms_get` `parameters_quarantine_compliance_traced_symptoms_set` `parameters_quarantine_dropout_positive_get` `parameters_quarantine_dropout_positive_set` `parameters_quarantine_dropout_traced_positive_get` `parameters_quarantine_dropout_traced_positive_set` `parameters_quarantine_dropout_traced_symptoms_get` `parameters_quarantine_dropout_traced_symptoms_set` `parameters_quarantine_dropout_self_get` `parameters_quarantine_dropout_self_set` `parameters_quarantine_length_positive_get` `parameters_quarantine_length_positive_set` `parameters_quarantine_length_traced_positive_get` `parameters_quarantine_length_traced_positive_set` `parameters_quarantine_length_traced_symptoms_get` `parameters_quarantine_length_traced_symptoms_set` `parameters_quarantine_length_self_get` `parameters_quarantine_length_self_set` `parameters_retrace_on_positive_get` `parameters_retrace_on_positive_set` `parameters_trace_on_positive_get` `parameters_trace_on_positive_set` `parameters_trace_on_symptoms_get` `parameters_trace_on_symptoms_set` `parameters_manual_traceable_fraction_get` `parameters_manual_traceable_fraction_set` `parameters_manual_trace_notifications_per_worker_day_get` `parameters_manual_trace_notifications_per_worker_day_set` `parameters_manual_trace_interviews_per_worker_day_get` `parameters_manual_trace_interviews_per_worker_day_set` `parameters_manual_trace_n_workers_get` `parameters_manual_trace_n_workers_set` `parameters_manual_trace_exclude_app_users_get` `parameters_manual_trace_exclude_app_users_set` `parameters_manual_trace_delay_get` `parameters_manual_trace_delay_set` `parameters_manual_trace_on_positive_get` `parameters_manual_trace_on_positive_set` `parameters_manual_trace_on_hospitalization_get` `parameters_manual_trace_on_hospitalization_set` `parameters_manual_trace_time_on_get` `parameters_manual_trace_time_on_set` `parameters_manual_trace_on_get` `parameters_manual_trace_on_set` `parameters_self_quarantine_fraction_get` `parameters_self_quarantine_fraction_set` `parameters_quarantine_days_get` `parameters_quarantine_days_set` `parameters_hospitalised_daily_interactions_get` `parameters_hospitalised_daily_interactions_set` `parameters_quarantined_daily_interactions_get` `parameters_quarantined_daily_interactions_set` `parameters_location_death_icu_get` `parameters_location_death_icu_set` `parameters_sd_time_critical_survive_get` `parameters_sd_time_critical_survive_set` `parameters_mean_time_critical_survive_get` `parameters_mean_time_critical_survive_set` `parameters_sd_time_hospitalised_recovery_get` `parameters_sd_time_hospitalised_recovery_set` `parameters_mean_time_hospitalised_recovery_get` `parameters_mean_time_hospitalised_recovery_set` `parameters_sd_asymptomatic_to_recovery_get` `parameters_sd_asymptomatic_to_recovery_set` `parameters_mean_asymptomatic_to_recovery_get` `parameters_mean_asymptomatic_to_recovery_set` `parameters_mild_infectious_factor_get` `parameters_mild_infectious_factor_set` `parameters_mild_fraction_get` `parameters_mild_fraction_set` `parameters_asymptomatic_infectious_factor_get` `parameters_asymptomatic_infectious_factor_set` `parameters_fraction_asymptomatic_get` `parameters_fraction_asymptomatic_set` `parameters_population_get` `parameters_population_set` `parameters_household_size_get` `parameters_household_size_set` `parameters_time_to_susceptible_shift_get` `parameters_time_to_susceptible_shift_set` `parameters_mean_time_to_susceptible_after_shift_get` `parameters_mean_time_to_susceptible_after_shift_set` `parameters_sd_time_to_death_get` `parameters_sd_time_to_death_set` `parameters_mean_time_to_death_get` `parameters_mean_time_to_death_set` `parameters_sd_time_to_recover_get` `parameters_sd_time_to_recover_set` `parameters_mean_time_to_recover_get` `parameters_mean_time_to_recover_set` `parameters_sd_time_to_critical_get` `parameters_sd_time_to_critical_set` `parameters_mean_time_to_critical_get` `parameters_mean_time_to_critical_set` `parameters_mean_time_to_hospital_get` `parameters_mean_time_to_hospital_set` `parameters_fatality_fraction_get` `parameters_fatality_fraction_set` `parameters_critical_fraction_get` `parameters_critical_fraction_set` `infection_event__next_set` `infection_event_time_infected_infector_get` `infection_event_time_infected_infector_set` `infection_event_infector_network_get` `infection_event_infector_network_set` `infection_event_infector_hospital_state_get` `infection_event_infector_hospital_state_set` `infection_event_infector_status_get` `infection_event_infector_status_set` `infection_event_infector_get` `infection_event_infector_set` `infection_event_times_get` `infection_event_times_set` CopyToC_interaction_block CopyToR_interaction_block `interaction_block__next_get` `interaction_block__next_set` `interaction_block_idx_get` `interaction_block_idx_set` `interaction_block_n_interactions_get` `interaction_block_n_interactions_set` `interaction_block_interactions_get` `interaction_block_interactions_set` CopyToC_interaction CopyToR_interaction `interaction__next_get` `interaction__next_set` `interaction_individual_get` `interaction_individual_set` `interaction_manual_traceable_get` `interaction_manual_traceable_set` `interaction_traceable_get` `interaction_traceable_set` `interaction_network_id_get` `interaction_network_id_set` `interaction_type_get` `interaction_type_set` CopyToC_individual CopyToR_individual `individual_immune_to_severe_get` `individual_immune_to_severe_set` `individual_immune_to_symptoms_get` `individual_immune_to_symptoms_set` `individual_immune_full_get` `individual_immune_full_set` `individual_vaccine_status_get` `individual_vaccine_status_set` `individual_worker_type_get` `individual_worker_type_set` `individual_next_hospital_event_get` `individual_next_hospital_event_set` `individual_current_hospital_event_get` `individual_current_hospital_event_set` `individual_disease_progression_predicted_get` `individual_disease_progression_predicted_set` `individual_hospital_state_get` `individual_hospital_state_set` `individual_hospital_idx_get` `individual_hospital_idx_set` `individual_ward_type_get` `individual_ward_type_set` `individual_ward_idx_get` `individual_ward_idx_set` `individual_app_user_get` `individual_app_user_set` `individual_traced_on_this_trace_get` `individual_traced_on_this_trace_set` `individual_index_token_release_event_get` `individual_index_token_release_event_set` `individual_index_trace_token_get` `parameters_hospitalised_fraction_get` `parameters_hospitalised_fraction_set` `parameters_sd_time_to_symptoms_get` `parameters_sd_time_to_symptoms_set` `parameters_mean_time_to_symptoms_get` `parameters_mean_time_to_symptoms_set` `parameters_relative_transmission_used_get` `parameters_relative_transmission_used_set` `parameters_relative_transmission_get` `parameters_relative_transmission_set` `parameters_relative_susceptibility_by_interaction_get` `parameters_sd_infectiousness_multiplier_get` `parameters_sd_infectiousness_multiplier_set` `parameters_infectious_rate_get` `parameters_infectious_rate_set` `parameters_sd_infectious_period_get` `parameters_sd_infectious_period_set` `parameters_mean_infectious_period_get` `parameters_mean_infectious_period_set` `parameters_work_network_rewire_get` `parameters_work_network_rewire_set` `parameters_elderly_network_adults_get` `parameters_elderly_network_adults_set` `parameters_child_network_adults_get` `parameters_child_network_adults_set` `parameters_daily_fraction_work_get` `parameters_daily_fraction_work_set` `parameters_mean_work_interactions_get` `parameters_mean_work_interactions_set` `parameters_random_interaction_distribution_get` `parameters_random_interaction_distribution_set` `parameters_sd_random_interactions_get` `parameters_sd_random_interactions_set` `parameters_mean_random_interactions_get` `parameters_mean_random_interactions_set` `parameters_rebuild_networks_get` `parameters_rebuild_networks_set` `parameters_n_seed_infection_get` `parameters_n_seed_infection_set` `parameters_end_time_get` `parameters_end_time_set` `parameters_days_of_interactions_get` `parameters_days_of_interactions_set` `parameters_n_total_get` `parameters_n_total_set` `parameters_param_id_get` `parameters_param_id_set` `parameters_hospital_param_line_number_get` `parameters_hospital_param_line_number_set` `parameters_param_line_number_get` `parameters_param_line_number_set` `parameters_output_file_dir_get` `parameters_output_file_dir_set` `parameters_input_household_file_get` `parameters_input_household_file_set` `parameters_hospital_input_param_file_get` `parameters_hospital_input_param_file_set` `parameters_input_param_file_get` `parameters_input_param_file_set` `parameters_rng_seed_get` `parameters_rng_seed_set` `get_network_ids` `get_network_by_id` `delete_network` `add_user_network_random` `add_user_network` `build_random_network_user` `build_random_network_default` `build_random_network` `build_daily_network` `add_interactions_from_network` `add_new_network` `return_interactions` `add_interaction_block` `transition_events_info` `transition_events` `update_event_list_counters` `remove_event_from_event_list` `destroy_event_list` `set_up_event_list` `add_individual_to_event_list` `create_event` `flu_infections` `one_time_step` `destroy_model` `set_up_individual_hazard` `set_up_occupation_network` `reset_counters` `set_up_counters` `set_up_networks` `set_up_seed_infection` `set_up_strains` `add_event_block` `set_up_events` `set_up_interactions` `set_up_healthcare_workers_and_hospitals` `set_up_population` `create_model` CopyToC_event CopyToR_event `event_last_get` `event_last_set` `event__next_get` `event__next_set` `event_info_get` `event_info_set` `event_time_get` `event_time_set` `event_type_get` `event_type_set` `event_individual_get` `event_individual_set` CopyToC_event_block CopyToR_event_block `event_block__next_get` `event_block__next_set` `event_block_events_get` `event_block_events_set` CopyToC_model CopyToR_model `model` `delete_model` `model_vaccines_get` `model_vaccines_set` `model_cross_immunity_get` `model_cross_immunity_set` `model_n_initialised_strains_get` `model_n_initialised_strains_set` `model_strains_get` `model_strains_set` `model_hospitals_get` `model_hospitals_set` `model_n_vaccinated_symptoms_by_age_get` `model_n_vaccinated_symptoms_by_age_set` `model_n_vaccinated_fully_by_age_get` `model_n_vaccinated_fully_by_age_set` `model_n_vaccinated_symptoms_get` `model_n_vaccinated_symptoms_set` `model_n_vaccinated_fully_get` `model_n_vaccinated_fully_set` `model_n_population_by_age_get` `model_n_population_by_age_set` `model_n_quarantine_release_events_app_user_get` `model_n_quarantine_release_events_app_user_set` `model_n_quarantine_release_events_get` `model_n_quarantine_release_events_set` `model_n_quarantine_events_app_user_get` `model_n_quarantine_events_app_user_set` `model_n_quarantine_events_get` `model_n_quarantine_events_set` `model_n_quarantine_app_user_recovered_get` `model_n_quarantine_app_user_recovered_set` `model_n_quarantine_app_user_infected_get` `model_n_quarantine_app_user_infected_set` `model_n_quarantine_recovered_get` `model_n_quarantine_recovered_set` `model_n_quarantine_infected_get` `model_n_quarantine_infected_set` `model_n_quarantine_app_user_get` `model_n_quarantine_app_user_set` `model_n_quarantine_days_get` `model_n_quarantine_days_set` `model_transition_time_distributions_get` `model_transition_time_distributions_set` `model_n_trace_tokens_get` `model_n_trace_tokens_set` `model_n_trace_tokens_used_get` `model_n_trace_tokens_used_set` `model_next_trace_token_get` `model_next_trace_token_set` `model_trace_token_block_get` `model_trace_token_block_set` `model_event_lists_get` `model_event_lists_set` `model_next_event_get` `model_next_event_set` `model_event_block_get` `model_event_block_set` `model_manual_trace_notification_quota_get` `model_manual_trace_notification_quota_set` `model_manual_trace_interview_quota_get` `model_manual_trace_interview_quota_set` `model_rebuild_networks_get` `model_rebuild_networks_set` `model_mean_interactions_by_age_get` `model_mean_interactions_by_age_set` `model_mean_interactions_get` `model_mean_interactions_set` `model_all_networks_get` `model_all_networks_set` `model_n_networks_get` `model_n_networks_set` `model_user_network_get` `model_user_network_set` `model_household_directory_get` `model_household_directory_set` `model_occupation_network_get` `model_occupation_network_set` `model_use_custom_occupation_networks_get` `model_use_custom_occupation_networks_set` `model_household_network_get` `model_household_network_set` `model_random_network_get` `model_random_network_set` `model_n_occupation_networks_get` `model_n_occupation_networks_set` `model_n_total_intereactions_get` `model_n_total_intereactions_set` `model_n_possible_interactions_get` `model_n_possible_interactions_set` `model_possible_interactions_get` `model_possible_interactions_set` `model_interaction_day_idx_get` `model_interaction_day_idx_set` `model_interaction_blocks_get` `model_interaction_blocks_set` `parameters_occupation_network_table_set` `parameters_demo_house_get` `parameters_demo_house_set` `parameters_REFERENCE_HOUSEHOLDS_get` `parameters_REFERENCE_HOUSEHOLDS_set` `parameters_N_REFERENCE_HOUSEHOLDS_get` `parameters_N_REFERENCE_HOUSEHOLDS_set` `parameters_sys_write_hospital_get` `parameters_sys_write_hospital_set` `parameters_sys_write_individual_get` `parameters_sys_write_individual_set` `parameters_intervention_start_time_get` `parameters_intervention_start_time_set` `parameters_relative_susceptibility_by_interaction_set` `parameters_adjusted_susceptibility_get` `parameters_adjusted_susceptibility_set` `parameters_relative_susceptibility_get` `parameters_relative_susceptibility_set` `model_time_get` `model_time_set` `model_population_get` `model_population_set` `model_params_get` `model_params_set` CopyToC_directory CopyToR_directory `directory_val_get` `directory_val_set` `directory_n_jdx_get` `directory_n_jdx_set` `directory_n_idx_get` `directory_n_idx_set` CopyToC_event_list CopyToR_event_list `event_list_infectious_curve_get` `event_list_infectious_curve_set` `event_list_n_current_get` `event_list_n_current_set` `event_list_n_total_by_age_get` `event_list_n_total_by_age_set` `event_list_n_total_get` `event_list_n_total_set` `event_list_n_daily_current_get` `event_list_n_daily_current_set` `event_list_n_daily_by_age_get` `event_list_n_daily_by_age_set` `event_list_n_daily_get` `event_list_n_daily_set` `event_list_events_get` `event_list_events_set` `event_list_type_get` `event_list_type_set` R_SWIG_addCallbackFunctionStack R_SWIG_getCallbackFunctionStack assert coerceIfNotSubclass enumFromInteger enumToInteger defineEnumeration SWIG_createNewRef 

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

##   Generated via the command line invocation:
##	 /Users/olegat/github.com/swig/swig/usr/bin/swig -r -package OpenABMCovid19 -Isrc -o src/covid19_wrap_R.c -outdir R src/covid19.i


#                         srun.swg                            #
#
# This is the basic code that is needed at run time within R to
# provide and define the relevant classes.  It is included
# automatically in the generated code by copying the contents of
# srun.swg into the newly created binding code.


# This could be provided as a separate run-time library but this
# approach allows the code to to be included directly into the
# generated bindings and so removes the need to have and install an
# additional library.  We may however end up with multiple copies of
# this and some confusion at run-time as to which class to use. This
# is an issue when we use NAMESPACES as we may need to export certain
# classes.

######################################################################

if(length(getClassDef("RSWIGStruct")) == 0) 
  setClass("RSWIGStruct", representation("VIRTUAL"))



if(length(getClassDef("ExternalReference")) == 0) 
# Should be virtual but this means it loses its slots currently
#representation("VIRTUAL")
  setClass("ExternalReference", representation( ref = "externalptr"))



if(length(getClassDef("NativeRoutinePointer")) == 0) 
  setClass("NativeRoutinePointer", 
              representation(parameterTypes = "character",
                             returnType = "character",
                             "VIRTUAL"), 
              contains = "ExternalReference")

if(length(getClassDef("CRoutinePointer")) == 0) 
  setClass("CRoutinePointer", contains = "NativeRoutinePointer")


if(length(getClassDef("EnumerationValue")) == 0) 
  setClass("EnumerationValue", contains = "integer")


if(!isGeneric("copyToR")) 
 setGeneric("copyToR",
            function(value, obj = new(gsub("Ref$", "", class(value)))) 
               standardGeneric("copyToR"
           ))

setGeneric("delete", function(obj) standardGeneric("delete"))


SWIG_createNewRef = 
function(className, ..., append = TRUE)
{
  f = get(paste("new", className, sep = "_"), mode = "function")

  f(...)
}

if(!isGeneric("copyToC")) 
 setGeneric("copyToC", 
             function(value, obj = SWIG_createNewRef(class(value)))
              standardGeneric("copyToC"
            ))


# 
defineEnumeration =
function(name, .values, where = topenv(parent.frame()), suffix = "Value")
{
   # Mirror the class definitions via the E analogous to .__C__
  defName = paste(".__E__", name, sep = "")
  assign(defName,  .values,  envir = where)

  if(nchar(suffix))
    name = paste(name, suffix, sep = "")

  setClass(name, contains = "EnumerationValue", where = where)
}

enumToInteger <- function(name,type)
{
   if (is.character(name)) {
   ans <- as.integer(get(paste(".__E__", type, sep = ""))[name])
   if (is.na(ans)) {warning("enum not found ", name, " ", type)}
   ans
   } 
}

enumFromInteger =
function(i,type)
{
  itemlist <- get(paste(".__E__", type, sep=""))
  names(itemlist)[match(i, itemlist)]
}

coerceIfNotSubclass =
function(obj, type) 
{
    if(!is(obj, type)) {as(obj, type)} else obj
}


setClass("SWIGArray", representation(dims = "integer"), contains = "ExternalReference")

setMethod("length", "SWIGArray", function(x) x@dims[1])


defineEnumeration("SCopyReferences",
                   .values = c( "FALSE" = 0, "TRUE" = 1, "DEEP" = 2))

assert = 
function(condition, message = "")
{
  if(!condition)
    stop(message)

  TRUE
}


if(FALSE) {
print.SWIGFunction =
function(x, ...)
 {
 }
}


#######################################################################

R_SWIG_getCallbackFunctionStack =
function()
{
    # No PACKAGE argument as we don't know what the DLL is.
  .Call("R_SWIG_debug_getCallbackFunctionData", PACKAGE="OpenABMCovid19")
}

R_SWIG_addCallbackFunctionStack =
function(fun, userData = NULL)
{
    # No PACKAGE argument as we don't know what the DLL is.
  .Call("R_SWIG_R_pushCallbackFunctionData", PACKAGE="OpenABMCovid19", fun, userData)
}


#######################################################################



setClass('_p_event_list', contains = 'ExternalReference')
setClass("event_list",
    representation(
        type = "integer",
        n_total = "integer",
        n_current = "integer"),
        contains = "RSWIGStruct")


# End class event_list

setClass('_p_directory', contains = 'ExternalReference')
setClass("directory",
    representation(
        n_idx = "integer"),
        contains = "RSWIGStruct")


# End class directory

setClass('_p_model', contains = 'ExternalReference')
setClass("model",
    representation(
        time = "integer",
        interaction_day_idx = "integer",
        n_possible_interactions = "integer",
        n_total_intereactions = "integer",
        n_occupation_networks = "integer",
        use_custom_occupation_networks = "integer",
        n_networks = "integer",
        mean_interactions = "numeric",
        mean_interactions_by_age = "numeric",
        rebuild_networks = "integer",
        manual_trace_interview_quota = "integer",
        manual_trace_notification_quota = "integer",
        n_trace_tokens_used = "integer",
        n_trace_tokens = "integer",
        n_quarantine_days = "integer",
        n_quarantine_app_user = "integer",
        n_quarantine_infected = "integer",
        n_quarantine_recovered = "integer",
        n_quarantine_app_user_infected = "integer",
        n_quarantine_app_user_recovered = "integer",
        n_quarantine_events = "integer",
        n_quarantine_events_app_user = "integer",
        n_quarantine_release_events = "integer",
        n_quarantine_release_events_app_user = "integer",
        n_population_by_age = "integer",
        n_vaccinated_fully = "integer",
        n_vaccinated_symptoms = "integer",
        n_vaccinated_fully_by_age = "integer",
        n_vaccinated_symptoms_by_age = "integer",
        n_initialised_strains = "integer"),
        contains = "RSWIGStruct")


# End class model

setClass('_p_event_block', contains = 'ExternalReference')
setClass("event_block",
    representation(
),
        contains = "RSWIGStruct")


# End class event_block

setClass('_p_event', contains = 'ExternalReference')
setClass("event",
    representation(
        type = "integer",
        time = "integer"),
        contains = "RSWIGStruct")


# End class event

setClass('_p_f_p_model_p_struct_individual__void',
        prototype = list(parameterTypes = c('_p_model', '_p_individual'),
                        returnType = '_p_f_p_model_p_struct_individual__void'),
        contains = 'CRoutinePointer')

##
setClass('_p_f_p_model_p_struct_individual_p_void__void',
        prototype = list(parameterTypes = c('_p_model', '_p_individual', '_p_void'),
                        returnType = '_p_f_p_model_p_struct_individual_p_void__void'),
        contains = 'CRoutinePointer')

##
setClass('_p_parameters', contains = 'ExternalReference')
setClass("parameters",
    representation(
        rng_seed = "integer",
        input_param_file = "character",
        hospital_input_param_file = "character",
        input_household_file = "character",
        output_file_dir = "character",
        param_line_number = "integer",
        hospital_param_line_number = "integer",
        param_id = "integer",
        n_total = "integer",
        days_of_interactions = "integer",
        end_time = "integer",
        n_seed_infection = "integer",
        rebuild_networks = "integer",
        mean_random_interactions = "numeric",
        sd_random_interactions = "numeric",
        random_interaction_distribution = "integer",
        mean_work_interactions = "numeric",
        daily_fraction_work = "numeric",
        child_network_adults = "numeric",
        elderly_network_adults = "numeric",
        work_network_rewire = "numeric",
        mean_infectious_period = "numeric",
        sd_infectious_period = "numeric",
        infectious_rate = "numeric",
        sd_infectiousness_multiplier = "numeric",
        relative_susceptibility = "numeric",
        adjusted_susceptibility = "numeric",
        relative_susceptibility_by_interaction = "integer",
        relative_transmission = "numeric",
        relative_transmission_used = "numeric",
        mean_time_to_symptoms = "numeric",
        sd_time_to_symptoms = "numeric",
        hospitalised_fraction = "numeric",
        critical_fraction = "numeric",
        fatality_fraction = "numeric",
        mean_time_to_hospital = "numeric",
        mean_time_to_critical = "numeric",
        sd_time_to_critical = "numeric",
        mean_time_to_recover = "numeric",
        sd_time_to_recover = "numeric",
        mean_time_to_death = "numeric",
        sd_time_to_death = "numeric",
        mean_time_to_susceptible_after_shift = "numeric",
        time_to_susceptible_shift = "integer",
        household_size = "numeric",
        population = "numeric",
        fraction_asymptomatic = "numeric",
        asymptomatic_infectious_factor = "numeric",
        mild_fraction = "numeric",
        mild_infectious_factor = "numeric",
        mean_asymptomatic_to_recovery = "numeric",
        sd_asymptomatic_to_recovery = "numeric",
        mean_time_hospitalised_recovery = "numeric",
        sd_time_hospitalised_recovery = "numeric",
        mean_time_critical_survive = "numeric",
        sd_time_critical_survive = "numeric",
        location_death_icu = "numeric",
        quarantined_daily_interactions = "integer",
        hospitalised_daily_interactions = "integer",
        quarantine_days = "integer",
        self_quarantine_fraction = "numeric",
        manual_trace_on = "integer",
        manual_trace_time_on = "integer",
        manual_trace_on_hospitalization = "integer",
        manual_trace_on_positive = "integer",
        manual_trace_delay = "integer",
        manual_trace_exclude_app_users = "integer",
        manual_trace_n_workers = "integer",
        manual_trace_interviews_per_worker_day = "integer",
        manual_trace_notifications_per_worker_day = "integer",
        manual_traceable_fraction = "numeric",
        trace_on_symptoms = "integer",
        trace_on_positive = "integer",
        retrace_on_positive = "integer",
        quarantine_length_self = "integer",
        quarantine_length_traced_symptoms = "integer",
        quarantine_length_traced_positive = "integer",
        quarantine_length_positive = "integer",
        quarantine_dropout_self = "numeric",
        quarantine_dropout_traced_symptoms = "numeric",
        quarantine_dropout_traced_positive = "numeric",
        quarantine_dropout_positive = "numeric",
        quarantine_compliance_traced_symptoms = "numeric",
        quarantine_compliance_traced_positive = "numeric",
        quarantine_on_traced = "integer",
        quarantine_smart_release_day = "integer",
        traceable_interaction_fraction = "numeric",
        tracing_network_depth = "integer",
        allow_clinical_diagnosis = "integer",
        quarantine_household_on_symptoms = "integer",
        quarantine_household_on_positive = "integer",
        quarantine_household_on_traced_symptoms = "integer",
        quarantine_household_on_traced_positive = "integer",
        quarantine_household_contacts_on_positive = "integer",
        quarantine_household_contacts_on_symptoms = "integer",
        test_on_symptoms = "integer",
        test_on_traced = "integer",
        test_result_wait = "integer",
        test_order_wait = "integer",
        test_result_wait_priority = "integer",
        test_order_wait_priority = "integer",
        test_release_on_negative = "integer",
        priority_test_contacts = "integer",
        test_insensitive_period = "integer",
        test_sensitive_period = "integer",
        test_sensitivity = "numeric",
        test_specificity = "numeric",
        app_users_fraction = "numeric",
        app_turned_on = "integer",
        app_turn_on_time = "integer",
        daily_non_cov_symptoms_rate = "numeric",
        lockdown_occupation_multiplier = "numeric",
        lockdown_random_network_multiplier = "numeric",
        lockdown_house_interaction_multiplier = "numeric",
        lockdown_time_on = "integer",
        lockdown_time_off = "integer",
        lockdown_on = "integer",
        lockdown_elderly_time_on = "integer",
        lockdown_elderly_time_off = "integer",
        lockdown_elderly_on = "integer",
        testing_symptoms_time_on = "integer",
        testing_symptoms_time_off = "integer",
        interventions_on = "integer",
        intervention_start_time = "integer",
        sys_write_individual = "integer",
        sys_write_hospital = "integer",
        N_REFERENCE_HOUSEHOLDS = "integer",
        hospital_on = "integer",
        n_hospitals = "integer",
        n_wards = "integer",
        n_ward_beds = "integer",
        n_hcw_per_ward = "integer",
        n_patient_required_interactions = "integer",
        max_hcw_daily_interactions = "integer",
        hospitalised_waiting_mod = "numeric",
        critical_waiting_mod = "numeric",
        hcw_mean_work_interactions = "numeric",
        max_n_strains = "integer"),
        contains = "RSWIGStruct")


# End class parameters

setClass('_p_parameters', contains = 'ExternalReference')
setClass('_p_individual', contains = 'ExternalReference')
setClass('_p_individual', contains = 'ExternalReference')
setClass("individual",
    representation(
        idx = "integer",
        house_no = "integer",
        age_group = "integer",
        age_type = "integer",
        occupation_network = "integer",
        base_random_interactions = "integer",
        random_interactions = "integer",
        status = "integer",
        infectiousness_multiplier = "numeric",
        quarantined = "integer",
        quarantine_test_result = "integer",
        traced_on_this_trace = "numeric",
        app_user = "integer",
        ward_idx = "integer",
        ward_type = "integer",
        hospital_idx = "integer",
        hospital_state = "integer",
        disease_progression_predicted = "integer",
        worker_type = "integer",
        vaccine_status = "integer"),
        contains = "RSWIGStruct")


# End class individual

setClass('_p_interaction', contains = 'ExternalReference')
setClass("interaction",
    representation(
        type = "integer",
        network_id = "integer",
        traceable = "integer",
        manual_traceable = "integer"),
        contains = "RSWIGStruct")


# End class interaction

setClass('_p_interaction_block', contains = 'ExternalReference')
setClass("interaction_block",
    representation(
        n_interactions = "integer",
        idx = "integer"),
        contains = "RSWIGStruct")


# End class interaction_block

setClass('_p_infection_event', contains = 'ExternalReference')
setClass("infection_event",
    representation(
        infector_status = "integer",
        infector_hospital_state = "integer",
        infector_network = "integer",
        time_infected_infector = "integer",
        is_case = "integer",
        network_id = "integer",
        expected_hospitalisation = "numeric"),
        contains = "RSWIGStruct")


# End class infection_event

setClass('_p_trace_token_block', contains = 'ExternalReference')
setClass("trace_token_block",
    representation(
),
        contains = "RSWIGStruct")


# End class trace_token_block

setClass('_p_trace_token', contains = 'ExternalReference')
setClass("trace_token",
    representation(
        contact_time = "integer",
        index_status = "integer"),
        contains = "RSWIGStruct")


# End class trace_token

setClass('_p_vaccine', contains = 'ExternalReference')
setClass("vaccine",
    representation(
        idx = "integer",
        time_to_protect = "integer",
        vaccine_protection_period = "integer",
        is_full = "integer",
        is_symptoms = "integer",
        is_severe = "integer",
        n_strains = "integer",
        name = "character"),
        contains = "RSWIGStruct")


# End class vaccine

setClass('_p_incomplete_gamma_p_params', contains = 'ExternalReference')
setClass("incomplete_gamma_p_params",
    representation(
        n = "integer",
        percentile = "numeric"),
        contains = "RSWIGStruct")


# End class incomplete_gamma_p_params

setClass('_p_network', contains = 'ExternalReference')
setClass('_p_edge', contains = 'ExternalReference')
setClass("edge",
    representation(
        id1 = "integer",
        id2 = "integer"),
        contains = "RSWIGStruct")


# End class edge

setClass('_p_network', contains = 'ExternalReference')
setClass("network",
    representation(
        n_edges = "integer",
        n_vertices = "integer",
        type = "integer",
        skip_hospitalised = "integer",
        skip_quarantined = "integer",
        daily_fraction = "numeric",
        network_id = "integer",
        name = "character",
        transmission_multiplier = "numeric",
        construction = "integer",
        opt_n_indiv = "integer",
        opt_long = "integer"),
        contains = "RSWIGStruct")


# End class network

setClass('_p_strain', contains = 'ExternalReference')
setClass('_p_strain', contains = 'ExternalReference')
setClass("strain",
    representation(
        idx = "integer",
        transmission_multiplier = "numeric",
        hospitalised_fraction = "numeric"),
        contains = "RSWIGStruct")


# End class strain

setClass('_p_doubleArray', contains = 'ExternalReference')
setClass("doubleArray",
    representation(
),
        contains = "RSWIGStruct")


# End class doubleArray

setClass('_p_doubleArray', contains = 'ExternalReference')
setClass('_p_intArray', contains = 'ExternalReference')
setClass("intArray",
    representation(
),
        contains = "RSWIGStruct")


# End class intArray

setClass('_p_intArray', contains = 'ExternalReference')
setClass('_p_longArray', contains = 'ExternalReference')
setClass("longArray",
    representation(
),
        contains = "RSWIGStruct")


# End class longArray

setClass('_p_longArray', contains = 'ExternalReference')
setClass('_p_shortArray', contains = 'ExternalReference')
setClass("shortArray",
    representation(
),
        contains = "RSWIGStruct")


# End class shortArray

setClass('_p_shortArray', contains = 'ExternalReference')
setClass('_p_floatArray', contains = 'ExternalReference')
setClass("floatArray",
    representation(
),
        contains = "RSWIGStruct")


# End class floatArray

setClass('_p_floatArray', contains = 'ExternalReference')



setMethod('[', "ExternalReference",
function(x,i,j, ..., drop=TRUE) 
if (!is.null(x$"__getitem__")) 
sapply(i, function(n) x$"__getitem__"(i=as.integer(n-1))))

setMethod('[<-' , "ExternalReference",
function(x,i,j, ..., value) 
if (!is.null(x$"__setitem__")) {
sapply(1:length(i), function(n) 
x$"__setitem__"(i=as.integer(i[n]-1), x=value[n]))
x
})

setAs('ExternalReference', 'character',
function(from) {if (!is.null(from$"__str__")) from$"__str__"()})

suppressMessages(suppressWarnings(setMethod('print', 'ExternalReference',
function(x) {print(as(x, "character"))})))

# Start of event_list_type_set

`event_list_type_set` = function(self, s_type)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_type = as.integer(s_type);
  
  if(length(s_type) > 1) {
    warning("using only the first element of s_type");
  };
  
  ;.Call('R_swig_event_list_type_set', self, s_type, PACKAGE='OpenABMCovid19');
  
}

attr(`event_list_type_set`, 'returnType') = 'void'
attr(`event_list_type_set`, "inputTypes") = c('_p_event_list', 'integer')
class(`event_list_type_set`) = c("SWIGFunction", class('event_list_type_set'))

# Start of event_list_type_get

`event_list_type_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_event_list_type_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`event_list_type_get`, 'returnType') = 'integer'
attr(`event_list_type_get`, "inputTypes") = c('_p_event_list')
class(`event_list_type_get`) = c("SWIGFunction", class('event_list_type_get'))

# Start of event_list_events_set

`event_list_events_set` = function(self, s_events)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_events, "ExternalReference")) s_events = slot(s_events,"ref") 
  ;.Call('R_swig_event_list_events_set', self, s_events, PACKAGE='OpenABMCovid19');
  
}

attr(`event_list_events_set`, 'returnType') = 'void'
attr(`event_list_events_set`, "inputTypes") = c('_p_event_list', '_p_p_event')
class(`event_list_events_set`) = c("SWIGFunction", class('event_list_events_set'))

# Start of event_list_events_get

`event_list_events_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_event_list_events_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_p_event", ref=ans) ;
  
  ans
  
}

attr(`event_list_events_get`, 'returnType') = '_p_p_event'
attr(`event_list_events_get`, "inputTypes") = c('_p_event_list')
class(`event_list_events_get`) = c("SWIGFunction", class('event_list_events_get'))

# Start of event_list_n_daily_set

`event_list_n_daily_set` = function(self, s_n_daily)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_daily = as.integer(s_n_daily);
  ;.Call('R_swig_event_list_n_daily_set', self, s_n_daily, PACKAGE='OpenABMCovid19');
  
}

attr(`event_list_n_daily_set`, 'returnType') = 'void'
attr(`event_list_n_daily_set`, "inputTypes") = c('_p_event_list', 'integer')
class(`event_list_n_daily_set`) = c("SWIGFunction", class('event_list_n_daily_set'))

# Start of event_list_n_daily_get

`event_list_n_daily_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_event_list_n_daily_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_long", ref=ans) ;
  
  ans
  
}

attr(`event_list_n_daily_get`, 'returnType') = 'integer'
attr(`event_list_n_daily_get`, "inputTypes") = c('_p_event_list')
class(`event_list_n_daily_get`) = c("SWIGFunction", class('event_list_n_daily_get'))

# Start of event_list_n_daily_by_age_set

`event_list_n_daily_by_age_set` = function(self, s_n_daily_by_age)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_n_daily_by_age, "ExternalReference")) s_n_daily_by_age = slot(s_n_daily_by_age,"ref") 
  ;.Call('R_swig_event_list_n_daily_by_age_set', self, s_n_daily_by_age, PACKAGE='OpenABMCovid19');
  
}

attr(`event_list_n_daily_by_age_set`, 'returnType') = 'void'
attr(`event_list_n_daily_by_age_set`, "inputTypes") = c('_p_event_list', '_p_p_long')
class(`event_list_n_daily_by_age_set`) = c("SWIGFunction", class('event_list_n_daily_by_age_set'))

# Start of event_list_n_daily_by_age_get

`event_list_n_daily_by_age_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_event_list_n_daily_by_age_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_p_long", ref=ans) ;
  
  ans
  
}

attr(`event_list_n_daily_by_age_get`, 'returnType') = '_p_p_long'
attr(`event_list_n_daily_by_age_get`, "inputTypes") = c('_p_event_list')
class(`event_list_n_daily_by_age_get`) = c("SWIGFunction", class('event_list_n_daily_by_age_get'))

# Start of event_list_n_daily_current_set

`event_list_n_daily_current_set` = function(self, s_n_daily_current)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_daily_current = as.integer(s_n_daily_current);
  ;.Call('R_swig_event_list_n_daily_current_set', self, s_n_daily_current, PACKAGE='OpenABMCovid19');
  
}

attr(`event_list_n_daily_current_set`, 'returnType') = 'void'
attr(`event_list_n_daily_current_set`, "inputTypes") = c('_p_event_list', 'integer')
class(`event_list_n_daily_current_set`) = c("SWIGFunction", class('event_list_n_daily_current_set'))

# Start of event_list_n_daily_current_get

`event_list_n_daily_current_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_event_list_n_daily_current_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_long", ref=ans) ;
  
  ans
  
}

attr(`event_list_n_daily_current_get`, 'returnType') = 'integer'
attr(`event_list_n_daily_current_get`, "inputTypes") = c('_p_event_list')
class(`event_list_n_daily_current_get`) = c("SWIGFunction", class('event_list_n_daily_current_get'))

# Start of event_list_n_total_set

`event_list_n_total_set` = function(self, s_n_total)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_total = as.integer(s_n_total);
  
  if(length(s_n_total) > 1) {
    warning("using only the first element of s_n_total");
  };
  
  ;.Call('R_swig_event_list_n_total_set', self, s_n_total, PACKAGE='OpenABMCovid19');
  
}

attr(`event_list_n_total_set`, 'returnType') = 'void'
attr(`event_list_n_total_set`, "inputTypes") = c('_p_event_list', 'integer')
class(`event_list_n_total_set`) = c("SWIGFunction", class('event_list_n_total_set'))

# Start of event_list_n_total_get

`event_list_n_total_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_event_list_n_total_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`event_list_n_total_get`, 'returnType') = 'integer'
attr(`event_list_n_total_get`, "inputTypes") = c('_p_event_list')
class(`event_list_n_total_get`) = c("SWIGFunction", class('event_list_n_total_get'))

# Start of event_list_n_total_by_age_set

`event_list_n_total_by_age_set` = function(self, s_n_total_by_age)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_total_by_age = as.integer(s_n_total_by_age);
  ;.Call('R_swig_event_list_n_total_by_age_set', self, s_n_total_by_age, PACKAGE='OpenABMCovid19');
  
}

attr(`event_list_n_total_by_age_set`, 'returnType') = 'void'
attr(`event_list_n_total_by_age_set`, "inputTypes") = c('_p_event_list', 'integer')
class(`event_list_n_total_by_age_set`) = c("SWIGFunction", class('event_list_n_total_by_age_set'))

# Start of event_list_n_total_by_age_get

`event_list_n_total_by_age_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_event_list_n_total_by_age_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_long", ref=ans) ;
  
  ans
  
}

attr(`event_list_n_total_by_age_get`, 'returnType') = 'integer'
attr(`event_list_n_total_by_age_get`, "inputTypes") = c('_p_event_list')
class(`event_list_n_total_by_age_get`) = c("SWIGFunction", class('event_list_n_total_by_age_get'))

# Start of event_list_n_current_set

`event_list_n_current_set` = function(self, s_n_current)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_current = as.integer(s_n_current);
  
  if(length(s_n_current) > 1) {
    warning("using only the first element of s_n_current");
  };
  
  ;.Call('R_swig_event_list_n_current_set', self, s_n_current, PACKAGE='OpenABMCovid19');
  
}

attr(`event_list_n_current_set`, 'returnType') = 'void'
attr(`event_list_n_current_set`, "inputTypes") = c('_p_event_list', 'integer')
class(`event_list_n_current_set`) = c("SWIGFunction", class('event_list_n_current_set'))

# Start of event_list_n_current_get

`event_list_n_current_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_event_list_n_current_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`event_list_n_current_get`, 'returnType') = 'integer'
attr(`event_list_n_current_get`, "inputTypes") = c('_p_event_list')
class(`event_list_n_current_get`) = c("SWIGFunction", class('event_list_n_current_get'))

# Start of event_list_infectious_curve_set

`event_list_infectious_curve_set` = function(self, s_infectious_curve)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_infectious_curve, "ExternalReference")) s_infectious_curve = slot(s_infectious_curve,"ref") 
  ;.Call('R_swig_event_list_infectious_curve_set', self, s_infectious_curve, PACKAGE='OpenABMCovid19');
  
}

attr(`event_list_infectious_curve_set`, 'returnType') = 'void'
attr(`event_list_infectious_curve_set`, "inputTypes") = c('_p_event_list', '_p_p_double')
class(`event_list_infectious_curve_set`) = c("SWIGFunction", class('event_list_infectious_curve_set'))

# Start of event_list_infectious_curve_get

`event_list_infectious_curve_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_event_list_infectious_curve_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_p_double", ref=ans) ;
  
  ans
  
}

attr(`event_list_infectious_curve_get`, 'returnType') = '_p_p_double'
attr(`event_list_infectious_curve_get`, "inputTypes") = c('_p_event_list')
class(`event_list_infectious_curve_get`) = c("SWIGFunction", class('event_list_infectious_curve_get'))

# Start of accessor method for event_list
setMethod('$', '_p_event_list', function(x, name)

{
  accessorFuns = list('type' = event_list_type_get, 'events' = event_list_events_get, 'n_daily' = event_list_n_daily_get, 'n_daily_by_age' = event_list_n_daily_by_age_get, 'n_daily_current' = event_list_n_daily_current_get, 'n_total' = event_list_n_total_get, 'n_total_by_age' = event_list_n_total_by_age_get, 'n_current' = event_list_n_current_get, 'infectious_curve' = event_list_infectious_curve_get);
  vaccessors = c('type', 'events', 'n_daily', 'n_daily_by_age', 'n_daily_current', 'n_total', 'n_total_by_age', 'n_current', 'infectious_curve');
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  if (is.na(match(name, vaccessors))) function(...){
    f(x, ...)
  } else f(x);
}


);
# end of accessor method for event_list
# Start of accessor method for event_list
setMethod('$<-', '_p_event_list', function(x, name, value)

{
  accessorFuns = list('type' = event_list_type_set, 'events' = event_list_events_set, 'n_daily' = event_list_n_daily_set, 'n_daily_by_age' = event_list_n_daily_by_age_set, 'n_daily_current' = event_list_n_daily_current_set, 'n_total' = event_list_n_total_set, 'n_total_by_age' = event_list_n_total_by_age_set, 'n_current' = event_list_n_current_set, 'infectious_curve' = event_list_infectious_curve_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
setMethod('[[<-', c('_p_event_list', 'character'),function(x, i, j, ..., value)

{
  name = i;
  accessorFuns = list('type' = event_list_type_set, 'events' = event_list_events_set, 'n_daily' = event_list_n_daily_set, 'n_daily_by_age' = event_list_n_daily_by_age_set, 'n_daily_current' = event_list_n_daily_current_set, 'n_total' = event_list_n_total_set, 'n_total_by_age' = event_list_n_total_by_age_set, 'n_current' = event_list_n_current_set, 'infectious_curve' = event_list_infectious_curve_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
# end of accessor method for event_list
# Start definition of copy functions & methods for event_list
CopyToR_event_list = function(value, obj = new("event_list"))
{
  obj@type = value$type;
  obj@n_total = value$n_total;
  obj@n_current = value$n_current;
  obj;
}



CopyToC_event_list = function(value, obj)
{
  obj$type = value@type;
  obj$n_total = value@n_total;
  obj$n_current = value@n_current;
  obj
}



# Start definition of copy methods for event_list
setMethod('copyToR', '_p_event_list', CopyToR_event_list);
setMethod('copyToC', 'event_list', CopyToC_event_list);

# End definition of copy methods for event_list
# End definition of copy functions & methods for event_list
# Start of directory_n_idx_set

`directory_n_idx_set` = function(self, s_n_idx)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_idx = as.integer(s_n_idx);
  
  if(length(s_n_idx) > 1) {
    warning("using only the first element of s_n_idx");
  };
  
  ;.Call('R_swig_directory_n_idx_set', self, s_n_idx, PACKAGE='OpenABMCovid19');
  
}

attr(`directory_n_idx_set`, 'returnType') = 'void'
attr(`directory_n_idx_set`, "inputTypes") = c('_p_directory', 'integer')
class(`directory_n_idx_set`) = c("SWIGFunction", class('directory_n_idx_set'))

# Start of directory_n_idx_get

`directory_n_idx_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_directory_n_idx_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`directory_n_idx_get`, 'returnType') = 'integer'
attr(`directory_n_idx_get`, "inputTypes") = c('_p_directory')
class(`directory_n_idx_get`) = c("SWIGFunction", class('directory_n_idx_get'))

# Start of directory_n_jdx_set

`directory_n_jdx_set` = function(self, s_n_jdx)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_jdx = as.integer(s_n_jdx);
  ;.Call('R_swig_directory_n_jdx_set', self, s_n_jdx, PACKAGE='OpenABMCovid19');
  
}

attr(`directory_n_jdx_set`, 'returnType') = 'void'
attr(`directory_n_jdx_set`, "inputTypes") = c('_p_directory', 'integer')
class(`directory_n_jdx_set`) = c("SWIGFunction", class('directory_n_jdx_set'))

# Start of directory_n_jdx_get

`directory_n_jdx_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_directory_n_jdx_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_int", ref=ans) ;
  
  ans
  
}

attr(`directory_n_jdx_get`, 'returnType') = 'integer'
attr(`directory_n_jdx_get`, "inputTypes") = c('_p_directory')
class(`directory_n_jdx_get`) = c("SWIGFunction", class('directory_n_jdx_get'))

# Start of directory_val_set

`directory_val_set` = function(self, s_val)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_val, "ExternalReference")) s_val = slot(s_val,"ref") 
  ;.Call('R_swig_directory_val_set', self, s_val, PACKAGE='OpenABMCovid19');
  
}

attr(`directory_val_set`, 'returnType') = 'void'
attr(`directory_val_set`, "inputTypes") = c('_p_directory', '_p_p_long')
class(`directory_val_set`) = c("SWIGFunction", class('directory_val_set'))

# Start of directory_val_get

`directory_val_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_directory_val_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_p_long", ref=ans) ;
  
  ans
  
}

attr(`directory_val_get`, 'returnType') = '_p_p_long'
attr(`directory_val_get`, "inputTypes") = c('_p_directory')
class(`directory_val_get`) = c("SWIGFunction", class('directory_val_get'))

# Start of accessor method for directory
setMethod('$', '_p_directory', function(x, name)

{
  accessorFuns = list('n_idx' = directory_n_idx_get, 'n_jdx' = directory_n_jdx_get, 'val' = directory_val_get);
  vaccessors = c('n_idx', 'n_jdx', 'val');
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  if (is.na(match(name, vaccessors))) function(...){
    f(x, ...)
  } else f(x);
}


);
# end of accessor method for directory
# Start of accessor method for directory
setMethod('$<-', '_p_directory', function(x, name, value)

{
  accessorFuns = list('n_idx' = directory_n_idx_set, 'n_jdx' = directory_n_jdx_set, 'val' = directory_val_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
setMethod('[[<-', c('_p_directory', 'character'),function(x, i, j, ..., value)

{
  name = i;
  accessorFuns = list('n_idx' = directory_n_idx_set, 'n_jdx' = directory_n_jdx_set, 'val' = directory_val_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
# end of accessor method for directory
# Start definition of copy functions & methods for directory
CopyToR_directory = function(value, obj = new("directory"))
{
  obj@n_idx = value$n_idx;
  obj;
}



CopyToC_directory = function(value, obj)
{
  obj$n_idx = value@n_idx;
  obj
}



# Start definition of copy methods for directory
setMethod('copyToR', '_p_directory', CopyToR_directory);
setMethod('copyToC', 'directory', CopyToC_directory);

# End definition of copy methods for directory
# End definition of copy functions & methods for directory
# Start of model_params_set

`model_params_set` = function(self, s_params)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_params, "ExternalReference")) s_params = slot(s_params,"ref") 
  ;.Call('R_swig_model_params_set', self, s_params, PACKAGE='OpenABMCovid19');
  
}

attr(`model_params_set`, 'returnType') = 'void'
attr(`model_params_set`, "inputTypes") = c('_p_model', '_p_parameters')
class(`model_params_set`) = c("SWIGFunction", class('model_params_set'))

# Start of model_params_get

`model_params_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_params_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_parameters", ref=ans) ;
  
  ans
  
}

attr(`model_params_get`, 'returnType') = '_p_parameters'
attr(`model_params_get`, "inputTypes") = c('_p_model')
class(`model_params_get`) = c("SWIGFunction", class('model_params_get'))

# Start of model_population_set

`model_population_set` = function(self, s_population)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_population, "ExternalReference")) s_population = slot(s_population,"ref") 
  ;.Call('R_swig_model_population_set', self, s_population, PACKAGE='OpenABMCovid19');
  
}

attr(`model_population_set`, 'returnType') = 'void'
attr(`model_population_set`, "inputTypes") = c('_p_model', '_p_individual')
class(`model_population_set`) = c("SWIGFunction", class('model_population_set'))

# Start of model_population_get

`model_population_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_population_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_individual", ref=ans) ;
  
  ans
  
}

attr(`model_population_get`, 'returnType') = '_p_individual'
attr(`model_population_get`, "inputTypes") = c('_p_model')
class(`model_population_get`) = c("SWIGFunction", class('model_population_get'))

# Start of model_time_set

`model_time_set` = function(self, s_time)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_time = as.integer(s_time);
  
  if(length(s_time) > 1) {
    warning("using only the first element of s_time");
  };
  
  ;.Call('R_swig_model_time_set', self, s_time, PACKAGE='OpenABMCovid19');
  
}

attr(`model_time_set`, 'returnType') = 'void'
attr(`model_time_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_time_set`) = c("SWIGFunction", class('model_time_set'))

# Start of model_time_get

`model_time_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_time_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_time_get`, 'returnType') = 'integer'
attr(`model_time_get`, "inputTypes") = c('_p_model')
class(`model_time_get`) = c("SWIGFunction", class('model_time_get'))

# Start of model_interaction_blocks_set

`model_interaction_blocks_set` = function(self, s_interaction_blocks)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_interaction_blocks, "ExternalReference")) s_interaction_blocks = slot(s_interaction_blocks,"ref") 
  ;.Call('R_swig_model_interaction_blocks_set', self, s_interaction_blocks, PACKAGE='OpenABMCovid19');
  
}

attr(`model_interaction_blocks_set`, 'returnType') = 'void'
attr(`model_interaction_blocks_set`, "inputTypes") = c('_p_model', '_p_p_interaction_block')
class(`model_interaction_blocks_set`) = c("SWIGFunction", class('model_interaction_blocks_set'))

# Start of model_interaction_blocks_get

`model_interaction_blocks_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_interaction_blocks_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_p_interaction_block", ref=ans) ;
  
  ans
  
}

attr(`model_interaction_blocks_get`, 'returnType') = '_p_p_interaction_block'
attr(`model_interaction_blocks_get`, "inputTypes") = c('_p_model')
class(`model_interaction_blocks_get`) = c("SWIGFunction", class('model_interaction_blocks_get'))

# Start of model_interaction_day_idx_set

`model_interaction_day_idx_set` = function(self, s_interaction_day_idx)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_interaction_day_idx = as.integer(s_interaction_day_idx);
  
  if(length(s_interaction_day_idx) > 1) {
    warning("using only the first element of s_interaction_day_idx");
  };
  
  ;.Call('R_swig_model_interaction_day_idx_set', self, s_interaction_day_idx, PACKAGE='OpenABMCovid19');
  
}

attr(`model_interaction_day_idx_set`, 'returnType') = 'void'
attr(`model_interaction_day_idx_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_interaction_day_idx_set`) = c("SWIGFunction", class('model_interaction_day_idx_set'))

# Start of model_interaction_day_idx_get

`model_interaction_day_idx_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_interaction_day_idx_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_interaction_day_idx_get`, 'returnType') = 'integer'
attr(`model_interaction_day_idx_get`, "inputTypes") = c('_p_model')
class(`model_interaction_day_idx_get`) = c("SWIGFunction", class('model_interaction_day_idx_get'))

# Start of model_possible_interactions_set

`model_possible_interactions_set` = function(self, s_possible_interactions)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_possible_interactions = as.integer(s_possible_interactions);
  ;.Call('R_swig_model_possible_interactions_set', self, s_possible_interactions, PACKAGE='OpenABMCovid19');
  
}

attr(`model_possible_interactions_set`, 'returnType') = 'void'
attr(`model_possible_interactions_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_possible_interactions_set`) = c("SWIGFunction", class('model_possible_interactions_set'))

# Start of model_possible_interactions_get

`model_possible_interactions_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_possible_interactions_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_long", ref=ans) ;
  
  ans
  
}

attr(`model_possible_interactions_get`, 'returnType') = 'integer'
attr(`model_possible_interactions_get`, "inputTypes") = c('_p_model')
class(`model_possible_interactions_get`) = c("SWIGFunction", class('model_possible_interactions_get'))

# Start of model_n_possible_interactions_set

`model_n_possible_interactions_set` = function(self, s_n_possible_interactions)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_possible_interactions = as.integer(s_n_possible_interactions);
  
  if(length(s_n_possible_interactions) > 1) {
    warning("using only the first element of s_n_possible_interactions");
  };
  
  ;.Call('R_swig_model_n_possible_interactions_set', self, s_n_possible_interactions, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_possible_interactions_set`, 'returnType') = 'void'
attr(`model_n_possible_interactions_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_possible_interactions_set`) = c("SWIGFunction", class('model_n_possible_interactions_set'))

# Start of model_n_possible_interactions_get

`model_n_possible_interactions_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_n_possible_interactions_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_possible_interactions_get`, 'returnType') = 'integer'
attr(`model_n_possible_interactions_get`, "inputTypes") = c('_p_model')
class(`model_n_possible_interactions_get`) = c("SWIGFunction", class('model_n_possible_interactions_get'))

# Start of model_n_total_intereactions_set

`model_n_total_intereactions_set` = function(self, s_n_total_intereactions)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_total_intereactions = as.integer(s_n_total_intereactions);
  
  if(length(s_n_total_intereactions) > 1) {
    warning("using only the first element of s_n_total_intereactions");
  };
  
  ;.Call('R_swig_model_n_total_intereactions_set', self, s_n_total_intereactions, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_total_intereactions_set`, 'returnType') = 'void'
attr(`model_n_total_intereactions_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_total_intereactions_set`) = c("SWIGFunction", class('model_n_total_intereactions_set'))

# Start of model_n_total_intereactions_get

`model_n_total_intereactions_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_n_total_intereactions_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_total_intereactions_get`, 'returnType') = 'integer'
attr(`model_n_total_intereactions_get`, "inputTypes") = c('_p_model')
class(`model_n_total_intereactions_get`) = c("SWIGFunction", class('model_n_total_intereactions_get'))

# Start of model_n_occupation_networks_set

`model_n_occupation_networks_set` = function(self, s_n_occupation_networks)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_occupation_networks = as.integer(s_n_occupation_networks);
  
  if(length(s_n_occupation_networks) > 1) {
    warning("using only the first element of s_n_occupation_networks");
  };
  
  ;.Call('R_swig_model_n_occupation_networks_set', self, s_n_occupation_networks, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_occupation_networks_set`, 'returnType') = 'void'
attr(`model_n_occupation_networks_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_occupation_networks_set`) = c("SWIGFunction", class('model_n_occupation_networks_set'))

# Start of model_n_occupation_networks_get

`model_n_occupation_networks_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_n_occupation_networks_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_occupation_networks_get`, 'returnType') = 'integer'
attr(`model_n_occupation_networks_get`, "inputTypes") = c('_p_model')
class(`model_n_occupation_networks_get`) = c("SWIGFunction", class('model_n_occupation_networks_get'))

# Start of model_random_network_set

`model_random_network_set` = function(self, s_random_network)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_random_network, "ExternalReference")) s_random_network = slot(s_random_network,"ref") 
  ;.Call('R_swig_model_random_network_set', self, s_random_network, PACKAGE='OpenABMCovid19');
  
}

attr(`model_random_network_set`, 'returnType') = 'void'
attr(`model_random_network_set`, "inputTypes") = c('_p_model', '_p_network')
class(`model_random_network_set`) = c("SWIGFunction", class('model_random_network_set'))

# Start of model_random_network_get

`model_random_network_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_random_network_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_network", ref=ans) ;
  
  ans
  
}

attr(`model_random_network_get`, 'returnType') = '_p_network'
attr(`model_random_network_get`, "inputTypes") = c('_p_model')
class(`model_random_network_get`) = c("SWIGFunction", class('model_random_network_get'))

# Start of model_household_network_set

`model_household_network_set` = function(self, s_household_network)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_household_network, "ExternalReference")) s_household_network = slot(s_household_network,"ref") 
  ;.Call('R_swig_model_household_network_set', self, s_household_network, PACKAGE='OpenABMCovid19');
  
}

attr(`model_household_network_set`, 'returnType') = 'void'
attr(`model_household_network_set`, "inputTypes") = c('_p_model', '_p_network')
class(`model_household_network_set`) = c("SWIGFunction", class('model_household_network_set'))

# Start of model_household_network_get

`model_household_network_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_household_network_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_network", ref=ans) ;
  
  ans
  
}

attr(`model_household_network_get`, 'returnType') = '_p_network'
attr(`model_household_network_get`, "inputTypes") = c('_p_model')
class(`model_household_network_get`) = c("SWIGFunction", class('model_household_network_get'))

# Start of model_use_custom_occupation_networks_set

`model_use_custom_occupation_networks_set` = function(self, s_use_custom_occupation_networks)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_use_custom_occupation_networks = as.integer(s_use_custom_occupation_networks);
  
  if(length(s_use_custom_occupation_networks) > 1) {
    warning("using only the first element of s_use_custom_occupation_networks");
  };
  
  ;.Call('R_swig_model_use_custom_occupation_networks_set', self, s_use_custom_occupation_networks, PACKAGE='OpenABMCovid19');
  
}

attr(`model_use_custom_occupation_networks_set`, 'returnType') = 'void'
attr(`model_use_custom_occupation_networks_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_use_custom_occupation_networks_set`) = c("SWIGFunction", class('model_use_custom_occupation_networks_set'))

# Start of model_use_custom_occupation_networks_get

`model_use_custom_occupation_networks_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_use_custom_occupation_networks_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_use_custom_occupation_networks_get`, 'returnType') = 'integer'
attr(`model_use_custom_occupation_networks_get`, "inputTypes") = c('_p_model')
class(`model_use_custom_occupation_networks_get`) = c("SWIGFunction", class('model_use_custom_occupation_networks_get'))

# Start of model_occupation_network_set

`model_occupation_network_set` = function(self, s_occupation_network)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_occupation_network, "ExternalReference")) s_occupation_network = slot(s_occupation_network,"ref") 
  ;.Call('R_swig_model_occupation_network_set', self, s_occupation_network, PACKAGE='OpenABMCovid19');
  
}

attr(`model_occupation_network_set`, 'returnType') = 'void'
attr(`model_occupation_network_set`, "inputTypes") = c('_p_model', '_p_p_network')
class(`model_occupation_network_set`) = c("SWIGFunction", class('model_occupation_network_set'))

# Start of model_occupation_network_get

`model_occupation_network_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_occupation_network_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_p_network", ref=ans) ;
  
  ans
  
}

attr(`model_occupation_network_get`, 'returnType') = '_p_p_network'
attr(`model_occupation_network_get`, "inputTypes") = c('_p_model')
class(`model_occupation_network_get`) = c("SWIGFunction", class('model_occupation_network_get'))

# Start of model_household_directory_set

`model_household_directory_set` = function(self, s_household_directory)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_household_directory, "ExternalReference")) s_household_directory = slot(s_household_directory,"ref") 
  ;.Call('R_swig_model_household_directory_set', self, s_household_directory, PACKAGE='OpenABMCovid19');
  
}

attr(`model_household_directory_set`, 'returnType') = 'void'
attr(`model_household_directory_set`, "inputTypes") = c('_p_model', '_p_directory')
class(`model_household_directory_set`) = c("SWIGFunction", class('model_household_directory_set'))

# Start of model_household_directory_get

`model_household_directory_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_household_directory_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_directory", ref=ans) ;
  
  ans
  
}

attr(`model_household_directory_get`, 'returnType') = '_p_directory'
attr(`model_household_directory_get`, "inputTypes") = c('_p_model')
class(`model_household_directory_get`) = c("SWIGFunction", class('model_household_directory_get'))

# Start of model_user_network_set

`model_user_network_set` = function(self, s_user_network)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_user_network, "ExternalReference")) s_user_network = slot(s_user_network,"ref") 
  ;.Call('R_swig_model_user_network_set', self, s_user_network, PACKAGE='OpenABMCovid19');
  
}

attr(`model_user_network_set`, 'returnType') = 'void'
attr(`model_user_network_set`, "inputTypes") = c('_p_model', '_p_network')
class(`model_user_network_set`) = c("SWIGFunction", class('model_user_network_set'))

# Start of model_user_network_get

`model_user_network_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_user_network_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_network", ref=ans) ;
  
  ans
  
}

attr(`model_user_network_get`, 'returnType') = '_p_network'
attr(`model_user_network_get`, "inputTypes") = c('_p_model')
class(`model_user_network_get`) = c("SWIGFunction", class('model_user_network_get'))

# Start of model_n_networks_set

`model_n_networks_set` = function(self, s_n_networks)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_networks = as.integer(s_n_networks);
  
  if(length(s_n_networks) > 1) {
    warning("using only the first element of s_n_networks");
  };
  
  ;.Call('R_swig_model_n_networks_set', self, s_n_networks, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_networks_set`, 'returnType') = 'void'
attr(`model_n_networks_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_networks_set`) = c("SWIGFunction", class('model_n_networks_set'))

# Start of model_n_networks_get

`model_n_networks_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_n_networks_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_networks_get`, 'returnType') = 'integer'
attr(`model_n_networks_get`, "inputTypes") = c('_p_model')
class(`model_n_networks_get`) = c("SWIGFunction", class('model_n_networks_get'))

# Start of model_all_networks_set

`model_all_networks_set` = function(self, s_all_networks)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_all_networks, "ExternalReference")) s_all_networks = slot(s_all_networks,"ref") 
  ;.Call('R_swig_model_all_networks_set', self, s_all_networks, PACKAGE='OpenABMCovid19');
  
}

attr(`model_all_networks_set`, 'returnType') = 'void'
attr(`model_all_networks_set`, "inputTypes") = c('_p_model', '_p_p_network')
class(`model_all_networks_set`) = c("SWIGFunction", class('model_all_networks_set'))

# Start of model_all_networks_get

`model_all_networks_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_all_networks_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_p_network", ref=ans) ;
  
  ans
  
}

attr(`model_all_networks_get`, 'returnType') = '_p_p_network'
attr(`model_all_networks_get`, "inputTypes") = c('_p_model')
class(`model_all_networks_get`) = c("SWIGFunction", class('model_all_networks_get'))

# Start of model_mean_interactions_set

`model_mean_interactions_set` = function(self, s_mean_interactions)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_model_mean_interactions_set', self, s_mean_interactions, PACKAGE='OpenABMCovid19');
  
}

attr(`model_mean_interactions_set`, 'returnType') = 'void'
attr(`model_mean_interactions_set`, "inputTypes") = c('_p_model', 'numeric')
class(`model_mean_interactions_set`) = c("SWIGFunction", class('model_mean_interactions_set'))

# Start of model_mean_interactions_get

`model_mean_interactions_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_mean_interactions_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_mean_interactions_get`, 'returnType') = 'numeric'
attr(`model_mean_interactions_get`, "inputTypes") = c('_p_model')
class(`model_mean_interactions_get`) = c("SWIGFunction", class('model_mean_interactions_get'))

# Start of model_mean_interactions_by_age_set

`model_mean_interactions_by_age_set` = function(self, s_mean_interactions_by_age)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  
#  assert(length(s_mean_interactions_by_age) >= N_AGE_TYPES)
  
  ;.Call('R_swig_model_mean_interactions_by_age_set', self, s_mean_interactions_by_age, PACKAGE='OpenABMCovid19');
  
}

attr(`model_mean_interactions_by_age_set`, 'returnType') = 'void'
attr(`model_mean_interactions_by_age_set`, "inputTypes") = c('_p_model', 'numeric')
class(`model_mean_interactions_by_age_set`) = c("SWIGFunction", class('model_mean_interactions_by_age_set'))

# Start of model_mean_interactions_by_age_get

`model_mean_interactions_by_age_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_mean_interactions_by_age_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_mean_interactions_by_age_get`, 'returnType') = 'numeric'
attr(`model_mean_interactions_by_age_get`, "inputTypes") = c('_p_model')
class(`model_mean_interactions_by_age_get`) = c("SWIGFunction", class('model_mean_interactions_by_age_get'))

# Start of model_rebuild_networks_set

`model_rebuild_networks_set` = function(self, s_rebuild_networks)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_rebuild_networks = as.integer(s_rebuild_networks);
  
  if(length(s_rebuild_networks) > 1) {
    warning("using only the first element of s_rebuild_networks");
  };
  
  ;.Call('R_swig_model_rebuild_networks_set', self, s_rebuild_networks, PACKAGE='OpenABMCovid19');
  
}

attr(`model_rebuild_networks_set`, 'returnType') = 'void'
attr(`model_rebuild_networks_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_rebuild_networks_set`) = c("SWIGFunction", class('model_rebuild_networks_set'))

# Start of model_rebuild_networks_get

`model_rebuild_networks_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_rebuild_networks_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_rebuild_networks_get`, 'returnType') = 'integer'
attr(`model_rebuild_networks_get`, "inputTypes") = c('_p_model')
class(`model_rebuild_networks_get`) = c("SWIGFunction", class('model_rebuild_networks_get'))

# Start of model_manual_trace_interview_quota_set

`model_manual_trace_interview_quota_set` = function(self, s_manual_trace_interview_quota)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_manual_trace_interview_quota = as.integer(s_manual_trace_interview_quota);
  
  if(length(s_manual_trace_interview_quota) > 1) {
    warning("using only the first element of s_manual_trace_interview_quota");
  };
  
  ;.Call('R_swig_model_manual_trace_interview_quota_set', self, s_manual_trace_interview_quota, PACKAGE='OpenABMCovid19');
  
}

attr(`model_manual_trace_interview_quota_set`, 'returnType') = 'void'
attr(`model_manual_trace_interview_quota_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_manual_trace_interview_quota_set`) = c("SWIGFunction", class('model_manual_trace_interview_quota_set'))

# Start of model_manual_trace_interview_quota_get

`model_manual_trace_interview_quota_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_manual_trace_interview_quota_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_manual_trace_interview_quota_get`, 'returnType') = 'integer'
attr(`model_manual_trace_interview_quota_get`, "inputTypes") = c('_p_model')
class(`model_manual_trace_interview_quota_get`) = c("SWIGFunction", class('model_manual_trace_interview_quota_get'))

# Start of model_manual_trace_notification_quota_set

`model_manual_trace_notification_quota_set` = function(self, s_manual_trace_notification_quota)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_manual_trace_notification_quota = as.integer(s_manual_trace_notification_quota);
  
  if(length(s_manual_trace_notification_quota) > 1) {
    warning("using only the first element of s_manual_trace_notification_quota");
  };
  
  ;.Call('R_swig_model_manual_trace_notification_quota_set', self, s_manual_trace_notification_quota, PACKAGE='OpenABMCovid19');
  
}

attr(`model_manual_trace_notification_quota_set`, 'returnType') = 'void'
attr(`model_manual_trace_notification_quota_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_manual_trace_notification_quota_set`) = c("SWIGFunction", class('model_manual_trace_notification_quota_set'))

# Start of model_manual_trace_notification_quota_get

`model_manual_trace_notification_quota_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_manual_trace_notification_quota_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_manual_trace_notification_quota_get`, 'returnType') = 'integer'
attr(`model_manual_trace_notification_quota_get`, "inputTypes") = c('_p_model')
class(`model_manual_trace_notification_quota_get`) = c("SWIGFunction", class('model_manual_trace_notification_quota_get'))

# Start of model_event_block_set

`model_event_block_set` = function(self, s_event_block)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_event_block, "ExternalReference")) s_event_block = slot(s_event_block,"ref") 
  ;.Call('R_swig_model_event_block_set', self, s_event_block, PACKAGE='OpenABMCovid19');
  
}

attr(`model_event_block_set`, 'returnType') = 'void'
attr(`model_event_block_set`, "inputTypes") = c('_p_model', '_p_event_block')
class(`model_event_block_set`) = c("SWIGFunction", class('model_event_block_set'))

# Start of model_event_block_get

`model_event_block_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_event_block_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_event_block", ref=ans) ;
  
  ans
  
}

attr(`model_event_block_get`, 'returnType') = '_p_event_block'
attr(`model_event_block_get`, "inputTypes") = c('_p_model')
class(`model_event_block_get`) = c("SWIGFunction", class('model_event_block_get'))

# Start of model_next_event_set

`model_next_event_set` = function(self, s_next_event)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_next_event, "ExternalReference")) s_next_event = slot(s_next_event,"ref") 
  ;.Call('R_swig_model_next_event_set', self, s_next_event, PACKAGE='OpenABMCovid19');
  
}

attr(`model_next_event_set`, 'returnType') = 'void'
attr(`model_next_event_set`, "inputTypes") = c('_p_model', '_p_event')
class(`model_next_event_set`) = c("SWIGFunction", class('model_next_event_set'))

# Start of model_next_event_get

`model_next_event_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_next_event_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_event", ref=ans) ;
  
  ans
  
}

attr(`model_next_event_get`, 'returnType') = '_p_event'
attr(`model_next_event_get`, "inputTypes") = c('_p_model')
class(`model_next_event_get`) = c("SWIGFunction", class('model_next_event_get'))

# Start of model_event_lists_set

`model_event_lists_set` = function(self, s_event_lists)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_event_lists, "ExternalReference")) s_event_lists = slot(s_event_lists,"ref") 
  ;.Call('R_swig_model_event_lists_set', self, s_event_lists, PACKAGE='OpenABMCovid19');
  
}

attr(`model_event_lists_set`, 'returnType') = 'void'
attr(`model_event_lists_set`, "inputTypes") = c('_p_model', '_p_event_list')
class(`model_event_lists_set`) = c("SWIGFunction", class('model_event_lists_set'))

# Start of model_event_lists_get

`model_event_lists_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_event_lists_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_event_list", ref=ans) ;
  
  ans
  
}

attr(`model_event_lists_get`, 'returnType') = '_p_event_list'
attr(`model_event_lists_get`, "inputTypes") = c('_p_model')
class(`model_event_lists_get`) = c("SWIGFunction", class('model_event_lists_get'))

# Start of model_trace_token_block_set

`model_trace_token_block_set` = function(self, s_trace_token_block)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_trace_token_block, "ExternalReference")) s_trace_token_block = slot(s_trace_token_block,"ref") 
  ;.Call('R_swig_model_trace_token_block_set', self, s_trace_token_block, PACKAGE='OpenABMCovid19');
  
}

attr(`model_trace_token_block_set`, 'returnType') = 'void'
attr(`model_trace_token_block_set`, "inputTypes") = c('_p_model', '_p_trace_token_block')
class(`model_trace_token_block_set`) = c("SWIGFunction", class('model_trace_token_block_set'))

# Start of model_trace_token_block_get

`model_trace_token_block_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_trace_token_block_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_trace_token_block", ref=ans) ;
  
  ans
  
}

attr(`model_trace_token_block_get`, 'returnType') = '_p_trace_token_block'
attr(`model_trace_token_block_get`, "inputTypes") = c('_p_model')
class(`model_trace_token_block_get`) = c("SWIGFunction", class('model_trace_token_block_get'))

# Start of model_next_trace_token_set

`model_next_trace_token_set` = function(self, s_next_trace_token)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_next_trace_token, "ExternalReference")) s_next_trace_token = slot(s_next_trace_token,"ref") 
  ;.Call('R_swig_model_next_trace_token_set', self, s_next_trace_token, PACKAGE='OpenABMCovid19');
  
}

attr(`model_next_trace_token_set`, 'returnType') = 'void'
attr(`model_next_trace_token_set`, "inputTypes") = c('_p_model', '_p_trace_token')
class(`model_next_trace_token_set`) = c("SWIGFunction", class('model_next_trace_token_set'))

# Start of model_next_trace_token_get

`model_next_trace_token_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_next_trace_token_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_trace_token", ref=ans) ;
  
  ans
  
}

attr(`model_next_trace_token_get`, 'returnType') = '_p_trace_token'
attr(`model_next_trace_token_get`, "inputTypes") = c('_p_model')
class(`model_next_trace_token_get`) = c("SWIGFunction", class('model_next_trace_token_get'))

# Start of model_n_trace_tokens_used_set

`model_n_trace_tokens_used_set` = function(self, s_n_trace_tokens_used)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_trace_tokens_used = as.integer(s_n_trace_tokens_used);
  
  if(length(s_n_trace_tokens_used) > 1) {
    warning("using only the first element of s_n_trace_tokens_used");
  };
  
  ;.Call('R_swig_model_n_trace_tokens_used_set', self, s_n_trace_tokens_used, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_trace_tokens_used_set`, 'returnType') = 'void'
attr(`model_n_trace_tokens_used_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_trace_tokens_used_set`) = c("SWIGFunction", class('model_n_trace_tokens_used_set'))

# Start of model_n_trace_tokens_used_get

`model_n_trace_tokens_used_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_n_trace_tokens_used_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_trace_tokens_used_get`, 'returnType') = 'integer'
attr(`model_n_trace_tokens_used_get`, "inputTypes") = c('_p_model')
class(`model_n_trace_tokens_used_get`) = c("SWIGFunction", class('model_n_trace_tokens_used_get'))

# Start of model_n_trace_tokens_set

`model_n_trace_tokens_set` = function(self, s_n_trace_tokens)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_trace_tokens = as.integer(s_n_trace_tokens);
  
  if(length(s_n_trace_tokens) > 1) {
    warning("using only the first element of s_n_trace_tokens");
  };
  
  ;.Call('R_swig_model_n_trace_tokens_set', self, s_n_trace_tokens, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_trace_tokens_set`, 'returnType') = 'void'
attr(`model_n_trace_tokens_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_trace_tokens_set`) = c("SWIGFunction", class('model_n_trace_tokens_set'))

# Start of model_n_trace_tokens_get

`model_n_trace_tokens_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_n_trace_tokens_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_trace_tokens_get`, 'returnType') = 'integer'
attr(`model_n_trace_tokens_get`, "inputTypes") = c('_p_model')
class(`model_n_trace_tokens_get`) = c("SWIGFunction", class('model_n_trace_tokens_get'))

# Start of model_transition_time_distributions_set

`model_transition_time_distributions_set` = function(self, s_transition_time_distributions)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_transition_time_distributions, "ExternalReference")) s_transition_time_distributions = slot(s_transition_time_distributions,"ref") 
  ;.Call('R_swig_model_transition_time_distributions_set', self, s_transition_time_distributions, PACKAGE='OpenABMCovid19');
  
}

attr(`model_transition_time_distributions_set`, 'returnType') = 'void'
attr(`model_transition_time_distributions_set`, "inputTypes") = c('_p_model', '_p_p_int')
class(`model_transition_time_distributions_set`) = c("SWIGFunction", class('model_transition_time_distributions_set'))

# Start of model_transition_time_distributions_get

`model_transition_time_distributions_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_transition_time_distributions_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_p_int", ref=ans) ;
  
  ans
  
}

attr(`model_transition_time_distributions_get`, 'returnType') = '_p_p_int'
attr(`model_transition_time_distributions_get`, "inputTypes") = c('_p_model')
class(`model_transition_time_distributions_get`) = c("SWIGFunction", class('model_transition_time_distributions_get'))

# Start of model_n_quarantine_days_set

`model_n_quarantine_days_set` = function(self, s_n_quarantine_days)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_quarantine_days = as.integer(s_n_quarantine_days);
  
  if(length(s_n_quarantine_days) > 1) {
    warning("using only the first element of s_n_quarantine_days");
  };
  
  ;.Call('R_swig_model_n_quarantine_days_set', self, s_n_quarantine_days, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_quarantine_days_set`, 'returnType') = 'void'
attr(`model_n_quarantine_days_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_quarantine_days_set`) = c("SWIGFunction", class('model_n_quarantine_days_set'))

# Start of model_n_quarantine_days_get

`model_n_quarantine_days_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_n_quarantine_days_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_quarantine_days_get`, 'returnType') = 'integer'
attr(`model_n_quarantine_days_get`, "inputTypes") = c('_p_model')
class(`model_n_quarantine_days_get`) = c("SWIGFunction", class('model_n_quarantine_days_get'))

# Start of model_n_quarantine_app_user_set

`model_n_quarantine_app_user_set` = function(self, s_n_quarantine_app_user)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_quarantine_app_user = as.integer(s_n_quarantine_app_user);
  
  if(length(s_n_quarantine_app_user) > 1) {
    warning("using only the first element of s_n_quarantine_app_user");
  };
  
  ;.Call('R_swig_model_n_quarantine_app_user_set', self, s_n_quarantine_app_user, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_quarantine_app_user_set`, 'returnType') = 'void'
attr(`model_n_quarantine_app_user_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_quarantine_app_user_set`) = c("SWIGFunction", class('model_n_quarantine_app_user_set'))

# Start of model_n_quarantine_app_user_get

`model_n_quarantine_app_user_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_n_quarantine_app_user_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_quarantine_app_user_get`, 'returnType') = 'integer'
attr(`model_n_quarantine_app_user_get`, "inputTypes") = c('_p_model')
class(`model_n_quarantine_app_user_get`) = c("SWIGFunction", class('model_n_quarantine_app_user_get'))

# Start of model_n_quarantine_infected_set

`model_n_quarantine_infected_set` = function(self, s_n_quarantine_infected)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_quarantine_infected = as.integer(s_n_quarantine_infected);
  
  if(length(s_n_quarantine_infected) > 1) {
    warning("using only the first element of s_n_quarantine_infected");
  };
  
  ;.Call('R_swig_model_n_quarantine_infected_set', self, s_n_quarantine_infected, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_quarantine_infected_set`, 'returnType') = 'void'
attr(`model_n_quarantine_infected_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_quarantine_infected_set`) = c("SWIGFunction", class('model_n_quarantine_infected_set'))

# Start of model_n_quarantine_infected_get

`model_n_quarantine_infected_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_n_quarantine_infected_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_quarantine_infected_get`, 'returnType') = 'integer'
attr(`model_n_quarantine_infected_get`, "inputTypes") = c('_p_model')
class(`model_n_quarantine_infected_get`) = c("SWIGFunction", class('model_n_quarantine_infected_get'))

# Start of model_n_quarantine_recovered_set

`model_n_quarantine_recovered_set` = function(self, s_n_quarantine_recovered)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_quarantine_recovered = as.integer(s_n_quarantine_recovered);
  
  if(length(s_n_quarantine_recovered) > 1) {
    warning("using only the first element of s_n_quarantine_recovered");
  };
  
  ;.Call('R_swig_model_n_quarantine_recovered_set', self, s_n_quarantine_recovered, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_quarantine_recovered_set`, 'returnType') = 'void'
attr(`model_n_quarantine_recovered_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_quarantine_recovered_set`) = c("SWIGFunction", class('model_n_quarantine_recovered_set'))

# Start of model_n_quarantine_recovered_get

`model_n_quarantine_recovered_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_n_quarantine_recovered_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_quarantine_recovered_get`, 'returnType') = 'integer'
attr(`model_n_quarantine_recovered_get`, "inputTypes") = c('_p_model')
class(`model_n_quarantine_recovered_get`) = c("SWIGFunction", class('model_n_quarantine_recovered_get'))

# Start of model_n_quarantine_app_user_infected_set

`model_n_quarantine_app_user_infected_set` = function(self, s_n_quarantine_app_user_infected)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_quarantine_app_user_infected = as.integer(s_n_quarantine_app_user_infected);
  
  if(length(s_n_quarantine_app_user_infected) > 1) {
    warning("using only the first element of s_n_quarantine_app_user_infected");
  };
  
  ;.Call('R_swig_model_n_quarantine_app_user_infected_set', self, s_n_quarantine_app_user_infected, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_quarantine_app_user_infected_set`, 'returnType') = 'void'
attr(`model_n_quarantine_app_user_infected_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_quarantine_app_user_infected_set`) = c("SWIGFunction", class('model_n_quarantine_app_user_infected_set'))

# Start of model_n_quarantine_app_user_infected_get

`model_n_quarantine_app_user_infected_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_n_quarantine_app_user_infected_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_quarantine_app_user_infected_get`, 'returnType') = 'integer'
attr(`model_n_quarantine_app_user_infected_get`, "inputTypes") = c('_p_model')
class(`model_n_quarantine_app_user_infected_get`) = c("SWIGFunction", class('model_n_quarantine_app_user_infected_get'))

# Start of model_n_quarantine_app_user_recovered_set

`model_n_quarantine_app_user_recovered_set` = function(self, s_n_quarantine_app_user_recovered)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_quarantine_app_user_recovered = as.integer(s_n_quarantine_app_user_recovered);
  
  if(length(s_n_quarantine_app_user_recovered) > 1) {
    warning("using only the first element of s_n_quarantine_app_user_recovered");
  };
  
  ;.Call('R_swig_model_n_quarantine_app_user_recovered_set', self, s_n_quarantine_app_user_recovered, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_quarantine_app_user_recovered_set`, 'returnType') = 'void'
attr(`model_n_quarantine_app_user_recovered_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_quarantine_app_user_recovered_set`) = c("SWIGFunction", class('model_n_quarantine_app_user_recovered_set'))

# Start of model_n_quarantine_app_user_recovered_get

`model_n_quarantine_app_user_recovered_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_n_quarantine_app_user_recovered_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_quarantine_app_user_recovered_get`, 'returnType') = 'integer'
attr(`model_n_quarantine_app_user_recovered_get`, "inputTypes") = c('_p_model')
class(`model_n_quarantine_app_user_recovered_get`) = c("SWIGFunction", class('model_n_quarantine_app_user_recovered_get'))

# Start of model_n_quarantine_events_set

`model_n_quarantine_events_set` = function(self, s_n_quarantine_events)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_quarantine_events = as.integer(s_n_quarantine_events);
  
  if(length(s_n_quarantine_events) > 1) {
    warning("using only the first element of s_n_quarantine_events");
  };
  
  ;.Call('R_swig_model_n_quarantine_events_set', self, s_n_quarantine_events, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_quarantine_events_set`, 'returnType') = 'void'
attr(`model_n_quarantine_events_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_quarantine_events_set`) = c("SWIGFunction", class('model_n_quarantine_events_set'))

# Start of model_n_quarantine_events_get

`model_n_quarantine_events_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_n_quarantine_events_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_quarantine_events_get`, 'returnType') = 'integer'
attr(`model_n_quarantine_events_get`, "inputTypes") = c('_p_model')
class(`model_n_quarantine_events_get`) = c("SWIGFunction", class('model_n_quarantine_events_get'))

# Start of model_n_quarantine_events_app_user_set

`model_n_quarantine_events_app_user_set` = function(self, s_n_quarantine_events_app_user)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_quarantine_events_app_user = as.integer(s_n_quarantine_events_app_user);
  
  if(length(s_n_quarantine_events_app_user) > 1) {
    warning("using only the first element of s_n_quarantine_events_app_user");
  };
  
  ;.Call('R_swig_model_n_quarantine_events_app_user_set', self, s_n_quarantine_events_app_user, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_quarantine_events_app_user_set`, 'returnType') = 'void'
attr(`model_n_quarantine_events_app_user_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_quarantine_events_app_user_set`) = c("SWIGFunction", class('model_n_quarantine_events_app_user_set'))

# Start of model_n_quarantine_events_app_user_get

`model_n_quarantine_events_app_user_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_n_quarantine_events_app_user_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_quarantine_events_app_user_get`, 'returnType') = 'integer'
attr(`model_n_quarantine_events_app_user_get`, "inputTypes") = c('_p_model')
class(`model_n_quarantine_events_app_user_get`) = c("SWIGFunction", class('model_n_quarantine_events_app_user_get'))

# Start of model_n_quarantine_release_events_set

`model_n_quarantine_release_events_set` = function(self, s_n_quarantine_release_events)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_quarantine_release_events = as.integer(s_n_quarantine_release_events);
  
  if(length(s_n_quarantine_release_events) > 1) {
    warning("using only the first element of s_n_quarantine_release_events");
  };
  
  ;.Call('R_swig_model_n_quarantine_release_events_set', self, s_n_quarantine_release_events, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_quarantine_release_events_set`, 'returnType') = 'void'
attr(`model_n_quarantine_release_events_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_quarantine_release_events_set`) = c("SWIGFunction", class('model_n_quarantine_release_events_set'))

# Start of model_n_quarantine_release_events_get

`model_n_quarantine_release_events_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_n_quarantine_release_events_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_quarantine_release_events_get`, 'returnType') = 'integer'
attr(`model_n_quarantine_release_events_get`, "inputTypes") = c('_p_model')
class(`model_n_quarantine_release_events_get`) = c("SWIGFunction", class('model_n_quarantine_release_events_get'))

# Start of model_n_quarantine_release_events_app_user_set

`model_n_quarantine_release_events_app_user_set` = function(self, s_n_quarantine_release_events_app_user)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_quarantine_release_events_app_user = as.integer(s_n_quarantine_release_events_app_user);
  
  if(length(s_n_quarantine_release_events_app_user) > 1) {
    warning("using only the first element of s_n_quarantine_release_events_app_user");
  };
  
  ;.Call('R_swig_model_n_quarantine_release_events_app_user_set', self, s_n_quarantine_release_events_app_user, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_quarantine_release_events_app_user_set`, 'returnType') = 'void'
attr(`model_n_quarantine_release_events_app_user_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_quarantine_release_events_app_user_set`) = c("SWIGFunction", class('model_n_quarantine_release_events_app_user_set'))

# Start of model_n_quarantine_release_events_app_user_get

`model_n_quarantine_release_events_app_user_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_n_quarantine_release_events_app_user_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_quarantine_release_events_app_user_get`, 'returnType') = 'integer'
attr(`model_n_quarantine_release_events_app_user_get`, "inputTypes") = c('_p_model')
class(`model_n_quarantine_release_events_app_user_get`) = c("SWIGFunction", class('model_n_quarantine_release_events_app_user_get'))

# Start of model_n_population_by_age_set

`model_n_population_by_age_set` = function(self, s_n_population_by_age)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_population_by_age = as.integer(s_n_population_by_age);
  
#  assert(length(s_n_population_by_age) >= N_AGE_GROUPS)
  
  ;.Call('R_swig_model_n_population_by_age_set', self, s_n_population_by_age, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_population_by_age_set`, 'returnType') = 'void'
attr(`model_n_population_by_age_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_population_by_age_set`) = c("SWIGFunction", class('model_n_population_by_age_set'))

# Start of model_n_population_by_age_get

`model_n_population_by_age_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_n_population_by_age_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  ans <- new("_p_long", ref=ans) ;
  
  ans
  
}

attr(`model_n_population_by_age_get`, 'returnType') = 'integer'
attr(`model_n_population_by_age_get`, "inputTypes") = c('_p_model')
class(`model_n_population_by_age_get`) = c("SWIGFunction", class('model_n_population_by_age_get'))

# Start of model_n_vaccinated_fully_set

`model_n_vaccinated_fully_set` = function(self, s_n_vaccinated_fully)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_vaccinated_fully = as.integer(s_n_vaccinated_fully);
  
  if(length(s_n_vaccinated_fully) > 1) {
    warning("using only the first element of s_n_vaccinated_fully");
  };
  
  ;.Call('R_swig_model_n_vaccinated_fully_set', self, s_n_vaccinated_fully, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_vaccinated_fully_set`, 'returnType') = 'void'
attr(`model_n_vaccinated_fully_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_vaccinated_fully_set`) = c("SWIGFunction", class('model_n_vaccinated_fully_set'))

# Start of model_n_vaccinated_fully_get

`model_n_vaccinated_fully_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_n_vaccinated_fully_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_vaccinated_fully_get`, 'returnType') = 'integer'
attr(`model_n_vaccinated_fully_get`, "inputTypes") = c('_p_model')
class(`model_n_vaccinated_fully_get`) = c("SWIGFunction", class('model_n_vaccinated_fully_get'))

# Start of model_n_vaccinated_symptoms_set

`model_n_vaccinated_symptoms_set` = function(self, s_n_vaccinated_symptoms)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_vaccinated_symptoms = as.integer(s_n_vaccinated_symptoms);
  
  if(length(s_n_vaccinated_symptoms) > 1) {
    warning("using only the first element of s_n_vaccinated_symptoms");
  };
  
  ;.Call('R_swig_model_n_vaccinated_symptoms_set', self, s_n_vaccinated_symptoms, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_vaccinated_symptoms_set`, 'returnType') = 'void'
attr(`model_n_vaccinated_symptoms_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_vaccinated_symptoms_set`) = c("SWIGFunction", class('model_n_vaccinated_symptoms_set'))

# Start of model_n_vaccinated_symptoms_get

`model_n_vaccinated_symptoms_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_n_vaccinated_symptoms_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_vaccinated_symptoms_get`, 'returnType') = 'integer'
attr(`model_n_vaccinated_symptoms_get`, "inputTypes") = c('_p_model')
class(`model_n_vaccinated_symptoms_get`) = c("SWIGFunction", class('model_n_vaccinated_symptoms_get'))

# Start of model_n_vaccinated_fully_by_age_set

`model_n_vaccinated_fully_by_age_set` = function(self, s_n_vaccinated_fully_by_age)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_vaccinated_fully_by_age = as.integer(s_n_vaccinated_fully_by_age);
  
#  assert(length(s_n_vaccinated_fully_by_age) >= N_AGE_GROUPS)
  
  ;.Call('R_swig_model_n_vaccinated_fully_by_age_set', self, s_n_vaccinated_fully_by_age, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_vaccinated_fully_by_age_set`, 'returnType') = 'void'
attr(`model_n_vaccinated_fully_by_age_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_vaccinated_fully_by_age_set`) = c("SWIGFunction", class('model_n_vaccinated_fully_by_age_set'))

# Start of model_n_vaccinated_fully_by_age_get

`model_n_vaccinated_fully_by_age_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_n_vaccinated_fully_by_age_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  ans <- new("_p_long", ref=ans) ;
  
  ans
  
}

attr(`model_n_vaccinated_fully_by_age_get`, 'returnType') = 'integer'
attr(`model_n_vaccinated_fully_by_age_get`, "inputTypes") = c('_p_model')
class(`model_n_vaccinated_fully_by_age_get`) = c("SWIGFunction", class('model_n_vaccinated_fully_by_age_get'))

# Start of model_n_vaccinated_symptoms_by_age_set

`model_n_vaccinated_symptoms_by_age_set` = function(self, s_n_vaccinated_symptoms_by_age)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_vaccinated_symptoms_by_age = as.integer(s_n_vaccinated_symptoms_by_age);
  
#  assert(length(s_n_vaccinated_symptoms_by_age) >= N_AGE_GROUPS)
  
  ;.Call('R_swig_model_n_vaccinated_symptoms_by_age_set', self, s_n_vaccinated_symptoms_by_age, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_vaccinated_symptoms_by_age_set`, 'returnType') = 'void'
attr(`model_n_vaccinated_symptoms_by_age_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_vaccinated_symptoms_by_age_set`) = c("SWIGFunction", class('model_n_vaccinated_symptoms_by_age_set'))

# Start of model_n_vaccinated_symptoms_by_age_get

`model_n_vaccinated_symptoms_by_age_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_n_vaccinated_symptoms_by_age_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  ans <- new("_p_long", ref=ans) ;
  
  ans
  
}

attr(`model_n_vaccinated_symptoms_by_age_get`, 'returnType') = 'integer'
attr(`model_n_vaccinated_symptoms_by_age_get`, "inputTypes") = c('_p_model')
class(`model_n_vaccinated_symptoms_by_age_get`) = c("SWIGFunction", class('model_n_vaccinated_symptoms_by_age_get'))

# Start of model_hospitals_set

`model_hospitals_set` = function(self, s_hospitals)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_hospitals, "ExternalReference")) s_hospitals = slot(s_hospitals,"ref") 
  ;.Call('R_swig_model_hospitals_set', self, s_hospitals, PACKAGE='OpenABMCovid19');
  
}

attr(`model_hospitals_set`, 'returnType') = 'void'
attr(`model_hospitals_set`, "inputTypes") = c('_p_model', '_p_hospital')
class(`model_hospitals_set`) = c("SWIGFunction", class('model_hospitals_set'))

# Start of model_hospitals_get

`model_hospitals_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_hospitals_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_hospital", ref=ans) ;
  
  ans
  
}

attr(`model_hospitals_get`, 'returnType') = '_p_hospital'
attr(`model_hospitals_get`, "inputTypes") = c('_p_model')
class(`model_hospitals_get`) = c("SWIGFunction", class('model_hospitals_get'))

# Start of model_strains_set

`model_strains_set` = function(self, s_strains)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_strains, "ExternalReference")) s_strains = slot(s_strains,"ref") 
  ;.Call('R_swig_model_strains_set', self, s_strains, PACKAGE='OpenABMCovid19');
  
}

attr(`model_strains_set`, 'returnType') = 'void'
attr(`model_strains_set`, "inputTypes") = c('_p_model', '_p_strain')
class(`model_strains_set`) = c("SWIGFunction", class('model_strains_set'))

# Start of model_strains_get

`model_strains_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_strains_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_strain", ref=ans) ;
  
  ans
  
}

attr(`model_strains_get`, 'returnType') = '_p_strain'
attr(`model_strains_get`, "inputTypes") = c('_p_model')
class(`model_strains_get`) = c("SWIGFunction", class('model_strains_get'))

# Start of model_n_initialised_strains_set

`model_n_initialised_strains_set` = function(self, s_n_initialised_strains)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_initialised_strains = as.integer(s_n_initialised_strains);
  
  if(length(s_n_initialised_strains) > 1) {
    warning("using only the first element of s_n_initialised_strains");
  };
  
  ;.Call('R_swig_model_n_initialised_strains_set', self, s_n_initialised_strains, PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_initialised_strains_set`, 'returnType') = 'void'
attr(`model_n_initialised_strains_set`, "inputTypes") = c('_p_model', 'integer')
class(`model_n_initialised_strains_set`) = c("SWIGFunction", class('model_n_initialised_strains_set'))

# Start of model_n_initialised_strains_get

`model_n_initialised_strains_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_model_n_initialised_strains_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`model_n_initialised_strains_get`, 'returnType') = 'integer'
attr(`model_n_initialised_strains_get`, "inputTypes") = c('_p_model')
class(`model_n_initialised_strains_get`) = c("SWIGFunction", class('model_n_initialised_strains_get'))

# Start of model_cross_immunity_set

`model_cross_immunity_set` = function(self, s_cross_immunity)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_cross_immunity, "ExternalReference")) s_cross_immunity = slot(s_cross_immunity,"ref") 
  ;.Call('R_swig_model_cross_immunity_set', self, s_cross_immunity, PACKAGE='OpenABMCovid19');
  
}

attr(`model_cross_immunity_set`, 'returnType') = 'void'
attr(`model_cross_immunity_set`, "inputTypes") = c('_p_model', '_p_p_float')
class(`model_cross_immunity_set`) = c("SWIGFunction", class('model_cross_immunity_set'))

# Start of model_cross_immunity_get

`model_cross_immunity_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_cross_immunity_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_p_float", ref=ans) ;
  
  ans
  
}

attr(`model_cross_immunity_get`, 'returnType') = '_p_p_float'
attr(`model_cross_immunity_get`, "inputTypes") = c('_p_model')
class(`model_cross_immunity_get`) = c("SWIGFunction", class('model_cross_immunity_get'))

# Start of model_vaccines_set

`model_vaccines_set` = function(self, s_vaccines)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_vaccines, "ExternalReference")) s_vaccines = slot(s_vaccines,"ref") 
  ;.Call('R_swig_model_vaccines_set', self, s_vaccines, PACKAGE='OpenABMCovid19');
  
}

attr(`model_vaccines_set`, 'returnType') = 'void'
attr(`model_vaccines_set`, "inputTypes") = c('_p_model', '_p_vaccine')
class(`model_vaccines_set`) = c("SWIGFunction", class('model_vaccines_set'))

# Start of model_vaccines_get

`model_vaccines_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_model_vaccines_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_vaccine", ref=ans) ;
  
  ans
  
}

attr(`model_vaccines_get`, 'returnType') = '_p_vaccine'
attr(`model_vaccines_get`, "inputTypes") = c('_p_model')
class(`model_vaccines_get`) = c("SWIGFunction", class('model_vaccines_get'))

# Start of delete_model

`delete_model` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_delete_model', self, PACKAGE='OpenABMCovid19');
  
}

attr(`delete_model`, 'returnType') = 'void'
attr(`delete_model`, "inputTypes") = c('_p_model')
class(`delete_model`) = c("SWIGFunction", class('delete_model'))

# Start of new_model

`model` = function(.copy = FALSE)
{
  ;ans = .Call('R_swig_new_model', as.logical(.copy), PACKAGE='OpenABMCovid19');
  ans <- new("_p_model", ref=ans) ;
  
  reg.finalizer(ans@ref, delete_model)
  ans
  
}

attr(`model`, 'returnType') = '_p_model'
class(`model`) = c("SWIGFunction", class('model'))

# Start of accessor method for model
setMethod('$', '_p_model', function(x, name)

{
  accessorFuns = list('params' = model_params_get, 'population' = model_population_get, 'time' = model_time_get, 'interaction_blocks' = model_interaction_blocks_get, 'interaction_day_idx' = model_interaction_day_idx_get, 'possible_interactions' = model_possible_interactions_get, 'n_possible_interactions' = model_n_possible_interactions_get, 'n_total_intereactions' = model_n_total_intereactions_get, 'n_occupation_networks' = model_n_occupation_networks_get, 'random_network' = model_random_network_get, 'household_network' = model_household_network_get, 'use_custom_occupation_networks' = model_use_custom_occupation_networks_get, 'occupation_network' = model_occupation_network_get, 'household_directory' = model_household_directory_get, 'user_network' = model_user_network_get, 'n_networks' = model_n_networks_get, 'all_networks' = model_all_networks_get, 'mean_interactions' = model_mean_interactions_get, 'mean_interactions_by_age' = model_mean_interactions_by_age_get, 'rebuild_networks' = model_rebuild_networks_get, 'manual_trace_interview_quota' = model_manual_trace_interview_quota_get, 'manual_trace_notification_quota' = model_manual_trace_notification_quota_get, 'event_block' = model_event_block_get, 'next_event' = model_next_event_get, 'event_lists' = model_event_lists_get, 'trace_token_block' = model_trace_token_block_get, 'next_trace_token' = model_next_trace_token_get, 'n_trace_tokens_used' = model_n_trace_tokens_used_get, 'n_trace_tokens' = model_n_trace_tokens_get, 'transition_time_distributions' = model_transition_time_distributions_get, 'n_quarantine_days' = model_n_quarantine_days_get, 'n_quarantine_app_user' = model_n_quarantine_app_user_get, 'n_quarantine_infected' = model_n_quarantine_infected_get, 'n_quarantine_recovered' = model_n_quarantine_recovered_get, 'n_quarantine_app_user_infected' = model_n_quarantine_app_user_infected_get, 'n_quarantine_app_user_recovered' = model_n_quarantine_app_user_recovered_get, 'n_quarantine_events' = model_n_quarantine_events_get, 'n_quarantine_events_app_user' = model_n_quarantine_events_app_user_get, 'n_quarantine_release_events' = model_n_quarantine_release_events_get, 'n_quarantine_release_events_app_user' = model_n_quarantine_release_events_app_user_get, 'n_population_by_age' = model_n_population_by_age_get, 'n_vaccinated_fully' = model_n_vaccinated_fully_get, 'n_vaccinated_symptoms' = model_n_vaccinated_symptoms_get, 'n_vaccinated_fully_by_age' = model_n_vaccinated_fully_by_age_get, 'n_vaccinated_symptoms_by_age' = model_n_vaccinated_symptoms_by_age_get, 'hospitals' = model_hospitals_get, 'strains' = model_strains_get, 'n_initialised_strains' = model_n_initialised_strains_get, 'cross_immunity' = model_cross_immunity_get, 'vaccines' = model_vaccines_get);
  vaccessors = c('params', 'population', 'time', 'interaction_blocks', 'interaction_day_idx', 'possible_interactions', 'n_possible_interactions', 'n_total_intereactions', 'n_occupation_networks', 'random_network', 'household_network', 'use_custom_occupation_networks', 'occupation_network', 'household_directory', 'user_network', 'n_networks', 'all_networks', 'mean_interactions', 'mean_interactions_by_age', 'rebuild_networks', 'manual_trace_interview_quota', 'manual_trace_notification_quota', 'event_block', 'next_event', 'event_lists', 'trace_token_block', 'next_trace_token', 'n_trace_tokens_used', 'n_trace_tokens', 'transition_time_distributions', 'n_quarantine_days', 'n_quarantine_app_user', 'n_quarantine_infected', 'n_quarantine_recovered', 'n_quarantine_app_user_infected', 'n_quarantine_app_user_recovered', 'n_quarantine_events', 'n_quarantine_events_app_user', 'n_quarantine_release_events', 'n_quarantine_release_events_app_user', 'n_population_by_age', 'n_vaccinated_fully', 'n_vaccinated_symptoms', 'n_vaccinated_fully_by_age', 'n_vaccinated_symptoms_by_age', 'hospitals', 'strains', 'n_initialised_strains', 'cross_immunity', 'vaccines');
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  if (is.na(match(name, vaccessors))) function(...){
    f(x, ...)
  } else f(x);
}


);
# end of accessor method for model
# Start of accessor method for model
setMethod('$<-', '_p_model', function(x, name, value)

{
  accessorFuns = list('params' = model_params_set, 'population' = model_population_set, 'time' = model_time_set, 'interaction_blocks' = model_interaction_blocks_set, 'interaction_day_idx' = model_interaction_day_idx_set, 'possible_interactions' = model_possible_interactions_set, 'n_possible_interactions' = model_n_possible_interactions_set, 'n_total_intereactions' = model_n_total_intereactions_set, 'n_occupation_networks' = model_n_occupation_networks_set, 'random_network' = model_random_network_set, 'household_network' = model_household_network_set, 'use_custom_occupation_networks' = model_use_custom_occupation_networks_set, 'occupation_network' = model_occupation_network_set, 'household_directory' = model_household_directory_set, 'user_network' = model_user_network_set, 'n_networks' = model_n_networks_set, 'all_networks' = model_all_networks_set, 'mean_interactions' = model_mean_interactions_set, 'mean_interactions_by_age' = model_mean_interactions_by_age_set, 'rebuild_networks' = model_rebuild_networks_set, 'manual_trace_interview_quota' = model_manual_trace_interview_quota_set, 'manual_trace_notification_quota' = model_manual_trace_notification_quota_set, 'event_block' = model_event_block_set, 'next_event' = model_next_event_set, 'event_lists' = model_event_lists_set, 'trace_token_block' = model_trace_token_block_set, 'next_trace_token' = model_next_trace_token_set, 'n_trace_tokens_used' = model_n_trace_tokens_used_set, 'n_trace_tokens' = model_n_trace_tokens_set, 'transition_time_distributions' = model_transition_time_distributions_set, 'n_quarantine_days' = model_n_quarantine_days_set, 'n_quarantine_app_user' = model_n_quarantine_app_user_set, 'n_quarantine_infected' = model_n_quarantine_infected_set, 'n_quarantine_recovered' = model_n_quarantine_recovered_set, 'n_quarantine_app_user_infected' = model_n_quarantine_app_user_infected_set, 'n_quarantine_app_user_recovered' = model_n_quarantine_app_user_recovered_set, 'n_quarantine_events' = model_n_quarantine_events_set, 'n_quarantine_events_app_user' = model_n_quarantine_events_app_user_set, 'n_quarantine_release_events' = model_n_quarantine_release_events_set, 'n_quarantine_release_events_app_user' = model_n_quarantine_release_events_app_user_set, 'n_population_by_age' = model_n_population_by_age_set, 'n_vaccinated_fully' = model_n_vaccinated_fully_set, 'n_vaccinated_symptoms' = model_n_vaccinated_symptoms_set, 'n_vaccinated_fully_by_age' = model_n_vaccinated_fully_by_age_set, 'n_vaccinated_symptoms_by_age' = model_n_vaccinated_symptoms_by_age_set, 'hospitals' = model_hospitals_set, 'strains' = model_strains_set, 'n_initialised_strains' = model_n_initialised_strains_set, 'cross_immunity' = model_cross_immunity_set, 'vaccines' = model_vaccines_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
setMethod('[[<-', c('_p_model', 'character'),function(x, i, j, ..., value)

{
  name = i;
  accessorFuns = list('params' = model_params_set, 'population' = model_population_set, 'time' = model_time_set, 'interaction_blocks' = model_interaction_blocks_set, 'interaction_day_idx' = model_interaction_day_idx_set, 'possible_interactions' = model_possible_interactions_set, 'n_possible_interactions' = model_n_possible_interactions_set, 'n_total_intereactions' = model_n_total_intereactions_set, 'n_occupation_networks' = model_n_occupation_networks_set, 'random_network' = model_random_network_set, 'household_network' = model_household_network_set, 'use_custom_occupation_networks' = model_use_custom_occupation_networks_set, 'occupation_network' = model_occupation_network_set, 'household_directory' = model_household_directory_set, 'user_network' = model_user_network_set, 'n_networks' = model_n_networks_set, 'all_networks' = model_all_networks_set, 'mean_interactions' = model_mean_interactions_set, 'mean_interactions_by_age' = model_mean_interactions_by_age_set, 'rebuild_networks' = model_rebuild_networks_set, 'manual_trace_interview_quota' = model_manual_trace_interview_quota_set, 'manual_trace_notification_quota' = model_manual_trace_notification_quota_set, 'event_block' = model_event_block_set, 'next_event' = model_next_event_set, 'event_lists' = model_event_lists_set, 'trace_token_block' = model_trace_token_block_set, 'next_trace_token' = model_next_trace_token_set, 'n_trace_tokens_used' = model_n_trace_tokens_used_set, 'n_trace_tokens' = model_n_trace_tokens_set, 'transition_time_distributions' = model_transition_time_distributions_set, 'n_quarantine_days' = model_n_quarantine_days_set, 'n_quarantine_app_user' = model_n_quarantine_app_user_set, 'n_quarantine_infected' = model_n_quarantine_infected_set, 'n_quarantine_recovered' = model_n_quarantine_recovered_set, 'n_quarantine_app_user_infected' = model_n_quarantine_app_user_infected_set, 'n_quarantine_app_user_recovered' = model_n_quarantine_app_user_recovered_set, 'n_quarantine_events' = model_n_quarantine_events_set, 'n_quarantine_events_app_user' = model_n_quarantine_events_app_user_set, 'n_quarantine_release_events' = model_n_quarantine_release_events_set, 'n_quarantine_release_events_app_user' = model_n_quarantine_release_events_app_user_set, 'n_population_by_age' = model_n_population_by_age_set, 'n_vaccinated_fully' = model_n_vaccinated_fully_set, 'n_vaccinated_symptoms' = model_n_vaccinated_symptoms_set, 'n_vaccinated_fully_by_age' = model_n_vaccinated_fully_by_age_set, 'n_vaccinated_symptoms_by_age' = model_n_vaccinated_symptoms_by_age_set, 'hospitals' = model_hospitals_set, 'strains' = model_strains_set, 'n_initialised_strains' = model_n_initialised_strains_set, 'cross_immunity' = model_cross_immunity_set, 'vaccines' = model_vaccines_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
# end of accessor method for model
setMethod('delete', '_p_model', function(obj) {delete_model(obj)})
# Start definition of copy functions & methods for model
CopyToR_model = function(value, obj = new("model"))
{
  obj@time = value$time;
  obj@interaction_day_idx = value$interaction_day_idx;
  obj@n_possible_interactions = value$n_possible_interactions;
  obj@n_total_intereactions = value$n_total_intereactions;
  obj@n_occupation_networks = value$n_occupation_networks;
  obj@use_custom_occupation_networks = value$use_custom_occupation_networks;
  obj@n_networks = value$n_networks;
  obj@mean_interactions = value$mean_interactions;
  obj@mean_interactions_by_age = value$mean_interactions_by_age;
  obj@rebuild_networks = value$rebuild_networks;
  obj@manual_trace_interview_quota = value$manual_trace_interview_quota;
  obj@manual_trace_notification_quota = value$manual_trace_notification_quota;
  obj@n_trace_tokens_used = value$n_trace_tokens_used;
  obj@n_trace_tokens = value$n_trace_tokens;
  obj@n_quarantine_days = value$n_quarantine_days;
  obj@n_quarantine_app_user = value$n_quarantine_app_user;
  obj@n_quarantine_infected = value$n_quarantine_infected;
  obj@n_quarantine_recovered = value$n_quarantine_recovered;
  obj@n_quarantine_app_user_infected = value$n_quarantine_app_user_infected;
  obj@n_quarantine_app_user_recovered = value$n_quarantine_app_user_recovered;
  obj@n_quarantine_events = value$n_quarantine_events;
  obj@n_quarantine_events_app_user = value$n_quarantine_events_app_user;
  obj@n_quarantine_release_events = value$n_quarantine_release_events;
  obj@n_quarantine_release_events_app_user = value$n_quarantine_release_events_app_user;
  obj@n_population_by_age = value$n_population_by_age;
  obj@n_vaccinated_fully = value$n_vaccinated_fully;
  obj@n_vaccinated_symptoms = value$n_vaccinated_symptoms;
  obj@n_vaccinated_fully_by_age = value$n_vaccinated_fully_by_age;
  obj@n_vaccinated_symptoms_by_age = value$n_vaccinated_symptoms_by_age;
  obj@n_initialised_strains = value$n_initialised_strains;
  obj;
}



CopyToC_model = function(value, obj)
{
  obj$time = value@time;
  obj$interaction_day_idx = value@interaction_day_idx;
  obj$n_possible_interactions = value@n_possible_interactions;
  obj$n_total_intereactions = value@n_total_intereactions;
  obj$n_occupation_networks = value@n_occupation_networks;
  obj$use_custom_occupation_networks = value@use_custom_occupation_networks;
  obj$n_networks = value@n_networks;
  obj$mean_interactions = value@mean_interactions;
  obj$mean_interactions_by_age = value@mean_interactions_by_age;
  obj$rebuild_networks = value@rebuild_networks;
  obj$manual_trace_interview_quota = value@manual_trace_interview_quota;
  obj$manual_trace_notification_quota = value@manual_trace_notification_quota;
  obj$n_trace_tokens_used = value@n_trace_tokens_used;
  obj$n_trace_tokens = value@n_trace_tokens;
  obj$n_quarantine_days = value@n_quarantine_days;
  obj$n_quarantine_app_user = value@n_quarantine_app_user;
  obj$n_quarantine_infected = value@n_quarantine_infected;
  obj$n_quarantine_recovered = value@n_quarantine_recovered;
  obj$n_quarantine_app_user_infected = value@n_quarantine_app_user_infected;
  obj$n_quarantine_app_user_recovered = value@n_quarantine_app_user_recovered;
  obj$n_quarantine_events = value@n_quarantine_events;
  obj$n_quarantine_events_app_user = value@n_quarantine_events_app_user;
  obj$n_quarantine_release_events = value@n_quarantine_release_events;
  obj$n_quarantine_release_events_app_user = value@n_quarantine_release_events_app_user;
  obj$n_population_by_age = value@n_population_by_age;
  obj$n_vaccinated_fully = value@n_vaccinated_fully;
  obj$n_vaccinated_symptoms = value@n_vaccinated_symptoms;
  obj$n_vaccinated_fully_by_age = value@n_vaccinated_fully_by_age;
  obj$n_vaccinated_symptoms_by_age = value@n_vaccinated_symptoms_by_age;
  obj$n_initialised_strains = value@n_initialised_strains;
  obj
}



# Start definition of copy methods for model
setMethod('copyToR', '_p_model', CopyToR_model);
setMethod('copyToC', 'model', CopyToC_model);

# End definition of copy methods for model
# End definition of copy functions & methods for model
# Start of event_block_events_set

`event_block_events_set` = function(self, s_events)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_events, "ExternalReference")) s_events = slot(s_events,"ref") 
  ;.Call('R_swig_event_block_events_set', self, s_events, PACKAGE='OpenABMCovid19');
  
}

attr(`event_block_events_set`, 'returnType') = 'void'
attr(`event_block_events_set`, "inputTypes") = c('_p_event_block', '_p_event')
class(`event_block_events_set`) = c("SWIGFunction", class('event_block_events_set'))

# Start of event_block_events_get

`event_block_events_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_event_block_events_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_event", ref=ans) ;
  
  ans
  
}

attr(`event_block_events_get`, 'returnType') = '_p_event'
attr(`event_block_events_get`, "inputTypes") = c('_p_event_block')
class(`event_block_events_get`) = c("SWIGFunction", class('event_block_events_get'))

# Start of event_block__next_set

`event_block__next_set` = function(self, s_arg2)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_event_block__next_set', self, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`event_block__next_set`, 'returnType') = 'void'
attr(`event_block__next_set`, "inputTypes") = c('_p_event_block', '_p_event_block')
class(`event_block__next_set`) = c("SWIGFunction", class('event_block__next_set'))

# Start of event_block__next_get

`event_block__next_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_event_block__next_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_event_block", ref=ans) ;
  
  ans
  
}

attr(`event_block__next_get`, 'returnType') = '_p_event_block'
attr(`event_block__next_get`, "inputTypes") = c('_p_event_block')
class(`event_block__next_get`) = c("SWIGFunction", class('event_block__next_get'))

# Start of accessor method for event_block
setMethod('$', '_p_event_block', function(x, name)

{
  accessorFuns = list('events' = event_block_events_get, '_next' = event_block__next_get);
  vaccessors = c('events', '_next');
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  if (is.na(match(name, vaccessors))) function(...){
    f(x, ...)
  } else f(x);
}


);
# end of accessor method for event_block
# Start of accessor method for event_block
setMethod('$<-', '_p_event_block', function(x, name, value)

{
  accessorFuns = list('events' = event_block_events_set, '_next' = event_block__next_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
setMethod('[[<-', c('_p_event_block', 'character'),function(x, i, j, ..., value)

{
  name = i;
  accessorFuns = list('events' = event_block_events_set, '_next' = event_block__next_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
# end of accessor method for event_block
# Start definition of copy functions & methods for event_block
CopyToR_event_block = function(value, obj = new("event_block"))
{
  obj;
}



CopyToC_event_block = function(value, obj)
{
  obj
}



# Start definition of copy methods for event_block
setMethod('copyToR', '_p_event_block', CopyToR_event_block);
setMethod('copyToC', 'event_block', CopyToC_event_block);

# End definition of copy methods for event_block
# End definition of copy functions & methods for event_block
# Start of event_individual_set

`event_individual_set` = function(self, s_individual)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_individual, "ExternalReference")) s_individual = slot(s_individual,"ref") 
  ;.Call('R_swig_event_individual_set', self, s_individual, PACKAGE='OpenABMCovid19');
  
}

attr(`event_individual_set`, 'returnType') = 'void'
attr(`event_individual_set`, "inputTypes") = c('_p_event', '_p_individual')
class(`event_individual_set`) = c("SWIGFunction", class('event_individual_set'))

# Start of event_individual_get

`event_individual_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_event_individual_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_individual", ref=ans) ;
  
  ans
  
}

attr(`event_individual_get`, 'returnType') = '_p_individual'
attr(`event_individual_get`, "inputTypes") = c('_p_event')
class(`event_individual_get`) = c("SWIGFunction", class('event_individual_get'))

# Start of event_type_set

`event_type_set` = function(self, s_type)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_type = as.integer(s_type);
  
  if(length(s_type) > 1) {
    warning("using only the first element of s_type");
  };
  
  ;.Call('R_swig_event_type_set', self, s_type, PACKAGE='OpenABMCovid19');
  
}

attr(`event_type_set`, 'returnType') = 'void'
attr(`event_type_set`, "inputTypes") = c('_p_event', 'integer')
class(`event_type_set`) = c("SWIGFunction", class('event_type_set'))

# Start of event_type_get

`event_type_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_event_type_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`event_type_get`, 'returnType') = 'integer'
attr(`event_type_get`, "inputTypes") = c('_p_event')
class(`event_type_get`) = c("SWIGFunction", class('event_type_get'))

# Start of event_time_set

`event_time_set` = function(self, s_time)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_time = as.integer(s_time);
  
  if(length(s_time) > 1) {
    warning("using only the first element of s_time");
  };
  
  ;.Call('R_swig_event_time_set', self, s_time, PACKAGE='OpenABMCovid19');
  
}

attr(`event_time_set`, 'returnType') = 'void'
attr(`event_time_set`, "inputTypes") = c('_p_event', 'integer')
class(`event_time_set`) = c("SWIGFunction", class('event_time_set'))

# Start of event_time_get

`event_time_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_event_time_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`event_time_get`, 'returnType') = 'integer'
attr(`event_time_get`, "inputTypes") = c('_p_event')
class(`event_time_get`) = c("SWIGFunction", class('event_time_get'))

# Start of event_info_set

`event_info_set` = function(self, s_info)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_info, "ExternalReference")) s_info = slot(s_info,"ref") 
  ;.Call('R_swig_event_info_set', self, s_info, PACKAGE='OpenABMCovid19');
  
}

attr(`event_info_set`, 'returnType') = 'void'
attr(`event_info_set`, "inputTypes") = c('_p_event', '_p_void')
class(`event_info_set`) = c("SWIGFunction", class('event_info_set'))

# Start of event_info_get

`event_info_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_event_info_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_void", ref=ans) ;
  
  ans
  
}

attr(`event_info_get`, 'returnType') = '_p_void'
attr(`event_info_get`, "inputTypes") = c('_p_event')
class(`event_info_get`) = c("SWIGFunction", class('event_info_get'))

# Start of event__next_set

`event__next_set` = function(self, s_arg2)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_event__next_set', self, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`event__next_set`, 'returnType') = 'void'
attr(`event__next_set`, "inputTypes") = c('_p_event', '_p_event')
class(`event__next_set`) = c("SWIGFunction", class('event__next_set'))

# Start of event__next_get

`event__next_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_event__next_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_event", ref=ans) ;
  
  ans
  
}

attr(`event__next_get`, 'returnType') = '_p_event'
attr(`event__next_get`, "inputTypes") = c('_p_event')
class(`event__next_get`) = c("SWIGFunction", class('event__next_get'))

# Start of event_last_set

`event_last_set` = function(self, s_last)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_last, "ExternalReference")) s_last = slot(s_last,"ref") 
  ;.Call('R_swig_event_last_set', self, s_last, PACKAGE='OpenABMCovid19');
  
}

attr(`event_last_set`, 'returnType') = 'void'
attr(`event_last_set`, "inputTypes") = c('_p_event', '_p_event')
class(`event_last_set`) = c("SWIGFunction", class('event_last_set'))

# Start of event_last_get

`event_last_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_event_last_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_event", ref=ans) ;
  
  ans
  
}

attr(`event_last_get`, 'returnType') = '_p_event'
attr(`event_last_get`, "inputTypes") = c('_p_event')
class(`event_last_get`) = c("SWIGFunction", class('event_last_get'))

# Start of accessor method for event
setMethod('$', '_p_event', function(x, name)

{
  accessorFuns = list('individual' = event_individual_get, 'type' = event_type_get, 'time' = event_time_get, 'info' = event_info_get, '_next' = event__next_get, 'last' = event_last_get);
  vaccessors = c('individual', 'type', 'time', 'info', '_next', 'last');
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  if (is.na(match(name, vaccessors))) function(...){
    f(x, ...)
  } else f(x);
}


);
# end of accessor method for event
# Start of accessor method for event
setMethod('$<-', '_p_event', function(x, name, value)

{
  accessorFuns = list('individual' = event_individual_set, 'type' = event_type_set, 'time' = event_time_set, 'info' = event_info_set, '_next' = event__next_set, 'last' = event_last_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
setMethod('[[<-', c('_p_event', 'character'),function(x, i, j, ..., value)

{
  name = i;
  accessorFuns = list('individual' = event_individual_set, 'type' = event_type_set, 'time' = event_time_set, 'info' = event_info_set, '_next' = event__next_set, 'last' = event_last_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
# end of accessor method for event
# Start definition of copy functions & methods for event
CopyToR_event = function(value, obj = new("event"))
{
  obj@type = value$type;
  obj@time = value$time;
  obj;
}



CopyToC_event = function(value, obj)
{
  obj$type = value@type;
  obj$time = value@time;
  obj
}



# Start definition of copy methods for event
setMethod('copyToR', '_p_event', CopyToR_event);
setMethod('copyToC', 'event', CopyToC_event);

# End definition of copy methods for event
# End definition of copy functions & methods for event
# Start of create_model

`create_model` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;ans = .Call('R_swig_create_model', s_arg1, PACKAGE='OpenABMCovid19');
  ans <- new("_p_model", ref=ans) ;
  
  ans
  
}

attr(`create_model`, 'returnType') = '_p_model'
attr(`create_model`, "inputTypes") = c('_p_parameters')
class(`create_model`) = c("SWIGFunction", class('create_model'))

# Start of set_up_population

`set_up_population` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_set_up_population', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`set_up_population`, 'returnType') = 'void'
attr(`set_up_population`, "inputTypes") = c('_p_model')
class(`set_up_population`) = c("SWIGFunction", class('set_up_population'))

# Start of set_up_healthcare_workers_and_hospitals

`set_up_healthcare_workers_and_hospitals` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_set_up_healthcare_workers_and_hospitals', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`set_up_healthcare_workers_and_hospitals`, 'returnType') = 'void'
attr(`set_up_healthcare_workers_and_hospitals`, "inputTypes") = c('_p_model')
class(`set_up_healthcare_workers_and_hospitals`) = c("SWIGFunction", class('set_up_healthcare_workers_and_hospitals'))

# Start of set_up_interactions

`set_up_interactions` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_set_up_interactions', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`set_up_interactions`, 'returnType') = 'void'
attr(`set_up_interactions`, "inputTypes") = c('_p_model')
class(`set_up_interactions`) = c("SWIGFunction", class('set_up_interactions'))

# Start of set_up_events

`set_up_events` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_set_up_events', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`set_up_events`, 'returnType') = 'void'
attr(`set_up_events`, "inputTypes") = c('_p_model')
class(`set_up_events`) = c("SWIGFunction", class('set_up_events'))

# Start of add_event_block

`add_event_block` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  
  ;.Call('R_swig_add_event_block', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`add_event_block`, 'returnType') = 'void'
attr(`add_event_block`, "inputTypes") = c('_p_model', 'numeric')
class(`add_event_block`) = c("SWIGFunction", class('add_event_block'))

# Start of set_up_strains

`set_up_strains` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_set_up_strains', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`set_up_strains`, 'returnType') = 'void'
attr(`set_up_strains`, "inputTypes") = c('_p_model')
class(`set_up_strains`) = c("SWIGFunction", class('set_up_strains'))

# Start of set_up_seed_infection

`set_up_seed_infection` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_set_up_seed_infection', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`set_up_seed_infection`, 'returnType') = 'void'
attr(`set_up_seed_infection`, "inputTypes") = c('_p_model')
class(`set_up_seed_infection`) = c("SWIGFunction", class('set_up_seed_infection'))

# Start of set_up_networks

`set_up_networks` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_set_up_networks', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`set_up_networks`, 'returnType') = 'void'
attr(`set_up_networks`, "inputTypes") = c('_p_model')
class(`set_up_networks`) = c("SWIGFunction", class('set_up_networks'))

# Start of set_up_counters

`set_up_counters` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_set_up_counters', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`set_up_counters`, 'returnType') = 'void'
attr(`set_up_counters`, "inputTypes") = c('_p_model')
class(`set_up_counters`) = c("SWIGFunction", class('set_up_counters'))

# Start of reset_counters

`reset_counters` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_reset_counters', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`reset_counters`, 'returnType') = 'void'
attr(`reset_counters`, "inputTypes") = c('_p_model')
class(`reset_counters`) = c("SWIGFunction", class('reset_counters'))

# Start of set_up_occupation_network

`set_up_occupation_network` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_set_up_occupation_network', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`set_up_occupation_network`, 'returnType') = 'void'
attr(`set_up_occupation_network`, "inputTypes") = c('_p_model')
class(`set_up_occupation_network`) = c("SWIGFunction", class('set_up_occupation_network'))

# Start of set_up_individual_hazard

`set_up_individual_hazard` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_set_up_individual_hazard', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`set_up_individual_hazard`, 'returnType') = 'void'
attr(`set_up_individual_hazard`, "inputTypes") = c('_p_model')
class(`set_up_individual_hazard`) = c("SWIGFunction", class('set_up_individual_hazard'))

# Start of destroy_model

`destroy_model` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_destroy_model', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`destroy_model`, 'returnType') = 'void'
attr(`destroy_model`, "inputTypes") = c('_p_model')
class(`destroy_model`) = c("SWIGFunction", class('destroy_model'))

# Start of one_time_step

`one_time_step` = function(s_arg1, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_one_time_step', s_arg1, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`one_time_step`, 'returnType') = 'integer'
attr(`one_time_step`, "inputTypes") = c('_p_model')
class(`one_time_step`) = c("SWIGFunction", class('one_time_step'))

# Start of flu_infections

`flu_infections` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_flu_infections', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`flu_infections`, 'returnType') = 'void'
attr(`flu_infections`, "inputTypes") = c('_p_model')
class(`flu_infections`) = c("SWIGFunction", class('flu_infections'))

# Start of create_event

`create_event` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;ans = .Call('R_swig_create_event', s_arg1, PACKAGE='OpenABMCovid19');
  ans <- new("_p_event", ref=ans) ;
  
  ans
  
}

attr(`create_event`, 'returnType') = '_p_event'
attr(`create_event`, "inputTypes") = c('_p_model')
class(`create_event`) = c("SWIGFunction", class('create_event'))

# Start of add_individual_to_event_list

`add_individual_to_event_list` = function(s_arg1, s_arg2, s_arg3, s_arg4, s_arg5)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  if (inherits(s_arg3, "ExternalReference")) s_arg3 = slot(s_arg3,"ref") 
  s_arg4 = as.integer(s_arg4);
  
  if(length(s_arg4) > 1) {
    warning("using only the first element of s_arg4");
  };
  
  if (inherits(s_arg5, "ExternalReference")) s_arg5 = slot(s_arg5,"ref") 
  ;ans = .Call('R_swig_add_individual_to_event_list', s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, PACKAGE='OpenABMCovid19');
  ans <- new("_p_event", ref=ans) ;
  
  ans
  
}

attr(`add_individual_to_event_list`, 'returnType') = '_p_event'
attr(`add_individual_to_event_list`, "inputTypes") = c('_p_model', 'integer', '_p_individual', 'integer', '_p_void')
class(`add_individual_to_event_list`) = c("SWIGFunction", class('add_individual_to_event_list'))

# Start of set_up_event_list

`set_up_event_list` = function(s_arg1, s_arg2, s_arg3)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;.Call('R_swig_set_up_event_list', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`set_up_event_list`, 'returnType') = 'void'
attr(`set_up_event_list`, "inputTypes") = c('_p_model', '_p_parameters', 'integer')
class(`set_up_event_list`) = c("SWIGFunction", class('set_up_event_list'))

# Start of destroy_event_list

`destroy_event_list` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  ;.Call('R_swig_destroy_event_list', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`destroy_event_list`, 'returnType') = 'void'
attr(`destroy_event_list`, "inputTypes") = c('_p_model', 'integer')
class(`destroy_event_list`) = c("SWIGFunction", class('destroy_event_list'))

# Start of remove_event_from_event_list

`remove_event_from_event_list` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_remove_event_from_event_list', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`remove_event_from_event_list`, 'returnType') = 'void'
attr(`remove_event_from_event_list`, "inputTypes") = c('_p_model', '_p_event')
class(`remove_event_from_event_list`) = c("SWIGFunction", class('remove_event_from_event_list'))

# Start of update_event_list_counters

`update_event_list_counters` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  ;.Call('R_swig_update_event_list_counters', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`update_event_list_counters`, 'returnType') = 'void'
attr(`update_event_list_counters`, "inputTypes") = c('_p_model', 'integer')
class(`update_event_list_counters`) = c("SWIGFunction", class('update_event_list_counters'))

# Start of transition_events

`transition_events` = function(s_arg1, s_arg2, s_arg3, s_arg4)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  if(is.function(s_arg3)) {
    assert('...' %in% names(formals(s_arg3)) || length(formals(s_arg3)) >= 2);
  } else {
    if(is.character(s_arg3)) {
      s_arg3 = getNativeSymbolInfo(s_arg3);
    };
    if(is(s_arg3, "NativeSymbolInfo")) {
      s_arg3 = s_arg3$address;
    }
    if(is(s_arg3, "ExternalReference")) {
      s_arg3 = s_arg3@ref;
    }
  }; 
  s_arg4 = as.integer(s_arg4);
  
  if(length(s_arg4) > 1) {
    warning("using only the first element of s_arg4");
  };
  
  ;.Call('R_swig_transition_events', s_arg1, s_arg2, s_arg3, s_arg4, PACKAGE='OpenABMCovid19');
  
}

attr(`transition_events`, 'returnType') = 'void'
attr(`transition_events`, "inputTypes") = c('_p_model', 'integer', '_p_f_p_model_p_struct_individual__void', 'integer')
class(`transition_events`) = c("SWIGFunction", class('transition_events'))

# Start of transition_events_info

`transition_events_info` = function(s_arg1, s_arg2, s_arg3, s_arg4)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  if(is.function(s_arg3)) {
    assert('...' %in% names(formals(s_arg3)) || length(formals(s_arg3)) >= 3);
  } else {
    if(is.character(s_arg3)) {
      s_arg3 = getNativeSymbolInfo(s_arg3);
    };
    if(is(s_arg3, "NativeSymbolInfo")) {
      s_arg3 = s_arg3$address;
    }
    if(is(s_arg3, "ExternalReference")) {
      s_arg3 = s_arg3@ref;
    }
  }; 
  s_arg4 = as.integer(s_arg4);
  
  if(length(s_arg4) > 1) {
    warning("using only the first element of s_arg4");
  };
  
  ;.Call('R_swig_transition_events_info', s_arg1, s_arg2, s_arg3, s_arg4, PACKAGE='OpenABMCovid19');
  
}

attr(`transition_events_info`, 'returnType') = 'void'
attr(`transition_events_info`, "inputTypes") = c('_p_model', 'integer', '_p_f_p_model_p_struct_individual_p_void__void', 'integer')
class(`transition_events_info`) = c("SWIGFunction", class('transition_events_info'))

# Start of add_interaction_block

`add_interaction_block` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  ;.Call('R_swig_add_interaction_block', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`add_interaction_block`, 'returnType') = 'void'
attr(`add_interaction_block`, "inputTypes") = c('_p_model', 'integer')
class(`add_interaction_block`) = c("SWIGFunction", class('add_interaction_block'))

# Start of return_interactions

`return_interactions` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_return_interactions', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`return_interactions`, 'returnType') = 'void'
attr(`return_interactions`, "inputTypes") = c('_p_model')
class(`return_interactions`) = c("SWIGFunction", class('return_interactions'))

# Start of add_new_network

`add_new_network` = function(s_arg1, s_arg2, s_arg3)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;ans = .Call('R_swig_add_new_network', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  ans <- new("_p_network", ref=ans) ;
  
  ans
  
}

attr(`add_new_network`, 'returnType') = '_p_network'
attr(`add_new_network`, "inputTypes") = c('_p_model', 'integer', 'integer')
class(`add_new_network`) = c("SWIGFunction", class('add_new_network'))

# Start of add_interactions_from_network

`add_interactions_from_network` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_add_interactions_from_network', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`add_interactions_from_network`, 'returnType') = 'void'
attr(`add_interactions_from_network`, "inputTypes") = c('_p_model', '_p_network')
class(`add_interactions_from_network`) = c("SWIGFunction", class('add_interactions_from_network'))

# Start of build_daily_network

`build_daily_network` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_build_daily_network', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`build_daily_network`, 'returnType') = 'void'
attr(`build_daily_network`, "inputTypes") = c('_p_model')
class(`build_daily_network`) = c("SWIGFunction", class('build_daily_network'))

# Start of build_random_network

`build_random_network` = function(s_arg1, s_arg2, s_arg3, s_arg4)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  s_arg4 = as.integer(s_arg4);
  ;.Call('R_swig_build_random_network', s_arg1, s_arg2, s_arg3, s_arg4, PACKAGE='OpenABMCovid19');
  
}

attr(`build_random_network`, 'returnType') = 'void'
attr(`build_random_network`, "inputTypes") = c('_p_model', '_p_network', 'integer', 'integer')
class(`build_random_network`) = c("SWIGFunction", class('build_random_network'))

# Start of build_random_network_default

`build_random_network_default` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_build_random_network_default', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`build_random_network_default`, 'returnType') = 'void'
attr(`build_random_network_default`, "inputTypes") = c('_p_model')
class(`build_random_network_default`) = c("SWIGFunction", class('build_random_network_default'))

# Start of build_random_network_user

`build_random_network_user` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_build_random_network_user', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`build_random_network_user`, 'returnType') = 'void'
attr(`build_random_network_user`, "inputTypes") = c('_p_model', '_p_network')
class(`build_random_network_user`) = c("SWIGFunction", class('build_random_network_user'))

# Start of add_user_network

`add_user_network` = function(s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, s_arg6, s_arg7, s_arg8, s_arg9, s_arg10, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  s_arg4 = as.integer(s_arg4);
  
  if(length(s_arg4) > 1) {
    warning("using only the first element of s_arg4");
  };
  
  s_arg5 = as.integer(s_arg5);
  
  if(length(s_arg5) > 1) {
    warning("using only the first element of s_arg5");
  };
  
  
  s_arg7 = as.integer(s_arg7);
  
  if(length(s_arg7) > 1) {
    warning("using only the first element of s_arg7");
  };
  
  s_arg8 = as.integer(s_arg8);
  s_arg9 = as.integer(s_arg9);
  s_arg10 = as(s_arg10, "character"); 
  ;.Call('R_swig_add_user_network', s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, s_arg6, s_arg7, s_arg8, s_arg9, s_arg10, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`add_user_network`, 'returnType') = 'integer'
attr(`add_user_network`, "inputTypes") = c('_p_model', 'integer', 'integer', 'integer', 'integer', 'numeric', 'integer', 'integer', 'integer', 'character')
class(`add_user_network`) = c("SWIGFunction", class('add_user_network'))

# Start of add_user_network_random

`add_user_network_random` = function(s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, s_arg6, s_arg7, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  s_arg4 = as.integer(s_arg4);
  
  if(length(s_arg4) > 1) {
    warning("using only the first element of s_arg4");
  };
  
  s_arg5 = as.integer(s_arg5);
  s_arg6 = as.integer(s_arg6);
  s_arg7 = as(s_arg7, "character"); 
  ;.Call('R_swig_add_user_network_random', s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, s_arg6, s_arg7, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`add_user_network_random`, 'returnType') = 'integer'
attr(`add_user_network_random`, "inputTypes") = c('_p_model', 'integer', 'integer', 'integer', 'integer', 'integer', 'character')
class(`add_user_network_random`) = c("SWIGFunction", class('add_user_network_random'))

# Start of delete_network

`delete_network` = function(s_arg1, n, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(n, "ExternalReference")) n = slot(n,"ref") 
  ;.Call('R_swig_delete_network', s_arg1, n, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`delete_network`, 'returnType') = 'integer'
attr(`delete_network`, "inputTypes") = c('_p_model', '_p_network')
class(`delete_network`) = c("SWIGFunction", class('delete_network'))

# Start of get_network_by_id

`get_network_by_id` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  ;ans = .Call('R_swig_get_network_by_id', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  ans <- new("_p_network", ref=ans) ;
  
  ans
  
}

attr(`get_network_by_id`, 'returnType') = '_p_network'
attr(`get_network_by_id`, "inputTypes") = c('_p_model', 'integer')
class(`get_network_by_id`) = c("SWIGFunction", class('get_network_by_id'))

# Start of get_network_ids

`get_network_ids` = function(s_arg1, s_arg2, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  ;.Call('R_swig_get_network_ids', s_arg1, s_arg2, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_network_ids`, 'returnType') = 'integer'
attr(`get_network_ids`, "inputTypes") = c('_p_model', 'integer')
class(`get_network_ids`) = c("SWIGFunction", class('get_network_ids'))

# Start of parameters_rng_seed_set

`parameters_rng_seed_set` = function(self, s_rng_seed)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_rng_seed = as.integer(s_rng_seed);
  
  if(length(s_rng_seed) > 1) {
    warning("using only the first element of s_rng_seed");
  };
  
  ;.Call('R_swig_parameters_rng_seed_set', self, s_rng_seed, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_rng_seed_set`, 'returnType') = 'void'
attr(`parameters_rng_seed_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_rng_seed_set`) = c("SWIGFunction", class('parameters_rng_seed_set'))

# Start of parameters_rng_seed_get

`parameters_rng_seed_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_rng_seed_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_rng_seed_get`, 'returnType') = 'integer'
attr(`parameters_rng_seed_get`, "inputTypes") = c('_p_parameters')
class(`parameters_rng_seed_get`) = c("SWIGFunction", class('parameters_rng_seed_get'))

# Start of parameters_input_param_file_set

`parameters_input_param_file_set` = function(self, s_input_param_file)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  if(is.list(s_input_param_file))
  assert(all(sapply(s_input_param_file, class) == "_p_char"));
  
  
#  assert(length(s_input_param_file) >= INPUT_CHAR_LEN)
  
  ;.Call('R_swig_parameters_input_param_file_set', self, s_input_param_file, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_input_param_file_set`, 'returnType') = 'void'
attr(`parameters_input_param_file_set`, "inputTypes") = c('_p_parameters', '_p_char')
class(`parameters_input_param_file_set`) = c("SWIGFunction", class('parameters_input_param_file_set'))

# Start of parameters_input_param_file_get

`parameters_input_param_file_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_parameters_input_param_file_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  #ans <- new("_p_char", ref=ans) ;
  
  ans
  
}

attr(`parameters_input_param_file_get`, 'returnType') = '_p_char'
attr(`parameters_input_param_file_get`, "inputTypes") = c('_p_parameters')
class(`parameters_input_param_file_get`) = c("SWIGFunction", class('parameters_input_param_file_get'))

# Start of parameters_hospital_input_param_file_set

`parameters_hospital_input_param_file_set` = function(self, s_hospital_input_param_file)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  if(is.list(s_hospital_input_param_file))
  assert(all(sapply(s_hospital_input_param_file, class) == "_p_char"));
  
  
#  assert(length(s_hospital_input_param_file) >= INPUT_CHAR_LEN)
  
  ;.Call('R_swig_parameters_hospital_input_param_file_set', self, s_hospital_input_param_file, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_hospital_input_param_file_set`, 'returnType') = 'void'
attr(`parameters_hospital_input_param_file_set`, "inputTypes") = c('_p_parameters', '_p_char')
class(`parameters_hospital_input_param_file_set`) = c("SWIGFunction", class('parameters_hospital_input_param_file_set'))

# Start of parameters_hospital_input_param_file_get

`parameters_hospital_input_param_file_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_parameters_hospital_input_param_file_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  #ans <- new("_p_char", ref=ans) ;
  
  ans
  
}

attr(`parameters_hospital_input_param_file_get`, 'returnType') = '_p_char'
attr(`parameters_hospital_input_param_file_get`, "inputTypes") = c('_p_parameters')
class(`parameters_hospital_input_param_file_get`) = c("SWIGFunction", class('parameters_hospital_input_param_file_get'))

# Start of parameters_input_household_file_set

`parameters_input_household_file_set` = function(self, s_input_household_file)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  if(is.list(s_input_household_file))
  assert(all(sapply(s_input_household_file, class) == "_p_char"));
  
  
#  assert(length(s_input_household_file) >= INPUT_CHAR_LEN)
  
  ;.Call('R_swig_parameters_input_household_file_set', self, s_input_household_file, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_input_household_file_set`, 'returnType') = 'void'
attr(`parameters_input_household_file_set`, "inputTypes") = c('_p_parameters', '_p_char')
class(`parameters_input_household_file_set`) = c("SWIGFunction", class('parameters_input_household_file_set'))

# Start of parameters_input_household_file_get

`parameters_input_household_file_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_parameters_input_household_file_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  #ans <- new("_p_char", ref=ans) ;
  
  ans
  
}

attr(`parameters_input_household_file_get`, 'returnType') = '_p_char'
attr(`parameters_input_household_file_get`, "inputTypes") = c('_p_parameters')
class(`parameters_input_household_file_get`) = c("SWIGFunction", class('parameters_input_household_file_get'))

# Start of parameters_output_file_dir_set

`parameters_output_file_dir_set` = function(self, s_output_file_dir)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  if(is.list(s_output_file_dir))
  assert(all(sapply(s_output_file_dir, class) == "_p_char"));
  
  
#  assert(length(s_output_file_dir) >= INPUT_CHAR_LEN)
  
  ;.Call('R_swig_parameters_output_file_dir_set', self, s_output_file_dir, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_output_file_dir_set`, 'returnType') = 'void'
attr(`parameters_output_file_dir_set`, "inputTypes") = c('_p_parameters', '_p_char')
class(`parameters_output_file_dir_set`) = c("SWIGFunction", class('parameters_output_file_dir_set'))

# Start of parameters_output_file_dir_get

`parameters_output_file_dir_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_parameters_output_file_dir_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  #ans <- new("_p_char", ref=ans) ;
  
  ans
  
}

attr(`parameters_output_file_dir_get`, 'returnType') = '_p_char'
attr(`parameters_output_file_dir_get`, "inputTypes") = c('_p_parameters')
class(`parameters_output_file_dir_get`) = c("SWIGFunction", class('parameters_output_file_dir_get'))

# Start of parameters_param_line_number_set

`parameters_param_line_number_set` = function(self, s_param_line_number)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_param_line_number = as.integer(s_param_line_number);
  
  if(length(s_param_line_number) > 1) {
    warning("using only the first element of s_param_line_number");
  };
  
  ;.Call('R_swig_parameters_param_line_number_set', self, s_param_line_number, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_param_line_number_set`, 'returnType') = 'void'
attr(`parameters_param_line_number_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_param_line_number_set`) = c("SWIGFunction", class('parameters_param_line_number_set'))

# Start of parameters_param_line_number_get

`parameters_param_line_number_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_param_line_number_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_param_line_number_get`, 'returnType') = 'integer'
attr(`parameters_param_line_number_get`, "inputTypes") = c('_p_parameters')
class(`parameters_param_line_number_get`) = c("SWIGFunction", class('parameters_param_line_number_get'))

# Start of parameters_hospital_param_line_number_set

`parameters_hospital_param_line_number_set` = function(self, s_hospital_param_line_number)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_hospital_param_line_number = as.integer(s_hospital_param_line_number);
  
  if(length(s_hospital_param_line_number) > 1) {
    warning("using only the first element of s_hospital_param_line_number");
  };
  
  ;.Call('R_swig_parameters_hospital_param_line_number_set', self, s_hospital_param_line_number, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_hospital_param_line_number_set`, 'returnType') = 'void'
attr(`parameters_hospital_param_line_number_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_hospital_param_line_number_set`) = c("SWIGFunction", class('parameters_hospital_param_line_number_set'))

# Start of parameters_hospital_param_line_number_get

`parameters_hospital_param_line_number_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_hospital_param_line_number_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_hospital_param_line_number_get`, 'returnType') = 'integer'
attr(`parameters_hospital_param_line_number_get`, "inputTypes") = c('_p_parameters')
class(`parameters_hospital_param_line_number_get`) = c("SWIGFunction", class('parameters_hospital_param_line_number_get'))

# Start of parameters_param_id_set

`parameters_param_id_set` = function(self, s_param_id)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_param_id = as.integer(s_param_id);
  
  if(length(s_param_id) > 1) {
    warning("using only the first element of s_param_id");
  };
  
  ;.Call('R_swig_parameters_param_id_set', self, s_param_id, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_param_id_set`, 'returnType') = 'void'
attr(`parameters_param_id_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_param_id_set`) = c("SWIGFunction", class('parameters_param_id_set'))

# Start of parameters_param_id_get

`parameters_param_id_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_param_id_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_param_id_get`, 'returnType') = 'integer'
attr(`parameters_param_id_get`, "inputTypes") = c('_p_parameters')
class(`parameters_param_id_get`) = c("SWIGFunction", class('parameters_param_id_get'))

# Start of parameters_n_total_set

`parameters_n_total_set` = function(self, s_n_total)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_total = as.integer(s_n_total);
  
  if(length(s_n_total) > 1) {
    warning("using only the first element of s_n_total");
  };
  
  ;.Call('R_swig_parameters_n_total_set', self, s_n_total, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_n_total_set`, 'returnType') = 'void'
attr(`parameters_n_total_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_n_total_set`) = c("SWIGFunction", class('parameters_n_total_set'))

# Start of parameters_n_total_get

`parameters_n_total_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_n_total_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_n_total_get`, 'returnType') = 'integer'
attr(`parameters_n_total_get`, "inputTypes") = c('_p_parameters')
class(`parameters_n_total_get`) = c("SWIGFunction", class('parameters_n_total_get'))

# Start of parameters_days_of_interactions_set

`parameters_days_of_interactions_set` = function(self, s_days_of_interactions)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_days_of_interactions = as.integer(s_days_of_interactions);
  
  if(length(s_days_of_interactions) > 1) {
    warning("using only the first element of s_days_of_interactions");
  };
  
  ;.Call('R_swig_parameters_days_of_interactions_set', self, s_days_of_interactions, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_days_of_interactions_set`, 'returnType') = 'void'
attr(`parameters_days_of_interactions_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_days_of_interactions_set`) = c("SWIGFunction", class('parameters_days_of_interactions_set'))

# Start of parameters_days_of_interactions_get

`parameters_days_of_interactions_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_days_of_interactions_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_days_of_interactions_get`, 'returnType') = 'integer'
attr(`parameters_days_of_interactions_get`, "inputTypes") = c('_p_parameters')
class(`parameters_days_of_interactions_get`) = c("SWIGFunction", class('parameters_days_of_interactions_get'))

# Start of parameters_end_time_set

`parameters_end_time_set` = function(self, s_end_time)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_end_time = as.integer(s_end_time);
  
  if(length(s_end_time) > 1) {
    warning("using only the first element of s_end_time");
  };
  
  ;.Call('R_swig_parameters_end_time_set', self, s_end_time, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_end_time_set`, 'returnType') = 'void'
attr(`parameters_end_time_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_end_time_set`) = c("SWIGFunction", class('parameters_end_time_set'))

# Start of parameters_end_time_get

`parameters_end_time_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_end_time_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_end_time_get`, 'returnType') = 'integer'
attr(`parameters_end_time_get`, "inputTypes") = c('_p_parameters')
class(`parameters_end_time_get`) = c("SWIGFunction", class('parameters_end_time_get'))

# Start of parameters_n_seed_infection_set

`parameters_n_seed_infection_set` = function(self, s_n_seed_infection)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_seed_infection = as.integer(s_n_seed_infection);
  
  if(length(s_n_seed_infection) > 1) {
    warning("using only the first element of s_n_seed_infection");
  };
  
  ;.Call('R_swig_parameters_n_seed_infection_set', self, s_n_seed_infection, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_n_seed_infection_set`, 'returnType') = 'void'
attr(`parameters_n_seed_infection_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_n_seed_infection_set`) = c("SWIGFunction", class('parameters_n_seed_infection_set'))

# Start of parameters_n_seed_infection_get

`parameters_n_seed_infection_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_n_seed_infection_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_n_seed_infection_get`, 'returnType') = 'integer'
attr(`parameters_n_seed_infection_get`, "inputTypes") = c('_p_parameters')
class(`parameters_n_seed_infection_get`) = c("SWIGFunction", class('parameters_n_seed_infection_get'))

# Start of parameters_rebuild_networks_set

`parameters_rebuild_networks_set` = function(self, s_rebuild_networks)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_rebuild_networks = as.integer(s_rebuild_networks);
  
  if(length(s_rebuild_networks) > 1) {
    warning("using only the first element of s_rebuild_networks");
  };
  
  ;.Call('R_swig_parameters_rebuild_networks_set', self, s_rebuild_networks, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_rebuild_networks_set`, 'returnType') = 'void'
attr(`parameters_rebuild_networks_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_rebuild_networks_set`) = c("SWIGFunction", class('parameters_rebuild_networks_set'))

# Start of parameters_rebuild_networks_get

`parameters_rebuild_networks_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_rebuild_networks_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_rebuild_networks_get`, 'returnType') = 'integer'
attr(`parameters_rebuild_networks_get`, "inputTypes") = c('_p_parameters')
class(`parameters_rebuild_networks_get`) = c("SWIGFunction", class('parameters_rebuild_networks_get'))

# Start of parameters_mean_random_interactions_set

`parameters_mean_random_interactions_set` = function(self, s_mean_random_interactions)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  
#  assert(length(s_mean_random_interactions) >= N_AGE_TYPES)
  
  ;.Call('R_swig_parameters_mean_random_interactions_set', self, s_mean_random_interactions, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_random_interactions_set`, 'returnType') = 'void'
attr(`parameters_mean_random_interactions_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_mean_random_interactions_set`) = c("SWIGFunction", class('parameters_mean_random_interactions_set'))

# Start of parameters_mean_random_interactions_get

`parameters_mean_random_interactions_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_mean_random_interactions_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_random_interactions_get`, 'returnType') = 'numeric'
attr(`parameters_mean_random_interactions_get`, "inputTypes") = c('_p_parameters')
class(`parameters_mean_random_interactions_get`) = c("SWIGFunction", class('parameters_mean_random_interactions_get'))

# Start of parameters_sd_random_interactions_set

`parameters_sd_random_interactions_set` = function(self, s_sd_random_interactions)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  
#  assert(length(s_sd_random_interactions) >= N_AGE_TYPES)
  
  ;.Call('R_swig_parameters_sd_random_interactions_set', self, s_sd_random_interactions, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sd_random_interactions_set`, 'returnType') = 'void'
attr(`parameters_sd_random_interactions_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_sd_random_interactions_set`) = c("SWIGFunction", class('parameters_sd_random_interactions_set'))

# Start of parameters_sd_random_interactions_get

`parameters_sd_random_interactions_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_sd_random_interactions_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sd_random_interactions_get`, 'returnType') = 'numeric'
attr(`parameters_sd_random_interactions_get`, "inputTypes") = c('_p_parameters')
class(`parameters_sd_random_interactions_get`) = c("SWIGFunction", class('parameters_sd_random_interactions_get'))

# Start of parameters_random_interaction_distribution_set

`parameters_random_interaction_distribution_set` = function(self, s_random_interaction_distribution)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_random_interaction_distribution = as.integer(s_random_interaction_distribution);
  
  if(length(s_random_interaction_distribution) > 1) {
    warning("using only the first element of s_random_interaction_distribution");
  };
  
  ;.Call('R_swig_parameters_random_interaction_distribution_set', self, s_random_interaction_distribution, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_random_interaction_distribution_set`, 'returnType') = 'void'
attr(`parameters_random_interaction_distribution_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_random_interaction_distribution_set`) = c("SWIGFunction", class('parameters_random_interaction_distribution_set'))

# Start of parameters_random_interaction_distribution_get

`parameters_random_interaction_distribution_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_random_interaction_distribution_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_random_interaction_distribution_get`, 'returnType') = 'integer'
attr(`parameters_random_interaction_distribution_get`, "inputTypes") = c('_p_parameters')
class(`parameters_random_interaction_distribution_get`) = c("SWIGFunction", class('parameters_random_interaction_distribution_get'))

# Start of parameters_mean_work_interactions_set

`parameters_mean_work_interactions_set` = function(self, s_mean_work_interactions)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  
#  assert(length(s_mean_work_interactions) >= N_DEFAULT_OCCUPATION_NETWORKS)
  
  ;.Call('R_swig_parameters_mean_work_interactions_set', self, s_mean_work_interactions, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_work_interactions_set`, 'returnType') = 'void'
attr(`parameters_mean_work_interactions_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_mean_work_interactions_set`) = c("SWIGFunction", class('parameters_mean_work_interactions_set'))

# Start of parameters_mean_work_interactions_get

`parameters_mean_work_interactions_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_mean_work_interactions_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_work_interactions_get`, 'returnType') = 'numeric'
attr(`parameters_mean_work_interactions_get`, "inputTypes") = c('_p_parameters')
class(`parameters_mean_work_interactions_get`) = c("SWIGFunction", class('parameters_mean_work_interactions_get'))

# Start of parameters_daily_fraction_work_set

`parameters_daily_fraction_work_set` = function(self, s_daily_fraction_work)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_daily_fraction_work_set', self, s_daily_fraction_work, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_daily_fraction_work_set`, 'returnType') = 'void'
attr(`parameters_daily_fraction_work_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_daily_fraction_work_set`) = c("SWIGFunction", class('parameters_daily_fraction_work_set'))

# Start of parameters_daily_fraction_work_get

`parameters_daily_fraction_work_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_daily_fraction_work_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_daily_fraction_work_get`, 'returnType') = 'numeric'
attr(`parameters_daily_fraction_work_get`, "inputTypes") = c('_p_parameters')
class(`parameters_daily_fraction_work_get`) = c("SWIGFunction", class('parameters_daily_fraction_work_get'))

# Start of parameters_child_network_adults_set

`parameters_child_network_adults_set` = function(self, s_child_network_adults)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_child_network_adults_set', self, s_child_network_adults, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_child_network_adults_set`, 'returnType') = 'void'
attr(`parameters_child_network_adults_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_child_network_adults_set`) = c("SWIGFunction", class('parameters_child_network_adults_set'))

# Start of parameters_child_network_adults_get

`parameters_child_network_adults_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_child_network_adults_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_child_network_adults_get`, 'returnType') = 'numeric'
attr(`parameters_child_network_adults_get`, "inputTypes") = c('_p_parameters')
class(`parameters_child_network_adults_get`) = c("SWIGFunction", class('parameters_child_network_adults_get'))

# Start of parameters_elderly_network_adults_set

`parameters_elderly_network_adults_set` = function(self, s_elderly_network_adults)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_elderly_network_adults_set', self, s_elderly_network_adults, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_elderly_network_adults_set`, 'returnType') = 'void'
attr(`parameters_elderly_network_adults_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_elderly_network_adults_set`) = c("SWIGFunction", class('parameters_elderly_network_adults_set'))

# Start of parameters_elderly_network_adults_get

`parameters_elderly_network_adults_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_elderly_network_adults_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_elderly_network_adults_get`, 'returnType') = 'numeric'
attr(`parameters_elderly_network_adults_get`, "inputTypes") = c('_p_parameters')
class(`parameters_elderly_network_adults_get`) = c("SWIGFunction", class('parameters_elderly_network_adults_get'))

# Start of parameters_work_network_rewire_set

`parameters_work_network_rewire_set` = function(self, s_work_network_rewire)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_work_network_rewire_set', self, s_work_network_rewire, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_work_network_rewire_set`, 'returnType') = 'void'
attr(`parameters_work_network_rewire_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_work_network_rewire_set`) = c("SWIGFunction", class('parameters_work_network_rewire_set'))

# Start of parameters_work_network_rewire_get

`parameters_work_network_rewire_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_work_network_rewire_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_work_network_rewire_get`, 'returnType') = 'numeric'
attr(`parameters_work_network_rewire_get`, "inputTypes") = c('_p_parameters')
class(`parameters_work_network_rewire_get`) = c("SWIGFunction", class('parameters_work_network_rewire_get'))

# Start of parameters_mean_infectious_period_set

`parameters_mean_infectious_period_set` = function(self, s_mean_infectious_period)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_mean_infectious_period_set', self, s_mean_infectious_period, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_infectious_period_set`, 'returnType') = 'void'
attr(`parameters_mean_infectious_period_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_mean_infectious_period_set`) = c("SWIGFunction", class('parameters_mean_infectious_period_set'))

# Start of parameters_mean_infectious_period_get

`parameters_mean_infectious_period_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_mean_infectious_period_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_infectious_period_get`, 'returnType') = 'numeric'
attr(`parameters_mean_infectious_period_get`, "inputTypes") = c('_p_parameters')
class(`parameters_mean_infectious_period_get`) = c("SWIGFunction", class('parameters_mean_infectious_period_get'))

# Start of parameters_sd_infectious_period_set

`parameters_sd_infectious_period_set` = function(self, s_sd_infectious_period)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_sd_infectious_period_set', self, s_sd_infectious_period, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sd_infectious_period_set`, 'returnType') = 'void'
attr(`parameters_sd_infectious_period_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_sd_infectious_period_set`) = c("SWIGFunction", class('parameters_sd_infectious_period_set'))

# Start of parameters_sd_infectious_period_get

`parameters_sd_infectious_period_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_sd_infectious_period_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sd_infectious_period_get`, 'returnType') = 'numeric'
attr(`parameters_sd_infectious_period_get`, "inputTypes") = c('_p_parameters')
class(`parameters_sd_infectious_period_get`) = c("SWIGFunction", class('parameters_sd_infectious_period_get'))

# Start of parameters_infectious_rate_set

`parameters_infectious_rate_set` = function(self, s_infectious_rate)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_infectious_rate_set', self, s_infectious_rate, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_infectious_rate_set`, 'returnType') = 'void'
attr(`parameters_infectious_rate_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_infectious_rate_set`) = c("SWIGFunction", class('parameters_infectious_rate_set'))

# Start of parameters_infectious_rate_get

`parameters_infectious_rate_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_infectious_rate_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_infectious_rate_get`, 'returnType') = 'numeric'
attr(`parameters_infectious_rate_get`, "inputTypes") = c('_p_parameters')
class(`parameters_infectious_rate_get`) = c("SWIGFunction", class('parameters_infectious_rate_get'))

# Start of parameters_sd_infectiousness_multiplier_set

`parameters_sd_infectiousness_multiplier_set` = function(self, s_sd_infectiousness_multiplier)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_sd_infectiousness_multiplier_set', self, s_sd_infectiousness_multiplier, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sd_infectiousness_multiplier_set`, 'returnType') = 'void'
attr(`parameters_sd_infectiousness_multiplier_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_sd_infectiousness_multiplier_set`) = c("SWIGFunction", class('parameters_sd_infectiousness_multiplier_set'))

# Start of parameters_sd_infectiousness_multiplier_get

`parameters_sd_infectiousness_multiplier_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_sd_infectiousness_multiplier_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sd_infectiousness_multiplier_get`, 'returnType') = 'numeric'
attr(`parameters_sd_infectiousness_multiplier_get`, "inputTypes") = c('_p_parameters')
class(`parameters_sd_infectiousness_multiplier_get`) = c("SWIGFunction", class('parameters_sd_infectiousness_multiplier_get'))

# Start of parameters_relative_susceptibility_set

`parameters_relative_susceptibility_set` = function(self, s_relative_susceptibility)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  
#  assert(length(s_relative_susceptibility) >= N_AGE_GROUPS)
  
  ;.Call('R_swig_parameters_relative_susceptibility_set', self, s_relative_susceptibility, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_relative_susceptibility_set`, 'returnType') = 'void'
attr(`parameters_relative_susceptibility_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_relative_susceptibility_set`) = c("SWIGFunction", class('parameters_relative_susceptibility_set'))

# Start of parameters_relative_susceptibility_get

`parameters_relative_susceptibility_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_relative_susceptibility_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_relative_susceptibility_get`, 'returnType') = 'numeric'
attr(`parameters_relative_susceptibility_get`, "inputTypes") = c('_p_parameters')
class(`parameters_relative_susceptibility_get`) = c("SWIGFunction", class('parameters_relative_susceptibility_get'))

# Start of parameters_adjusted_susceptibility_set

`parameters_adjusted_susceptibility_set` = function(self, s_adjusted_susceptibility)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  
#  assert(length(s_adjusted_susceptibility) >= N_AGE_GROUPS)
  
  ;.Call('R_swig_parameters_adjusted_susceptibility_set', self, s_adjusted_susceptibility, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_adjusted_susceptibility_set`, 'returnType') = 'void'
attr(`parameters_adjusted_susceptibility_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_adjusted_susceptibility_set`) = c("SWIGFunction", class('parameters_adjusted_susceptibility_set'))

# Start of parameters_adjusted_susceptibility_get

`parameters_adjusted_susceptibility_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_adjusted_susceptibility_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_adjusted_susceptibility_get`, 'returnType') = 'numeric'
attr(`parameters_adjusted_susceptibility_get`, "inputTypes") = c('_p_parameters')
class(`parameters_adjusted_susceptibility_get`) = c("SWIGFunction", class('parameters_adjusted_susceptibility_get'))

# Start of parameters_relative_susceptibility_by_interaction_set

`parameters_relative_susceptibility_by_interaction_set` = function(self, s_relative_susceptibility_by_interaction)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_relative_susceptibility_by_interaction = as.integer(s_relative_susceptibility_by_interaction);
  
  if(length(s_relative_susceptibility_by_interaction) > 1) {
    warning("using only the first element of s_relative_susceptibility_by_interaction");
  };
  
  ;.Call('R_swig_parameters_relative_susceptibility_by_interaction_set', self, s_relative_susceptibility_by_interaction, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_relative_susceptibility_by_interaction_set`, 'returnType') = 'void'
attr(`parameters_relative_susceptibility_by_interaction_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_relative_susceptibility_by_interaction_set`) = c("SWIGFunction", class('parameters_relative_susceptibility_by_interaction_set'))

# Start of parameters_relative_susceptibility_by_interaction_get

`parameters_relative_susceptibility_by_interaction_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_relative_susceptibility_by_interaction_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_relative_susceptibility_by_interaction_get`, 'returnType') = 'integer'
attr(`parameters_relative_susceptibility_by_interaction_get`, "inputTypes") = c('_p_parameters')
class(`parameters_relative_susceptibility_by_interaction_get`) = c("SWIGFunction", class('parameters_relative_susceptibility_by_interaction_get'))

# Start of parameters_relative_transmission_set

`parameters_relative_transmission_set` = function(self, s_relative_transmission)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  
#  assert(length(s_relative_transmission) >= N_INTERACTION_TYPES)
  
  ;.Call('R_swig_parameters_relative_transmission_set', self, s_relative_transmission, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_relative_transmission_set`, 'returnType') = 'void'
attr(`parameters_relative_transmission_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_relative_transmission_set`) = c("SWIGFunction", class('parameters_relative_transmission_set'))

# Start of parameters_relative_transmission_get

`parameters_relative_transmission_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_relative_transmission_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_relative_transmission_get`, 'returnType') = 'numeric'
attr(`parameters_relative_transmission_get`, "inputTypes") = c('_p_parameters')
class(`parameters_relative_transmission_get`) = c("SWIGFunction", class('parameters_relative_transmission_get'))

# Start of parameters_relative_transmission_used_set

`parameters_relative_transmission_used_set` = function(self, s_relative_transmission_used)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  
#  assert(length(s_relative_transmission_used) >= N_INTERACTION_TYPES)
  
  ;.Call('R_swig_parameters_relative_transmission_used_set', self, s_relative_transmission_used, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_relative_transmission_used_set`, 'returnType') = 'void'
attr(`parameters_relative_transmission_used_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_relative_transmission_used_set`) = c("SWIGFunction", class('parameters_relative_transmission_used_set'))

# Start of parameters_relative_transmission_used_get

`parameters_relative_transmission_used_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_relative_transmission_used_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_relative_transmission_used_get`, 'returnType') = 'numeric'
attr(`parameters_relative_transmission_used_get`, "inputTypes") = c('_p_parameters')
class(`parameters_relative_transmission_used_get`) = c("SWIGFunction", class('parameters_relative_transmission_used_get'))

# Start of parameters_mean_time_to_symptoms_set

`parameters_mean_time_to_symptoms_set` = function(self, s_mean_time_to_symptoms)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_mean_time_to_symptoms_set', self, s_mean_time_to_symptoms, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_time_to_symptoms_set`, 'returnType') = 'void'
attr(`parameters_mean_time_to_symptoms_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_mean_time_to_symptoms_set`) = c("SWIGFunction", class('parameters_mean_time_to_symptoms_set'))

# Start of parameters_mean_time_to_symptoms_get

`parameters_mean_time_to_symptoms_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_mean_time_to_symptoms_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_time_to_symptoms_get`, 'returnType') = 'numeric'
attr(`parameters_mean_time_to_symptoms_get`, "inputTypes") = c('_p_parameters')
class(`parameters_mean_time_to_symptoms_get`) = c("SWIGFunction", class('parameters_mean_time_to_symptoms_get'))

# Start of parameters_sd_time_to_symptoms_set

`parameters_sd_time_to_symptoms_set` = function(self, s_sd_time_to_symptoms)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_sd_time_to_symptoms_set', self, s_sd_time_to_symptoms, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sd_time_to_symptoms_set`, 'returnType') = 'void'
attr(`parameters_sd_time_to_symptoms_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_sd_time_to_symptoms_set`) = c("SWIGFunction", class('parameters_sd_time_to_symptoms_set'))

# Start of parameters_sd_time_to_symptoms_get

`parameters_sd_time_to_symptoms_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_sd_time_to_symptoms_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sd_time_to_symptoms_get`, 'returnType') = 'numeric'
attr(`parameters_sd_time_to_symptoms_get`, "inputTypes") = c('_p_parameters')
class(`parameters_sd_time_to_symptoms_get`) = c("SWIGFunction", class('parameters_sd_time_to_symptoms_get'))

# Start of parameters_hospitalised_fraction_set

`parameters_hospitalised_fraction_set` = function(self, s_hospitalised_fraction)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  
#  assert(length(s_hospitalised_fraction) >= N_AGE_GROUPS)
  
  ;.Call('R_swig_parameters_hospitalised_fraction_set', self, s_hospitalised_fraction, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_hospitalised_fraction_set`, 'returnType') = 'void'
attr(`parameters_hospitalised_fraction_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_hospitalised_fraction_set`) = c("SWIGFunction", class('parameters_hospitalised_fraction_set'))

# Start of parameters_hospitalised_fraction_get

`parameters_hospitalised_fraction_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_hospitalised_fraction_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_hospitalised_fraction_get`, 'returnType') = 'numeric'
attr(`parameters_hospitalised_fraction_get`, "inputTypes") = c('_p_parameters')
class(`parameters_hospitalised_fraction_get`) = c("SWIGFunction", class('parameters_hospitalised_fraction_get'))

# Start of parameters_critical_fraction_set

`parameters_critical_fraction_set` = function(self, s_critical_fraction)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  
#  assert(length(s_critical_fraction) >= N_AGE_GROUPS)
  
  ;.Call('R_swig_parameters_critical_fraction_set', self, s_critical_fraction, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_critical_fraction_set`, 'returnType') = 'void'
attr(`parameters_critical_fraction_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_critical_fraction_set`) = c("SWIGFunction", class('parameters_critical_fraction_set'))

# Start of parameters_critical_fraction_get

`parameters_critical_fraction_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_critical_fraction_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_critical_fraction_get`, 'returnType') = 'numeric'
attr(`parameters_critical_fraction_get`, "inputTypes") = c('_p_parameters')
class(`parameters_critical_fraction_get`) = c("SWIGFunction", class('parameters_critical_fraction_get'))

# Start of parameters_fatality_fraction_set

`parameters_fatality_fraction_set` = function(self, s_fatality_fraction)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  
#  assert(length(s_fatality_fraction) >= N_AGE_GROUPS)
  
  ;.Call('R_swig_parameters_fatality_fraction_set', self, s_fatality_fraction, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_fatality_fraction_set`, 'returnType') = 'void'
attr(`parameters_fatality_fraction_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_fatality_fraction_set`) = c("SWIGFunction", class('parameters_fatality_fraction_set'))

# Start of parameters_fatality_fraction_get

`parameters_fatality_fraction_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_fatality_fraction_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_fatality_fraction_get`, 'returnType') = 'numeric'
attr(`parameters_fatality_fraction_get`, "inputTypes") = c('_p_parameters')
class(`parameters_fatality_fraction_get`) = c("SWIGFunction", class('parameters_fatality_fraction_get'))

# Start of parameters_mean_time_to_hospital_set

`parameters_mean_time_to_hospital_set` = function(self, s_mean_time_to_hospital)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_mean_time_to_hospital_set', self, s_mean_time_to_hospital, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_time_to_hospital_set`, 'returnType') = 'void'
attr(`parameters_mean_time_to_hospital_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_mean_time_to_hospital_set`) = c("SWIGFunction", class('parameters_mean_time_to_hospital_set'))

# Start of parameters_mean_time_to_hospital_get

`parameters_mean_time_to_hospital_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_mean_time_to_hospital_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_time_to_hospital_get`, 'returnType') = 'numeric'
attr(`parameters_mean_time_to_hospital_get`, "inputTypes") = c('_p_parameters')
class(`parameters_mean_time_to_hospital_get`) = c("SWIGFunction", class('parameters_mean_time_to_hospital_get'))

# Start of parameters_mean_time_to_critical_set

`parameters_mean_time_to_critical_set` = function(self, s_mean_time_to_critical)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_mean_time_to_critical_set', self, s_mean_time_to_critical, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_time_to_critical_set`, 'returnType') = 'void'
attr(`parameters_mean_time_to_critical_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_mean_time_to_critical_set`) = c("SWIGFunction", class('parameters_mean_time_to_critical_set'))

# Start of parameters_mean_time_to_critical_get

`parameters_mean_time_to_critical_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_mean_time_to_critical_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_time_to_critical_get`, 'returnType') = 'numeric'
attr(`parameters_mean_time_to_critical_get`, "inputTypes") = c('_p_parameters')
class(`parameters_mean_time_to_critical_get`) = c("SWIGFunction", class('parameters_mean_time_to_critical_get'))

# Start of parameters_sd_time_to_critical_set

`parameters_sd_time_to_critical_set` = function(self, s_sd_time_to_critical)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_sd_time_to_critical_set', self, s_sd_time_to_critical, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sd_time_to_critical_set`, 'returnType') = 'void'
attr(`parameters_sd_time_to_critical_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_sd_time_to_critical_set`) = c("SWIGFunction", class('parameters_sd_time_to_critical_set'))

# Start of parameters_sd_time_to_critical_get

`parameters_sd_time_to_critical_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_sd_time_to_critical_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sd_time_to_critical_get`, 'returnType') = 'numeric'
attr(`parameters_sd_time_to_critical_get`, "inputTypes") = c('_p_parameters')
class(`parameters_sd_time_to_critical_get`) = c("SWIGFunction", class('parameters_sd_time_to_critical_get'))

# Start of parameters_mean_time_to_recover_set

`parameters_mean_time_to_recover_set` = function(self, s_mean_time_to_recover)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_mean_time_to_recover_set', self, s_mean_time_to_recover, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_time_to_recover_set`, 'returnType') = 'void'
attr(`parameters_mean_time_to_recover_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_mean_time_to_recover_set`) = c("SWIGFunction", class('parameters_mean_time_to_recover_set'))

# Start of parameters_mean_time_to_recover_get

`parameters_mean_time_to_recover_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_mean_time_to_recover_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_time_to_recover_get`, 'returnType') = 'numeric'
attr(`parameters_mean_time_to_recover_get`, "inputTypes") = c('_p_parameters')
class(`parameters_mean_time_to_recover_get`) = c("SWIGFunction", class('parameters_mean_time_to_recover_get'))

# Start of parameters_sd_time_to_recover_set

`parameters_sd_time_to_recover_set` = function(self, s_sd_time_to_recover)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_sd_time_to_recover_set', self, s_sd_time_to_recover, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sd_time_to_recover_set`, 'returnType') = 'void'
attr(`parameters_sd_time_to_recover_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_sd_time_to_recover_set`) = c("SWIGFunction", class('parameters_sd_time_to_recover_set'))

# Start of parameters_sd_time_to_recover_get

`parameters_sd_time_to_recover_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_sd_time_to_recover_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sd_time_to_recover_get`, 'returnType') = 'numeric'
attr(`parameters_sd_time_to_recover_get`, "inputTypes") = c('_p_parameters')
class(`parameters_sd_time_to_recover_get`) = c("SWIGFunction", class('parameters_sd_time_to_recover_get'))

# Start of parameters_mean_time_to_death_set

`parameters_mean_time_to_death_set` = function(self, s_mean_time_to_death)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_mean_time_to_death_set', self, s_mean_time_to_death, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_time_to_death_set`, 'returnType') = 'void'
attr(`parameters_mean_time_to_death_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_mean_time_to_death_set`) = c("SWIGFunction", class('parameters_mean_time_to_death_set'))

# Start of parameters_mean_time_to_death_get

`parameters_mean_time_to_death_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_mean_time_to_death_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_time_to_death_get`, 'returnType') = 'numeric'
attr(`parameters_mean_time_to_death_get`, "inputTypes") = c('_p_parameters')
class(`parameters_mean_time_to_death_get`) = c("SWIGFunction", class('parameters_mean_time_to_death_get'))

# Start of parameters_sd_time_to_death_set

`parameters_sd_time_to_death_set` = function(self, s_sd_time_to_death)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_sd_time_to_death_set', self, s_sd_time_to_death, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sd_time_to_death_set`, 'returnType') = 'void'
attr(`parameters_sd_time_to_death_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_sd_time_to_death_set`) = c("SWIGFunction", class('parameters_sd_time_to_death_set'))

# Start of parameters_sd_time_to_death_get

`parameters_sd_time_to_death_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_sd_time_to_death_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sd_time_to_death_get`, 'returnType') = 'numeric'
attr(`parameters_sd_time_to_death_get`, "inputTypes") = c('_p_parameters')
class(`parameters_sd_time_to_death_get`) = c("SWIGFunction", class('parameters_sd_time_to_death_get'))

# Start of parameters_mean_time_to_susceptible_after_shift_set

`parameters_mean_time_to_susceptible_after_shift_set` = function(self, s_mean_time_to_susceptible_after_shift)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_mean_time_to_susceptible_after_shift_set', self, s_mean_time_to_susceptible_after_shift, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_time_to_susceptible_after_shift_set`, 'returnType') = 'void'
attr(`parameters_mean_time_to_susceptible_after_shift_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_mean_time_to_susceptible_after_shift_set`) = c("SWIGFunction", class('parameters_mean_time_to_susceptible_after_shift_set'))

# Start of parameters_mean_time_to_susceptible_after_shift_get

`parameters_mean_time_to_susceptible_after_shift_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_mean_time_to_susceptible_after_shift_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_time_to_susceptible_after_shift_get`, 'returnType') = 'numeric'
attr(`parameters_mean_time_to_susceptible_after_shift_get`, "inputTypes") = c('_p_parameters')
class(`parameters_mean_time_to_susceptible_after_shift_get`) = c("SWIGFunction", class('parameters_mean_time_to_susceptible_after_shift_get'))

# Start of parameters_time_to_susceptible_shift_set

`parameters_time_to_susceptible_shift_set` = function(self, s_time_to_susceptible_shift)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_time_to_susceptible_shift = as.integer(s_time_to_susceptible_shift);
  
  if(length(s_time_to_susceptible_shift) > 1) {
    warning("using only the first element of s_time_to_susceptible_shift");
  };
  
  ;.Call('R_swig_parameters_time_to_susceptible_shift_set', self, s_time_to_susceptible_shift, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_time_to_susceptible_shift_set`, 'returnType') = 'void'
attr(`parameters_time_to_susceptible_shift_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_time_to_susceptible_shift_set`) = c("SWIGFunction", class('parameters_time_to_susceptible_shift_set'))

# Start of parameters_time_to_susceptible_shift_get

`parameters_time_to_susceptible_shift_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_time_to_susceptible_shift_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_time_to_susceptible_shift_get`, 'returnType') = 'integer'
attr(`parameters_time_to_susceptible_shift_get`, "inputTypes") = c('_p_parameters')
class(`parameters_time_to_susceptible_shift_get`) = c("SWIGFunction", class('parameters_time_to_susceptible_shift_get'))

# Start of parameters_household_size_set

`parameters_household_size_set` = function(self, s_household_size)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  
#  assert(length(s_household_size) >= N_HOUSEHOLD_MAX)
  
  ;.Call('R_swig_parameters_household_size_set', self, s_household_size, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_household_size_set`, 'returnType') = 'void'
attr(`parameters_household_size_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_household_size_set`) = c("SWIGFunction", class('parameters_household_size_set'))

# Start of parameters_household_size_get

`parameters_household_size_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_household_size_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_household_size_get`, 'returnType') = 'numeric'
attr(`parameters_household_size_get`, "inputTypes") = c('_p_parameters')
class(`parameters_household_size_get`) = c("SWIGFunction", class('parameters_household_size_get'))

# Start of parameters_population_set

`parameters_population_set` = function(self, s_population)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  
#  assert(length(s_population) >= N_AGE_GROUPS)
  
  ;.Call('R_swig_parameters_population_set', self, s_population, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_population_set`, 'returnType') = 'void'
attr(`parameters_population_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_population_set`) = c("SWIGFunction", class('parameters_population_set'))

# Start of parameters_population_get

`parameters_population_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_population_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_population_get`, 'returnType') = 'numeric'
attr(`parameters_population_get`, "inputTypes") = c('_p_parameters')
class(`parameters_population_get`) = c("SWIGFunction", class('parameters_population_get'))

# Start of parameters_fraction_asymptomatic_set

`parameters_fraction_asymptomatic_set` = function(self, s_fraction_asymptomatic)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  
#  assert(length(s_fraction_asymptomatic) >= N_AGE_GROUPS)
  
  ;.Call('R_swig_parameters_fraction_asymptomatic_set', self, s_fraction_asymptomatic, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_fraction_asymptomatic_set`, 'returnType') = 'void'
attr(`parameters_fraction_asymptomatic_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_fraction_asymptomatic_set`) = c("SWIGFunction", class('parameters_fraction_asymptomatic_set'))

# Start of parameters_fraction_asymptomatic_get

`parameters_fraction_asymptomatic_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_fraction_asymptomatic_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_fraction_asymptomatic_get`, 'returnType') = 'numeric'
attr(`parameters_fraction_asymptomatic_get`, "inputTypes") = c('_p_parameters')
class(`parameters_fraction_asymptomatic_get`) = c("SWIGFunction", class('parameters_fraction_asymptomatic_get'))

# Start of parameters_asymptomatic_infectious_factor_set

`parameters_asymptomatic_infectious_factor_set` = function(self, s_asymptomatic_infectious_factor)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_asymptomatic_infectious_factor_set', self, s_asymptomatic_infectious_factor, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_asymptomatic_infectious_factor_set`, 'returnType') = 'void'
attr(`parameters_asymptomatic_infectious_factor_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_asymptomatic_infectious_factor_set`) = c("SWIGFunction", class('parameters_asymptomatic_infectious_factor_set'))

# Start of parameters_asymptomatic_infectious_factor_get

`parameters_asymptomatic_infectious_factor_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_asymptomatic_infectious_factor_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_asymptomatic_infectious_factor_get`, 'returnType') = 'numeric'
attr(`parameters_asymptomatic_infectious_factor_get`, "inputTypes") = c('_p_parameters')
class(`parameters_asymptomatic_infectious_factor_get`) = c("SWIGFunction", class('parameters_asymptomatic_infectious_factor_get'))

# Start of parameters_mild_fraction_set

`parameters_mild_fraction_set` = function(self, s_mild_fraction)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  
#  assert(length(s_mild_fraction) >= N_AGE_GROUPS)
  
  ;.Call('R_swig_parameters_mild_fraction_set', self, s_mild_fraction, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mild_fraction_set`, 'returnType') = 'void'
attr(`parameters_mild_fraction_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_mild_fraction_set`) = c("SWIGFunction", class('parameters_mild_fraction_set'))

# Start of parameters_mild_fraction_get

`parameters_mild_fraction_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_mild_fraction_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mild_fraction_get`, 'returnType') = 'numeric'
attr(`parameters_mild_fraction_get`, "inputTypes") = c('_p_parameters')
class(`parameters_mild_fraction_get`) = c("SWIGFunction", class('parameters_mild_fraction_get'))

# Start of parameters_mild_infectious_factor_set

`parameters_mild_infectious_factor_set` = function(self, s_mild_infectious_factor)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_mild_infectious_factor_set', self, s_mild_infectious_factor, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mild_infectious_factor_set`, 'returnType') = 'void'
attr(`parameters_mild_infectious_factor_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_mild_infectious_factor_set`) = c("SWIGFunction", class('parameters_mild_infectious_factor_set'))

# Start of parameters_mild_infectious_factor_get

`parameters_mild_infectious_factor_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_mild_infectious_factor_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mild_infectious_factor_get`, 'returnType') = 'numeric'
attr(`parameters_mild_infectious_factor_get`, "inputTypes") = c('_p_parameters')
class(`parameters_mild_infectious_factor_get`) = c("SWIGFunction", class('parameters_mild_infectious_factor_get'))

# Start of parameters_mean_asymptomatic_to_recovery_set

`parameters_mean_asymptomatic_to_recovery_set` = function(self, s_mean_asymptomatic_to_recovery)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_mean_asymptomatic_to_recovery_set', self, s_mean_asymptomatic_to_recovery, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_asymptomatic_to_recovery_set`, 'returnType') = 'void'
attr(`parameters_mean_asymptomatic_to_recovery_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_mean_asymptomatic_to_recovery_set`) = c("SWIGFunction", class('parameters_mean_asymptomatic_to_recovery_set'))

# Start of parameters_mean_asymptomatic_to_recovery_get

`parameters_mean_asymptomatic_to_recovery_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_mean_asymptomatic_to_recovery_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_asymptomatic_to_recovery_get`, 'returnType') = 'numeric'
attr(`parameters_mean_asymptomatic_to_recovery_get`, "inputTypes") = c('_p_parameters')
class(`parameters_mean_asymptomatic_to_recovery_get`) = c("SWIGFunction", class('parameters_mean_asymptomatic_to_recovery_get'))

# Start of parameters_sd_asymptomatic_to_recovery_set

`parameters_sd_asymptomatic_to_recovery_set` = function(self, s_sd_asymptomatic_to_recovery)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_sd_asymptomatic_to_recovery_set', self, s_sd_asymptomatic_to_recovery, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sd_asymptomatic_to_recovery_set`, 'returnType') = 'void'
attr(`parameters_sd_asymptomatic_to_recovery_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_sd_asymptomatic_to_recovery_set`) = c("SWIGFunction", class('parameters_sd_asymptomatic_to_recovery_set'))

# Start of parameters_sd_asymptomatic_to_recovery_get

`parameters_sd_asymptomatic_to_recovery_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_sd_asymptomatic_to_recovery_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sd_asymptomatic_to_recovery_get`, 'returnType') = 'numeric'
attr(`parameters_sd_asymptomatic_to_recovery_get`, "inputTypes") = c('_p_parameters')
class(`parameters_sd_asymptomatic_to_recovery_get`) = c("SWIGFunction", class('parameters_sd_asymptomatic_to_recovery_get'))

# Start of parameters_mean_time_hospitalised_recovery_set

`parameters_mean_time_hospitalised_recovery_set` = function(self, s_mean_time_hospitalised_recovery)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_mean_time_hospitalised_recovery_set', self, s_mean_time_hospitalised_recovery, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_time_hospitalised_recovery_set`, 'returnType') = 'void'
attr(`parameters_mean_time_hospitalised_recovery_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_mean_time_hospitalised_recovery_set`) = c("SWIGFunction", class('parameters_mean_time_hospitalised_recovery_set'))

# Start of parameters_mean_time_hospitalised_recovery_get

`parameters_mean_time_hospitalised_recovery_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_mean_time_hospitalised_recovery_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_time_hospitalised_recovery_get`, 'returnType') = 'numeric'
attr(`parameters_mean_time_hospitalised_recovery_get`, "inputTypes") = c('_p_parameters')
class(`parameters_mean_time_hospitalised_recovery_get`) = c("SWIGFunction", class('parameters_mean_time_hospitalised_recovery_get'))

# Start of parameters_sd_time_hospitalised_recovery_set

`parameters_sd_time_hospitalised_recovery_set` = function(self, s_sd_time_hospitalised_recovery)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_sd_time_hospitalised_recovery_set', self, s_sd_time_hospitalised_recovery, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sd_time_hospitalised_recovery_set`, 'returnType') = 'void'
attr(`parameters_sd_time_hospitalised_recovery_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_sd_time_hospitalised_recovery_set`) = c("SWIGFunction", class('parameters_sd_time_hospitalised_recovery_set'))

# Start of parameters_sd_time_hospitalised_recovery_get

`parameters_sd_time_hospitalised_recovery_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_sd_time_hospitalised_recovery_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sd_time_hospitalised_recovery_get`, 'returnType') = 'numeric'
attr(`parameters_sd_time_hospitalised_recovery_get`, "inputTypes") = c('_p_parameters')
class(`parameters_sd_time_hospitalised_recovery_get`) = c("SWIGFunction", class('parameters_sd_time_hospitalised_recovery_get'))

# Start of parameters_mean_time_critical_survive_set

`parameters_mean_time_critical_survive_set` = function(self, s_mean_time_critical_survive)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_mean_time_critical_survive_set', self, s_mean_time_critical_survive, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_time_critical_survive_set`, 'returnType') = 'void'
attr(`parameters_mean_time_critical_survive_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_mean_time_critical_survive_set`) = c("SWIGFunction", class('parameters_mean_time_critical_survive_set'))

# Start of parameters_mean_time_critical_survive_get

`parameters_mean_time_critical_survive_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_mean_time_critical_survive_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_mean_time_critical_survive_get`, 'returnType') = 'numeric'
attr(`parameters_mean_time_critical_survive_get`, "inputTypes") = c('_p_parameters')
class(`parameters_mean_time_critical_survive_get`) = c("SWIGFunction", class('parameters_mean_time_critical_survive_get'))

# Start of parameters_sd_time_critical_survive_set

`parameters_sd_time_critical_survive_set` = function(self, s_sd_time_critical_survive)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_sd_time_critical_survive_set', self, s_sd_time_critical_survive, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sd_time_critical_survive_set`, 'returnType') = 'void'
attr(`parameters_sd_time_critical_survive_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_sd_time_critical_survive_set`) = c("SWIGFunction", class('parameters_sd_time_critical_survive_set'))

# Start of parameters_sd_time_critical_survive_get

`parameters_sd_time_critical_survive_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_sd_time_critical_survive_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sd_time_critical_survive_get`, 'returnType') = 'numeric'
attr(`parameters_sd_time_critical_survive_get`, "inputTypes") = c('_p_parameters')
class(`parameters_sd_time_critical_survive_get`) = c("SWIGFunction", class('parameters_sd_time_critical_survive_get'))

# Start of parameters_location_death_icu_set

`parameters_location_death_icu_set` = function(self, s_location_death_icu)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  
#  assert(length(s_location_death_icu) >= N_AGE_GROUPS)
  
  ;.Call('R_swig_parameters_location_death_icu_set', self, s_location_death_icu, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_location_death_icu_set`, 'returnType') = 'void'
attr(`parameters_location_death_icu_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_location_death_icu_set`) = c("SWIGFunction", class('parameters_location_death_icu_set'))

# Start of parameters_location_death_icu_get

`parameters_location_death_icu_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_location_death_icu_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_location_death_icu_get`, 'returnType') = 'numeric'
attr(`parameters_location_death_icu_get`, "inputTypes") = c('_p_parameters')
class(`parameters_location_death_icu_get`) = c("SWIGFunction", class('parameters_location_death_icu_get'))

# Start of parameters_quarantined_daily_interactions_set

`parameters_quarantined_daily_interactions_set` = function(self, s_quarantined_daily_interactions)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_quarantined_daily_interactions = as.integer(s_quarantined_daily_interactions);
  
  if(length(s_quarantined_daily_interactions) > 1) {
    warning("using only the first element of s_quarantined_daily_interactions");
  };
  
  ;.Call('R_swig_parameters_quarantined_daily_interactions_set', self, s_quarantined_daily_interactions, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantined_daily_interactions_set`, 'returnType') = 'void'
attr(`parameters_quarantined_daily_interactions_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_quarantined_daily_interactions_set`) = c("SWIGFunction", class('parameters_quarantined_daily_interactions_set'))

# Start of parameters_quarantined_daily_interactions_get

`parameters_quarantined_daily_interactions_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_quarantined_daily_interactions_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantined_daily_interactions_get`, 'returnType') = 'integer'
attr(`parameters_quarantined_daily_interactions_get`, "inputTypes") = c('_p_parameters')
class(`parameters_quarantined_daily_interactions_get`) = c("SWIGFunction", class('parameters_quarantined_daily_interactions_get'))

# Start of parameters_hospitalised_daily_interactions_set

`parameters_hospitalised_daily_interactions_set` = function(self, s_hospitalised_daily_interactions)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_hospitalised_daily_interactions = as.integer(s_hospitalised_daily_interactions);
  
  if(length(s_hospitalised_daily_interactions) > 1) {
    warning("using only the first element of s_hospitalised_daily_interactions");
  };
  
  ;.Call('R_swig_parameters_hospitalised_daily_interactions_set', self, s_hospitalised_daily_interactions, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_hospitalised_daily_interactions_set`, 'returnType') = 'void'
attr(`parameters_hospitalised_daily_interactions_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_hospitalised_daily_interactions_set`) = c("SWIGFunction", class('parameters_hospitalised_daily_interactions_set'))

# Start of parameters_hospitalised_daily_interactions_get

`parameters_hospitalised_daily_interactions_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_hospitalised_daily_interactions_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_hospitalised_daily_interactions_get`, 'returnType') = 'integer'
attr(`parameters_hospitalised_daily_interactions_get`, "inputTypes") = c('_p_parameters')
class(`parameters_hospitalised_daily_interactions_get`) = c("SWIGFunction", class('parameters_hospitalised_daily_interactions_get'))

# Start of parameters_quarantine_days_set

`parameters_quarantine_days_set` = function(self, s_quarantine_days)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_quarantine_days = as.integer(s_quarantine_days);
  
  if(length(s_quarantine_days) > 1) {
    warning("using only the first element of s_quarantine_days");
  };
  
  ;.Call('R_swig_parameters_quarantine_days_set', self, s_quarantine_days, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_days_set`, 'returnType') = 'void'
attr(`parameters_quarantine_days_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_quarantine_days_set`) = c("SWIGFunction", class('parameters_quarantine_days_set'))

# Start of parameters_quarantine_days_get

`parameters_quarantine_days_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_quarantine_days_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_days_get`, 'returnType') = 'integer'
attr(`parameters_quarantine_days_get`, "inputTypes") = c('_p_parameters')
class(`parameters_quarantine_days_get`) = c("SWIGFunction", class('parameters_quarantine_days_get'))

# Start of parameters_self_quarantine_fraction_set

`parameters_self_quarantine_fraction_set` = function(self, s_self_quarantine_fraction)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_self_quarantine_fraction_set', self, s_self_quarantine_fraction, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_self_quarantine_fraction_set`, 'returnType') = 'void'
attr(`parameters_self_quarantine_fraction_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_self_quarantine_fraction_set`) = c("SWIGFunction", class('parameters_self_quarantine_fraction_set'))

# Start of parameters_self_quarantine_fraction_get

`parameters_self_quarantine_fraction_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_self_quarantine_fraction_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_self_quarantine_fraction_get`, 'returnType') = 'numeric'
attr(`parameters_self_quarantine_fraction_get`, "inputTypes") = c('_p_parameters')
class(`parameters_self_quarantine_fraction_get`) = c("SWIGFunction", class('parameters_self_quarantine_fraction_get'))

# Start of parameters_manual_trace_on_set

`parameters_manual_trace_on_set` = function(self, s_manual_trace_on)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_manual_trace_on = as.integer(s_manual_trace_on);
  
  if(length(s_manual_trace_on) > 1) {
    warning("using only the first element of s_manual_trace_on");
  };
  
  ;.Call('R_swig_parameters_manual_trace_on_set', self, s_manual_trace_on, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_manual_trace_on_set`, 'returnType') = 'void'
attr(`parameters_manual_trace_on_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_manual_trace_on_set`) = c("SWIGFunction", class('parameters_manual_trace_on_set'))

# Start of parameters_manual_trace_on_get

`parameters_manual_trace_on_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_manual_trace_on_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_manual_trace_on_get`, 'returnType') = 'integer'
attr(`parameters_manual_trace_on_get`, "inputTypes") = c('_p_parameters')
class(`parameters_manual_trace_on_get`) = c("SWIGFunction", class('parameters_manual_trace_on_get'))

# Start of parameters_manual_trace_time_on_set

`parameters_manual_trace_time_on_set` = function(self, s_manual_trace_time_on)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_manual_trace_time_on = as.integer(s_manual_trace_time_on);
  
  if(length(s_manual_trace_time_on) > 1) {
    warning("using only the first element of s_manual_trace_time_on");
  };
  
  ;.Call('R_swig_parameters_manual_trace_time_on_set', self, s_manual_trace_time_on, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_manual_trace_time_on_set`, 'returnType') = 'void'
attr(`parameters_manual_trace_time_on_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_manual_trace_time_on_set`) = c("SWIGFunction", class('parameters_manual_trace_time_on_set'))

# Start of parameters_manual_trace_time_on_get

`parameters_manual_trace_time_on_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_manual_trace_time_on_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_manual_trace_time_on_get`, 'returnType') = 'integer'
attr(`parameters_manual_trace_time_on_get`, "inputTypes") = c('_p_parameters')
class(`parameters_manual_trace_time_on_get`) = c("SWIGFunction", class('parameters_manual_trace_time_on_get'))

# Start of parameters_manual_trace_on_hospitalization_set

`parameters_manual_trace_on_hospitalization_set` = function(self, s_manual_trace_on_hospitalization)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_manual_trace_on_hospitalization = as.integer(s_manual_trace_on_hospitalization);
  
  if(length(s_manual_trace_on_hospitalization) > 1) {
    warning("using only the first element of s_manual_trace_on_hospitalization");
  };
  
  ;.Call('R_swig_parameters_manual_trace_on_hospitalization_set', self, s_manual_trace_on_hospitalization, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_manual_trace_on_hospitalization_set`, 'returnType') = 'void'
attr(`parameters_manual_trace_on_hospitalization_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_manual_trace_on_hospitalization_set`) = c("SWIGFunction", class('parameters_manual_trace_on_hospitalization_set'))

# Start of parameters_manual_trace_on_hospitalization_get

`parameters_manual_trace_on_hospitalization_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_manual_trace_on_hospitalization_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_manual_trace_on_hospitalization_get`, 'returnType') = 'integer'
attr(`parameters_manual_trace_on_hospitalization_get`, "inputTypes") = c('_p_parameters')
class(`parameters_manual_trace_on_hospitalization_get`) = c("SWIGFunction", class('parameters_manual_trace_on_hospitalization_get'))

# Start of parameters_manual_trace_on_positive_set

`parameters_manual_trace_on_positive_set` = function(self, s_manual_trace_on_positive)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_manual_trace_on_positive = as.integer(s_manual_trace_on_positive);
  
  if(length(s_manual_trace_on_positive) > 1) {
    warning("using only the first element of s_manual_trace_on_positive");
  };
  
  ;.Call('R_swig_parameters_manual_trace_on_positive_set', self, s_manual_trace_on_positive, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_manual_trace_on_positive_set`, 'returnType') = 'void'
attr(`parameters_manual_trace_on_positive_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_manual_trace_on_positive_set`) = c("SWIGFunction", class('parameters_manual_trace_on_positive_set'))

# Start of parameters_manual_trace_on_positive_get

`parameters_manual_trace_on_positive_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_manual_trace_on_positive_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_manual_trace_on_positive_get`, 'returnType') = 'integer'
attr(`parameters_manual_trace_on_positive_get`, "inputTypes") = c('_p_parameters')
class(`parameters_manual_trace_on_positive_get`) = c("SWIGFunction", class('parameters_manual_trace_on_positive_get'))

# Start of parameters_manual_trace_delay_set

`parameters_manual_trace_delay_set` = function(self, s_manual_trace_delay)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_manual_trace_delay = as.integer(s_manual_trace_delay);
  
  if(length(s_manual_trace_delay) > 1) {
    warning("using only the first element of s_manual_trace_delay");
  };
  
  ;.Call('R_swig_parameters_manual_trace_delay_set', self, s_manual_trace_delay, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_manual_trace_delay_set`, 'returnType') = 'void'
attr(`parameters_manual_trace_delay_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_manual_trace_delay_set`) = c("SWIGFunction", class('parameters_manual_trace_delay_set'))

# Start of parameters_manual_trace_delay_get

`parameters_manual_trace_delay_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_manual_trace_delay_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_manual_trace_delay_get`, 'returnType') = 'integer'
attr(`parameters_manual_trace_delay_get`, "inputTypes") = c('_p_parameters')
class(`parameters_manual_trace_delay_get`) = c("SWIGFunction", class('parameters_manual_trace_delay_get'))

# Start of parameters_manual_trace_exclude_app_users_set

`parameters_manual_trace_exclude_app_users_set` = function(self, s_manual_trace_exclude_app_users)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_manual_trace_exclude_app_users = as.integer(s_manual_trace_exclude_app_users);
  
  if(length(s_manual_trace_exclude_app_users) > 1) {
    warning("using only the first element of s_manual_trace_exclude_app_users");
  };
  
  ;.Call('R_swig_parameters_manual_trace_exclude_app_users_set', self, s_manual_trace_exclude_app_users, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_manual_trace_exclude_app_users_set`, 'returnType') = 'void'
attr(`parameters_manual_trace_exclude_app_users_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_manual_trace_exclude_app_users_set`) = c("SWIGFunction", class('parameters_manual_trace_exclude_app_users_set'))

# Start of parameters_manual_trace_exclude_app_users_get

`parameters_manual_trace_exclude_app_users_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_manual_trace_exclude_app_users_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_manual_trace_exclude_app_users_get`, 'returnType') = 'integer'
attr(`parameters_manual_trace_exclude_app_users_get`, "inputTypes") = c('_p_parameters')
class(`parameters_manual_trace_exclude_app_users_get`) = c("SWIGFunction", class('parameters_manual_trace_exclude_app_users_get'))

# Start of parameters_manual_trace_n_workers_set

`parameters_manual_trace_n_workers_set` = function(self, s_manual_trace_n_workers)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_manual_trace_n_workers = as.integer(s_manual_trace_n_workers);
  
  if(length(s_manual_trace_n_workers) > 1) {
    warning("using only the first element of s_manual_trace_n_workers");
  };
  
  ;.Call('R_swig_parameters_manual_trace_n_workers_set', self, s_manual_trace_n_workers, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_manual_trace_n_workers_set`, 'returnType') = 'void'
attr(`parameters_manual_trace_n_workers_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_manual_trace_n_workers_set`) = c("SWIGFunction", class('parameters_manual_trace_n_workers_set'))

# Start of parameters_manual_trace_n_workers_get

`parameters_manual_trace_n_workers_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_manual_trace_n_workers_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_manual_trace_n_workers_get`, 'returnType') = 'integer'
attr(`parameters_manual_trace_n_workers_get`, "inputTypes") = c('_p_parameters')
class(`parameters_manual_trace_n_workers_get`) = c("SWIGFunction", class('parameters_manual_trace_n_workers_get'))

# Start of parameters_manual_trace_interviews_per_worker_day_set

`parameters_manual_trace_interviews_per_worker_day_set` = function(self, s_manual_trace_interviews_per_worker_day)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_manual_trace_interviews_per_worker_day = as.integer(s_manual_trace_interviews_per_worker_day);
  
  if(length(s_manual_trace_interviews_per_worker_day) > 1) {
    warning("using only the first element of s_manual_trace_interviews_per_worker_day");
  };
  
  ;.Call('R_swig_parameters_manual_trace_interviews_per_worker_day_set', self, s_manual_trace_interviews_per_worker_day, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_manual_trace_interviews_per_worker_day_set`, 'returnType') = 'void'
attr(`parameters_manual_trace_interviews_per_worker_day_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_manual_trace_interviews_per_worker_day_set`) = c("SWIGFunction", class('parameters_manual_trace_interviews_per_worker_day_set'))

# Start of parameters_manual_trace_interviews_per_worker_day_get

`parameters_manual_trace_interviews_per_worker_day_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_manual_trace_interviews_per_worker_day_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_manual_trace_interviews_per_worker_day_get`, 'returnType') = 'integer'
attr(`parameters_manual_trace_interviews_per_worker_day_get`, "inputTypes") = c('_p_parameters')
class(`parameters_manual_trace_interviews_per_worker_day_get`) = c("SWIGFunction", class('parameters_manual_trace_interviews_per_worker_day_get'))

# Start of parameters_manual_trace_notifications_per_worker_day_set

`parameters_manual_trace_notifications_per_worker_day_set` = function(self, s_manual_trace_notifications_per_worker_day)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_manual_trace_notifications_per_worker_day = as.integer(s_manual_trace_notifications_per_worker_day);
  
  if(length(s_manual_trace_notifications_per_worker_day) > 1) {
    warning("using only the first element of s_manual_trace_notifications_per_worker_day");
  };
  
  ;.Call('R_swig_parameters_manual_trace_notifications_per_worker_day_set', self, s_manual_trace_notifications_per_worker_day, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_manual_trace_notifications_per_worker_day_set`, 'returnType') = 'void'
attr(`parameters_manual_trace_notifications_per_worker_day_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_manual_trace_notifications_per_worker_day_set`) = c("SWIGFunction", class('parameters_manual_trace_notifications_per_worker_day_set'))

# Start of parameters_manual_trace_notifications_per_worker_day_get

`parameters_manual_trace_notifications_per_worker_day_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_manual_trace_notifications_per_worker_day_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_manual_trace_notifications_per_worker_day_get`, 'returnType') = 'integer'
attr(`parameters_manual_trace_notifications_per_worker_day_get`, "inputTypes") = c('_p_parameters')
class(`parameters_manual_trace_notifications_per_worker_day_get`) = c("SWIGFunction", class('parameters_manual_trace_notifications_per_worker_day_get'))

# Start of parameters_manual_traceable_fraction_set

`parameters_manual_traceable_fraction_set` = function(self, s_manual_traceable_fraction)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  
#  assert(length(s_manual_traceable_fraction) >= N_INTERACTION_TYPES)
  
  ;.Call('R_swig_parameters_manual_traceable_fraction_set', self, s_manual_traceable_fraction, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_manual_traceable_fraction_set`, 'returnType') = 'void'
attr(`parameters_manual_traceable_fraction_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_manual_traceable_fraction_set`) = c("SWIGFunction", class('parameters_manual_traceable_fraction_set'))

# Start of parameters_manual_traceable_fraction_get

`parameters_manual_traceable_fraction_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_manual_traceable_fraction_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_manual_traceable_fraction_get`, 'returnType') = 'numeric'
attr(`parameters_manual_traceable_fraction_get`, "inputTypes") = c('_p_parameters')
class(`parameters_manual_traceable_fraction_get`) = c("SWIGFunction", class('parameters_manual_traceable_fraction_get'))

# Start of parameters_trace_on_symptoms_set

`parameters_trace_on_symptoms_set` = function(self, s_trace_on_symptoms)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_trace_on_symptoms = as.integer(s_trace_on_symptoms);
  
  if(length(s_trace_on_symptoms) > 1) {
    warning("using only the first element of s_trace_on_symptoms");
  };
  
  ;.Call('R_swig_parameters_trace_on_symptoms_set', self, s_trace_on_symptoms, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_trace_on_symptoms_set`, 'returnType') = 'void'
attr(`parameters_trace_on_symptoms_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_trace_on_symptoms_set`) = c("SWIGFunction", class('parameters_trace_on_symptoms_set'))

# Start of parameters_trace_on_symptoms_get

`parameters_trace_on_symptoms_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_trace_on_symptoms_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_trace_on_symptoms_get`, 'returnType') = 'integer'
attr(`parameters_trace_on_symptoms_get`, "inputTypes") = c('_p_parameters')
class(`parameters_trace_on_symptoms_get`) = c("SWIGFunction", class('parameters_trace_on_symptoms_get'))

# Start of parameters_trace_on_positive_set

`parameters_trace_on_positive_set` = function(self, s_trace_on_positive)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_trace_on_positive = as.integer(s_trace_on_positive);
  
  if(length(s_trace_on_positive) > 1) {
    warning("using only the first element of s_trace_on_positive");
  };
  
  ;.Call('R_swig_parameters_trace_on_positive_set', self, s_trace_on_positive, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_trace_on_positive_set`, 'returnType') = 'void'
attr(`parameters_trace_on_positive_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_trace_on_positive_set`) = c("SWIGFunction", class('parameters_trace_on_positive_set'))

# Start of parameters_trace_on_positive_get

`parameters_trace_on_positive_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_trace_on_positive_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_trace_on_positive_get`, 'returnType') = 'integer'
attr(`parameters_trace_on_positive_get`, "inputTypes") = c('_p_parameters')
class(`parameters_trace_on_positive_get`) = c("SWIGFunction", class('parameters_trace_on_positive_get'))

# Start of parameters_retrace_on_positive_set

`parameters_retrace_on_positive_set` = function(self, s_retrace_on_positive)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_retrace_on_positive = as.integer(s_retrace_on_positive);
  
  if(length(s_retrace_on_positive) > 1) {
    warning("using only the first element of s_retrace_on_positive");
  };
  
  ;.Call('R_swig_parameters_retrace_on_positive_set', self, s_retrace_on_positive, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_retrace_on_positive_set`, 'returnType') = 'void'
attr(`parameters_retrace_on_positive_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_retrace_on_positive_set`) = c("SWIGFunction", class('parameters_retrace_on_positive_set'))

# Start of parameters_retrace_on_positive_get

`parameters_retrace_on_positive_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_retrace_on_positive_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_retrace_on_positive_get`, 'returnType') = 'integer'
attr(`parameters_retrace_on_positive_get`, "inputTypes") = c('_p_parameters')
class(`parameters_retrace_on_positive_get`) = c("SWIGFunction", class('parameters_retrace_on_positive_get'))

# Start of parameters_quarantine_length_self_set

`parameters_quarantine_length_self_set` = function(self, s_quarantine_length_self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_quarantine_length_self = as.integer(s_quarantine_length_self);
  
  if(length(s_quarantine_length_self) > 1) {
    warning("using only the first element of s_quarantine_length_self");
  };
  
  ;.Call('R_swig_parameters_quarantine_length_self_set', self, s_quarantine_length_self, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_length_self_set`, 'returnType') = 'void'
attr(`parameters_quarantine_length_self_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_quarantine_length_self_set`) = c("SWIGFunction", class('parameters_quarantine_length_self_set'))

# Start of parameters_quarantine_length_self_get

`parameters_quarantine_length_self_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_quarantine_length_self_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_length_self_get`, 'returnType') = 'integer'
attr(`parameters_quarantine_length_self_get`, "inputTypes") = c('_p_parameters')
class(`parameters_quarantine_length_self_get`) = c("SWIGFunction", class('parameters_quarantine_length_self_get'))

# Start of parameters_quarantine_length_traced_symptoms_set

`parameters_quarantine_length_traced_symptoms_set` = function(self, s_quarantine_length_traced_symptoms)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_quarantine_length_traced_symptoms = as.integer(s_quarantine_length_traced_symptoms);
  
  if(length(s_quarantine_length_traced_symptoms) > 1) {
    warning("using only the first element of s_quarantine_length_traced_symptoms");
  };
  
  ;.Call('R_swig_parameters_quarantine_length_traced_symptoms_set', self, s_quarantine_length_traced_symptoms, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_length_traced_symptoms_set`, 'returnType') = 'void'
attr(`parameters_quarantine_length_traced_symptoms_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_quarantine_length_traced_symptoms_set`) = c("SWIGFunction", class('parameters_quarantine_length_traced_symptoms_set'))

# Start of parameters_quarantine_length_traced_symptoms_get

`parameters_quarantine_length_traced_symptoms_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_quarantine_length_traced_symptoms_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_length_traced_symptoms_get`, 'returnType') = 'integer'
attr(`parameters_quarantine_length_traced_symptoms_get`, "inputTypes") = c('_p_parameters')
class(`parameters_quarantine_length_traced_symptoms_get`) = c("SWIGFunction", class('parameters_quarantine_length_traced_symptoms_get'))

# Start of parameters_quarantine_length_traced_positive_set

`parameters_quarantine_length_traced_positive_set` = function(self, s_quarantine_length_traced_positive)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_quarantine_length_traced_positive = as.integer(s_quarantine_length_traced_positive);
  
  if(length(s_quarantine_length_traced_positive) > 1) {
    warning("using only the first element of s_quarantine_length_traced_positive");
  };
  
  ;.Call('R_swig_parameters_quarantine_length_traced_positive_set', self, s_quarantine_length_traced_positive, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_length_traced_positive_set`, 'returnType') = 'void'
attr(`parameters_quarantine_length_traced_positive_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_quarantine_length_traced_positive_set`) = c("SWIGFunction", class('parameters_quarantine_length_traced_positive_set'))

# Start of parameters_quarantine_length_traced_positive_get

`parameters_quarantine_length_traced_positive_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_quarantine_length_traced_positive_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_length_traced_positive_get`, 'returnType') = 'integer'
attr(`parameters_quarantine_length_traced_positive_get`, "inputTypes") = c('_p_parameters')
class(`parameters_quarantine_length_traced_positive_get`) = c("SWIGFunction", class('parameters_quarantine_length_traced_positive_get'))

# Start of parameters_quarantine_length_positive_set

`parameters_quarantine_length_positive_set` = function(self, s_quarantine_length_positive)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_quarantine_length_positive = as.integer(s_quarantine_length_positive);
  
  if(length(s_quarantine_length_positive) > 1) {
    warning("using only the first element of s_quarantine_length_positive");
  };
  
  ;.Call('R_swig_parameters_quarantine_length_positive_set', self, s_quarantine_length_positive, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_length_positive_set`, 'returnType') = 'void'
attr(`parameters_quarantine_length_positive_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_quarantine_length_positive_set`) = c("SWIGFunction", class('parameters_quarantine_length_positive_set'))

# Start of parameters_quarantine_length_positive_get

`parameters_quarantine_length_positive_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_quarantine_length_positive_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_length_positive_get`, 'returnType') = 'integer'
attr(`parameters_quarantine_length_positive_get`, "inputTypes") = c('_p_parameters')
class(`parameters_quarantine_length_positive_get`) = c("SWIGFunction", class('parameters_quarantine_length_positive_get'))

# Start of parameters_quarantine_dropout_self_set

`parameters_quarantine_dropout_self_set` = function(self, s_quarantine_dropout_self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_quarantine_dropout_self_set', self, s_quarantine_dropout_self, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_dropout_self_set`, 'returnType') = 'void'
attr(`parameters_quarantine_dropout_self_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_quarantine_dropout_self_set`) = c("SWIGFunction", class('parameters_quarantine_dropout_self_set'))

# Start of parameters_quarantine_dropout_self_get

`parameters_quarantine_dropout_self_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_quarantine_dropout_self_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_dropout_self_get`, 'returnType') = 'numeric'
attr(`parameters_quarantine_dropout_self_get`, "inputTypes") = c('_p_parameters')
class(`parameters_quarantine_dropout_self_get`) = c("SWIGFunction", class('parameters_quarantine_dropout_self_get'))

# Start of parameters_quarantine_dropout_traced_symptoms_set

`parameters_quarantine_dropout_traced_symptoms_set` = function(self, s_quarantine_dropout_traced_symptoms)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_quarantine_dropout_traced_symptoms_set', self, s_quarantine_dropout_traced_symptoms, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_dropout_traced_symptoms_set`, 'returnType') = 'void'
attr(`parameters_quarantine_dropout_traced_symptoms_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_quarantine_dropout_traced_symptoms_set`) = c("SWIGFunction", class('parameters_quarantine_dropout_traced_symptoms_set'))

# Start of parameters_quarantine_dropout_traced_symptoms_get

`parameters_quarantine_dropout_traced_symptoms_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_quarantine_dropout_traced_symptoms_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_dropout_traced_symptoms_get`, 'returnType') = 'numeric'
attr(`parameters_quarantine_dropout_traced_symptoms_get`, "inputTypes") = c('_p_parameters')
class(`parameters_quarantine_dropout_traced_symptoms_get`) = c("SWIGFunction", class('parameters_quarantine_dropout_traced_symptoms_get'))

# Start of parameters_quarantine_dropout_traced_positive_set

`parameters_quarantine_dropout_traced_positive_set` = function(self, s_quarantine_dropout_traced_positive)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_quarantine_dropout_traced_positive_set', self, s_quarantine_dropout_traced_positive, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_dropout_traced_positive_set`, 'returnType') = 'void'
attr(`parameters_quarantine_dropout_traced_positive_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_quarantine_dropout_traced_positive_set`) = c("SWIGFunction", class('parameters_quarantine_dropout_traced_positive_set'))

# Start of parameters_quarantine_dropout_traced_positive_get

`parameters_quarantine_dropout_traced_positive_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_quarantine_dropout_traced_positive_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_dropout_traced_positive_get`, 'returnType') = 'numeric'
attr(`parameters_quarantine_dropout_traced_positive_get`, "inputTypes") = c('_p_parameters')
class(`parameters_quarantine_dropout_traced_positive_get`) = c("SWIGFunction", class('parameters_quarantine_dropout_traced_positive_get'))

# Start of parameters_quarantine_dropout_positive_set

`parameters_quarantine_dropout_positive_set` = function(self, s_quarantine_dropout_positive)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_quarantine_dropout_positive_set', self, s_quarantine_dropout_positive, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_dropout_positive_set`, 'returnType') = 'void'
attr(`parameters_quarantine_dropout_positive_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_quarantine_dropout_positive_set`) = c("SWIGFunction", class('parameters_quarantine_dropout_positive_set'))

# Start of parameters_quarantine_dropout_positive_get

`parameters_quarantine_dropout_positive_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_quarantine_dropout_positive_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_dropout_positive_get`, 'returnType') = 'numeric'
attr(`parameters_quarantine_dropout_positive_get`, "inputTypes") = c('_p_parameters')
class(`parameters_quarantine_dropout_positive_get`) = c("SWIGFunction", class('parameters_quarantine_dropout_positive_get'))

# Start of parameters_quarantine_compliance_traced_symptoms_set

`parameters_quarantine_compliance_traced_symptoms_set` = function(self, s_quarantine_compliance_traced_symptoms)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_quarantine_compliance_traced_symptoms_set', self, s_quarantine_compliance_traced_symptoms, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_compliance_traced_symptoms_set`, 'returnType') = 'void'
attr(`parameters_quarantine_compliance_traced_symptoms_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_quarantine_compliance_traced_symptoms_set`) = c("SWIGFunction", class('parameters_quarantine_compliance_traced_symptoms_set'))

# Start of parameters_quarantine_compliance_traced_symptoms_get

`parameters_quarantine_compliance_traced_symptoms_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_quarantine_compliance_traced_symptoms_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_compliance_traced_symptoms_get`, 'returnType') = 'numeric'
attr(`parameters_quarantine_compliance_traced_symptoms_get`, "inputTypes") = c('_p_parameters')
class(`parameters_quarantine_compliance_traced_symptoms_get`) = c("SWIGFunction", class('parameters_quarantine_compliance_traced_symptoms_get'))

# Start of parameters_quarantine_compliance_traced_positive_set

`parameters_quarantine_compliance_traced_positive_set` = function(self, s_quarantine_compliance_traced_positive)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_quarantine_compliance_traced_positive_set', self, s_quarantine_compliance_traced_positive, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_compliance_traced_positive_set`, 'returnType') = 'void'
attr(`parameters_quarantine_compliance_traced_positive_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_quarantine_compliance_traced_positive_set`) = c("SWIGFunction", class('parameters_quarantine_compliance_traced_positive_set'))

# Start of parameters_quarantine_compliance_traced_positive_get

`parameters_quarantine_compliance_traced_positive_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_quarantine_compliance_traced_positive_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_compliance_traced_positive_get`, 'returnType') = 'numeric'
attr(`parameters_quarantine_compliance_traced_positive_get`, "inputTypes") = c('_p_parameters')
class(`parameters_quarantine_compliance_traced_positive_get`) = c("SWIGFunction", class('parameters_quarantine_compliance_traced_positive_get'))

# Start of parameters_quarantine_on_traced_set

`parameters_quarantine_on_traced_set` = function(self, s_quarantine_on_traced)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_quarantine_on_traced = as.integer(s_quarantine_on_traced);
  
  if(length(s_quarantine_on_traced) > 1) {
    warning("using only the first element of s_quarantine_on_traced");
  };
  
  ;.Call('R_swig_parameters_quarantine_on_traced_set', self, s_quarantine_on_traced, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_on_traced_set`, 'returnType') = 'void'
attr(`parameters_quarantine_on_traced_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_quarantine_on_traced_set`) = c("SWIGFunction", class('parameters_quarantine_on_traced_set'))

# Start of parameters_quarantine_on_traced_get

`parameters_quarantine_on_traced_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_quarantine_on_traced_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_on_traced_get`, 'returnType') = 'integer'
attr(`parameters_quarantine_on_traced_get`, "inputTypes") = c('_p_parameters')
class(`parameters_quarantine_on_traced_get`) = c("SWIGFunction", class('parameters_quarantine_on_traced_get'))

# Start of parameters_quarantine_smart_release_day_set

`parameters_quarantine_smart_release_day_set` = function(self, s_quarantine_smart_release_day)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_quarantine_smart_release_day = as.integer(s_quarantine_smart_release_day);
  
  if(length(s_quarantine_smart_release_day) > 1) {
    warning("using only the first element of s_quarantine_smart_release_day");
  };
  
  ;.Call('R_swig_parameters_quarantine_smart_release_day_set', self, s_quarantine_smart_release_day, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_smart_release_day_set`, 'returnType') = 'void'
attr(`parameters_quarantine_smart_release_day_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_quarantine_smart_release_day_set`) = c("SWIGFunction", class('parameters_quarantine_smart_release_day_set'))

# Start of parameters_quarantine_smart_release_day_get

`parameters_quarantine_smart_release_day_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_quarantine_smart_release_day_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_smart_release_day_get`, 'returnType') = 'integer'
attr(`parameters_quarantine_smart_release_day_get`, "inputTypes") = c('_p_parameters')
class(`parameters_quarantine_smart_release_day_get`) = c("SWIGFunction", class('parameters_quarantine_smart_release_day_get'))

# Start of parameters_traceable_interaction_fraction_set

`parameters_traceable_interaction_fraction_set` = function(self, s_traceable_interaction_fraction)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_traceable_interaction_fraction_set', self, s_traceable_interaction_fraction, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_traceable_interaction_fraction_set`, 'returnType') = 'void'
attr(`parameters_traceable_interaction_fraction_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_traceable_interaction_fraction_set`) = c("SWIGFunction", class('parameters_traceable_interaction_fraction_set'))

# Start of parameters_traceable_interaction_fraction_get

`parameters_traceable_interaction_fraction_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_traceable_interaction_fraction_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_traceable_interaction_fraction_get`, 'returnType') = 'numeric'
attr(`parameters_traceable_interaction_fraction_get`, "inputTypes") = c('_p_parameters')
class(`parameters_traceable_interaction_fraction_get`) = c("SWIGFunction", class('parameters_traceable_interaction_fraction_get'))

# Start of parameters_tracing_network_depth_set

`parameters_tracing_network_depth_set` = function(self, s_tracing_network_depth)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_tracing_network_depth = as.integer(s_tracing_network_depth);
  
  if(length(s_tracing_network_depth) > 1) {
    warning("using only the first element of s_tracing_network_depth");
  };
  
  ;.Call('R_swig_parameters_tracing_network_depth_set', self, s_tracing_network_depth, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_tracing_network_depth_set`, 'returnType') = 'void'
attr(`parameters_tracing_network_depth_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_tracing_network_depth_set`) = c("SWIGFunction", class('parameters_tracing_network_depth_set'))

# Start of parameters_tracing_network_depth_get

`parameters_tracing_network_depth_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_tracing_network_depth_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_tracing_network_depth_get`, 'returnType') = 'integer'
attr(`parameters_tracing_network_depth_get`, "inputTypes") = c('_p_parameters')
class(`parameters_tracing_network_depth_get`) = c("SWIGFunction", class('parameters_tracing_network_depth_get'))

# Start of parameters_allow_clinical_diagnosis_set

`parameters_allow_clinical_diagnosis_set` = function(self, s_allow_clinical_diagnosis)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_allow_clinical_diagnosis = as.integer(s_allow_clinical_diagnosis);
  
  if(length(s_allow_clinical_diagnosis) > 1) {
    warning("using only the first element of s_allow_clinical_diagnosis");
  };
  
  ;.Call('R_swig_parameters_allow_clinical_diagnosis_set', self, s_allow_clinical_diagnosis, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_allow_clinical_diagnosis_set`, 'returnType') = 'void'
attr(`parameters_allow_clinical_diagnosis_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_allow_clinical_diagnosis_set`) = c("SWIGFunction", class('parameters_allow_clinical_diagnosis_set'))

# Start of parameters_allow_clinical_diagnosis_get

`parameters_allow_clinical_diagnosis_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_allow_clinical_diagnosis_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_allow_clinical_diagnosis_get`, 'returnType') = 'integer'
attr(`parameters_allow_clinical_diagnosis_get`, "inputTypes") = c('_p_parameters')
class(`parameters_allow_clinical_diagnosis_get`) = c("SWIGFunction", class('parameters_allow_clinical_diagnosis_get'))

# Start of parameters_quarantine_household_on_symptoms_set

`parameters_quarantine_household_on_symptoms_set` = function(self, s_quarantine_household_on_symptoms)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_quarantine_household_on_symptoms = as.integer(s_quarantine_household_on_symptoms);
  
  if(length(s_quarantine_household_on_symptoms) > 1) {
    warning("using only the first element of s_quarantine_household_on_symptoms");
  };
  
  ;.Call('R_swig_parameters_quarantine_household_on_symptoms_set', self, s_quarantine_household_on_symptoms, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_household_on_symptoms_set`, 'returnType') = 'void'
attr(`parameters_quarantine_household_on_symptoms_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_quarantine_household_on_symptoms_set`) = c("SWIGFunction", class('parameters_quarantine_household_on_symptoms_set'))

# Start of parameters_quarantine_household_on_symptoms_get

`parameters_quarantine_household_on_symptoms_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_quarantine_household_on_symptoms_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_household_on_symptoms_get`, 'returnType') = 'integer'
attr(`parameters_quarantine_household_on_symptoms_get`, "inputTypes") = c('_p_parameters')
class(`parameters_quarantine_household_on_symptoms_get`) = c("SWIGFunction", class('parameters_quarantine_household_on_symptoms_get'))

# Start of parameters_quarantine_household_on_positive_set

`parameters_quarantine_household_on_positive_set` = function(self, s_quarantine_household_on_positive)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_quarantine_household_on_positive = as.integer(s_quarantine_household_on_positive);
  
  if(length(s_quarantine_household_on_positive) > 1) {
    warning("using only the first element of s_quarantine_household_on_positive");
  };
  
  ;.Call('R_swig_parameters_quarantine_household_on_positive_set', self, s_quarantine_household_on_positive, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_household_on_positive_set`, 'returnType') = 'void'
attr(`parameters_quarantine_household_on_positive_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_quarantine_household_on_positive_set`) = c("SWIGFunction", class('parameters_quarantine_household_on_positive_set'))

# Start of parameters_quarantine_household_on_positive_get

`parameters_quarantine_household_on_positive_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_quarantine_household_on_positive_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_household_on_positive_get`, 'returnType') = 'integer'
attr(`parameters_quarantine_household_on_positive_get`, "inputTypes") = c('_p_parameters')
class(`parameters_quarantine_household_on_positive_get`) = c("SWIGFunction", class('parameters_quarantine_household_on_positive_get'))

# Start of parameters_quarantine_household_on_traced_symptoms_set

`parameters_quarantine_household_on_traced_symptoms_set` = function(self, s_quarantine_household_on_traced_symptoms)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_quarantine_household_on_traced_symptoms = as.integer(s_quarantine_household_on_traced_symptoms);
  
  if(length(s_quarantine_household_on_traced_symptoms) > 1) {
    warning("using only the first element of s_quarantine_household_on_traced_symptoms");
  };
  
  ;.Call('R_swig_parameters_quarantine_household_on_traced_symptoms_set', self, s_quarantine_household_on_traced_symptoms, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_household_on_traced_symptoms_set`, 'returnType') = 'void'
attr(`parameters_quarantine_household_on_traced_symptoms_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_quarantine_household_on_traced_symptoms_set`) = c("SWIGFunction", class('parameters_quarantine_household_on_traced_symptoms_set'))

# Start of parameters_quarantine_household_on_traced_symptoms_get

`parameters_quarantine_household_on_traced_symptoms_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_quarantine_household_on_traced_symptoms_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_household_on_traced_symptoms_get`, 'returnType') = 'integer'
attr(`parameters_quarantine_household_on_traced_symptoms_get`, "inputTypes") = c('_p_parameters')
class(`parameters_quarantine_household_on_traced_symptoms_get`) = c("SWIGFunction", class('parameters_quarantine_household_on_traced_symptoms_get'))

# Start of parameters_quarantine_household_on_traced_positive_set

`parameters_quarantine_household_on_traced_positive_set` = function(self, s_quarantine_household_on_traced_positive)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_quarantine_household_on_traced_positive = as.integer(s_quarantine_household_on_traced_positive);
  
  if(length(s_quarantine_household_on_traced_positive) > 1) {
    warning("using only the first element of s_quarantine_household_on_traced_positive");
  };
  
  ;.Call('R_swig_parameters_quarantine_household_on_traced_positive_set', self, s_quarantine_household_on_traced_positive, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_household_on_traced_positive_set`, 'returnType') = 'void'
attr(`parameters_quarantine_household_on_traced_positive_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_quarantine_household_on_traced_positive_set`) = c("SWIGFunction", class('parameters_quarantine_household_on_traced_positive_set'))

# Start of parameters_quarantine_household_on_traced_positive_get

`parameters_quarantine_household_on_traced_positive_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_quarantine_household_on_traced_positive_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_household_on_traced_positive_get`, 'returnType') = 'integer'
attr(`parameters_quarantine_household_on_traced_positive_get`, "inputTypes") = c('_p_parameters')
class(`parameters_quarantine_household_on_traced_positive_get`) = c("SWIGFunction", class('parameters_quarantine_household_on_traced_positive_get'))

# Start of parameters_quarantine_household_contacts_on_positive_set

`parameters_quarantine_household_contacts_on_positive_set` = function(self, s_quarantine_household_contacts_on_positive)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_quarantine_household_contacts_on_positive = as.integer(s_quarantine_household_contacts_on_positive);
  
  if(length(s_quarantine_household_contacts_on_positive) > 1) {
    warning("using only the first element of s_quarantine_household_contacts_on_positive");
  };
  
  ;.Call('R_swig_parameters_quarantine_household_contacts_on_positive_set', self, s_quarantine_household_contacts_on_positive, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_household_contacts_on_positive_set`, 'returnType') = 'void'
attr(`parameters_quarantine_household_contacts_on_positive_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_quarantine_household_contacts_on_positive_set`) = c("SWIGFunction", class('parameters_quarantine_household_contacts_on_positive_set'))

# Start of parameters_quarantine_household_contacts_on_positive_get

`parameters_quarantine_household_contacts_on_positive_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_quarantine_household_contacts_on_positive_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_household_contacts_on_positive_get`, 'returnType') = 'integer'
attr(`parameters_quarantine_household_contacts_on_positive_get`, "inputTypes") = c('_p_parameters')
class(`parameters_quarantine_household_contacts_on_positive_get`) = c("SWIGFunction", class('parameters_quarantine_household_contacts_on_positive_get'))

# Start of parameters_quarantine_household_contacts_on_symptoms_set

`parameters_quarantine_household_contacts_on_symptoms_set` = function(self, s_quarantine_household_contacts_on_symptoms)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_quarantine_household_contacts_on_symptoms = as.integer(s_quarantine_household_contacts_on_symptoms);
  
  if(length(s_quarantine_household_contacts_on_symptoms) > 1) {
    warning("using only the first element of s_quarantine_household_contacts_on_symptoms");
  };
  
  ;.Call('R_swig_parameters_quarantine_household_contacts_on_symptoms_set', self, s_quarantine_household_contacts_on_symptoms, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_household_contacts_on_symptoms_set`, 'returnType') = 'void'
attr(`parameters_quarantine_household_contacts_on_symptoms_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_quarantine_household_contacts_on_symptoms_set`) = c("SWIGFunction", class('parameters_quarantine_household_contacts_on_symptoms_set'))

# Start of parameters_quarantine_household_contacts_on_symptoms_get

`parameters_quarantine_household_contacts_on_symptoms_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_quarantine_household_contacts_on_symptoms_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_quarantine_household_contacts_on_symptoms_get`, 'returnType') = 'integer'
attr(`parameters_quarantine_household_contacts_on_symptoms_get`, "inputTypes") = c('_p_parameters')
class(`parameters_quarantine_household_contacts_on_symptoms_get`) = c("SWIGFunction", class('parameters_quarantine_household_contacts_on_symptoms_get'))

# Start of parameters_test_on_symptoms_set

`parameters_test_on_symptoms_set` = function(self, s_test_on_symptoms)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_test_on_symptoms = as.integer(s_test_on_symptoms);
  
  if(length(s_test_on_symptoms) > 1) {
    warning("using only the first element of s_test_on_symptoms");
  };
  
  ;.Call('R_swig_parameters_test_on_symptoms_set', self, s_test_on_symptoms, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_on_symptoms_set`, 'returnType') = 'void'
attr(`parameters_test_on_symptoms_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_test_on_symptoms_set`) = c("SWIGFunction", class('parameters_test_on_symptoms_set'))

# Start of parameters_test_on_symptoms_get

`parameters_test_on_symptoms_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_test_on_symptoms_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_on_symptoms_get`, 'returnType') = 'integer'
attr(`parameters_test_on_symptoms_get`, "inputTypes") = c('_p_parameters')
class(`parameters_test_on_symptoms_get`) = c("SWIGFunction", class('parameters_test_on_symptoms_get'))

# Start of parameters_test_on_traced_set

`parameters_test_on_traced_set` = function(self, s_test_on_traced)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_test_on_traced = as.integer(s_test_on_traced);
  
  if(length(s_test_on_traced) > 1) {
    warning("using only the first element of s_test_on_traced");
  };
  
  ;.Call('R_swig_parameters_test_on_traced_set', self, s_test_on_traced, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_on_traced_set`, 'returnType') = 'void'
attr(`parameters_test_on_traced_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_test_on_traced_set`) = c("SWIGFunction", class('parameters_test_on_traced_set'))

# Start of parameters_test_on_traced_get

`parameters_test_on_traced_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_test_on_traced_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_on_traced_get`, 'returnType') = 'integer'
attr(`parameters_test_on_traced_get`, "inputTypes") = c('_p_parameters')
class(`parameters_test_on_traced_get`) = c("SWIGFunction", class('parameters_test_on_traced_get'))

# Start of parameters_test_result_wait_set

`parameters_test_result_wait_set` = function(self, s_test_result_wait)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_test_result_wait = as.integer(s_test_result_wait);
  
  if(length(s_test_result_wait) > 1) {
    warning("using only the first element of s_test_result_wait");
  };
  
  ;.Call('R_swig_parameters_test_result_wait_set', self, s_test_result_wait, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_result_wait_set`, 'returnType') = 'void'
attr(`parameters_test_result_wait_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_test_result_wait_set`) = c("SWIGFunction", class('parameters_test_result_wait_set'))

# Start of parameters_test_result_wait_get

`parameters_test_result_wait_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_test_result_wait_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_result_wait_get`, 'returnType') = 'integer'
attr(`parameters_test_result_wait_get`, "inputTypes") = c('_p_parameters')
class(`parameters_test_result_wait_get`) = c("SWIGFunction", class('parameters_test_result_wait_get'))

# Start of parameters_test_order_wait_set

`parameters_test_order_wait_set` = function(self, s_test_order_wait)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_test_order_wait = as.integer(s_test_order_wait);
  
  if(length(s_test_order_wait) > 1) {
    warning("using only the first element of s_test_order_wait");
  };
  
  ;.Call('R_swig_parameters_test_order_wait_set', self, s_test_order_wait, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_order_wait_set`, 'returnType') = 'void'
attr(`parameters_test_order_wait_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_test_order_wait_set`) = c("SWIGFunction", class('parameters_test_order_wait_set'))

# Start of parameters_test_order_wait_get

`parameters_test_order_wait_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_test_order_wait_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_order_wait_get`, 'returnType') = 'integer'
attr(`parameters_test_order_wait_get`, "inputTypes") = c('_p_parameters')
class(`parameters_test_order_wait_get`) = c("SWIGFunction", class('parameters_test_order_wait_get'))

# Start of parameters_test_result_wait_priority_set

`parameters_test_result_wait_priority_set` = function(self, s_test_result_wait_priority)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_test_result_wait_priority = as.integer(s_test_result_wait_priority);
  
  if(length(s_test_result_wait_priority) > 1) {
    warning("using only the first element of s_test_result_wait_priority");
  };
  
  ;.Call('R_swig_parameters_test_result_wait_priority_set', self, s_test_result_wait_priority, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_result_wait_priority_set`, 'returnType') = 'void'
attr(`parameters_test_result_wait_priority_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_test_result_wait_priority_set`) = c("SWIGFunction", class('parameters_test_result_wait_priority_set'))

# Start of parameters_test_result_wait_priority_get

`parameters_test_result_wait_priority_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_test_result_wait_priority_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_result_wait_priority_get`, 'returnType') = 'integer'
attr(`parameters_test_result_wait_priority_get`, "inputTypes") = c('_p_parameters')
class(`parameters_test_result_wait_priority_get`) = c("SWIGFunction", class('parameters_test_result_wait_priority_get'))

# Start of parameters_test_order_wait_priority_set

`parameters_test_order_wait_priority_set` = function(self, s_test_order_wait_priority)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_test_order_wait_priority = as.integer(s_test_order_wait_priority);
  
  if(length(s_test_order_wait_priority) > 1) {
    warning("using only the first element of s_test_order_wait_priority");
  };
  
  ;.Call('R_swig_parameters_test_order_wait_priority_set', self, s_test_order_wait_priority, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_order_wait_priority_set`, 'returnType') = 'void'
attr(`parameters_test_order_wait_priority_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_test_order_wait_priority_set`) = c("SWIGFunction", class('parameters_test_order_wait_priority_set'))

# Start of parameters_test_order_wait_priority_get

`parameters_test_order_wait_priority_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_test_order_wait_priority_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_order_wait_priority_get`, 'returnType') = 'integer'
attr(`parameters_test_order_wait_priority_get`, "inputTypes") = c('_p_parameters')
class(`parameters_test_order_wait_priority_get`) = c("SWIGFunction", class('parameters_test_order_wait_priority_get'))

# Start of parameters_test_release_on_negative_set

`parameters_test_release_on_negative_set` = function(self, s_test_release_on_negative)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_test_release_on_negative = as.integer(s_test_release_on_negative);
  
  if(length(s_test_release_on_negative) > 1) {
    warning("using only the first element of s_test_release_on_negative");
  };
  
  ;.Call('R_swig_parameters_test_release_on_negative_set', self, s_test_release_on_negative, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_release_on_negative_set`, 'returnType') = 'void'
attr(`parameters_test_release_on_negative_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_test_release_on_negative_set`) = c("SWIGFunction", class('parameters_test_release_on_negative_set'))

# Start of parameters_test_release_on_negative_get

`parameters_test_release_on_negative_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_test_release_on_negative_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_release_on_negative_get`, 'returnType') = 'integer'
attr(`parameters_test_release_on_negative_get`, "inputTypes") = c('_p_parameters')
class(`parameters_test_release_on_negative_get`) = c("SWIGFunction", class('parameters_test_release_on_negative_get'))

# Start of parameters_priority_test_contacts_set

`parameters_priority_test_contacts_set` = function(self, s_priority_test_contacts)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_priority_test_contacts = as.integer(s_priority_test_contacts);
  
#  assert(length(s_priority_test_contacts) >= N_AGE_GROUPS)
  
  ;.Call('R_swig_parameters_priority_test_contacts_set', self, s_priority_test_contacts, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_priority_test_contacts_set`, 'returnType') = 'void'
attr(`parameters_priority_test_contacts_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_priority_test_contacts_set`) = c("SWIGFunction", class('parameters_priority_test_contacts_set'))

# Start of parameters_priority_test_contacts_get

`parameters_priority_test_contacts_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_parameters_priority_test_contacts_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  ans <- new("_p_int", ref=ans) ;
  
  ans
  
}

attr(`parameters_priority_test_contacts_get`, 'returnType') = 'integer'
attr(`parameters_priority_test_contacts_get`, "inputTypes") = c('_p_parameters')
class(`parameters_priority_test_contacts_get`) = c("SWIGFunction", class('parameters_priority_test_contacts_get'))

# Start of parameters_test_insensitive_period_set

`parameters_test_insensitive_period_set` = function(self, s_test_insensitive_period)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_test_insensitive_period = as.integer(s_test_insensitive_period);
  
  if(length(s_test_insensitive_period) > 1) {
    warning("using only the first element of s_test_insensitive_period");
  };
  
  ;.Call('R_swig_parameters_test_insensitive_period_set', self, s_test_insensitive_period, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_insensitive_period_set`, 'returnType') = 'void'
attr(`parameters_test_insensitive_period_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_test_insensitive_period_set`) = c("SWIGFunction", class('parameters_test_insensitive_period_set'))

# Start of parameters_test_insensitive_period_get

`parameters_test_insensitive_period_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_test_insensitive_period_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_insensitive_period_get`, 'returnType') = 'integer'
attr(`parameters_test_insensitive_period_get`, "inputTypes") = c('_p_parameters')
class(`parameters_test_insensitive_period_get`) = c("SWIGFunction", class('parameters_test_insensitive_period_get'))

# Start of parameters_test_sensitive_period_set

`parameters_test_sensitive_period_set` = function(self, s_test_sensitive_period)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_test_sensitive_period = as.integer(s_test_sensitive_period);
  
  if(length(s_test_sensitive_period) > 1) {
    warning("using only the first element of s_test_sensitive_period");
  };
  
  ;.Call('R_swig_parameters_test_sensitive_period_set', self, s_test_sensitive_period, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_sensitive_period_set`, 'returnType') = 'void'
attr(`parameters_test_sensitive_period_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_test_sensitive_period_set`) = c("SWIGFunction", class('parameters_test_sensitive_period_set'))

# Start of parameters_test_sensitive_period_get

`parameters_test_sensitive_period_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_test_sensitive_period_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_sensitive_period_get`, 'returnType') = 'integer'
attr(`parameters_test_sensitive_period_get`, "inputTypes") = c('_p_parameters')
class(`parameters_test_sensitive_period_get`) = c("SWIGFunction", class('parameters_test_sensitive_period_get'))

# Start of parameters_test_sensitivity_set

`parameters_test_sensitivity_set` = function(self, s_test_sensitivity)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_test_sensitivity_set', self, s_test_sensitivity, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_sensitivity_set`, 'returnType') = 'void'
attr(`parameters_test_sensitivity_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_test_sensitivity_set`) = c("SWIGFunction", class('parameters_test_sensitivity_set'))

# Start of parameters_test_sensitivity_get

`parameters_test_sensitivity_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_test_sensitivity_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_sensitivity_get`, 'returnType') = 'numeric'
attr(`parameters_test_sensitivity_get`, "inputTypes") = c('_p_parameters')
class(`parameters_test_sensitivity_get`) = c("SWIGFunction", class('parameters_test_sensitivity_get'))

# Start of parameters_test_specificity_set

`parameters_test_specificity_set` = function(self, s_test_specificity)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_test_specificity_set', self, s_test_specificity, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_specificity_set`, 'returnType') = 'void'
attr(`parameters_test_specificity_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_test_specificity_set`) = c("SWIGFunction", class('parameters_test_specificity_set'))

# Start of parameters_test_specificity_get

`parameters_test_specificity_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_test_specificity_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_test_specificity_get`, 'returnType') = 'numeric'
attr(`parameters_test_specificity_get`, "inputTypes") = c('_p_parameters')
class(`parameters_test_specificity_get`) = c("SWIGFunction", class('parameters_test_specificity_get'))

# Start of parameters_app_users_fraction_set

`parameters_app_users_fraction_set` = function(self, s_app_users_fraction)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  
#  assert(length(s_app_users_fraction) >= N_AGE_GROUPS)
  
  ;.Call('R_swig_parameters_app_users_fraction_set', self, s_app_users_fraction, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_app_users_fraction_set`, 'returnType') = 'void'
attr(`parameters_app_users_fraction_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_app_users_fraction_set`) = c("SWIGFunction", class('parameters_app_users_fraction_set'))

# Start of parameters_app_users_fraction_get

`parameters_app_users_fraction_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_app_users_fraction_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_app_users_fraction_get`, 'returnType') = 'numeric'
attr(`parameters_app_users_fraction_get`, "inputTypes") = c('_p_parameters')
class(`parameters_app_users_fraction_get`) = c("SWIGFunction", class('parameters_app_users_fraction_get'))

# Start of parameters_app_turned_on_set

`parameters_app_turned_on_set` = function(self, s_app_turned_on)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_app_turned_on = as.integer(s_app_turned_on);
  
  if(length(s_app_turned_on) > 1) {
    warning("using only the first element of s_app_turned_on");
  };
  
  ;.Call('R_swig_parameters_app_turned_on_set', self, s_app_turned_on, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_app_turned_on_set`, 'returnType') = 'void'
attr(`parameters_app_turned_on_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_app_turned_on_set`) = c("SWIGFunction", class('parameters_app_turned_on_set'))

# Start of parameters_app_turned_on_get

`parameters_app_turned_on_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_app_turned_on_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_app_turned_on_get`, 'returnType') = 'integer'
attr(`parameters_app_turned_on_get`, "inputTypes") = c('_p_parameters')
class(`parameters_app_turned_on_get`) = c("SWIGFunction", class('parameters_app_turned_on_get'))

# Start of parameters_app_turn_on_time_set

`parameters_app_turn_on_time_set` = function(self, s_app_turn_on_time)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_app_turn_on_time = as.integer(s_app_turn_on_time);
  
  if(length(s_app_turn_on_time) > 1) {
    warning("using only the first element of s_app_turn_on_time");
  };
  
  ;.Call('R_swig_parameters_app_turn_on_time_set', self, s_app_turn_on_time, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_app_turn_on_time_set`, 'returnType') = 'void'
attr(`parameters_app_turn_on_time_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_app_turn_on_time_set`) = c("SWIGFunction", class('parameters_app_turn_on_time_set'))

# Start of parameters_app_turn_on_time_get

`parameters_app_turn_on_time_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_app_turn_on_time_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_app_turn_on_time_get`, 'returnType') = 'integer'
attr(`parameters_app_turn_on_time_get`, "inputTypes") = c('_p_parameters')
class(`parameters_app_turn_on_time_get`) = c("SWIGFunction", class('parameters_app_turn_on_time_get'))

# Start of parameters_daily_non_cov_symptoms_rate_set

`parameters_daily_non_cov_symptoms_rate_set` = function(self, s_daily_non_cov_symptoms_rate)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_daily_non_cov_symptoms_rate_set', self, s_daily_non_cov_symptoms_rate, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_daily_non_cov_symptoms_rate_set`, 'returnType') = 'void'
attr(`parameters_daily_non_cov_symptoms_rate_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_daily_non_cov_symptoms_rate_set`) = c("SWIGFunction", class('parameters_daily_non_cov_symptoms_rate_set'))

# Start of parameters_daily_non_cov_symptoms_rate_get

`parameters_daily_non_cov_symptoms_rate_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_daily_non_cov_symptoms_rate_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_daily_non_cov_symptoms_rate_get`, 'returnType') = 'numeric'
attr(`parameters_daily_non_cov_symptoms_rate_get`, "inputTypes") = c('_p_parameters')
class(`parameters_daily_non_cov_symptoms_rate_get`) = c("SWIGFunction", class('parameters_daily_non_cov_symptoms_rate_get'))

# Start of parameters_lockdown_occupation_multiplier_set

`parameters_lockdown_occupation_multiplier_set` = function(self, s_lockdown_occupation_multiplier)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  
#  assert(length(s_lockdown_occupation_multiplier) >= N_DEFAULT_OCCUPATION_NETWORKS)
  
  ;.Call('R_swig_parameters_lockdown_occupation_multiplier_set', self, s_lockdown_occupation_multiplier, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_lockdown_occupation_multiplier_set`, 'returnType') = 'void'
attr(`parameters_lockdown_occupation_multiplier_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_lockdown_occupation_multiplier_set`) = c("SWIGFunction", class('parameters_lockdown_occupation_multiplier_set'))

# Start of parameters_lockdown_occupation_multiplier_get

`parameters_lockdown_occupation_multiplier_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_lockdown_occupation_multiplier_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_lockdown_occupation_multiplier_get`, 'returnType') = 'numeric'
attr(`parameters_lockdown_occupation_multiplier_get`, "inputTypes") = c('_p_parameters')
class(`parameters_lockdown_occupation_multiplier_get`) = c("SWIGFunction", class('parameters_lockdown_occupation_multiplier_get'))

# Start of parameters_lockdown_random_network_multiplier_set

`parameters_lockdown_random_network_multiplier_set` = function(self, s_lockdown_random_network_multiplier)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_lockdown_random_network_multiplier_set', self, s_lockdown_random_network_multiplier, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_lockdown_random_network_multiplier_set`, 'returnType') = 'void'
attr(`parameters_lockdown_random_network_multiplier_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_lockdown_random_network_multiplier_set`) = c("SWIGFunction", class('parameters_lockdown_random_network_multiplier_set'))

# Start of parameters_lockdown_random_network_multiplier_get

`parameters_lockdown_random_network_multiplier_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_lockdown_random_network_multiplier_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_lockdown_random_network_multiplier_get`, 'returnType') = 'numeric'
attr(`parameters_lockdown_random_network_multiplier_get`, "inputTypes") = c('_p_parameters')
class(`parameters_lockdown_random_network_multiplier_get`) = c("SWIGFunction", class('parameters_lockdown_random_network_multiplier_get'))

# Start of parameters_lockdown_house_interaction_multiplier_set

`parameters_lockdown_house_interaction_multiplier_set` = function(self, s_lockdown_house_interaction_multiplier)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_lockdown_house_interaction_multiplier_set', self, s_lockdown_house_interaction_multiplier, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_lockdown_house_interaction_multiplier_set`, 'returnType') = 'void'
attr(`parameters_lockdown_house_interaction_multiplier_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_lockdown_house_interaction_multiplier_set`) = c("SWIGFunction", class('parameters_lockdown_house_interaction_multiplier_set'))

# Start of parameters_lockdown_house_interaction_multiplier_get

`parameters_lockdown_house_interaction_multiplier_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_lockdown_house_interaction_multiplier_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_lockdown_house_interaction_multiplier_get`, 'returnType') = 'numeric'
attr(`parameters_lockdown_house_interaction_multiplier_get`, "inputTypes") = c('_p_parameters')
class(`parameters_lockdown_house_interaction_multiplier_get`) = c("SWIGFunction", class('parameters_lockdown_house_interaction_multiplier_get'))

# Start of parameters_lockdown_time_on_set

`parameters_lockdown_time_on_set` = function(self, s_lockdown_time_on)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_lockdown_time_on = as.integer(s_lockdown_time_on);
  
  if(length(s_lockdown_time_on) > 1) {
    warning("using only the first element of s_lockdown_time_on");
  };
  
  ;.Call('R_swig_parameters_lockdown_time_on_set', self, s_lockdown_time_on, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_lockdown_time_on_set`, 'returnType') = 'void'
attr(`parameters_lockdown_time_on_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_lockdown_time_on_set`) = c("SWIGFunction", class('parameters_lockdown_time_on_set'))

# Start of parameters_lockdown_time_on_get

`parameters_lockdown_time_on_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_lockdown_time_on_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_lockdown_time_on_get`, 'returnType') = 'integer'
attr(`parameters_lockdown_time_on_get`, "inputTypes") = c('_p_parameters')
class(`parameters_lockdown_time_on_get`) = c("SWIGFunction", class('parameters_lockdown_time_on_get'))

# Start of parameters_lockdown_time_off_set

`parameters_lockdown_time_off_set` = function(self, s_lockdown_time_off)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_lockdown_time_off = as.integer(s_lockdown_time_off);
  
  if(length(s_lockdown_time_off) > 1) {
    warning("using only the first element of s_lockdown_time_off");
  };
  
  ;.Call('R_swig_parameters_lockdown_time_off_set', self, s_lockdown_time_off, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_lockdown_time_off_set`, 'returnType') = 'void'
attr(`parameters_lockdown_time_off_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_lockdown_time_off_set`) = c("SWIGFunction", class('parameters_lockdown_time_off_set'))

# Start of parameters_lockdown_time_off_get

`parameters_lockdown_time_off_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_lockdown_time_off_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_lockdown_time_off_get`, 'returnType') = 'integer'
attr(`parameters_lockdown_time_off_get`, "inputTypes") = c('_p_parameters')
class(`parameters_lockdown_time_off_get`) = c("SWIGFunction", class('parameters_lockdown_time_off_get'))

# Start of parameters_lockdown_on_set

`parameters_lockdown_on_set` = function(self, s_lockdown_on)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_lockdown_on = as.integer(s_lockdown_on);
  
  if(length(s_lockdown_on) > 1) {
    warning("using only the first element of s_lockdown_on");
  };
  
  ;.Call('R_swig_parameters_lockdown_on_set', self, s_lockdown_on, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_lockdown_on_set`, 'returnType') = 'void'
attr(`parameters_lockdown_on_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_lockdown_on_set`) = c("SWIGFunction", class('parameters_lockdown_on_set'))

# Start of parameters_lockdown_on_get

`parameters_lockdown_on_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_lockdown_on_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_lockdown_on_get`, 'returnType') = 'integer'
attr(`parameters_lockdown_on_get`, "inputTypes") = c('_p_parameters')
class(`parameters_lockdown_on_get`) = c("SWIGFunction", class('parameters_lockdown_on_get'))

# Start of parameters_lockdown_elderly_time_on_set

`parameters_lockdown_elderly_time_on_set` = function(self, s_lockdown_elderly_time_on)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_lockdown_elderly_time_on = as.integer(s_lockdown_elderly_time_on);
  
  if(length(s_lockdown_elderly_time_on) > 1) {
    warning("using only the first element of s_lockdown_elderly_time_on");
  };
  
  ;.Call('R_swig_parameters_lockdown_elderly_time_on_set', self, s_lockdown_elderly_time_on, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_lockdown_elderly_time_on_set`, 'returnType') = 'void'
attr(`parameters_lockdown_elderly_time_on_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_lockdown_elderly_time_on_set`) = c("SWIGFunction", class('parameters_lockdown_elderly_time_on_set'))

# Start of parameters_lockdown_elderly_time_on_get

`parameters_lockdown_elderly_time_on_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_lockdown_elderly_time_on_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_lockdown_elderly_time_on_get`, 'returnType') = 'integer'
attr(`parameters_lockdown_elderly_time_on_get`, "inputTypes") = c('_p_parameters')
class(`parameters_lockdown_elderly_time_on_get`) = c("SWIGFunction", class('parameters_lockdown_elderly_time_on_get'))

# Start of parameters_lockdown_elderly_time_off_set

`parameters_lockdown_elderly_time_off_set` = function(self, s_lockdown_elderly_time_off)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_lockdown_elderly_time_off = as.integer(s_lockdown_elderly_time_off);
  
  if(length(s_lockdown_elderly_time_off) > 1) {
    warning("using only the first element of s_lockdown_elderly_time_off");
  };
  
  ;.Call('R_swig_parameters_lockdown_elderly_time_off_set', self, s_lockdown_elderly_time_off, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_lockdown_elderly_time_off_set`, 'returnType') = 'void'
attr(`parameters_lockdown_elderly_time_off_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_lockdown_elderly_time_off_set`) = c("SWIGFunction", class('parameters_lockdown_elderly_time_off_set'))

# Start of parameters_lockdown_elderly_time_off_get

`parameters_lockdown_elderly_time_off_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_lockdown_elderly_time_off_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_lockdown_elderly_time_off_get`, 'returnType') = 'integer'
attr(`parameters_lockdown_elderly_time_off_get`, "inputTypes") = c('_p_parameters')
class(`parameters_lockdown_elderly_time_off_get`) = c("SWIGFunction", class('parameters_lockdown_elderly_time_off_get'))

# Start of parameters_lockdown_elderly_on_set

`parameters_lockdown_elderly_on_set` = function(self, s_lockdown_elderly_on)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_lockdown_elderly_on = as.integer(s_lockdown_elderly_on);
  
  if(length(s_lockdown_elderly_on) > 1) {
    warning("using only the first element of s_lockdown_elderly_on");
  };
  
  ;.Call('R_swig_parameters_lockdown_elderly_on_set', self, s_lockdown_elderly_on, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_lockdown_elderly_on_set`, 'returnType') = 'void'
attr(`parameters_lockdown_elderly_on_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_lockdown_elderly_on_set`) = c("SWIGFunction", class('parameters_lockdown_elderly_on_set'))

# Start of parameters_lockdown_elderly_on_get

`parameters_lockdown_elderly_on_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_lockdown_elderly_on_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_lockdown_elderly_on_get`, 'returnType') = 'integer'
attr(`parameters_lockdown_elderly_on_get`, "inputTypes") = c('_p_parameters')
class(`parameters_lockdown_elderly_on_get`) = c("SWIGFunction", class('parameters_lockdown_elderly_on_get'))

# Start of parameters_testing_symptoms_time_on_set

`parameters_testing_symptoms_time_on_set` = function(self, s_testing_symptoms_time_on)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_testing_symptoms_time_on = as.integer(s_testing_symptoms_time_on);
  
  if(length(s_testing_symptoms_time_on) > 1) {
    warning("using only the first element of s_testing_symptoms_time_on");
  };
  
  ;.Call('R_swig_parameters_testing_symptoms_time_on_set', self, s_testing_symptoms_time_on, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_testing_symptoms_time_on_set`, 'returnType') = 'void'
attr(`parameters_testing_symptoms_time_on_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_testing_symptoms_time_on_set`) = c("SWIGFunction", class('parameters_testing_symptoms_time_on_set'))

# Start of parameters_testing_symptoms_time_on_get

`parameters_testing_symptoms_time_on_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_testing_symptoms_time_on_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_testing_symptoms_time_on_get`, 'returnType') = 'integer'
attr(`parameters_testing_symptoms_time_on_get`, "inputTypes") = c('_p_parameters')
class(`parameters_testing_symptoms_time_on_get`) = c("SWIGFunction", class('parameters_testing_symptoms_time_on_get'))

# Start of parameters_testing_symptoms_time_off_set

`parameters_testing_symptoms_time_off_set` = function(self, s_testing_symptoms_time_off)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_testing_symptoms_time_off = as.integer(s_testing_symptoms_time_off);
  
  if(length(s_testing_symptoms_time_off) > 1) {
    warning("using only the first element of s_testing_symptoms_time_off");
  };
  
  ;.Call('R_swig_parameters_testing_symptoms_time_off_set', self, s_testing_symptoms_time_off, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_testing_symptoms_time_off_set`, 'returnType') = 'void'
attr(`parameters_testing_symptoms_time_off_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_testing_symptoms_time_off_set`) = c("SWIGFunction", class('parameters_testing_symptoms_time_off_set'))

# Start of parameters_testing_symptoms_time_off_get

`parameters_testing_symptoms_time_off_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_testing_symptoms_time_off_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_testing_symptoms_time_off_get`, 'returnType') = 'integer'
attr(`parameters_testing_symptoms_time_off_get`, "inputTypes") = c('_p_parameters')
class(`parameters_testing_symptoms_time_off_get`) = c("SWIGFunction", class('parameters_testing_symptoms_time_off_get'))

# Start of parameters_interventions_on_set

`parameters_interventions_on_set` = function(self, s_interventions_on)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_interventions_on = as.integer(s_interventions_on);
  
  if(length(s_interventions_on) > 1) {
    warning("using only the first element of s_interventions_on");
  };
  
  ;.Call('R_swig_parameters_interventions_on_set', self, s_interventions_on, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_interventions_on_set`, 'returnType') = 'void'
attr(`parameters_interventions_on_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_interventions_on_set`) = c("SWIGFunction", class('parameters_interventions_on_set'))

# Start of parameters_interventions_on_get

`parameters_interventions_on_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_interventions_on_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_interventions_on_get`, 'returnType') = 'integer'
attr(`parameters_interventions_on_get`, "inputTypes") = c('_p_parameters')
class(`parameters_interventions_on_get`) = c("SWIGFunction", class('parameters_interventions_on_get'))

# Start of parameters_intervention_start_time_set

`parameters_intervention_start_time_set` = function(self, s_intervention_start_time)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_intervention_start_time = as.integer(s_intervention_start_time);
  
  if(length(s_intervention_start_time) > 1) {
    warning("using only the first element of s_intervention_start_time");
  };
  
  ;.Call('R_swig_parameters_intervention_start_time_set', self, s_intervention_start_time, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_intervention_start_time_set`, 'returnType') = 'void'
attr(`parameters_intervention_start_time_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_intervention_start_time_set`) = c("SWIGFunction", class('parameters_intervention_start_time_set'))

# Start of parameters_intervention_start_time_get

`parameters_intervention_start_time_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_intervention_start_time_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_intervention_start_time_get`, 'returnType') = 'integer'
attr(`parameters_intervention_start_time_get`, "inputTypes") = c('_p_parameters')
class(`parameters_intervention_start_time_get`) = c("SWIGFunction", class('parameters_intervention_start_time_get'))

# Start of parameters_sys_write_individual_set

`parameters_sys_write_individual_set` = function(self, s_sys_write_individual)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_sys_write_individual = as.integer(s_sys_write_individual);
  
  if(length(s_sys_write_individual) > 1) {
    warning("using only the first element of s_sys_write_individual");
  };
  
  ;.Call('R_swig_parameters_sys_write_individual_set', self, s_sys_write_individual, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sys_write_individual_set`, 'returnType') = 'void'
attr(`parameters_sys_write_individual_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_sys_write_individual_set`) = c("SWIGFunction", class('parameters_sys_write_individual_set'))

# Start of parameters_sys_write_individual_get

`parameters_sys_write_individual_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_sys_write_individual_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sys_write_individual_get`, 'returnType') = 'integer'
attr(`parameters_sys_write_individual_get`, "inputTypes") = c('_p_parameters')
class(`parameters_sys_write_individual_get`) = c("SWIGFunction", class('parameters_sys_write_individual_get'))

# Start of parameters_sys_write_hospital_set

`parameters_sys_write_hospital_set` = function(self, s_sys_write_hospital)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_sys_write_hospital = as.integer(s_sys_write_hospital);
  
  if(length(s_sys_write_hospital) > 1) {
    warning("using only the first element of s_sys_write_hospital");
  };
  
  ;.Call('R_swig_parameters_sys_write_hospital_set', self, s_sys_write_hospital, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sys_write_hospital_set`, 'returnType') = 'void'
attr(`parameters_sys_write_hospital_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_sys_write_hospital_set`) = c("SWIGFunction", class('parameters_sys_write_hospital_set'))

# Start of parameters_sys_write_hospital_get

`parameters_sys_write_hospital_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_sys_write_hospital_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_sys_write_hospital_get`, 'returnType') = 'integer'
attr(`parameters_sys_write_hospital_get`, "inputTypes") = c('_p_parameters')
class(`parameters_sys_write_hospital_get`) = c("SWIGFunction", class('parameters_sys_write_hospital_get'))

# Start of parameters_N_REFERENCE_HOUSEHOLDS_set

`parameters_N_REFERENCE_HOUSEHOLDS_set` = function(self, s_N_REFERENCE_HOUSEHOLDS)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_N_REFERENCE_HOUSEHOLDS = as.integer(s_N_REFERENCE_HOUSEHOLDS);
  
  if(length(s_N_REFERENCE_HOUSEHOLDS) > 1) {
    warning("using only the first element of s_N_REFERENCE_HOUSEHOLDS");
  };
  
  ;.Call('R_swig_parameters_N_REFERENCE_HOUSEHOLDS_set', self, s_N_REFERENCE_HOUSEHOLDS, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_N_REFERENCE_HOUSEHOLDS_set`, 'returnType') = 'void'
attr(`parameters_N_REFERENCE_HOUSEHOLDS_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_N_REFERENCE_HOUSEHOLDS_set`) = c("SWIGFunction", class('parameters_N_REFERENCE_HOUSEHOLDS_set'))

# Start of parameters_N_REFERENCE_HOUSEHOLDS_get

`parameters_N_REFERENCE_HOUSEHOLDS_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_N_REFERENCE_HOUSEHOLDS_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_N_REFERENCE_HOUSEHOLDS_get`, 'returnType') = 'integer'
attr(`parameters_N_REFERENCE_HOUSEHOLDS_get`, "inputTypes") = c('_p_parameters')
class(`parameters_N_REFERENCE_HOUSEHOLDS_get`) = c("SWIGFunction", class('parameters_N_REFERENCE_HOUSEHOLDS_get'))

# Start of parameters_REFERENCE_HOUSEHOLDS_set

`parameters_REFERENCE_HOUSEHOLDS_set` = function(self, s_REFERENCE_HOUSEHOLDS)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_REFERENCE_HOUSEHOLDS, "ExternalReference")) s_REFERENCE_HOUSEHOLDS = slot(s_REFERENCE_HOUSEHOLDS,"ref") 
  ;.Call('R_swig_parameters_REFERENCE_HOUSEHOLDS_set', self, s_REFERENCE_HOUSEHOLDS, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_REFERENCE_HOUSEHOLDS_set`, 'returnType') = 'void'
attr(`parameters_REFERENCE_HOUSEHOLDS_set`, "inputTypes") = c('_p_parameters', '_p_p_int')
class(`parameters_REFERENCE_HOUSEHOLDS_set`) = c("SWIGFunction", class('parameters_REFERENCE_HOUSEHOLDS_set'))

# Start of parameters_REFERENCE_HOUSEHOLDS_get

`parameters_REFERENCE_HOUSEHOLDS_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_parameters_REFERENCE_HOUSEHOLDS_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_p_int", ref=ans) ;
  
  ans
  
}

attr(`parameters_REFERENCE_HOUSEHOLDS_get`, 'returnType') = '_p_p_int'
attr(`parameters_REFERENCE_HOUSEHOLDS_get`, "inputTypes") = c('_p_parameters')
class(`parameters_REFERENCE_HOUSEHOLDS_get`) = c("SWIGFunction", class('parameters_REFERENCE_HOUSEHOLDS_get'))

# Start of parameters_demo_house_set

`parameters_demo_house_set` = function(self, s_demo_house)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_demo_house, "ExternalReference")) s_demo_house = slot(s_demo_house,"ref") 
  ;.Call('R_swig_parameters_demo_house_set', self, s_demo_house, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_demo_house_set`, 'returnType') = 'void'
attr(`parameters_demo_house_set`, "inputTypes") = c('_p_parameters', '_p_demographic_household_table')
class(`parameters_demo_house_set`) = c("SWIGFunction", class('parameters_demo_house_set'))

# Start of parameters_demo_house_get

`parameters_demo_house_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_parameters_demo_house_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_demographic_household_table", ref=ans) ;
  
  ans
  
}

attr(`parameters_demo_house_get`, 'returnType') = '_p_demographic_household_table'
attr(`parameters_demo_house_get`, "inputTypes") = c('_p_parameters')
class(`parameters_demo_house_get`) = c("SWIGFunction", class('parameters_demo_house_get'))

# Start of parameters_occupation_network_table_set

`parameters_occupation_network_table_set` = function(self, s_occupation_network_table)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_occupation_network_table, "ExternalReference")) s_occupation_network_table = slot(s_occupation_network_table,"ref") 
  ;.Call('R_swig_parameters_occupation_network_table_set', self, s_occupation_network_table, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_occupation_network_table_set`, 'returnType') = 'void'
attr(`parameters_occupation_network_table_set`, "inputTypes") = c('_p_parameters', '_p_demographic_occupation_network_table')
class(`parameters_occupation_network_table_set`) = c("SWIGFunction", class('parameters_occupation_network_table_set'))

# Start of parameters_occupation_network_table_get

`parameters_occupation_network_table_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_parameters_occupation_network_table_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_demographic_occupation_network_table", ref=ans) ;
  
  ans
  
}

attr(`parameters_occupation_network_table_get`, 'returnType') = '_p_demographic_occupation_network_table'
attr(`parameters_occupation_network_table_get`, "inputTypes") = c('_p_parameters')
class(`parameters_occupation_network_table_get`) = c("SWIGFunction", class('parameters_occupation_network_table_get'))

# Start of parameters_risk_score_set

`parameters_risk_score_set` = function(self, s_risk_score)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_risk_score, "ExternalReference")) s_risk_score = slot(s_risk_score,"ref") 
  ;.Call('R_swig_parameters_risk_score_set', self, s_risk_score, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_risk_score_set`, 'returnType') = 'void'
attr(`parameters_risk_score_set`, "inputTypes") = c('_p_parameters', '_p_p_p_double')
class(`parameters_risk_score_set`) = c("SWIGFunction", class('parameters_risk_score_set'))

# Start of parameters_risk_score_get

`parameters_risk_score_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_parameters_risk_score_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_p_p_double", ref=ans) ;
  
  ans
  
}

attr(`parameters_risk_score_get`, 'returnType') = '_p_p_p_double'
attr(`parameters_risk_score_get`, "inputTypes") = c('_p_parameters')
class(`parameters_risk_score_get`) = c("SWIGFunction", class('parameters_risk_score_get'))

# Start of parameters_risk_score_household_set

`parameters_risk_score_household_set` = function(self, s_risk_score_household)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_risk_score_household, "ExternalReference")) s_risk_score_household = slot(s_risk_score_household,"ref") 
  ;.Call('R_swig_parameters_risk_score_household_set', self, s_risk_score_household, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_risk_score_household_set`, 'returnType') = 'void'
attr(`parameters_risk_score_household_set`, "inputTypes") = c('_p_parameters', '_p_p_double')
class(`parameters_risk_score_household_set`) = c("SWIGFunction", class('parameters_risk_score_household_set'))

# Start of parameters_risk_score_household_get

`parameters_risk_score_household_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_parameters_risk_score_household_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_p_double", ref=ans) ;
  
  ans
  
}

attr(`parameters_risk_score_household_get`, 'returnType') = '_p_p_double'
attr(`parameters_risk_score_household_get`, "inputTypes") = c('_p_parameters')
class(`parameters_risk_score_household_get`) = c("SWIGFunction", class('parameters_risk_score_household_get'))

# Start of parameters_hospital_on_set

`parameters_hospital_on_set` = function(self, s_hospital_on)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_hospital_on = as.integer(s_hospital_on);
  
  if(length(s_hospital_on) > 1) {
    warning("using only the first element of s_hospital_on");
  };
  
  ;.Call('R_swig_parameters_hospital_on_set', self, s_hospital_on, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_hospital_on_set`, 'returnType') = 'void'
attr(`parameters_hospital_on_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_hospital_on_set`) = c("SWIGFunction", class('parameters_hospital_on_set'))

# Start of parameters_hospital_on_get

`parameters_hospital_on_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_hospital_on_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_hospital_on_get`, 'returnType') = 'integer'
attr(`parameters_hospital_on_get`, "inputTypes") = c('_p_parameters')
class(`parameters_hospital_on_get`) = c("SWIGFunction", class('parameters_hospital_on_get'))

# Start of parameters_n_hospitals_set

`parameters_n_hospitals_set` = function(self, s_n_hospitals)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_hospitals = as.integer(s_n_hospitals);
  
  if(length(s_n_hospitals) > 1) {
    warning("using only the first element of s_n_hospitals");
  };
  
  ;.Call('R_swig_parameters_n_hospitals_set', self, s_n_hospitals, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_n_hospitals_set`, 'returnType') = 'void'
attr(`parameters_n_hospitals_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_n_hospitals_set`) = c("SWIGFunction", class('parameters_n_hospitals_set'))

# Start of parameters_n_hospitals_get

`parameters_n_hospitals_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_n_hospitals_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_n_hospitals_get`, 'returnType') = 'integer'
attr(`parameters_n_hospitals_get`, "inputTypes") = c('_p_parameters')
class(`parameters_n_hospitals_get`) = c("SWIGFunction", class('parameters_n_hospitals_get'))

# Start of parameters_n_wards_set

`parameters_n_wards_set` = function(self, s_n_wards)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_wards = as.integer(s_n_wards);
  
#  assert(length(s_n_wards) >= N_HOSPITAL_WARD_TYPES)
  
  ;.Call('R_swig_parameters_n_wards_set', self, s_n_wards, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_n_wards_set`, 'returnType') = 'void'
attr(`parameters_n_wards_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_n_wards_set`) = c("SWIGFunction", class('parameters_n_wards_set'))

# Start of parameters_n_wards_get

`parameters_n_wards_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_parameters_n_wards_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  ans <- new("_p_int", ref=ans) ;
  
  ans
  
}

attr(`parameters_n_wards_get`, 'returnType') = 'integer'
attr(`parameters_n_wards_get`, "inputTypes") = c('_p_parameters')
class(`parameters_n_wards_get`) = c("SWIGFunction", class('parameters_n_wards_get'))

# Start of parameters_n_ward_beds_set

`parameters_n_ward_beds_set` = function(self, s_n_ward_beds)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_ward_beds = as.integer(s_n_ward_beds);
  
#  assert(length(s_n_ward_beds) >= N_HOSPITAL_WARD_TYPES)
  
  ;.Call('R_swig_parameters_n_ward_beds_set', self, s_n_ward_beds, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_n_ward_beds_set`, 'returnType') = 'void'
attr(`parameters_n_ward_beds_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_n_ward_beds_set`) = c("SWIGFunction", class('parameters_n_ward_beds_set'))

# Start of parameters_n_ward_beds_get

`parameters_n_ward_beds_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_parameters_n_ward_beds_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  ans <- new("_p_int", ref=ans) ;
  
  ans
  
}

attr(`parameters_n_ward_beds_get`, 'returnType') = 'integer'
attr(`parameters_n_ward_beds_get`, "inputTypes") = c('_p_parameters')
class(`parameters_n_ward_beds_get`) = c("SWIGFunction", class('parameters_n_ward_beds_get'))

# Start of parameters_n_hcw_per_ward_set

`parameters_n_hcw_per_ward_set` = function(self, s_n_hcw_per_ward)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  if(is.list(s_n_hcw_per_ward))
  assert(all(sapply(s_n_hcw_per_ward, class) == "_p_a_N_WORKER_TYPES__int"));
  
  
#  assert(length(s_n_hcw_per_ward) >= N_HOSPITAL_WARD_TYPES)
  
  ;.Call('R_swig_parameters_n_hcw_per_ward_set', self, s_n_hcw_per_ward, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_n_hcw_per_ward_set`, 'returnType') = 'void'
attr(`parameters_n_hcw_per_ward_set`, "inputTypes") = c('_p_parameters', '_p_a_N_WORKER_TYPES__int')
class(`parameters_n_hcw_per_ward_set`) = c("SWIGFunction", class('parameters_n_hcw_per_ward_set'))

# Start of parameters_n_hcw_per_ward_get

`parameters_n_hcw_per_ward_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_parameters_n_hcw_per_ward_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  ans <- new("_p_a_N_WORKER_TYPES__int", ref=ans) ;
  
  ans
  
}

attr(`parameters_n_hcw_per_ward_get`, 'returnType') = '_p_a_N_WORKER_TYPES__int'
attr(`parameters_n_hcw_per_ward_get`, "inputTypes") = c('_p_parameters')
class(`parameters_n_hcw_per_ward_get`) = c("SWIGFunction", class('parameters_n_hcw_per_ward_get'))

# Start of parameters_n_patient_required_interactions_set

`parameters_n_patient_required_interactions_set` = function(self, s_n_patient_required_interactions)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  if(is.list(s_n_patient_required_interactions))
  assert(all(sapply(s_n_patient_required_interactions, class) == "_p_a_N_WORKER_TYPES__int"));
  
  
#  assert(length(s_n_patient_required_interactions) >= N_HOSPITAL_WARD_TYPES)
  
  ;.Call('R_swig_parameters_n_patient_required_interactions_set', self, s_n_patient_required_interactions, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_n_patient_required_interactions_set`, 'returnType') = 'void'
attr(`parameters_n_patient_required_interactions_set`, "inputTypes") = c('_p_parameters', '_p_a_N_WORKER_TYPES__int')
class(`parameters_n_patient_required_interactions_set`) = c("SWIGFunction", class('parameters_n_patient_required_interactions_set'))

# Start of parameters_n_patient_required_interactions_get

`parameters_n_patient_required_interactions_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_parameters_n_patient_required_interactions_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  ans <- new("_p_a_N_WORKER_TYPES__int", ref=ans) ;
  
  ans
  
}

attr(`parameters_n_patient_required_interactions_get`, 'returnType') = '_p_a_N_WORKER_TYPES__int'
attr(`parameters_n_patient_required_interactions_get`, "inputTypes") = c('_p_parameters')
class(`parameters_n_patient_required_interactions_get`) = c("SWIGFunction", class('parameters_n_patient_required_interactions_get'))

# Start of parameters_max_hcw_daily_interactions_set

`parameters_max_hcw_daily_interactions_set` = function(self, s_max_hcw_daily_interactions)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_max_hcw_daily_interactions = as.integer(s_max_hcw_daily_interactions);
  
  if(length(s_max_hcw_daily_interactions) > 1) {
    warning("using only the first element of s_max_hcw_daily_interactions");
  };
  
  ;.Call('R_swig_parameters_max_hcw_daily_interactions_set', self, s_max_hcw_daily_interactions, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_max_hcw_daily_interactions_set`, 'returnType') = 'void'
attr(`parameters_max_hcw_daily_interactions_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_max_hcw_daily_interactions_set`) = c("SWIGFunction", class('parameters_max_hcw_daily_interactions_set'))

# Start of parameters_max_hcw_daily_interactions_get

`parameters_max_hcw_daily_interactions_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_max_hcw_daily_interactions_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_max_hcw_daily_interactions_get`, 'returnType') = 'integer'
attr(`parameters_max_hcw_daily_interactions_get`, "inputTypes") = c('_p_parameters')
class(`parameters_max_hcw_daily_interactions_get`) = c("SWIGFunction", class('parameters_max_hcw_daily_interactions_get'))

# Start of parameters_hospitalised_waiting_mod_set

`parameters_hospitalised_waiting_mod_set` = function(self, s_hospitalised_waiting_mod)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_hospitalised_waiting_mod_set', self, s_hospitalised_waiting_mod, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_hospitalised_waiting_mod_set`, 'returnType') = 'void'
attr(`parameters_hospitalised_waiting_mod_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_hospitalised_waiting_mod_set`) = c("SWIGFunction", class('parameters_hospitalised_waiting_mod_set'))

# Start of parameters_hospitalised_waiting_mod_get

`parameters_hospitalised_waiting_mod_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_hospitalised_waiting_mod_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_hospitalised_waiting_mod_get`, 'returnType') = 'numeric'
attr(`parameters_hospitalised_waiting_mod_get`, "inputTypes") = c('_p_parameters')
class(`parameters_hospitalised_waiting_mod_get`) = c("SWIGFunction", class('parameters_hospitalised_waiting_mod_get'))

# Start of parameters_critical_waiting_mod_set

`parameters_critical_waiting_mod_set` = function(self, s_critical_waiting_mod)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_critical_waiting_mod_set', self, s_critical_waiting_mod, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_critical_waiting_mod_set`, 'returnType') = 'void'
attr(`parameters_critical_waiting_mod_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_critical_waiting_mod_set`) = c("SWIGFunction", class('parameters_critical_waiting_mod_set'))

# Start of parameters_critical_waiting_mod_get

`parameters_critical_waiting_mod_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_critical_waiting_mod_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_critical_waiting_mod_get`, 'returnType') = 'numeric'
attr(`parameters_critical_waiting_mod_get`, "inputTypes") = c('_p_parameters')
class(`parameters_critical_waiting_mod_get`) = c("SWIGFunction", class('parameters_critical_waiting_mod_get'))

# Start of parameters_hcw_mean_work_interactions_set

`parameters_hcw_mean_work_interactions_set` = function(self, s_hcw_mean_work_interactions)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_parameters_hcw_mean_work_interactions_set', self, s_hcw_mean_work_interactions, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_hcw_mean_work_interactions_set`, 'returnType') = 'void'
attr(`parameters_hcw_mean_work_interactions_set`, "inputTypes") = c('_p_parameters', 'numeric')
class(`parameters_hcw_mean_work_interactions_set`) = c("SWIGFunction", class('parameters_hcw_mean_work_interactions_set'))

# Start of parameters_hcw_mean_work_interactions_get

`parameters_hcw_mean_work_interactions_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_hcw_mean_work_interactions_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_hcw_mean_work_interactions_get`, 'returnType') = 'numeric'
attr(`parameters_hcw_mean_work_interactions_get`, "inputTypes") = c('_p_parameters')
class(`parameters_hcw_mean_work_interactions_get`) = c("SWIGFunction", class('parameters_hcw_mean_work_interactions_get'))

# Start of parameters_max_n_strains_set

`parameters_max_n_strains_set` = function(self, s_max_n_strains)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_max_n_strains = as.integer(s_max_n_strains);
  
  if(length(s_max_n_strains) > 1) {
    warning("using only the first element of s_max_n_strains");
  };
  
  ;.Call('R_swig_parameters_max_n_strains_set', self, s_max_n_strains, PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_max_n_strains_set`, 'returnType') = 'void'
attr(`parameters_max_n_strains_set`, "inputTypes") = c('_p_parameters', 'integer')
class(`parameters_max_n_strains_set`) = c("SWIGFunction", class('parameters_max_n_strains_set'))

# Start of parameters_max_n_strains_get

`parameters_max_n_strains_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_parameters_max_n_strains_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`parameters_max_n_strains_get`, 'returnType') = 'integer'
attr(`parameters_max_n_strains_get`, "inputTypes") = c('_p_parameters')
class(`parameters_max_n_strains_get`) = c("SWIGFunction", class('parameters_max_n_strains_get'))

# Start of delete_parameters

`delete_parameters` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_delete_parameters', self, PACKAGE='OpenABMCovid19');
  
}

attr(`delete_parameters`, 'returnType') = 'void'
attr(`delete_parameters`, "inputTypes") = c('_p_parameters')
class(`delete_parameters`) = c("SWIGFunction", class('delete_parameters'))

# Start of new_parameters

`parameters` = function()
{
  ;ans = .Call('R_swig_new_parameters', PACKAGE='OpenABMCovid19');
  ans <- new("_p_parameters", ref=ans) ;
  
  reg.finalizer(ans@ref, delete_parameters)
  ans
  
}

attr(`parameters`, 'returnType') = '_p_parameters'
class(`parameters`) = c("SWIGFunction", class('parameters'))

# Start of accessor method for parameters
setMethod('$', '_p_parameters', function(x, name)

{
  accessorFuns = list('rng_seed' = parameters_rng_seed_get, 'input_param_file' = parameters_input_param_file_get, 'hospital_input_param_file' = parameters_hospital_input_param_file_get, 'input_household_file' = parameters_input_household_file_get, 'output_file_dir' = parameters_output_file_dir_get, 'param_line_number' = parameters_param_line_number_get, 'hospital_param_line_number' = parameters_hospital_param_line_number_get, 'param_id' = parameters_param_id_get, 'n_total' = parameters_n_total_get, 'days_of_interactions' = parameters_days_of_interactions_get, 'end_time' = parameters_end_time_get, 'n_seed_infection' = parameters_n_seed_infection_get, 'rebuild_networks' = parameters_rebuild_networks_get, 'mean_random_interactions' = parameters_mean_random_interactions_get, 'sd_random_interactions' = parameters_sd_random_interactions_get, 'random_interaction_distribution' = parameters_random_interaction_distribution_get, 'mean_work_interactions' = parameters_mean_work_interactions_get, 'daily_fraction_work' = parameters_daily_fraction_work_get, 'child_network_adults' = parameters_child_network_adults_get, 'elderly_network_adults' = parameters_elderly_network_adults_get, 'work_network_rewire' = parameters_work_network_rewire_get, 'mean_infectious_period' = parameters_mean_infectious_period_get, 'sd_infectious_period' = parameters_sd_infectious_period_get, 'infectious_rate' = parameters_infectious_rate_get, 'sd_infectiousness_multiplier' = parameters_sd_infectiousness_multiplier_get, 'relative_susceptibility' = parameters_relative_susceptibility_get, 'adjusted_susceptibility' = parameters_adjusted_susceptibility_get, 'relative_susceptibility_by_interaction' = parameters_relative_susceptibility_by_interaction_get, 'relative_transmission' = parameters_relative_transmission_get, 'relative_transmission_used' = parameters_relative_transmission_used_get, 'mean_time_to_symptoms' = parameters_mean_time_to_symptoms_get, 'sd_time_to_symptoms' = parameters_sd_time_to_symptoms_get, 'hospitalised_fraction' = parameters_hospitalised_fraction_get, 'critical_fraction' = parameters_critical_fraction_get, 'fatality_fraction' = parameters_fatality_fraction_get, 'mean_time_to_hospital' = parameters_mean_time_to_hospital_get, 'mean_time_to_critical' = parameters_mean_time_to_critical_get, 'sd_time_to_critical' = parameters_sd_time_to_critical_get, 'mean_time_to_recover' = parameters_mean_time_to_recover_get, 'sd_time_to_recover' = parameters_sd_time_to_recover_get, 'mean_time_to_death' = parameters_mean_time_to_death_get, 'sd_time_to_death' = parameters_sd_time_to_death_get, 'mean_time_to_susceptible_after_shift' = parameters_mean_time_to_susceptible_after_shift_get, 'time_to_susceptible_shift' = parameters_time_to_susceptible_shift_get, 'household_size' = parameters_household_size_get, 'population' = parameters_population_get, 'fraction_asymptomatic' = parameters_fraction_asymptomatic_get, 'asymptomatic_infectious_factor' = parameters_asymptomatic_infectious_factor_get, 'mild_fraction' = parameters_mild_fraction_get, 'mild_infectious_factor' = parameters_mild_infectious_factor_get, 'mean_asymptomatic_to_recovery' = parameters_mean_asymptomatic_to_recovery_get, 'sd_asymptomatic_to_recovery' = parameters_sd_asymptomatic_to_recovery_get, 'mean_time_hospitalised_recovery' = parameters_mean_time_hospitalised_recovery_get, 'sd_time_hospitalised_recovery' = parameters_sd_time_hospitalised_recovery_get, 'mean_time_critical_survive' = parameters_mean_time_critical_survive_get, 'sd_time_critical_survive' = parameters_sd_time_critical_survive_get, 'location_death_icu' = parameters_location_death_icu_get, 'quarantined_daily_interactions' = parameters_quarantined_daily_interactions_get, 'hospitalised_daily_interactions' = parameters_hospitalised_daily_interactions_get, 'quarantine_days' = parameters_quarantine_days_get, 'self_quarantine_fraction' = parameters_self_quarantine_fraction_get, 'manual_trace_on' = parameters_manual_trace_on_get, 'manual_trace_time_on' = parameters_manual_trace_time_on_get, 'manual_trace_on_hospitalization' = parameters_manual_trace_on_hospitalization_get, 'manual_trace_on_positive' = parameters_manual_trace_on_positive_get, 'manual_trace_delay' = parameters_manual_trace_delay_get, 'manual_trace_exclude_app_users' = parameters_manual_trace_exclude_app_users_get, 'manual_trace_n_workers' = parameters_manual_trace_n_workers_get, 'manual_trace_interviews_per_worker_day' = parameters_manual_trace_interviews_per_worker_day_get, 'manual_trace_notifications_per_worker_day' = parameters_manual_trace_notifications_per_worker_day_get, 'manual_traceable_fraction' = parameters_manual_traceable_fraction_get, 'trace_on_symptoms' = parameters_trace_on_symptoms_get, 'trace_on_positive' = parameters_trace_on_positive_get, 'retrace_on_positive' = parameters_retrace_on_positive_get, 'quarantine_length_self' = parameters_quarantine_length_self_get, 'quarantine_length_traced_symptoms' = parameters_quarantine_length_traced_symptoms_get, 'quarantine_length_traced_positive' = parameters_quarantine_length_traced_positive_get, 'quarantine_length_positive' = parameters_quarantine_length_positive_get, 'quarantine_dropout_self' = parameters_quarantine_dropout_self_get, 'quarantine_dropout_traced_symptoms' = parameters_quarantine_dropout_traced_symptoms_get, 'quarantine_dropout_traced_positive' = parameters_quarantine_dropout_traced_positive_get, 'quarantine_dropout_positive' = parameters_quarantine_dropout_positive_get, 'quarantine_compliance_traced_symptoms' = parameters_quarantine_compliance_traced_symptoms_get, 'quarantine_compliance_traced_positive' = parameters_quarantine_compliance_traced_positive_get, 'quarantine_on_traced' = parameters_quarantine_on_traced_get, 'quarantine_smart_release_day' = parameters_quarantine_smart_release_day_get, 'traceable_interaction_fraction' = parameters_traceable_interaction_fraction_get, 'tracing_network_depth' = parameters_tracing_network_depth_get, 'allow_clinical_diagnosis' = parameters_allow_clinical_diagnosis_get, 'quarantine_household_on_symptoms' = parameters_quarantine_household_on_symptoms_get, 'quarantine_household_on_positive' = parameters_quarantine_household_on_positive_get, 'quarantine_household_on_traced_symptoms' = parameters_quarantine_household_on_traced_symptoms_get, 'quarantine_household_on_traced_positive' = parameters_quarantine_household_on_traced_positive_get, 'quarantine_household_contacts_on_positive' = parameters_quarantine_household_contacts_on_positive_get, 'quarantine_household_contacts_on_symptoms' = parameters_quarantine_household_contacts_on_symptoms_get, 'test_on_symptoms' = parameters_test_on_symptoms_get, 'test_on_traced' = parameters_test_on_traced_get, 'test_result_wait' = parameters_test_result_wait_get, 'test_order_wait' = parameters_test_order_wait_get, 'test_result_wait_priority' = parameters_test_result_wait_priority_get, 'test_order_wait_priority' = parameters_test_order_wait_priority_get, 'test_release_on_negative' = parameters_test_release_on_negative_get, 'priority_test_contacts' = parameters_priority_test_contacts_get, 'test_insensitive_period' = parameters_test_insensitive_period_get, 'test_sensitive_period' = parameters_test_sensitive_period_get, 'test_sensitivity' = parameters_test_sensitivity_get, 'test_specificity' = parameters_test_specificity_get, 'app_users_fraction' = parameters_app_users_fraction_get, 'app_turned_on' = parameters_app_turned_on_get, 'app_turn_on_time' = parameters_app_turn_on_time_get, 'daily_non_cov_symptoms_rate' = parameters_daily_non_cov_symptoms_rate_get, 'lockdown_occupation_multiplier' = parameters_lockdown_occupation_multiplier_get, 'lockdown_random_network_multiplier' = parameters_lockdown_random_network_multiplier_get, 'lockdown_house_interaction_multiplier' = parameters_lockdown_house_interaction_multiplier_get, 'lockdown_time_on' = parameters_lockdown_time_on_get, 'lockdown_time_off' = parameters_lockdown_time_off_get, 'lockdown_on' = parameters_lockdown_on_get, 'lockdown_elderly_time_on' = parameters_lockdown_elderly_time_on_get, 'lockdown_elderly_time_off' = parameters_lockdown_elderly_time_off_get, 'lockdown_elderly_on' = parameters_lockdown_elderly_on_get, 'testing_symptoms_time_on' = parameters_testing_symptoms_time_on_get, 'testing_symptoms_time_off' = parameters_testing_symptoms_time_off_get, 'interventions_on' = parameters_interventions_on_get, 'intervention_start_time' = parameters_intervention_start_time_get, 'sys_write_individual' = parameters_sys_write_individual_get, 'sys_write_hospital' = parameters_sys_write_hospital_get, 'N_REFERENCE_HOUSEHOLDS' = parameters_N_REFERENCE_HOUSEHOLDS_get, 'REFERENCE_HOUSEHOLDS' = parameters_REFERENCE_HOUSEHOLDS_get, 'demo_house' = parameters_demo_house_get, 'occupation_network_table' = parameters_occupation_network_table_get, 'risk_score' = parameters_risk_score_get, 'risk_score_household' = parameters_risk_score_household_get, 'hospital_on' = parameters_hospital_on_get, 'n_hospitals' = parameters_n_hospitals_get, 'n_wards' = parameters_n_wards_get, 'n_ward_beds' = parameters_n_ward_beds_get, 'n_hcw_per_ward' = parameters_n_hcw_per_ward_get, 'n_patient_required_interactions' = parameters_n_patient_required_interactions_get, 'max_hcw_daily_interactions' = parameters_max_hcw_daily_interactions_get, 'hospitalised_waiting_mod' = parameters_hospitalised_waiting_mod_get, 'critical_waiting_mod' = parameters_critical_waiting_mod_get, 'hcw_mean_work_interactions' = parameters_hcw_mean_work_interactions_get, 'max_n_strains' = parameters_max_n_strains_get);
  vaccessors = c('rng_seed', 'input_param_file', 'hospital_input_param_file', 'input_household_file', 'output_file_dir', 'param_line_number', 'hospital_param_line_number', 'param_id', 'n_total', 'days_of_interactions', 'end_time', 'n_seed_infection', 'rebuild_networks', 'mean_random_interactions', 'sd_random_interactions', 'random_interaction_distribution', 'mean_work_interactions', 'daily_fraction_work', 'child_network_adults', 'elderly_network_adults', 'work_network_rewire', 'mean_infectious_period', 'sd_infectious_period', 'infectious_rate', 'sd_infectiousness_multiplier', 'relative_susceptibility', 'adjusted_susceptibility', 'relative_susceptibility_by_interaction', 'relative_transmission', 'relative_transmission_used', 'mean_time_to_symptoms', 'sd_time_to_symptoms', 'hospitalised_fraction', 'critical_fraction', 'fatality_fraction', 'mean_time_to_hospital', 'mean_time_to_critical', 'sd_time_to_critical', 'mean_time_to_recover', 'sd_time_to_recover', 'mean_time_to_death', 'sd_time_to_death', 'mean_time_to_susceptible_after_shift', 'time_to_susceptible_shift', 'household_size', 'population', 'fraction_asymptomatic', 'asymptomatic_infectious_factor', 'mild_fraction', 'mild_infectious_factor', 'mean_asymptomatic_to_recovery', 'sd_asymptomatic_to_recovery', 'mean_time_hospitalised_recovery', 'sd_time_hospitalised_recovery', 'mean_time_critical_survive', 'sd_time_critical_survive', 'location_death_icu', 'quarantined_daily_interactions', 'hospitalised_daily_interactions', 'quarantine_days', 'self_quarantine_fraction', 'manual_trace_on', 'manual_trace_time_on', 'manual_trace_on_hospitalization', 'manual_trace_on_positive', 'manual_trace_delay', 'manual_trace_exclude_app_users', 'manual_trace_n_workers', 'manual_trace_interviews_per_worker_day', 'manual_trace_notifications_per_worker_day', 'manual_traceable_fraction', 'trace_on_symptoms', 'trace_on_positive', 'retrace_on_positive', 'quarantine_length_self', 'quarantine_length_traced_symptoms', 'quarantine_length_traced_positive', 'quarantine_length_positive', 'quarantine_dropout_self', 'quarantine_dropout_traced_symptoms', 'quarantine_dropout_traced_positive', 'quarantine_dropout_positive', 'quarantine_compliance_traced_symptoms', 'quarantine_compliance_traced_positive', 'quarantine_on_traced', 'quarantine_smart_release_day', 'traceable_interaction_fraction', 'tracing_network_depth', 'allow_clinical_diagnosis', 'quarantine_household_on_symptoms', 'quarantine_household_on_positive', 'quarantine_household_on_traced_symptoms', 'quarantine_household_on_traced_positive', 'quarantine_household_contacts_on_positive', 'quarantine_household_contacts_on_symptoms', 'test_on_symptoms', 'test_on_traced', 'test_result_wait', 'test_order_wait', 'test_result_wait_priority', 'test_order_wait_priority', 'test_release_on_negative', 'priority_test_contacts', 'test_insensitive_period', 'test_sensitive_period', 'test_sensitivity', 'test_specificity', 'app_users_fraction', 'app_turned_on', 'app_turn_on_time', 'daily_non_cov_symptoms_rate', 'lockdown_occupation_multiplier', 'lockdown_random_network_multiplier', 'lockdown_house_interaction_multiplier', 'lockdown_time_on', 'lockdown_time_off', 'lockdown_on', 'lockdown_elderly_time_on', 'lockdown_elderly_time_off', 'lockdown_elderly_on', 'testing_symptoms_time_on', 'testing_symptoms_time_off', 'interventions_on', 'intervention_start_time', 'sys_write_individual', 'sys_write_hospital', 'N_REFERENCE_HOUSEHOLDS', 'REFERENCE_HOUSEHOLDS', 'demo_house', 'occupation_network_table', 'risk_score', 'risk_score_household', 'hospital_on', 'n_hospitals', 'n_wards', 'n_ward_beds', 'n_hcw_per_ward', 'n_patient_required_interactions', 'max_hcw_daily_interactions', 'hospitalised_waiting_mod', 'critical_waiting_mod', 'hcw_mean_work_interactions', 'max_n_strains');
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  if (is.na(match(name, vaccessors))) function(...){
    f(x, ...)
  } else f(x);
}


);
# end of accessor method for parameters
# Start of accessor method for parameters
setMethod('$<-', '_p_parameters', function(x, name, value)

{
  accessorFuns = list('rng_seed' = parameters_rng_seed_set, 'input_param_file' = parameters_input_param_file_set, 'hospital_input_param_file' = parameters_hospital_input_param_file_set, 'input_household_file' = parameters_input_household_file_set, 'output_file_dir' = parameters_output_file_dir_set, 'param_line_number' = parameters_param_line_number_set, 'hospital_param_line_number' = parameters_hospital_param_line_number_set, 'param_id' = parameters_param_id_set, 'n_total' = parameters_n_total_set, 'days_of_interactions' = parameters_days_of_interactions_set, 'end_time' = parameters_end_time_set, 'n_seed_infection' = parameters_n_seed_infection_set, 'rebuild_networks' = parameters_rebuild_networks_set, 'mean_random_interactions' = parameters_mean_random_interactions_set, 'sd_random_interactions' = parameters_sd_random_interactions_set, 'random_interaction_distribution' = parameters_random_interaction_distribution_set, 'mean_work_interactions' = parameters_mean_work_interactions_set, 'daily_fraction_work' = parameters_daily_fraction_work_set, 'child_network_adults' = parameters_child_network_adults_set, 'elderly_network_adults' = parameters_elderly_network_adults_set, 'work_network_rewire' = parameters_work_network_rewire_set, 'mean_infectious_period' = parameters_mean_infectious_period_set, 'sd_infectious_period' = parameters_sd_infectious_period_set, 'infectious_rate' = parameters_infectious_rate_set, 'sd_infectiousness_multiplier' = parameters_sd_infectiousness_multiplier_set, 'relative_susceptibility' = parameters_relative_susceptibility_set, 'adjusted_susceptibility' = parameters_adjusted_susceptibility_set, 'relative_susceptibility_by_interaction' = parameters_relative_susceptibility_by_interaction_set, 'relative_transmission' = parameters_relative_transmission_set, 'relative_transmission_used' = parameters_relative_transmission_used_set, 'mean_time_to_symptoms' = parameters_mean_time_to_symptoms_set, 'sd_time_to_symptoms' = parameters_sd_time_to_symptoms_set, 'hospitalised_fraction' = parameters_hospitalised_fraction_set, 'critical_fraction' = parameters_critical_fraction_set, 'fatality_fraction' = parameters_fatality_fraction_set, 'mean_time_to_hospital' = parameters_mean_time_to_hospital_set, 'mean_time_to_critical' = parameters_mean_time_to_critical_set, 'sd_time_to_critical' = parameters_sd_time_to_critical_set, 'mean_time_to_recover' = parameters_mean_time_to_recover_set, 'sd_time_to_recover' = parameters_sd_time_to_recover_set, 'mean_time_to_death' = parameters_mean_time_to_death_set, 'sd_time_to_death' = parameters_sd_time_to_death_set, 'mean_time_to_susceptible_after_shift' = parameters_mean_time_to_susceptible_after_shift_set, 'time_to_susceptible_shift' = parameters_time_to_susceptible_shift_set, 'household_size' = parameters_household_size_set, 'population' = parameters_population_set, 'fraction_asymptomatic' = parameters_fraction_asymptomatic_set, 'asymptomatic_infectious_factor' = parameters_asymptomatic_infectious_factor_set, 'mild_fraction' = parameters_mild_fraction_set, 'mild_infectious_factor' = parameters_mild_infectious_factor_set, 'mean_asymptomatic_to_recovery' = parameters_mean_asymptomatic_to_recovery_set, 'sd_asymptomatic_to_recovery' = parameters_sd_asymptomatic_to_recovery_set, 'mean_time_hospitalised_recovery' = parameters_mean_time_hospitalised_recovery_set, 'sd_time_hospitalised_recovery' = parameters_sd_time_hospitalised_recovery_set, 'mean_time_critical_survive' = parameters_mean_time_critical_survive_set, 'sd_time_critical_survive' = parameters_sd_time_critical_survive_set, 'location_death_icu' = parameters_location_death_icu_set, 'quarantined_daily_interactions' = parameters_quarantined_daily_interactions_set, 'hospitalised_daily_interactions' = parameters_hospitalised_daily_interactions_set, 'quarantine_days' = parameters_quarantine_days_set, 'self_quarantine_fraction' = parameters_self_quarantine_fraction_set, 'manual_trace_on' = parameters_manual_trace_on_set, 'manual_trace_time_on' = parameters_manual_trace_time_on_set, 'manual_trace_on_hospitalization' = parameters_manual_trace_on_hospitalization_set, 'manual_trace_on_positive' = parameters_manual_trace_on_positive_set, 'manual_trace_delay' = parameters_manual_trace_delay_set, 'manual_trace_exclude_app_users' = parameters_manual_trace_exclude_app_users_set, 'manual_trace_n_workers' = parameters_manual_trace_n_workers_set, 'manual_trace_interviews_per_worker_day' = parameters_manual_trace_interviews_per_worker_day_set, 'manual_trace_notifications_per_worker_day' = parameters_manual_trace_notifications_per_worker_day_set, 'manual_traceable_fraction' = parameters_manual_traceable_fraction_set, 'trace_on_symptoms' = parameters_trace_on_symptoms_set, 'trace_on_positive' = parameters_trace_on_positive_set, 'retrace_on_positive' = parameters_retrace_on_positive_set, 'quarantine_length_self' = parameters_quarantine_length_self_set, 'quarantine_length_traced_symptoms' = parameters_quarantine_length_traced_symptoms_set, 'quarantine_length_traced_positive' = parameters_quarantine_length_traced_positive_set, 'quarantine_length_positive' = parameters_quarantine_length_positive_set, 'quarantine_dropout_self' = parameters_quarantine_dropout_self_set, 'quarantine_dropout_traced_symptoms' = parameters_quarantine_dropout_traced_symptoms_set, 'quarantine_dropout_traced_positive' = parameters_quarantine_dropout_traced_positive_set, 'quarantine_dropout_positive' = parameters_quarantine_dropout_positive_set, 'quarantine_compliance_traced_symptoms' = parameters_quarantine_compliance_traced_symptoms_set, 'quarantine_compliance_traced_positive' = parameters_quarantine_compliance_traced_positive_set, 'quarantine_on_traced' = parameters_quarantine_on_traced_set, 'quarantine_smart_release_day' = parameters_quarantine_smart_release_day_set, 'traceable_interaction_fraction' = parameters_traceable_interaction_fraction_set, 'tracing_network_depth' = parameters_tracing_network_depth_set, 'allow_clinical_diagnosis' = parameters_allow_clinical_diagnosis_set, 'quarantine_household_on_symptoms' = parameters_quarantine_household_on_symptoms_set, 'quarantine_household_on_positive' = parameters_quarantine_household_on_positive_set, 'quarantine_household_on_traced_symptoms' = parameters_quarantine_household_on_traced_symptoms_set, 'quarantine_household_on_traced_positive' = parameters_quarantine_household_on_traced_positive_set, 'quarantine_household_contacts_on_positive' = parameters_quarantine_household_contacts_on_positive_set, 'quarantine_household_contacts_on_symptoms' = parameters_quarantine_household_contacts_on_symptoms_set, 'test_on_symptoms' = parameters_test_on_symptoms_set, 'test_on_traced' = parameters_test_on_traced_set, 'test_result_wait' = parameters_test_result_wait_set, 'test_order_wait' = parameters_test_order_wait_set, 'test_result_wait_priority' = parameters_test_result_wait_priority_set, 'test_order_wait_priority' = parameters_test_order_wait_priority_set, 'test_release_on_negative' = parameters_test_release_on_negative_set, 'priority_test_contacts' = parameters_priority_test_contacts_set, 'test_insensitive_period' = parameters_test_insensitive_period_set, 'test_sensitive_period' = parameters_test_sensitive_period_set, 'test_sensitivity' = parameters_test_sensitivity_set, 'test_specificity' = parameters_test_specificity_set, 'app_users_fraction' = parameters_app_users_fraction_set, 'app_turned_on' = parameters_app_turned_on_set, 'app_turn_on_time' = parameters_app_turn_on_time_set, 'daily_non_cov_symptoms_rate' = parameters_daily_non_cov_symptoms_rate_set, 'lockdown_occupation_multiplier' = parameters_lockdown_occupation_multiplier_set, 'lockdown_random_network_multiplier' = parameters_lockdown_random_network_multiplier_set, 'lockdown_house_interaction_multiplier' = parameters_lockdown_house_interaction_multiplier_set, 'lockdown_time_on' = parameters_lockdown_time_on_set, 'lockdown_time_off' = parameters_lockdown_time_off_set, 'lockdown_on' = parameters_lockdown_on_set, 'lockdown_elderly_time_on' = parameters_lockdown_elderly_time_on_set, 'lockdown_elderly_time_off' = parameters_lockdown_elderly_time_off_set, 'lockdown_elderly_on' = parameters_lockdown_elderly_on_set, 'testing_symptoms_time_on' = parameters_testing_symptoms_time_on_set, 'testing_symptoms_time_off' = parameters_testing_symptoms_time_off_set, 'interventions_on' = parameters_interventions_on_set, 'intervention_start_time' = parameters_intervention_start_time_set, 'sys_write_individual' = parameters_sys_write_individual_set, 'sys_write_hospital' = parameters_sys_write_hospital_set, 'N_REFERENCE_HOUSEHOLDS' = parameters_N_REFERENCE_HOUSEHOLDS_set, 'REFERENCE_HOUSEHOLDS' = parameters_REFERENCE_HOUSEHOLDS_set, 'demo_house' = parameters_demo_house_set, 'occupation_network_table' = parameters_occupation_network_table_set, 'risk_score' = parameters_risk_score_set, 'risk_score_household' = parameters_risk_score_household_set, 'hospital_on' = parameters_hospital_on_set, 'n_hospitals' = parameters_n_hospitals_set, 'n_wards' = parameters_n_wards_set, 'n_ward_beds' = parameters_n_ward_beds_set, 'n_hcw_per_ward' = parameters_n_hcw_per_ward_set, 'n_patient_required_interactions' = parameters_n_patient_required_interactions_set, 'max_hcw_daily_interactions' = parameters_max_hcw_daily_interactions_set, 'hospitalised_waiting_mod' = parameters_hospitalised_waiting_mod_set, 'critical_waiting_mod' = parameters_critical_waiting_mod_set, 'hcw_mean_work_interactions' = parameters_hcw_mean_work_interactions_set, 'max_n_strains' = parameters_max_n_strains_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
setMethod('[[<-', c('_p_parameters', 'character'),function(x, i, j, ..., value)

{
  name = i;
  accessorFuns = list('rng_seed' = parameters_rng_seed_set, 'input_param_file' = parameters_input_param_file_set, 'hospital_input_param_file' = parameters_hospital_input_param_file_set, 'input_household_file' = parameters_input_household_file_set, 'output_file_dir' = parameters_output_file_dir_set, 'param_line_number' = parameters_param_line_number_set, 'hospital_param_line_number' = parameters_hospital_param_line_number_set, 'param_id' = parameters_param_id_set, 'n_total' = parameters_n_total_set, 'days_of_interactions' = parameters_days_of_interactions_set, 'end_time' = parameters_end_time_set, 'n_seed_infection' = parameters_n_seed_infection_set, 'rebuild_networks' = parameters_rebuild_networks_set, 'mean_random_interactions' = parameters_mean_random_interactions_set, 'sd_random_interactions' = parameters_sd_random_interactions_set, 'random_interaction_distribution' = parameters_random_interaction_distribution_set, 'mean_work_interactions' = parameters_mean_work_interactions_set, 'daily_fraction_work' = parameters_daily_fraction_work_set, 'child_network_adults' = parameters_child_network_adults_set, 'elderly_network_adults' = parameters_elderly_network_adults_set, 'work_network_rewire' = parameters_work_network_rewire_set, 'mean_infectious_period' = parameters_mean_infectious_period_set, 'sd_infectious_period' = parameters_sd_infectious_period_set, 'infectious_rate' = parameters_infectious_rate_set, 'sd_infectiousness_multiplier' = parameters_sd_infectiousness_multiplier_set, 'relative_susceptibility' = parameters_relative_susceptibility_set, 'adjusted_susceptibility' = parameters_adjusted_susceptibility_set, 'relative_susceptibility_by_interaction' = parameters_relative_susceptibility_by_interaction_set, 'relative_transmission' = parameters_relative_transmission_set, 'relative_transmission_used' = parameters_relative_transmission_used_set, 'mean_time_to_symptoms' = parameters_mean_time_to_symptoms_set, 'sd_time_to_symptoms' = parameters_sd_time_to_symptoms_set, 'hospitalised_fraction' = parameters_hospitalised_fraction_set, 'critical_fraction' = parameters_critical_fraction_set, 'fatality_fraction' = parameters_fatality_fraction_set, 'mean_time_to_hospital' = parameters_mean_time_to_hospital_set, 'mean_time_to_critical' = parameters_mean_time_to_critical_set, 'sd_time_to_critical' = parameters_sd_time_to_critical_set, 'mean_time_to_recover' = parameters_mean_time_to_recover_set, 'sd_time_to_recover' = parameters_sd_time_to_recover_set, 'mean_time_to_death' = parameters_mean_time_to_death_set, 'sd_time_to_death' = parameters_sd_time_to_death_set, 'mean_time_to_susceptible_after_shift' = parameters_mean_time_to_susceptible_after_shift_set, 'time_to_susceptible_shift' = parameters_time_to_susceptible_shift_set, 'household_size' = parameters_household_size_set, 'population' = parameters_population_set, 'fraction_asymptomatic' = parameters_fraction_asymptomatic_set, 'asymptomatic_infectious_factor' = parameters_asymptomatic_infectious_factor_set, 'mild_fraction' = parameters_mild_fraction_set, 'mild_infectious_factor' = parameters_mild_infectious_factor_set, 'mean_asymptomatic_to_recovery' = parameters_mean_asymptomatic_to_recovery_set, 'sd_asymptomatic_to_recovery' = parameters_sd_asymptomatic_to_recovery_set, 'mean_time_hospitalised_recovery' = parameters_mean_time_hospitalised_recovery_set, 'sd_time_hospitalised_recovery' = parameters_sd_time_hospitalised_recovery_set, 'mean_time_critical_survive' = parameters_mean_time_critical_survive_set, 'sd_time_critical_survive' = parameters_sd_time_critical_survive_set, 'location_death_icu' = parameters_location_death_icu_set, 'quarantined_daily_interactions' = parameters_quarantined_daily_interactions_set, 'hospitalised_daily_interactions' = parameters_hospitalised_daily_interactions_set, 'quarantine_days' = parameters_quarantine_days_set, 'self_quarantine_fraction' = parameters_self_quarantine_fraction_set, 'manual_trace_on' = parameters_manual_trace_on_set, 'manual_trace_time_on' = parameters_manual_trace_time_on_set, 'manual_trace_on_hospitalization' = parameters_manual_trace_on_hospitalization_set, 'manual_trace_on_positive' = parameters_manual_trace_on_positive_set, 'manual_trace_delay' = parameters_manual_trace_delay_set, 'manual_trace_exclude_app_users' = parameters_manual_trace_exclude_app_users_set, 'manual_trace_n_workers' = parameters_manual_trace_n_workers_set, 'manual_trace_interviews_per_worker_day' = parameters_manual_trace_interviews_per_worker_day_set, 'manual_trace_notifications_per_worker_day' = parameters_manual_trace_notifications_per_worker_day_set, 'manual_traceable_fraction' = parameters_manual_traceable_fraction_set, 'trace_on_symptoms' = parameters_trace_on_symptoms_set, 'trace_on_positive' = parameters_trace_on_positive_set, 'retrace_on_positive' = parameters_retrace_on_positive_set, 'quarantine_length_self' = parameters_quarantine_length_self_set, 'quarantine_length_traced_symptoms' = parameters_quarantine_length_traced_symptoms_set, 'quarantine_length_traced_positive' = parameters_quarantine_length_traced_positive_set, 'quarantine_length_positive' = parameters_quarantine_length_positive_set, 'quarantine_dropout_self' = parameters_quarantine_dropout_self_set, 'quarantine_dropout_traced_symptoms' = parameters_quarantine_dropout_traced_symptoms_set, 'quarantine_dropout_traced_positive' = parameters_quarantine_dropout_traced_positive_set, 'quarantine_dropout_positive' = parameters_quarantine_dropout_positive_set, 'quarantine_compliance_traced_symptoms' = parameters_quarantine_compliance_traced_symptoms_set, 'quarantine_compliance_traced_positive' = parameters_quarantine_compliance_traced_positive_set, 'quarantine_on_traced' = parameters_quarantine_on_traced_set, 'quarantine_smart_release_day' = parameters_quarantine_smart_release_day_set, 'traceable_interaction_fraction' = parameters_traceable_interaction_fraction_set, 'tracing_network_depth' = parameters_tracing_network_depth_set, 'allow_clinical_diagnosis' = parameters_allow_clinical_diagnosis_set, 'quarantine_household_on_symptoms' = parameters_quarantine_household_on_symptoms_set, 'quarantine_household_on_positive' = parameters_quarantine_household_on_positive_set, 'quarantine_household_on_traced_symptoms' = parameters_quarantine_household_on_traced_symptoms_set, 'quarantine_household_on_traced_positive' = parameters_quarantine_household_on_traced_positive_set, 'quarantine_household_contacts_on_positive' = parameters_quarantine_household_contacts_on_positive_set, 'quarantine_household_contacts_on_symptoms' = parameters_quarantine_household_contacts_on_symptoms_set, 'test_on_symptoms' = parameters_test_on_symptoms_set, 'test_on_traced' = parameters_test_on_traced_set, 'test_result_wait' = parameters_test_result_wait_set, 'test_order_wait' = parameters_test_order_wait_set, 'test_result_wait_priority' = parameters_test_result_wait_priority_set, 'test_order_wait_priority' = parameters_test_order_wait_priority_set, 'test_release_on_negative' = parameters_test_release_on_negative_set, 'priority_test_contacts' = parameters_priority_test_contacts_set, 'test_insensitive_period' = parameters_test_insensitive_period_set, 'test_sensitive_period' = parameters_test_sensitive_period_set, 'test_sensitivity' = parameters_test_sensitivity_set, 'test_specificity' = parameters_test_specificity_set, 'app_users_fraction' = parameters_app_users_fraction_set, 'app_turned_on' = parameters_app_turned_on_set, 'app_turn_on_time' = parameters_app_turn_on_time_set, 'daily_non_cov_symptoms_rate' = parameters_daily_non_cov_symptoms_rate_set, 'lockdown_occupation_multiplier' = parameters_lockdown_occupation_multiplier_set, 'lockdown_random_network_multiplier' = parameters_lockdown_random_network_multiplier_set, 'lockdown_house_interaction_multiplier' = parameters_lockdown_house_interaction_multiplier_set, 'lockdown_time_on' = parameters_lockdown_time_on_set, 'lockdown_time_off' = parameters_lockdown_time_off_set, 'lockdown_on' = parameters_lockdown_on_set, 'lockdown_elderly_time_on' = parameters_lockdown_elderly_time_on_set, 'lockdown_elderly_time_off' = parameters_lockdown_elderly_time_off_set, 'lockdown_elderly_on' = parameters_lockdown_elderly_on_set, 'testing_symptoms_time_on' = parameters_testing_symptoms_time_on_set, 'testing_symptoms_time_off' = parameters_testing_symptoms_time_off_set, 'interventions_on' = parameters_interventions_on_set, 'intervention_start_time' = parameters_intervention_start_time_set, 'sys_write_individual' = parameters_sys_write_individual_set, 'sys_write_hospital' = parameters_sys_write_hospital_set, 'N_REFERENCE_HOUSEHOLDS' = parameters_N_REFERENCE_HOUSEHOLDS_set, 'REFERENCE_HOUSEHOLDS' = parameters_REFERENCE_HOUSEHOLDS_set, 'demo_house' = parameters_demo_house_set, 'occupation_network_table' = parameters_occupation_network_table_set, 'risk_score' = parameters_risk_score_set, 'risk_score_household' = parameters_risk_score_household_set, 'hospital_on' = parameters_hospital_on_set, 'n_hospitals' = parameters_n_hospitals_set, 'n_wards' = parameters_n_wards_set, 'n_ward_beds' = parameters_n_ward_beds_set, 'n_hcw_per_ward' = parameters_n_hcw_per_ward_set, 'n_patient_required_interactions' = parameters_n_patient_required_interactions_set, 'max_hcw_daily_interactions' = parameters_max_hcw_daily_interactions_set, 'hospitalised_waiting_mod' = parameters_hospitalised_waiting_mod_set, 'critical_waiting_mod' = parameters_critical_waiting_mod_set, 'hcw_mean_work_interactions' = parameters_hcw_mean_work_interactions_set, 'max_n_strains' = parameters_max_n_strains_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
# end of accessor method for parameters
setMethod('delete', '_p_parameters', function(obj) {delete_parameters(obj)})
# Start definition of copy functions & methods for parameters
CopyToR_parameters = function(value, obj = new("parameters"))
{
  obj@rng_seed = value$rng_seed;
  obj@input_param_file = value$input_param_file;
  obj@hospital_input_param_file = value$hospital_input_param_file;
  obj@input_household_file = value$input_household_file;
  obj@output_file_dir = value$output_file_dir;
  obj@param_line_number = value$param_line_number;
  obj@hospital_param_line_number = value$hospital_param_line_number;
  obj@param_id = value$param_id;
  obj@n_total = value$n_total;
  obj@days_of_interactions = value$days_of_interactions;
  obj@end_time = value$end_time;
  obj@n_seed_infection = value$n_seed_infection;
  obj@rebuild_networks = value$rebuild_networks;
  obj@mean_random_interactions = value$mean_random_interactions;
  obj@sd_random_interactions = value$sd_random_interactions;
  obj@random_interaction_distribution = value$random_interaction_distribution;
  obj@mean_work_interactions = value$mean_work_interactions;
  obj@daily_fraction_work = value$daily_fraction_work;
  obj@child_network_adults = value$child_network_adults;
  obj@elderly_network_adults = value$elderly_network_adults;
  obj@work_network_rewire = value$work_network_rewire;
  obj@mean_infectious_period = value$mean_infectious_period;
  obj@sd_infectious_period = value$sd_infectious_period;
  obj@infectious_rate = value$infectious_rate;
  obj@sd_infectiousness_multiplier = value$sd_infectiousness_multiplier;
  obj@relative_susceptibility = value$relative_susceptibility;
  obj@adjusted_susceptibility = value$adjusted_susceptibility;
  obj@relative_susceptibility_by_interaction = value$relative_susceptibility_by_interaction;
  obj@relative_transmission = value$relative_transmission;
  obj@relative_transmission_used = value$relative_transmission_used;
  obj@mean_time_to_symptoms = value$mean_time_to_symptoms;
  obj@sd_time_to_symptoms = value$sd_time_to_symptoms;
  obj@hospitalised_fraction = value$hospitalised_fraction;
  obj@critical_fraction = value$critical_fraction;
  obj@fatality_fraction = value$fatality_fraction;
  obj@mean_time_to_hospital = value$mean_time_to_hospital;
  obj@mean_time_to_critical = value$mean_time_to_critical;
  obj@sd_time_to_critical = value$sd_time_to_critical;
  obj@mean_time_to_recover = value$mean_time_to_recover;
  obj@sd_time_to_recover = value$sd_time_to_recover;
  obj@mean_time_to_death = value$mean_time_to_death;
  obj@sd_time_to_death = value$sd_time_to_death;
  obj@mean_time_to_susceptible_after_shift = value$mean_time_to_susceptible_after_shift;
  obj@time_to_susceptible_shift = value$time_to_susceptible_shift;
  obj@household_size = value$household_size;
  obj@population = value$population;
  obj@fraction_asymptomatic = value$fraction_asymptomatic;
  obj@asymptomatic_infectious_factor = value$asymptomatic_infectious_factor;
  obj@mild_fraction = value$mild_fraction;
  obj@mild_infectious_factor = value$mild_infectious_factor;
  obj@mean_asymptomatic_to_recovery = value$mean_asymptomatic_to_recovery;
  obj@sd_asymptomatic_to_recovery = value$sd_asymptomatic_to_recovery;
  obj@mean_time_hospitalised_recovery = value$mean_time_hospitalised_recovery;
  obj@sd_time_hospitalised_recovery = value$sd_time_hospitalised_recovery;
  obj@mean_time_critical_survive = value$mean_time_critical_survive;
  obj@sd_time_critical_survive = value$sd_time_critical_survive;
  obj@location_death_icu = value$location_death_icu;
  obj@quarantined_daily_interactions = value$quarantined_daily_interactions;
  obj@hospitalised_daily_interactions = value$hospitalised_daily_interactions;
  obj@quarantine_days = value$quarantine_days;
  obj@self_quarantine_fraction = value$self_quarantine_fraction;
  obj@manual_trace_on = value$manual_trace_on;
  obj@manual_trace_time_on = value$manual_trace_time_on;
  obj@manual_trace_on_hospitalization = value$manual_trace_on_hospitalization;
  obj@manual_trace_on_positive = value$manual_trace_on_positive;
  obj@manual_trace_delay = value$manual_trace_delay;
  obj@manual_trace_exclude_app_users = value$manual_trace_exclude_app_users;
  obj@manual_trace_n_workers = value$manual_trace_n_workers;
  obj@manual_trace_interviews_per_worker_day = value$manual_trace_interviews_per_worker_day;
  obj@manual_trace_notifications_per_worker_day = value$manual_trace_notifications_per_worker_day;
  obj@manual_traceable_fraction = value$manual_traceable_fraction;
  obj@trace_on_symptoms = value$trace_on_symptoms;
  obj@trace_on_positive = value$trace_on_positive;
  obj@retrace_on_positive = value$retrace_on_positive;
  obj@quarantine_length_self = value$quarantine_length_self;
  obj@quarantine_length_traced_symptoms = value$quarantine_length_traced_symptoms;
  obj@quarantine_length_traced_positive = value$quarantine_length_traced_positive;
  obj@quarantine_length_positive = value$quarantine_length_positive;
  obj@quarantine_dropout_self = value$quarantine_dropout_self;
  obj@quarantine_dropout_traced_symptoms = value$quarantine_dropout_traced_symptoms;
  obj@quarantine_dropout_traced_positive = value$quarantine_dropout_traced_positive;
  obj@quarantine_dropout_positive = value$quarantine_dropout_positive;
  obj@quarantine_compliance_traced_symptoms = value$quarantine_compliance_traced_symptoms;
  obj@quarantine_compliance_traced_positive = value$quarantine_compliance_traced_positive;
  obj@quarantine_on_traced = value$quarantine_on_traced;
  obj@quarantine_smart_release_day = value$quarantine_smart_release_day;
  obj@traceable_interaction_fraction = value$traceable_interaction_fraction;
  obj@tracing_network_depth = value$tracing_network_depth;
  obj@allow_clinical_diagnosis = value$allow_clinical_diagnosis;
  obj@quarantine_household_on_symptoms = value$quarantine_household_on_symptoms;
  obj@quarantine_household_on_positive = value$quarantine_household_on_positive;
  obj@quarantine_household_on_traced_symptoms = value$quarantine_household_on_traced_symptoms;
  obj@quarantine_household_on_traced_positive = value$quarantine_household_on_traced_positive;
  obj@quarantine_household_contacts_on_positive = value$quarantine_household_contacts_on_positive;
  obj@quarantine_household_contacts_on_symptoms = value$quarantine_household_contacts_on_symptoms;
  obj@test_on_symptoms = value$test_on_symptoms;
  obj@test_on_traced = value$test_on_traced;
  obj@test_result_wait = value$test_result_wait;
  obj@test_order_wait = value$test_order_wait;
  obj@test_result_wait_priority = value$test_result_wait_priority;
  obj@test_order_wait_priority = value$test_order_wait_priority;
  obj@test_release_on_negative = value$test_release_on_negative;
  obj@priority_test_contacts = value$priority_test_contacts;
  obj@test_insensitive_period = value$test_insensitive_period;
  obj@test_sensitive_period = value$test_sensitive_period;
  obj@test_sensitivity = value$test_sensitivity;
  obj@test_specificity = value$test_specificity;
  obj@app_users_fraction = value$app_users_fraction;
  obj@app_turned_on = value$app_turned_on;
  obj@app_turn_on_time = value$app_turn_on_time;
  obj@daily_non_cov_symptoms_rate = value$daily_non_cov_symptoms_rate;
  obj@lockdown_occupation_multiplier = value$lockdown_occupation_multiplier;
  obj@lockdown_random_network_multiplier = value$lockdown_random_network_multiplier;
  obj@lockdown_house_interaction_multiplier = value$lockdown_house_interaction_multiplier;
  obj@lockdown_time_on = value$lockdown_time_on;
  obj@lockdown_time_off = value$lockdown_time_off;
  obj@lockdown_on = value$lockdown_on;
  obj@lockdown_elderly_time_on = value$lockdown_elderly_time_on;
  obj@lockdown_elderly_time_off = value$lockdown_elderly_time_off;
  obj@lockdown_elderly_on = value$lockdown_elderly_on;
  obj@testing_symptoms_time_on = value$testing_symptoms_time_on;
  obj@testing_symptoms_time_off = value$testing_symptoms_time_off;
  obj@interventions_on = value$interventions_on;
  obj@intervention_start_time = value$intervention_start_time;
  obj@sys_write_individual = value$sys_write_individual;
  obj@sys_write_hospital = value$sys_write_hospital;
  obj@N_REFERENCE_HOUSEHOLDS = value$N_REFERENCE_HOUSEHOLDS;
  obj@hospital_on = value$hospital_on;
  obj@n_hospitals = value$n_hospitals;
  obj@n_wards = value$n_wards;
  obj@n_ward_beds = value$n_ward_beds;
  obj@n_hcw_per_ward = value$n_hcw_per_ward;
  obj@n_patient_required_interactions = value$n_patient_required_interactions;
  obj@max_hcw_daily_interactions = value$max_hcw_daily_interactions;
  obj@hospitalised_waiting_mod = value$hospitalised_waiting_mod;
  obj@critical_waiting_mod = value$critical_waiting_mod;
  obj@hcw_mean_work_interactions = value$hcw_mean_work_interactions;
  obj@max_n_strains = value$max_n_strains;
  obj;
}



CopyToC_parameters = function(value, obj)
{
  obj$rng_seed = value@rng_seed;
  obj$input_param_file = value@input_param_file;
  obj$hospital_input_param_file = value@hospital_input_param_file;
  obj$input_household_file = value@input_household_file;
  obj$output_file_dir = value@output_file_dir;
  obj$param_line_number = value@param_line_number;
  obj$hospital_param_line_number = value@hospital_param_line_number;
  obj$param_id = value@param_id;
  obj$n_total = value@n_total;
  obj$days_of_interactions = value@days_of_interactions;
  obj$end_time = value@end_time;
  obj$n_seed_infection = value@n_seed_infection;
  obj$rebuild_networks = value@rebuild_networks;
  obj$mean_random_interactions = value@mean_random_interactions;
  obj$sd_random_interactions = value@sd_random_interactions;
  obj$random_interaction_distribution = value@random_interaction_distribution;
  obj$mean_work_interactions = value@mean_work_interactions;
  obj$daily_fraction_work = value@daily_fraction_work;
  obj$child_network_adults = value@child_network_adults;
  obj$elderly_network_adults = value@elderly_network_adults;
  obj$work_network_rewire = value@work_network_rewire;
  obj$mean_infectious_period = value@mean_infectious_period;
  obj$sd_infectious_period = value@sd_infectious_period;
  obj$infectious_rate = value@infectious_rate;
  obj$sd_infectiousness_multiplier = value@sd_infectiousness_multiplier;
  obj$relative_susceptibility = value@relative_susceptibility;
  obj$adjusted_susceptibility = value@adjusted_susceptibility;
  obj$relative_susceptibility_by_interaction = value@relative_susceptibility_by_interaction;
  obj$relative_transmission = value@relative_transmission;
  obj$relative_transmission_used = value@relative_transmission_used;
  obj$mean_time_to_symptoms = value@mean_time_to_symptoms;
  obj$sd_time_to_symptoms = value@sd_time_to_symptoms;
  obj$hospitalised_fraction = value@hospitalised_fraction;
  obj$critical_fraction = value@critical_fraction;
  obj$fatality_fraction = value@fatality_fraction;
  obj$mean_time_to_hospital = value@mean_time_to_hospital;
  obj$mean_time_to_critical = value@mean_time_to_critical;
  obj$sd_time_to_critical = value@sd_time_to_critical;
  obj$mean_time_to_recover = value@mean_time_to_recover;
  obj$sd_time_to_recover = value@sd_time_to_recover;
  obj$mean_time_to_death = value@mean_time_to_death;
  obj$sd_time_to_death = value@sd_time_to_death;
  obj$mean_time_to_susceptible_after_shift = value@mean_time_to_susceptible_after_shift;
  obj$time_to_susceptible_shift = value@time_to_susceptible_shift;
  obj$household_size = value@household_size;
  obj$population = value@population;
  obj$fraction_asymptomatic = value@fraction_asymptomatic;
  obj$asymptomatic_infectious_factor = value@asymptomatic_infectious_factor;
  obj$mild_fraction = value@mild_fraction;
  obj$mild_infectious_factor = value@mild_infectious_factor;
  obj$mean_asymptomatic_to_recovery = value@mean_asymptomatic_to_recovery;
  obj$sd_asymptomatic_to_recovery = value@sd_asymptomatic_to_recovery;
  obj$mean_time_hospitalised_recovery = value@mean_time_hospitalised_recovery;
  obj$sd_time_hospitalised_recovery = value@sd_time_hospitalised_recovery;
  obj$mean_time_critical_survive = value@mean_time_critical_survive;
  obj$sd_time_critical_survive = value@sd_time_critical_survive;
  obj$location_death_icu = value@location_death_icu;
  obj$quarantined_daily_interactions = value@quarantined_daily_interactions;
  obj$hospitalised_daily_interactions = value@hospitalised_daily_interactions;
  obj$quarantine_days = value@quarantine_days;
  obj$self_quarantine_fraction = value@self_quarantine_fraction;
  obj$manual_trace_on = value@manual_trace_on;
  obj$manual_trace_time_on = value@manual_trace_time_on;
  obj$manual_trace_on_hospitalization = value@manual_trace_on_hospitalization;
  obj$manual_trace_on_positive = value@manual_trace_on_positive;
  obj$manual_trace_delay = value@manual_trace_delay;
  obj$manual_trace_exclude_app_users = value@manual_trace_exclude_app_users;
  obj$manual_trace_n_workers = value@manual_trace_n_workers;
  obj$manual_trace_interviews_per_worker_day = value@manual_trace_interviews_per_worker_day;
  obj$manual_trace_notifications_per_worker_day = value@manual_trace_notifications_per_worker_day;
  obj$manual_traceable_fraction = value@manual_traceable_fraction;
  obj$trace_on_symptoms = value@trace_on_symptoms;
  obj$trace_on_positive = value@trace_on_positive;
  obj$retrace_on_positive = value@retrace_on_positive;
  obj$quarantine_length_self = value@quarantine_length_self;
  obj$quarantine_length_traced_symptoms = value@quarantine_length_traced_symptoms;
  obj$quarantine_length_traced_positive = value@quarantine_length_traced_positive;
  obj$quarantine_length_positive = value@quarantine_length_positive;
  obj$quarantine_dropout_self = value@quarantine_dropout_self;
  obj$quarantine_dropout_traced_symptoms = value@quarantine_dropout_traced_symptoms;
  obj$quarantine_dropout_traced_positive = value@quarantine_dropout_traced_positive;
  obj$quarantine_dropout_positive = value@quarantine_dropout_positive;
  obj$quarantine_compliance_traced_symptoms = value@quarantine_compliance_traced_symptoms;
  obj$quarantine_compliance_traced_positive = value@quarantine_compliance_traced_positive;
  obj$quarantine_on_traced = value@quarantine_on_traced;
  obj$quarantine_smart_release_day = value@quarantine_smart_release_day;
  obj$traceable_interaction_fraction = value@traceable_interaction_fraction;
  obj$tracing_network_depth = value@tracing_network_depth;
  obj$allow_clinical_diagnosis = value@allow_clinical_diagnosis;
  obj$quarantine_household_on_symptoms = value@quarantine_household_on_symptoms;
  obj$quarantine_household_on_positive = value@quarantine_household_on_positive;
  obj$quarantine_household_on_traced_symptoms = value@quarantine_household_on_traced_symptoms;
  obj$quarantine_household_on_traced_positive = value@quarantine_household_on_traced_positive;
  obj$quarantine_household_contacts_on_positive = value@quarantine_household_contacts_on_positive;
  obj$quarantine_household_contacts_on_symptoms = value@quarantine_household_contacts_on_symptoms;
  obj$test_on_symptoms = value@test_on_symptoms;
  obj$test_on_traced = value@test_on_traced;
  obj$test_result_wait = value@test_result_wait;
  obj$test_order_wait = value@test_order_wait;
  obj$test_result_wait_priority = value@test_result_wait_priority;
  obj$test_order_wait_priority = value@test_order_wait_priority;
  obj$test_release_on_negative = value@test_release_on_negative;
  obj$priority_test_contacts = value@priority_test_contacts;
  obj$test_insensitive_period = value@test_insensitive_period;
  obj$test_sensitive_period = value@test_sensitive_period;
  obj$test_sensitivity = value@test_sensitivity;
  obj$test_specificity = value@test_specificity;
  obj$app_users_fraction = value@app_users_fraction;
  obj$app_turned_on = value@app_turned_on;
  obj$app_turn_on_time = value@app_turn_on_time;
  obj$daily_non_cov_symptoms_rate = value@daily_non_cov_symptoms_rate;
  obj$lockdown_occupation_multiplier = value@lockdown_occupation_multiplier;
  obj$lockdown_random_network_multiplier = value@lockdown_random_network_multiplier;
  obj$lockdown_house_interaction_multiplier = value@lockdown_house_interaction_multiplier;
  obj$lockdown_time_on = value@lockdown_time_on;
  obj$lockdown_time_off = value@lockdown_time_off;
  obj$lockdown_on = value@lockdown_on;
  obj$lockdown_elderly_time_on = value@lockdown_elderly_time_on;
  obj$lockdown_elderly_time_off = value@lockdown_elderly_time_off;
  obj$lockdown_elderly_on = value@lockdown_elderly_on;
  obj$testing_symptoms_time_on = value@testing_symptoms_time_on;
  obj$testing_symptoms_time_off = value@testing_symptoms_time_off;
  obj$interventions_on = value@interventions_on;
  obj$intervention_start_time = value@intervention_start_time;
  obj$sys_write_individual = value@sys_write_individual;
  obj$sys_write_hospital = value@sys_write_hospital;
  obj$N_REFERENCE_HOUSEHOLDS = value@N_REFERENCE_HOUSEHOLDS;
  obj$hospital_on = value@hospital_on;
  obj$n_hospitals = value@n_hospitals;
  obj$n_wards = value@n_wards;
  obj$n_ward_beds = value@n_ward_beds;
  obj$n_hcw_per_ward = value@n_hcw_per_ward;
  obj$n_patient_required_interactions = value@n_patient_required_interactions;
  obj$max_hcw_daily_interactions = value@max_hcw_daily_interactions;
  obj$hospitalised_waiting_mod = value@hospitalised_waiting_mod;
  obj$critical_waiting_mod = value@critical_waiting_mod;
  obj$hcw_mean_work_interactions = value@hcw_mean_work_interactions;
  obj$max_n_strains = value@max_n_strains;
  obj
}



# Start definition of copy methods for parameters
setMethod('copyToR', '_p_parameters', CopyToR_parameters);
setMethod('copyToC', 'parameters', CopyToC_parameters);

# End definition of copy methods for parameters
# End definition of copy functions & methods for parameters
# Start of get_model_param_hospital_on

`get_model_param_hospital_on` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_hospital_on', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_hospital_on`, 'returnType') = 'integer'
attr(`get_model_param_hospital_on`, "inputTypes") = c('_p_model')
class(`get_model_param_hospital_on`) = c("SWIGFunction", class('get_model_param_hospital_on'))

# Start of get_model_param_daily_fraction_work_used

`get_model_param_daily_fraction_work_used` = function(pmodel, idx, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_model_param_daily_fraction_work_used', pmodel, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_daily_fraction_work_used`, 'returnType') = 'numeric'
attr(`get_model_param_daily_fraction_work_used`, "inputTypes") = c('_p_model', 'integer')
class(`get_model_param_daily_fraction_work_used`) = c("SWIGFunction", class('get_model_param_daily_fraction_work_used'))

# Start of get_model_param_quarantine_days

`get_model_param_quarantine_days` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_quarantine_days', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_quarantine_days`, 'returnType') = 'integer'
attr(`get_model_param_quarantine_days`, "inputTypes") = c('_p_model')
class(`get_model_param_quarantine_days`) = c("SWIGFunction", class('get_model_param_quarantine_days'))

# Start of get_model_param_self_quarantine_fraction

`get_model_param_self_quarantine_fraction` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_self_quarantine_fraction', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_self_quarantine_fraction`, 'returnType') = 'numeric'
attr(`get_model_param_self_quarantine_fraction`, "inputTypes") = c('_p_model')
class(`get_model_param_self_quarantine_fraction`) = c("SWIGFunction", class('get_model_param_self_quarantine_fraction'))

# Start of get_model_param_trace_on_symptoms

`get_model_param_trace_on_symptoms` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_trace_on_symptoms', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_trace_on_symptoms`, 'returnType') = 'integer'
attr(`get_model_param_trace_on_symptoms`, "inputTypes") = c('_p_model')
class(`get_model_param_trace_on_symptoms`) = c("SWIGFunction", class('get_model_param_trace_on_symptoms'))

# Start of get_model_param_trace_on_positive

`get_model_param_trace_on_positive` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_trace_on_positive', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_trace_on_positive`, 'returnType') = 'integer'
attr(`get_model_param_trace_on_positive`, "inputTypes") = c('_p_model')
class(`get_model_param_trace_on_positive`) = c("SWIGFunction", class('get_model_param_trace_on_positive'))

# Start of get_model_param_quarantine_on_traced

`get_model_param_quarantine_on_traced` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_quarantine_on_traced', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_quarantine_on_traced`, 'returnType') = 'integer'
attr(`get_model_param_quarantine_on_traced`, "inputTypes") = c('_p_model')
class(`get_model_param_quarantine_on_traced`) = c("SWIGFunction", class('get_model_param_quarantine_on_traced'))

# Start of get_model_param_traceable_interaction_fraction

`get_model_param_traceable_interaction_fraction` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_traceable_interaction_fraction', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_traceable_interaction_fraction`, 'returnType') = 'numeric'
attr(`get_model_param_traceable_interaction_fraction`, "inputTypes") = c('_p_model')
class(`get_model_param_traceable_interaction_fraction`) = c("SWIGFunction", class('get_model_param_traceable_interaction_fraction'))

# Start of get_model_param_tracing_network_depth

`get_model_param_tracing_network_depth` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_tracing_network_depth', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_tracing_network_depth`, 'returnType') = 'integer'
attr(`get_model_param_tracing_network_depth`, "inputTypes") = c('_p_model')
class(`get_model_param_tracing_network_depth`) = c("SWIGFunction", class('get_model_param_tracing_network_depth'))

# Start of get_model_param_allow_clinical_diagnosis

`get_model_param_allow_clinical_diagnosis` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_allow_clinical_diagnosis', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_allow_clinical_diagnosis`, 'returnType') = 'integer'
attr(`get_model_param_allow_clinical_diagnosis`, "inputTypes") = c('_p_model')
class(`get_model_param_allow_clinical_diagnosis`) = c("SWIGFunction", class('get_model_param_allow_clinical_diagnosis'))

# Start of get_model_param_quarantine_household_on_symptoms

`get_model_param_quarantine_household_on_symptoms` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_quarantine_household_on_symptoms', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_quarantine_household_on_symptoms`, 'returnType') = 'integer'
attr(`get_model_param_quarantine_household_on_symptoms`, "inputTypes") = c('_p_model')
class(`get_model_param_quarantine_household_on_symptoms`) = c("SWIGFunction", class('get_model_param_quarantine_household_on_symptoms'))

# Start of get_model_param_quarantine_household_on_positive

`get_model_param_quarantine_household_on_positive` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_quarantine_household_on_positive', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_quarantine_household_on_positive`, 'returnType') = 'integer'
attr(`get_model_param_quarantine_household_on_positive`, "inputTypes") = c('_p_model')
class(`get_model_param_quarantine_household_on_positive`) = c("SWIGFunction", class('get_model_param_quarantine_household_on_positive'))

# Start of get_model_param_quarantine_household_on_traced_symptoms

`get_model_param_quarantine_household_on_traced_symptoms` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_quarantine_household_on_traced_symptoms', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_quarantine_household_on_traced_symptoms`, 'returnType') = 'integer'
attr(`get_model_param_quarantine_household_on_traced_symptoms`, "inputTypes") = c('_p_model')
class(`get_model_param_quarantine_household_on_traced_symptoms`) = c("SWIGFunction", class('get_model_param_quarantine_household_on_traced_symptoms'))

# Start of get_model_param_quarantine_household_on_traced_positive

`get_model_param_quarantine_household_on_traced_positive` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_quarantine_household_on_traced_positive', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_quarantine_household_on_traced_positive`, 'returnType') = 'integer'
attr(`get_model_param_quarantine_household_on_traced_positive`, "inputTypes") = c('_p_model')
class(`get_model_param_quarantine_household_on_traced_positive`) = c("SWIGFunction", class('get_model_param_quarantine_household_on_traced_positive'))

# Start of get_model_param_quarantine_household_contacts_on_positive

`get_model_param_quarantine_household_contacts_on_positive` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_quarantine_household_contacts_on_positive', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_quarantine_household_contacts_on_positive`, 'returnType') = 'integer'
attr(`get_model_param_quarantine_household_contacts_on_positive`, "inputTypes") = c('_p_model')
class(`get_model_param_quarantine_household_contacts_on_positive`) = c("SWIGFunction", class('get_model_param_quarantine_household_contacts_on_positive'))

# Start of set_model_param_relative_transmission

`set_model_param_relative_transmission` = function(pmodel, value, type, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  
  type = as.integer(type);
  
  if(length(type) > 1) {
    warning("using only the first element of type");
  };
  
  ;.Call('R_swig_set_model_param_relative_transmission', pmodel, value, type, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_relative_transmission`, 'returnType') = 'integer'
attr(`set_model_param_relative_transmission`, "inputTypes") = c('_p_model', 'numeric', 'integer')
class(`set_model_param_relative_transmission`) = c("SWIGFunction", class('set_model_param_relative_transmission'))

# Start of get_model_param_quarantine_household_contacts_on_symptoms

`get_model_param_quarantine_household_contacts_on_symptoms` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_quarantine_household_contacts_on_symptoms', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_quarantine_household_contacts_on_symptoms`, 'returnType') = 'integer'
attr(`get_model_param_quarantine_household_contacts_on_symptoms`, "inputTypes") = c('_p_model')
class(`get_model_param_quarantine_household_contacts_on_symptoms`) = c("SWIGFunction", class('get_model_param_quarantine_household_contacts_on_symptoms'))

# Start of get_model_param_test_on_symptoms

`get_model_param_test_on_symptoms` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_test_on_symptoms', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_test_on_symptoms`, 'returnType') = 'integer'
attr(`get_model_param_test_on_symptoms`, "inputTypes") = c('_p_model')
class(`get_model_param_test_on_symptoms`) = c("SWIGFunction", class('get_model_param_test_on_symptoms'))

# Start of get_model_param_test_release_on_negative

`get_model_param_test_release_on_negative` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_test_release_on_negative', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_test_release_on_negative`, 'returnType') = 'integer'
attr(`get_model_param_test_release_on_negative`, "inputTypes") = c('_p_model')
class(`get_model_param_test_release_on_negative`) = c("SWIGFunction", class('get_model_param_test_release_on_negative'))

# Start of get_model_param_test_on_traced

`get_model_param_test_on_traced` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_test_on_traced', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_test_on_traced`, 'returnType') = 'integer'
attr(`get_model_param_test_on_traced`, "inputTypes") = c('_p_model')
class(`get_model_param_test_on_traced`) = c("SWIGFunction", class('get_model_param_test_on_traced'))

# Start of get_model_param_test_result_wait

`get_model_param_test_result_wait` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_test_result_wait', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_test_result_wait`, 'returnType') = 'integer'
attr(`get_model_param_test_result_wait`, "inputTypes") = c('_p_model')
class(`get_model_param_test_result_wait`) = c("SWIGFunction", class('get_model_param_test_result_wait'))

# Start of get_model_param_test_order_wait

`get_model_param_test_order_wait` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_test_order_wait', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_test_order_wait`, 'returnType') = 'integer'
attr(`get_model_param_test_order_wait`, "inputTypes") = c('_p_model')
class(`get_model_param_test_order_wait`) = c("SWIGFunction", class('get_model_param_test_order_wait'))

# Start of get_model_param_test_result_wait_priority

`get_model_param_test_result_wait_priority` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_test_result_wait_priority', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_test_result_wait_priority`, 'returnType') = 'integer'
attr(`get_model_param_test_result_wait_priority`, "inputTypes") = c('_p_model')
class(`get_model_param_test_result_wait_priority`) = c("SWIGFunction", class('get_model_param_test_result_wait_priority'))

# Start of get_model_param_test_order_wait_priority

`get_model_param_test_order_wait_priority` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_test_order_wait_priority', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_test_order_wait_priority`, 'returnType') = 'integer'
attr(`get_model_param_test_order_wait_priority`, "inputTypes") = c('_p_model')
class(`get_model_param_test_order_wait_priority`) = c("SWIGFunction", class('get_model_param_test_order_wait_priority'))

# Start of get_model_param_priority_test_contacts

`get_model_param_priority_test_contacts` = function(pmodel, idx, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_model_param_priority_test_contacts', pmodel, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_priority_test_contacts`, 'returnType') = 'integer'
attr(`get_model_param_priority_test_contacts`, "inputTypes") = c('_p_model', 'integer')
class(`get_model_param_priority_test_contacts`) = c("SWIGFunction", class('get_model_param_priority_test_contacts'))

# Start of get_model_param_app_users_fraction

`get_model_param_app_users_fraction` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_app_users_fraction', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_app_users_fraction`, 'returnType') = 'numeric'
attr(`get_model_param_app_users_fraction`, "inputTypes") = c('_p_model')
class(`get_model_param_app_users_fraction`) = c("SWIGFunction", class('get_model_param_app_users_fraction'))

# Start of get_model_param_app_turned_on

`get_model_param_app_turned_on` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_app_turned_on', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_app_turned_on`, 'returnType') = 'integer'
attr(`get_model_param_app_turned_on`, "inputTypes") = c('_p_model')
class(`get_model_param_app_turned_on`) = c("SWIGFunction", class('get_model_param_app_turned_on'))

# Start of get_model_param_lockdown_on

`get_model_param_lockdown_on` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_lockdown_on', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_lockdown_on`, 'returnType') = 'integer'
attr(`get_model_param_lockdown_on`, "inputTypes") = c('_p_model')
class(`get_model_param_lockdown_on`) = c("SWIGFunction", class('get_model_param_lockdown_on'))

# Start of get_model_param_risk_score

`get_model_param_risk_score` = function(s_arg1, s_arg2, s_arg3, s_arg4, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  s_arg4 = as.integer(s_arg4);
  
  if(length(s_arg4) > 1) {
    warning("using only the first element of s_arg4");
  };
  
  ;.Call('R_swig_get_model_param_risk_score', s_arg1, s_arg2, s_arg3, s_arg4, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_risk_score`, 'returnType') = 'numeric'
attr(`get_model_param_risk_score`, "inputTypes") = c('_p_model', 'integer', 'integer', 'integer')
class(`get_model_param_risk_score`) = c("SWIGFunction", class('get_model_param_risk_score'))

# Start of get_model_param_risk_score_household

`get_model_param_risk_score_household` = function(s_arg1, s_arg2, s_arg3, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;.Call('R_swig_get_model_param_risk_score_household', s_arg1, s_arg2, s_arg3, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_risk_score_household`, 'returnType') = 'numeric'
attr(`get_model_param_risk_score_household`, "inputTypes") = c('_p_model', 'integer', 'integer')
class(`get_model_param_risk_score_household`) = c("SWIGFunction", class('get_model_param_risk_score_household'))

# Start of get_model_param_lockdown_house_interaction_multiplier

`get_model_param_lockdown_house_interaction_multiplier` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_lockdown_house_interaction_multiplier', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_lockdown_house_interaction_multiplier`, 'returnType') = 'numeric'
attr(`get_model_param_lockdown_house_interaction_multiplier`, "inputTypes") = c('_p_model')
class(`get_model_param_lockdown_house_interaction_multiplier`) = c("SWIGFunction", class('get_model_param_lockdown_house_interaction_multiplier'))

# Start of get_model_param_lockdown_random_network_multiplier

`get_model_param_lockdown_random_network_multiplier` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_lockdown_random_network_multiplier', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_lockdown_random_network_multiplier`, 'returnType') = 'numeric'
attr(`get_model_param_lockdown_random_network_multiplier`, "inputTypes") = c('_p_model')
class(`get_model_param_lockdown_random_network_multiplier`) = c("SWIGFunction", class('get_model_param_lockdown_random_network_multiplier'))

# Start of get_model_param_lockdown_occupation_multiplier

`get_model_param_lockdown_occupation_multiplier` = function(pmodel, idx, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_model_param_lockdown_occupation_multiplier', pmodel, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_lockdown_occupation_multiplier`, 'returnType') = 'numeric'
attr(`get_model_param_lockdown_occupation_multiplier`, "inputTypes") = c('_p_model', 'integer')
class(`get_model_param_lockdown_occupation_multiplier`) = c("SWIGFunction", class('get_model_param_lockdown_occupation_multiplier'))

# Start of get_model_param_manual_trace_on_hospitalization

`get_model_param_manual_trace_on_hospitalization` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_manual_trace_on_hospitalization', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_manual_trace_on_hospitalization`, 'returnType') = 'integer'
attr(`get_model_param_manual_trace_on_hospitalization`, "inputTypes") = c('_p_model')
class(`get_model_param_manual_trace_on_hospitalization`) = c("SWIGFunction", class('get_model_param_manual_trace_on_hospitalization'))

# Start of get_model_param_manual_trace_on_positive

`get_model_param_manual_trace_on_positive` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_manual_trace_on_positive', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_manual_trace_on_positive`, 'returnType') = 'integer'
attr(`get_model_param_manual_trace_on_positive`, "inputTypes") = c('_p_model')
class(`get_model_param_manual_trace_on_positive`) = c("SWIGFunction", class('get_model_param_manual_trace_on_positive'))

# Start of get_model_param_manual_trace_on

`get_model_param_manual_trace_on` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_manual_trace_on', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_manual_trace_on`, 'returnType') = 'integer'
attr(`get_model_param_manual_trace_on`, "inputTypes") = c('_p_model')
class(`get_model_param_manual_trace_on`) = c("SWIGFunction", class('get_model_param_manual_trace_on'))

# Start of get_model_param_manual_trace_delay

`get_model_param_manual_trace_delay` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_manual_trace_delay', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_manual_trace_delay`, 'returnType') = 'integer'
attr(`get_model_param_manual_trace_delay`, "inputTypes") = c('_p_model')
class(`get_model_param_manual_trace_delay`) = c("SWIGFunction", class('get_model_param_manual_trace_delay'))

# Start of get_model_param_manual_trace_exclude_app_users

`get_model_param_manual_trace_exclude_app_users` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_manual_trace_exclude_app_users', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_manual_trace_exclude_app_users`, 'returnType') = 'integer'
attr(`get_model_param_manual_trace_exclude_app_users`, "inputTypes") = c('_p_model')
class(`get_model_param_manual_trace_exclude_app_users`) = c("SWIGFunction", class('get_model_param_manual_trace_exclude_app_users'))

# Start of get_model_param_manual_trace_n_workers

`get_model_param_manual_trace_n_workers` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_manual_trace_n_workers', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_manual_trace_n_workers`, 'returnType') = 'integer'
attr(`get_model_param_manual_trace_n_workers`, "inputTypes") = c('_p_model')
class(`get_model_param_manual_trace_n_workers`) = c("SWIGFunction", class('get_model_param_manual_trace_n_workers'))

# Start of get_model_param_manual_trace_interviews_per_worker_day

`get_model_param_manual_trace_interviews_per_worker_day` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_manual_trace_interviews_per_worker_day', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_manual_trace_interviews_per_worker_day`, 'returnType') = 'integer'
attr(`get_model_param_manual_trace_interviews_per_worker_day`, "inputTypes") = c('_p_model')
class(`get_model_param_manual_trace_interviews_per_worker_day`) = c("SWIGFunction", class('get_model_param_manual_trace_interviews_per_worker_day'))

# Start of get_model_param_manual_trace_notifications_per_worker_day

`get_model_param_manual_trace_notifications_per_worker_day` = function(pmodel, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_get_model_param_manual_trace_notifications_per_worker_day', pmodel, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_manual_trace_notifications_per_worker_day`, 'returnType') = 'integer'
attr(`get_model_param_manual_trace_notifications_per_worker_day`, "inputTypes") = c('_p_model')
class(`get_model_param_manual_trace_notifications_per_worker_day`) = c("SWIGFunction", class('get_model_param_manual_trace_notifications_per_worker_day'))

# Start of get_model_param_manual_traceable_fraction

`get_model_param_manual_traceable_fraction` = function(pmodel, s_arg2, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  ;.Call('R_swig_get_model_param_manual_traceable_fraction', pmodel, s_arg2, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_manual_traceable_fraction`, 'returnType') = 'numeric'
attr(`get_model_param_manual_traceable_fraction`, "inputTypes") = c('_p_model', 'integer')
class(`get_model_param_manual_traceable_fraction`) = c("SWIGFunction", class('get_model_param_manual_traceable_fraction'))

# Start of get_model_param_fatality_fraction

`get_model_param_fatality_fraction` = function(pmodel, age_group, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  age_group = as.integer(age_group);
  
  if(length(age_group) > 1) {
    warning("using only the first element of age_group");
  };
  
  ;.Call('R_swig_get_model_param_fatality_fraction', pmodel, age_group, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_model_param_fatality_fraction`, 'returnType') = 'numeric'
attr(`get_model_param_fatality_fraction`, "inputTypes") = c('_p_model', 'integer')
class(`get_model_param_fatality_fraction`) = c("SWIGFunction", class('get_model_param_fatality_fraction'))

# Start of set_model_param_quarantine_days

`set_model_param_quarantine_days` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_quarantine_days', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_quarantine_days`, 'returnType') = 'integer'
attr(`set_model_param_quarantine_days`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_quarantine_days`) = c("SWIGFunction", class('set_model_param_quarantine_days'))

# Start of set_model_param_self_quarantine_fraction

`set_model_param_self_quarantine_fraction` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  
  ;.Call('R_swig_set_model_param_self_quarantine_fraction', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_self_quarantine_fraction`, 'returnType') = 'integer'
attr(`set_model_param_self_quarantine_fraction`, "inputTypes") = c('_p_model', 'numeric')
class(`set_model_param_self_quarantine_fraction`) = c("SWIGFunction", class('set_model_param_self_quarantine_fraction'))

# Start of set_model_param_trace_on_symptoms

`set_model_param_trace_on_symptoms` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_trace_on_symptoms', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_trace_on_symptoms`, 'returnType') = 'integer'
attr(`set_model_param_trace_on_symptoms`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_trace_on_symptoms`) = c("SWIGFunction", class('set_model_param_trace_on_symptoms'))

# Start of set_model_param_trace_on_positive

`set_model_param_trace_on_positive` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_trace_on_positive', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_trace_on_positive`, 'returnType') = 'integer'
attr(`set_model_param_trace_on_positive`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_trace_on_positive`) = c("SWIGFunction", class('set_model_param_trace_on_positive'))

# Start of set_model_param_quarantine_on_traced

`set_model_param_quarantine_on_traced` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_quarantine_on_traced', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_quarantine_on_traced`, 'returnType') = 'integer'
attr(`set_model_param_quarantine_on_traced`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_quarantine_on_traced`) = c("SWIGFunction", class('set_model_param_quarantine_on_traced'))

# Start of set_model_param_traceable_interaction_fraction

`set_model_param_traceable_interaction_fraction` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  
  ;.Call('R_swig_set_model_param_traceable_interaction_fraction', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_traceable_interaction_fraction`, 'returnType') = 'integer'
attr(`set_model_param_traceable_interaction_fraction`, "inputTypes") = c('_p_model', 'numeric')
class(`set_model_param_traceable_interaction_fraction`) = c("SWIGFunction", class('set_model_param_traceable_interaction_fraction'))

# Start of set_model_param_tracing_network_depth

`set_model_param_tracing_network_depth` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_tracing_network_depth', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_tracing_network_depth`, 'returnType') = 'integer'
attr(`set_model_param_tracing_network_depth`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_tracing_network_depth`) = c("SWIGFunction", class('set_model_param_tracing_network_depth'))

# Start of set_model_param_allow_clinical_diagnosis

`set_model_param_allow_clinical_diagnosis` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_allow_clinical_diagnosis', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_allow_clinical_diagnosis`, 'returnType') = 'integer'
attr(`set_model_param_allow_clinical_diagnosis`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_allow_clinical_diagnosis`) = c("SWIGFunction", class('set_model_param_allow_clinical_diagnosis'))

# Start of set_model_param_quarantine_household_on_symptoms

`set_model_param_quarantine_household_on_symptoms` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_quarantine_household_on_symptoms', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_quarantine_household_on_symptoms`, 'returnType') = 'integer'
attr(`set_model_param_quarantine_household_on_symptoms`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_quarantine_household_on_symptoms`) = c("SWIGFunction", class('set_model_param_quarantine_household_on_symptoms'))

# Start of set_model_param_quarantine_household_on_positive

`set_model_param_quarantine_household_on_positive` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_quarantine_household_on_positive', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_quarantine_household_on_positive`, 'returnType') = 'integer'
attr(`set_model_param_quarantine_household_on_positive`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_quarantine_household_on_positive`) = c("SWIGFunction", class('set_model_param_quarantine_household_on_positive'))

# Start of set_model_param_quarantine_household_on_traced_symptoms

`set_model_param_quarantine_household_on_traced_symptoms` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_quarantine_household_on_traced_symptoms', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_quarantine_household_on_traced_symptoms`, 'returnType') = 'integer'
attr(`set_model_param_quarantine_household_on_traced_symptoms`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_quarantine_household_on_traced_symptoms`) = c("SWIGFunction", class('set_model_param_quarantine_household_on_traced_symptoms'))

# Start of set_model_param_quarantine_household_on_traced_positive

`set_model_param_quarantine_household_on_traced_positive` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_quarantine_household_on_traced_positive', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_quarantine_household_on_traced_positive`, 'returnType') = 'integer'
attr(`set_model_param_quarantine_household_on_traced_positive`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_quarantine_household_on_traced_positive`) = c("SWIGFunction", class('set_model_param_quarantine_household_on_traced_positive'))

# Start of set_model_param_quarantine_household_contacts_on_positive

`set_model_param_quarantine_household_contacts_on_positive` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_quarantine_household_contacts_on_positive', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_quarantine_household_contacts_on_positive`, 'returnType') = 'integer'
attr(`set_model_param_quarantine_household_contacts_on_positive`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_quarantine_household_contacts_on_positive`) = c("SWIGFunction", class('set_model_param_quarantine_household_contacts_on_positive'))

# Start of set_model_param_quarantine_household_contacts_on_symptoms

`set_model_param_quarantine_household_contacts_on_symptoms` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_quarantine_household_contacts_on_symptoms', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_quarantine_household_contacts_on_symptoms`, 'returnType') = 'integer'
attr(`set_model_param_quarantine_household_contacts_on_symptoms`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_quarantine_household_contacts_on_symptoms`) = c("SWIGFunction", class('set_model_param_quarantine_household_contacts_on_symptoms'))

# Start of set_model_param_test_on_symptoms

`set_model_param_test_on_symptoms` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_test_on_symptoms', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_test_on_symptoms`, 'returnType') = 'integer'
attr(`set_model_param_test_on_symptoms`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_test_on_symptoms`) = c("SWIGFunction", class('set_model_param_test_on_symptoms'))

# Start of set_model_param_test_release_on_negative

`set_model_param_test_release_on_negative` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_test_release_on_negative', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_test_release_on_negative`, 'returnType') = 'integer'
attr(`set_model_param_test_release_on_negative`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_test_release_on_negative`) = c("SWIGFunction", class('set_model_param_test_release_on_negative'))

# Start of set_model_param_test_on_traced

`set_model_param_test_on_traced` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_test_on_traced', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_test_on_traced`, 'returnType') = 'integer'
attr(`set_model_param_test_on_traced`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_test_on_traced`) = c("SWIGFunction", class('set_model_param_test_on_traced'))

# Start of set_model_param_test_result_wait

`set_model_param_test_result_wait` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_test_result_wait', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_test_result_wait`, 'returnType') = 'integer'
attr(`set_model_param_test_result_wait`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_test_result_wait`) = c("SWIGFunction", class('set_model_param_test_result_wait'))

# Start of set_model_param_test_order_wait

`set_model_param_test_order_wait` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_test_order_wait', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_test_order_wait`, 'returnType') = 'integer'
attr(`set_model_param_test_order_wait`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_test_order_wait`) = c("SWIGFunction", class('set_model_param_test_order_wait'))

# Start of set_model_param_test_result_wait_priority

`set_model_param_test_result_wait_priority` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_test_result_wait_priority', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_test_result_wait_priority`, 'returnType') = 'integer'
attr(`set_model_param_test_result_wait_priority`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_test_result_wait_priority`) = c("SWIGFunction", class('set_model_param_test_result_wait_priority'))

# Start of set_model_param_test_order_wait_priority

`set_model_param_test_order_wait_priority` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_test_order_wait_priority', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_test_order_wait_priority`, 'returnType') = 'integer'
attr(`set_model_param_test_order_wait_priority`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_test_order_wait_priority`) = c("SWIGFunction", class('set_model_param_test_order_wait_priority'))

# Start of set_model_param_priority_test_contacts

`set_model_param_priority_test_contacts` = function(pmodel, value, idx, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_set_model_param_priority_test_contacts', pmodel, value, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_priority_test_contacts`, 'returnType') = 'integer'
attr(`set_model_param_priority_test_contacts`, "inputTypes") = c('_p_model', 'integer', 'integer')
class(`set_model_param_priority_test_contacts`) = c("SWIGFunction", class('set_model_param_priority_test_contacts'))

# Start of set_model_param_app_users_fraction

`set_model_param_app_users_fraction` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  
  ;.Call('R_swig_set_model_param_app_users_fraction', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_app_users_fraction`, 'returnType') = 'integer'
attr(`set_model_param_app_users_fraction`, "inputTypes") = c('_p_model', 'numeric')
class(`set_model_param_app_users_fraction`) = c("SWIGFunction", class('set_model_param_app_users_fraction'))

# Start of set_model_param_app_turned_on

`set_model_param_app_turned_on` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_app_turned_on', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_app_turned_on`, 'returnType') = 'integer'
attr(`set_model_param_app_turned_on`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_app_turned_on`) = c("SWIGFunction", class('set_model_param_app_turned_on'))

# Start of set_model_param_lockdown_on

`set_model_param_lockdown_on` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_lockdown_on', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_lockdown_on`, 'returnType') = 'integer'
attr(`set_model_param_lockdown_on`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_lockdown_on`) = c("SWIGFunction", class('set_model_param_lockdown_on'))

# Start of set_model_param_lockdown_house_interaction_multiplier

`set_model_param_lockdown_house_interaction_multiplier` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  
  ;.Call('R_swig_set_model_param_lockdown_house_interaction_multiplier', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_lockdown_house_interaction_multiplier`, 'returnType') = 'integer'
attr(`set_model_param_lockdown_house_interaction_multiplier`, "inputTypes") = c('_p_model', 'numeric')
class(`set_model_param_lockdown_house_interaction_multiplier`) = c("SWIGFunction", class('set_model_param_lockdown_house_interaction_multiplier'))

# Start of set_model_param_lockdown_random_network_multiplier

`set_model_param_lockdown_random_network_multiplier` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  
  ;.Call('R_swig_set_model_param_lockdown_random_network_multiplier', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_lockdown_random_network_multiplier`, 'returnType') = 'integer'
attr(`set_model_param_lockdown_random_network_multiplier`, "inputTypes") = c('_p_model', 'numeric')
class(`set_model_param_lockdown_random_network_multiplier`) = c("SWIGFunction", class('set_model_param_lockdown_random_network_multiplier'))

# Start of set_model_param_lockdown_occupation_multiplier

`set_model_param_lockdown_occupation_multiplier` = function(pmodel, value, idx, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_set_model_param_lockdown_occupation_multiplier', pmodel, value, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_lockdown_occupation_multiplier`, 'returnType') = 'integer'
attr(`set_model_param_lockdown_occupation_multiplier`, "inputTypes") = c('_p_model', 'numeric', 'integer')
class(`set_model_param_lockdown_occupation_multiplier`) = c("SWIGFunction", class('set_model_param_lockdown_occupation_multiplier'))

# Start of set_model_param_lockdown_elderly_on

`set_model_param_lockdown_elderly_on` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_lockdown_elderly_on', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_lockdown_elderly_on`, 'returnType') = 'integer'
attr(`set_model_param_lockdown_elderly_on`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_lockdown_elderly_on`) = c("SWIGFunction", class('set_model_param_lockdown_elderly_on'))

# Start of set_model_param_manual_trace_on_hospitalization

`set_model_param_manual_trace_on_hospitalization` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_manual_trace_on_hospitalization', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_manual_trace_on_hospitalization`, 'returnType') = 'integer'
attr(`set_model_param_manual_trace_on_hospitalization`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_manual_trace_on_hospitalization`) = c("SWIGFunction", class('set_model_param_manual_trace_on_hospitalization'))

# Start of set_model_param_manual_trace_on_positive

`set_model_param_manual_trace_on_positive` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_manual_trace_on_positive', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_manual_trace_on_positive`, 'returnType') = 'integer'
attr(`set_model_param_manual_trace_on_positive`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_manual_trace_on_positive`) = c("SWIGFunction", class('set_model_param_manual_trace_on_positive'))

# Start of set_model_param_manual_trace_on

`set_model_param_manual_trace_on` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_manual_trace_on', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_manual_trace_on`, 'returnType') = 'integer'
attr(`set_model_param_manual_trace_on`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_manual_trace_on`) = c("SWIGFunction", class('set_model_param_manual_trace_on'))

# Start of set_model_param_manual_trace_delay

`set_model_param_manual_trace_delay` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_manual_trace_delay', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_manual_trace_delay`, 'returnType') = 'integer'
attr(`set_model_param_manual_trace_delay`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_manual_trace_delay`) = c("SWIGFunction", class('set_model_param_manual_trace_delay'))

# Start of set_model_param_manual_trace_exclude_app_users

`set_model_param_manual_trace_exclude_app_users` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_manual_trace_exclude_app_users', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_manual_trace_exclude_app_users`, 'returnType') = 'integer'
attr(`set_model_param_manual_trace_exclude_app_users`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_manual_trace_exclude_app_users`) = c("SWIGFunction", class('set_model_param_manual_trace_exclude_app_users'))

# Start of set_model_param_manual_trace_n_workers

`set_model_param_manual_trace_n_workers` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_manual_trace_n_workers', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_manual_trace_n_workers`, 'returnType') = 'integer'
attr(`set_model_param_manual_trace_n_workers`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_manual_trace_n_workers`) = c("SWIGFunction", class('set_model_param_manual_trace_n_workers'))

# Start of set_model_param_manual_trace_interviews_per_worker_day

`set_model_param_manual_trace_interviews_per_worker_day` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_manual_trace_interviews_per_worker_day', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_manual_trace_interviews_per_worker_day`, 'returnType') = 'integer'
attr(`set_model_param_manual_trace_interviews_per_worker_day`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_manual_trace_interviews_per_worker_day`) = c("SWIGFunction", class('set_model_param_manual_trace_interviews_per_worker_day'))

# Start of set_model_param_manual_trace_notifications_per_worker_day

`set_model_param_manual_trace_notifications_per_worker_day` = function(pmodel, value, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_model_param_manual_trace_notifications_per_worker_day', pmodel, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_manual_trace_notifications_per_worker_day`, 'returnType') = 'integer'
attr(`set_model_param_manual_trace_notifications_per_worker_day`, "inputTypes") = c('_p_model', 'integer')
class(`set_model_param_manual_trace_notifications_per_worker_day`) = c("SWIGFunction", class('set_model_param_manual_trace_notifications_per_worker_day'))

# Start of set_model_param_manual_traceable_fraction

`set_model_param_manual_traceable_fraction` = function(pmodel, value, type, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  
  type = as.integer(type);
  
  if(length(type) > 1) {
    warning("using only the first element of type");
  };
  
  ;.Call('R_swig_set_model_param_manual_traceable_fraction', pmodel, value, type, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_manual_traceable_fraction`, 'returnType') = 'integer'
attr(`set_model_param_manual_traceable_fraction`, "inputTypes") = c('_p_model', 'numeric', 'integer')
class(`set_model_param_manual_traceable_fraction`) = c("SWIGFunction", class('set_model_param_manual_traceable_fraction'))

# Start of set_model_param_risk_score

`set_model_param_risk_score` = function(s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  s_arg4 = as.integer(s_arg4);
  
  if(length(s_arg4) > 1) {
    warning("using only the first element of s_arg4");
  };
  
  
  ;.Call('R_swig_set_model_param_risk_score', s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_risk_score`, 'returnType') = 'integer'
attr(`set_model_param_risk_score`, "inputTypes") = c('_p_model', 'integer', 'integer', 'integer', 'numeric')
class(`set_model_param_risk_score`) = c("SWIGFunction", class('set_model_param_risk_score'))

# Start of set_model_param_risk_score_household

`set_model_param_risk_score_household` = function(s_arg1, s_arg2, s_arg3, s_arg4, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  
  ;.Call('R_swig_set_model_param_risk_score_household', s_arg1, s_arg2, s_arg3, s_arg4, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_risk_score_household`, 'returnType') = 'integer'
attr(`set_model_param_risk_score_household`, "inputTypes") = c('_p_model', 'integer', 'integer', 'numeric')
class(`set_model_param_risk_score_household`) = c("SWIGFunction", class('set_model_param_risk_score_household'))

# Start of set_model_param_fatality_fraction

`set_model_param_fatality_fraction` = function(pmodel, value, age_group, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  
  age_group = as.integer(age_group);
  
  if(length(age_group) > 1) {
    warning("using only the first element of age_group");
  };
  
  ;.Call('R_swig_set_model_param_fatality_fraction', pmodel, value, age_group, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_model_param_fatality_fraction`, 'returnType') = 'integer'
attr(`set_model_param_fatality_fraction`, "inputTypes") = c('_p_model', 'numeric', 'integer')
class(`set_model_param_fatality_fraction`) = c("SWIGFunction", class('set_model_param_fatality_fraction'))

# Start of set_demographic_house_table

`set_demographic_house_table` = function(s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, s_arg6, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  s_arg4 = as.integer(s_arg4);
  s_arg5 = as.integer(s_arg5);
  s_arg6 = as.integer(s_arg6);
  ;.Call('R_swig_set_demographic_house_table', s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, s_arg6, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_demographic_house_table`, 'returnType') = 'integer'
attr(`set_demographic_house_table`, "inputTypes") = c('_p_parameters', 'integer', 'integer', 'integer', 'integer', 'integer')
class(`set_demographic_house_table`) = c("SWIGFunction", class('set_demographic_house_table'))

# Start of set_occupation_network_table

`set_occupation_network_table` = function(params, n_total, n_networks, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  n_total = as.integer(n_total);
  
  if(length(n_total) > 1) {
    warning("using only the first element of n_total");
  };
  
  n_networks = as.integer(n_networks);
  
  if(length(n_networks) > 1) {
    warning("using only the first element of n_networks");
  };
  
  ;.Call('R_swig_set_occupation_network_table', params, n_total, n_networks, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_occupation_network_table`, 'returnType') = 'integer'
attr(`set_occupation_network_table`, "inputTypes") = c('_p_parameters', 'integer', 'integer')
class(`set_occupation_network_table`) = c("SWIGFunction", class('set_occupation_network_table'))

# Start of set_indiv_occupation_network_property

`set_indiv_occupation_network_property` = function(params, network, age_type, mean_interaction, lockdown_multiplier, network_name, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  network = as.integer(network);
  
  if(length(network) > 1) {
    warning("using only the first element of network");
  };
  
  age_type = as.integer(age_type);
  
  if(length(age_type) > 1) {
    warning("using only the first element of age_type");
  };
  
  
  
  network_name = as(network_name, "character"); 
  ;.Call('R_swig_set_indiv_occupation_network_property', params, network, age_type, mean_interaction, lockdown_multiplier, network_name, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_indiv_occupation_network_property`, 'returnType') = 'integer'
attr(`set_indiv_occupation_network_property`, "inputTypes") = c('_p_parameters', 'integer', 'integer', 'numeric', 'numeric', 'character')
class(`set_indiv_occupation_network_property`) = c("SWIGFunction", class('set_indiv_occupation_network_property'))

# Start of set_indiv_occupation_network

`set_indiv_occupation_network` = function(params, n_total, people, network, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  n_total = as.integer(n_total);
  
  if(length(n_total) > 1) {
    warning("using only the first element of n_total");
  };
  
  people = as.integer(people);
  network = as.integer(network);
  ;.Call('R_swig_set_indiv_occupation_network', params, n_total, people, network, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_indiv_occupation_network`, 'returnType') = 'integer'
attr(`set_indiv_occupation_network`, "inputTypes") = c('_p_parameters', 'integer', 'integer', 'integer')
class(`set_indiv_occupation_network`) = c("SWIGFunction", class('set_indiv_occupation_network'))

# Start of set_up_default_occupation_network_table

`set_up_default_occupation_network_table` = function(params)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_set_up_default_occupation_network_table', params, PACKAGE='OpenABMCovid19');
  
}

attr(`set_up_default_occupation_network_table`, 'returnType') = 'void'
attr(`set_up_default_occupation_network_table`, "inputTypes") = c('_p_parameters')
class(`set_up_default_occupation_network_table`) = c("SWIGFunction", class('set_up_default_occupation_network_table'))

# Start of set_app_users

`set_app_users` = function(s_arg1, s_arg2, s_arg3, s_arg4, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  s_arg4 = as.integer(s_arg4);
  
  if(length(s_arg4) > 1) {
    warning("using only the first element of s_arg4");
  };
  
  ;.Call('R_swig_set_app_users', s_arg1, s_arg2, s_arg3, s_arg4, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_app_users`, 'returnType') = 'integer'
attr(`set_app_users`, "inputTypes") = c('_p_model', 'integer', 'integer', 'integer')
class(`set_app_users`) = c("SWIGFunction", class('set_app_users'))

# Start of get_app_users

`get_app_users` = function(s_arg1, s_arg2, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  ;.Call('R_swig_get_app_users', s_arg1, s_arg2, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_app_users`, 'returnType') = 'integer'
attr(`get_app_users`, "inputTypes") = c('_p_model', 'integer')
class(`get_app_users`) = c("SWIGFunction", class('get_app_users'))

# Start of get_app_user_by_index

`get_app_user_by_index` = function(s_arg1, s_arg2, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  ;.Call('R_swig_get_app_user_by_index', s_arg1, s_arg2, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_app_user_by_index`, 'returnType') = 'integer'
attr(`get_app_user_by_index`, "inputTypes") = c('_p_model', 'integer')
class(`get_app_user_by_index`) = c("SWIGFunction", class('get_app_user_by_index'))

# Start of get_individuals

`get_individuals` = function(s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, s_arg6, s_arg7, s_arg8, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  s_arg3 = as.integer(s_arg3);
  s_arg4 = as.integer(s_arg4);
  s_arg5 = as.integer(s_arg5);
  s_arg6 = as.integer(s_arg6);
  s_arg7 = as.integer(s_arg7);
  s_arg8 = as.integer(s_arg8);
  ;.Call('R_swig_get_individuals', s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, s_arg6, s_arg7, s_arg8, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_individuals`, 'returnType') = 'integer'
attr(`get_individuals`, "inputTypes") = c('_p_model', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer')
class(`get_individuals`) = c("SWIGFunction", class('get_individuals'))

# Start of update_work_intervention_state

`update_work_intervention_state` = function(pmodel, value)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_update_work_intervention_state', pmodel, value, PACKAGE='OpenABMCovid19');
  
}

attr(`update_work_intervention_state`, 'returnType') = 'void'
attr(`update_work_intervention_state`, "inputTypes") = c('_p_model', 'integer')
class(`update_work_intervention_state`) = c("SWIGFunction", class('update_work_intervention_state'))

# Start of update_household_intervention_state

`update_household_intervention_state` = function(pmodel, value)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_update_household_intervention_state', pmodel, value, PACKAGE='OpenABMCovid19');
  
}

attr(`update_household_intervention_state`, 'returnType') = 'void'
attr(`update_household_intervention_state`, "inputTypes") = c('_p_model', 'integer')
class(`update_household_intervention_state`) = c("SWIGFunction", class('update_household_intervention_state'))

# Start of check_params

`check_params` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_check_params', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`check_params`, 'returnType') = 'void'
attr(`check_params`, "inputTypes") = c('_p_parameters')
class(`check_params`) = c("SWIGFunction", class('check_params'))

# Start of check_hospital_params

`check_hospital_params` = function(params)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_check_hospital_params', params, PACKAGE='OpenABMCovid19');
  
}

attr(`check_hospital_params`, 'returnType') = 'void'
attr(`check_hospital_params`, "inputTypes") = c('_p_parameters')
class(`check_hospital_params`) = c("SWIGFunction", class('check_hospital_params'))

# Start of initialize_params

`initialize_params` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_initialize_params', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`initialize_params`, 'returnType') = 'void'
attr(`initialize_params`, "inputTypes") = c('_p_parameters')
class(`initialize_params`) = c("SWIGFunction", class('initialize_params'))

# Start of destroy_params

`destroy_params` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_destroy_params', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`destroy_params`, 'returnType') = 'void'
attr(`destroy_params`, "inputTypes") = c('_p_parameters')
class(`destroy_params`) = c("SWIGFunction", class('destroy_params'))

# Start of destroy_occupation_network_table

`destroy_occupation_network_table` = function(params)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_destroy_occupation_network_table', params, PACKAGE='OpenABMCovid19');
  
}

attr(`destroy_occupation_network_table`, 'returnType') = 'void'
attr(`destroy_occupation_network_table`, "inputTypes") = c('_p_parameters')
class(`destroy_occupation_network_table`) = c("SWIGFunction", class('destroy_occupation_network_table'))

defineEnumeration('_EVENT_TYPES',
                    .values = c(
                        'SUSCEPTIBLE' = 0, 
                        'PRESYMPTOMATIC' = 1, 
                        'PRESYMPTOMATIC_MILD' = 2, 
                        'ASYMPTOMATIC' = 3, 
                        'SYMPTOMATIC' = 4, 
                        'SYMPTOMATIC_MILD' = 5, 
                        'HOSPITALISED' = 6, 
                        'CRITICAL' = 7, 
                        'HOSPITALISED_RECOVERING' = 8, 
                        'RECOVERED' = 9, 
                        'DEATH' = 10, 
                        'QUARANTINED' = 11, 
                        'QUARANTINE_RELEASE' = 12, 
                        'TEST_TAKE' = 13, 
                        'TEST_RESULT' = 14, 
                        'CASE' = 15, 
                        'TRACE_TOKEN_RELEASE' = 16, 
                        'NOT_IN_HOSPITAL' = 17, 
                        'WAITING' = 18, 
                        'GENERAL' = 19, 
                        'ICU' = 20, 
                        'MORTUARY' = 21, 
                        'DISCHARGED' = 22, 
                        'MANUAL_CONTACT_TRACING' = 23, 
                        'TRANSITION_TO_HOSPITAL' = 24, 
                        'TRANSITION_TO_CRITICAL' = 25, 
                        'VACCINE_PROTECT' = 26, 
                        'VACCINE_WANE' = 27, 
                        'N_EVENT_TYPES' = 28
))
defineEnumeration('_TRANSITIONS_TYPES',
                    .values = c(
                        'ASYMPTOMATIC_RECOVERED' = 0, 
                        'PRESYMPTOMATIC_SYMPTOMATIC' = 1, 
                        'PRESYMPTOMATIC_MILD_SYMPTOMATIC_MILD' = 2, 
                        'SYMPTOMATIC_RECOVERED' = 3, 
                        'SYMPTOMATIC_HOSPITALISED' = 4, 
                        'SYMPTOMATIC_MILD_RECOVERED' = 5, 
                        'HOSPITALISED_CRITICAL' = 6, 
                        'HOSPITALISED_RECOVERED' = 7, 
                        'CRITICAL_DEATH' = 8, 
                        'CRITICAL_HOSPITALISED_RECOVERING' = 9, 
                        'HOSPITALISED_RECOVERING_RECOVERED' = 10, 
                        'SYMPTOMATIC_QUARANTINE' = 11, 
                        'TRACED_QUARANTINE_SYMPTOMS' = 12, 
                        'TRACED_QUARANTINE_POSITIVE' = 13, 
                        'TEST_RESULT_QUARANTINE' = 14, 
                        'RECOVERED_SUSCEPTIBLE' = 15, 
                        'VACCINE_PROTECTED_SUSCEPTIBLE' = 16, 
                        'VACCINE_PROTECTED_SYMPTOMS_VACCINE_WANED' = 17, 
                        'N_TRANSITION_TYPES' = 18
))
defineEnumeration('_AGE_GROUPS',
                    .values = c(
                        'AGE_0_9' = 0, 
                        'AGE_10_19' = 1, 
                        'AGE_20_29' = 2, 
                        'AGE_30_39' = 3, 
                        'AGE_40_49' = 4, 
                        'AGE_50_59' = 5, 
                        'AGE_60_69' = 6, 
                        'AGE_70_79' = 7, 
                        'AGE_80' = 8, 
                        'N_AGE_GROUPS' = 9
))
defineEnumeration('_AGE_TYPES',
                    .values = c(
                        'AGE_TYPE_CHILD' = 0, 
                        'AGE_TYPE_ADULT' = 1, 
                        'AGE_TYPE_ELDERLY' = 2, 
                        'N_AGE_TYPES' = 3
))
defineEnumeration('_OCCUPATION_NETWORKS',
                    .values = c(
                        'PRIMARY_NETWORK' = 0, 
                        'SECONDARY_NETWORK' = 1, 
                        'WORKING_NETWORK' = 2, 
                        'RETIRED_NETWORK' = 3, 
                        'ELDERLY_NETWORK' = 4, 
                        'N_DEFAULT_OCCUPATION_NETWORKS' = 5
))
defineEnumeration('_OCCUPATION_NETWORKS_TYPES',
                    .values = c(
                        'NETWORK_TYPE_CHILD' = 0, 
                        'NETWORK_TYPE_ADULT' = 1, 
                        'NETWORK_TYPE_ELDERLY' = 2, 
                        'N_OCCUPATION_NETWORK_TYPES' = 3
))
defineEnumeration('_WORKER_TYPES',
                    .values = c(
                        'DOCTOR' = 0, 
                        'NURSE' = 1, 
                        'N_WORKER_TYPES' = 2
))
defineEnumeration('_DEFAULT_NETWORKS',
                    .values = c(
                        'HOUSEHOLD_NETWORK' = 0, 
                        'OCCUPATION_PRIMARY_NETWORK' = 1, 
                        'OCCUPATION_SECONDARY_NETWORK' = 2, 
                        'OCCUPATION_WORKING_NETWORK' = 3, 
                        'OCCUPATION_RETIRED_NETWORK' = 4, 
                        'OCCUPATION_ELDERLY_NETWORK' = 5, 
                        'RANDOM_NETWORK' = 6, 
                        'N_DEFAULT_NETWORKS' = 7
))
defineEnumeration('_NETWORK_CONSTRUCTIONS',
                    .values = c(
                        'NETWORK_CONSTRUCTION_BESPOKE' = 0, 
                        'NETWORK_CONSTRUCTION_HOUSEHOLD' = 1, 
                        'NETWORK_CONSTRUCTION_WATTS_STROGATZ' = 2, 
                        'NETWORK_CONSTRUCTION_RANDOM_DEFAULT' = 3, 
                        'NETWORK_CONSTRUCTION_RANDOM' = 4, 
                        'N_NETWORK_CONSTRUCTIONS' = 5
))
# Start of AGE_OCCUPATION_MAP_get

`AGE_OCCUPATION_MAP_get` = function(.copy = FALSE)
{
  ;ans = .Call('R_swig_AGE_OCCUPATION_MAP_get', as.logical(.copy), PACKAGE='OpenABMCovid19');
  ans <- new("_p_int", ref=ans) ;
  
  ans
  
}

attr(`AGE_OCCUPATION_MAP_get`, 'returnType') = 'integer'
class(`AGE_OCCUPATION_MAP_get`) = c("SWIGFunction", class('AGE_OCCUPATION_MAP_get'))

AGE_OCCUPATION_MAP = 
function(value, .copy = FALSE)
{
  if(missing(value)) {
    AGE_OCCUPATION_MAP_get(.copy)
  } else {
    AGE_OCCUPATION_MAP_set(value)
  }
}

# Start of NETWORK_TYPE_MAP_get

`NETWORK_TYPE_MAP_get` = function(.copy = FALSE)
{
  ;ans = .Call('R_swig_NETWORK_TYPE_MAP_get', as.logical(.copy), PACKAGE='OpenABMCovid19');
  ans <- new("_p_int", ref=ans) ;
  
  ans
  
}

attr(`NETWORK_TYPE_MAP_get`, 'returnType') = 'integer'
class(`NETWORK_TYPE_MAP_get`) = c("SWIGFunction", class('NETWORK_TYPE_MAP_get'))

NETWORK_TYPE_MAP = 
function(value, .copy = FALSE)
{
  if(missing(value)) {
    NETWORK_TYPE_MAP_get(.copy)
  } else {
    NETWORK_TYPE_MAP_set(value)
  }
}

# Start of OCCUPATION_DEFAULT_MAP_get

`OCCUPATION_DEFAULT_MAP_get` = function(.copy = FALSE)
{
  ;ans = .Call('R_swig_OCCUPATION_DEFAULT_MAP_get', as.logical(.copy), PACKAGE='OpenABMCovid19');
  ans <- new("_p_int", ref=ans) ;
  
  ans
  
}

attr(`OCCUPATION_DEFAULT_MAP_get`, 'returnType') = 'integer'
class(`OCCUPATION_DEFAULT_MAP_get`) = c("SWIGFunction", class('OCCUPATION_DEFAULT_MAP_get'))

OCCUPATION_DEFAULT_MAP = 
function(value, .copy = FALSE)
{
  if(missing(value)) {
    OCCUPATION_DEFAULT_MAP_get(.copy)
  } else {
    OCCUPATION_DEFAULT_MAP_set(value)
  }
}

# Start of AGE_TYPE_MAP_get

`AGE_TYPE_MAP_get` = function(.copy = FALSE)
{
  ;ans = .Call('R_swig_AGE_TYPE_MAP_get', as.logical(.copy), PACKAGE='OpenABMCovid19');
  ans <- new("_p_int", ref=ans) ;
  
  ans
  
}

attr(`AGE_TYPE_MAP_get`, 'returnType') = 'integer'
class(`AGE_TYPE_MAP_get`) = c("SWIGFunction", class('AGE_TYPE_MAP_get'))

AGE_TYPE_MAP = 
function(value, .copy = FALSE)
{
  if(missing(value)) {
    AGE_TYPE_MAP_get(.copy)
  } else {
    AGE_TYPE_MAP_set(value)
  }
}

# Start of AGE_TEXT_MAP_set

`AGE_TEXT_MAP_set` = function(s_AGE_TEXT_MAP)
{
  if(is.list(s_AGE_TEXT_MAP))
  assert(all(sapply(s_AGE_TEXT_MAP, class) == "_p_p_char"));
  
  
#  assert(length(s_AGE_TEXT_MAP) >= N_AGE_GROUPS)
  
  ;.Call('R_swig_AGE_TEXT_MAP_set', s_AGE_TEXT_MAP, PACKAGE='OpenABMCovid19');
  
}

attr(`AGE_TEXT_MAP_set`, 'returnType') = 'void'
attr(`AGE_TEXT_MAP_set`, "inputTypes") = c('_p_p_char')
class(`AGE_TEXT_MAP_set`) = c("SWIGFunction", class('AGE_TEXT_MAP_set'))

# Start of AGE_TEXT_MAP_get

`AGE_TEXT_MAP_get` = function(.copy = FALSE)
{
  ;ans = .Call('R_swig_AGE_TEXT_MAP_get', as.logical(.copy), PACKAGE='OpenABMCovid19');
  ans <- new("_p_p_char", ref=ans) ;
  
  ans
  
}

attr(`AGE_TEXT_MAP_get`, 'returnType') = '_p_p_char'
class(`AGE_TEXT_MAP_get`) = c("SWIGFunction", class('AGE_TEXT_MAP_get'))

AGE_TEXT_MAP = 
function(value, .copy = FALSE)
{
  if(missing(value)) {
    AGE_TEXT_MAP_get(.copy)
  } else {
    AGE_TEXT_MAP_set(value)
  }
}

# Start of EVENT_TYPE_TO_WARD_MAP_get

`EVENT_TYPE_TO_WARD_MAP_get` = function(.copy = FALSE)
{
  ;ans = .Call('R_swig_EVENT_TYPE_TO_WARD_MAP_get', as.logical(.copy), PACKAGE='OpenABMCovid19');
  ans <- new("_p_int", ref=ans) ;
  
  ans
  
}

attr(`EVENT_TYPE_TO_WARD_MAP_get`, 'returnType') = 'integer'
class(`EVENT_TYPE_TO_WARD_MAP_get`) = c("SWIGFunction", class('EVENT_TYPE_TO_WARD_MAP_get'))

EVENT_TYPE_TO_WARD_MAP = 
function(value, .copy = FALSE)
{
  if(missing(value)) {
    EVENT_TYPE_TO_WARD_MAP_get(.copy)
  } else {
    EVENT_TYPE_TO_WARD_MAP_set(value)
  }
}

# Start of DEFAULT_NETWORKS_NAMES_set

`DEFAULT_NETWORKS_NAMES_set` = function(s_DEFAULT_NETWORKS_NAMES)
{
  if(is.list(s_DEFAULT_NETWORKS_NAMES))
  assert(all(sapply(s_DEFAULT_NETWORKS_NAMES, class) == "_p_p_char"));
  
  
#  assert(length(s_DEFAULT_NETWORKS_NAMES) >= N_DEFAULT_NETWORKS)
  
  ;.Call('R_swig_DEFAULT_NETWORKS_NAMES_set', s_DEFAULT_NETWORKS_NAMES, PACKAGE='OpenABMCovid19');
  
}

attr(`DEFAULT_NETWORKS_NAMES_set`, 'returnType') = 'void'
attr(`DEFAULT_NETWORKS_NAMES_set`, "inputTypes") = c('_p_p_char')
class(`DEFAULT_NETWORKS_NAMES_set`) = c("SWIGFunction", class('DEFAULT_NETWORKS_NAMES_set'))

# Start of DEFAULT_NETWORKS_NAMES_get

`DEFAULT_NETWORKS_NAMES_get` = function(.copy = FALSE)
{
  ;ans = .Call('R_swig_DEFAULT_NETWORKS_NAMES_get', as.logical(.copy), PACKAGE='OpenABMCovid19');
  ans <- new("_p_p_char", ref=ans) ;
  
  ans
  
}

attr(`DEFAULT_NETWORKS_NAMES_get`, 'returnType') = '_p_p_char'
class(`DEFAULT_NETWORKS_NAMES_get`) = c("SWIGFunction", class('DEFAULT_NETWORKS_NAMES_get'))

DEFAULT_NETWORKS_NAMES = 
function(value, .copy = FALSE)
{
  if(missing(value)) {
    DEFAULT_NETWORKS_NAMES_get(.copy)
  } else {
    DEFAULT_NETWORKS_NAMES_set(value)
  }
}

# Start of NEWLY_INFECTED_STATES_get

`NEWLY_INFECTED_STATES_get` = function(.copy = FALSE)
{
  ;ans = .Call('R_swig_NEWLY_INFECTED_STATES_get', as.logical(.copy), PACKAGE='OpenABMCovid19');
  ans <- new("_p_int", ref=ans) ;
  
  ans
  
}

attr(`NEWLY_INFECTED_STATES_get`, 'returnType') = 'integer'
class(`NEWLY_INFECTED_STATES_get`) = c("SWIGFunction", class('NEWLY_INFECTED_STATES_get'))

NEWLY_INFECTED_STATES = 
function(value, .copy = FALSE)
{
  if(missing(value)) {
    NEWLY_INFECTED_STATES_get(.copy)
  } else {
    NEWLY_INFECTED_STATES_set(value)
  }
}

defineEnumeration('_HOUSEHOLD_SIZE',
                    .values = c(
                        'HH_1' = 0, 
                        'HH_2' = 1, 
                        'HH_3' = 2, 
                        'HH_4' = 3, 
                        'HH_5' = 4, 
                        'HH_6' = 5, 
                        'N_HOUSEHOLD_MAX' = 6
))
defineEnumeration('_INTERACTION_TYPE',
                    .values = c(
                        'HOUSEHOLD' = 0, 
                        'OCCUPATION' = 1, 
                        'RANDOM' = 2, 
                        'HOSPITAL_WORK' = 3, 
                        'HOSPITAL_DOCTOR_PATIENT_GENERAL' = 4, 
                        'HOSPITAL_NURSE_PATIENT_GENERAL' = 5, 
                        'HOSPITAL_DOCTOR_PATIENT_ICU' = 6, 
                        'HOSPITAL_NURSE_PATIENT_ICU' = 7, 
                        'N_INTERACTION_TYPES' = 8
))
defineEnumeration('_DISTRIBUTIONS',
                    .values = c(
                        'FIXED' = 0, 
                        'NEGATIVE_BINOMIAL' = 1
))
defineEnumeration('_HOSPITAL_WARD_TYPES',
                    .values = c(
                        'COVID_GENERAL' = 0, 
                        'COVID_ICU' = 1, 
                        'N_HOSPITAL_WARD_TYPES' = 2
))
defineEnumeration('_INDEX_STATUS',
                    .values = c(
                        'SYMPTOMS_ONLY' = 0, 
                        'POSITIVE_TEST' = 1
))
defineEnumeration('_QUARANTINE_REASONS',
                    .values = c(
                        'QR_SELF_POSITIVE' = 0, 
                        'QR_SELF_SYMPTOMS' = 1, 
                        'QR_HOUSEHOLD_POSITIVE' = 2, 
                        'QR_HOUSEHOLD_SYMPTOMS' = 3, 
                        'QR_TRACE_POSITIVE' = 4, 
                        'QR_TRACE_SYMPTOMS' = 5, 
                        'N_QUARANTINE_REASONS' = 6
))
defineEnumeration('_TRACE_TYPE',
                    .values = c(
                        'NO_TRACE' = 0, 
                        'DIGITAL_TRACE' = 1, 
                        'MANUAL_TRACE' = 2
))
defineEnumeration('_VACCINE_STATUS',
                    .values = c(
                        'NO_VACCINE' = 0, 
                        'VACCINE_NO_PROTECTION' = 1, 
                        'VACCINE_PROTECTED_FULLY' = 2, 
                        'VACCINE_PROTECTED_SYMPTOMS' = 3, 
                        'VACCINE_PROTECTED_SEVERE' = 4, 
                        'VACCINE_WANED' = 5
))
defineEnumeration('_VACCINE_TYPES',
                    .values = c(
                        'VACCINE_TYPE_FULL' = 0, 
                        'VACCINE_TYPE_SYMPTOMS' = 1
))
defineEnumeration('_IMMUNE_TYPES',
                    .values = c(
                        'IMMUNE_FULL' = 0, 
                        'IMMUNE_SYMPTOMS' = 1, 
                        'IMMUNE_SEVERE' = 2
))
# Start of rng_set

`rng_set` = function(s_rng)
{
  if (inherits(s_rng, "ExternalReference")) s_rng = slot(s_rng,"ref") 
  ;.Call('R_swig_rng_set', s_rng, PACKAGE='OpenABMCovid19');
  
}

attr(`rng_set`, 'returnType') = 'void'
attr(`rng_set`, "inputTypes") = c('_p_gsl_rng')
class(`rng_set`) = c("SWIGFunction", class('rng_set'))

# Start of rng_get

`rng_get` = function()
{
  ;ans = .Call('R_swig_rng_get', PACKAGE='OpenABMCovid19');
  ans <- new("_p_gsl_rng", ref=ans) ;
  
  ans
  
}

attr(`rng_get`, 'returnType') = '_p_gsl_rng'
class(`rng_get`) = c("SWIGFunction", class('rng_get'))

rng = 
function(value)
{
  if(missing(value)) {
    rng_get()
  } else {
    rng_set(value)
  }
}

# Start of read_command_line_args

`read_command_line_args` = function(s_arg1, s_arg2, s_arg3)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  if (inherits(s_arg3, "ExternalReference")) s_arg3 = slot(s_arg3,"ref") 
  ;.Call('R_swig_read_command_line_args', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`read_command_line_args`, 'returnType') = 'void'
attr(`read_command_line_args`, "inputTypes") = c('_p_parameters', 'integer', 'character')
class(`read_command_line_args`) = c("SWIGFunction", class('read_command_line_args'))

# Start of read_param_file

`read_param_file` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_read_param_file', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`read_param_file`, 'returnType') = 'void'
attr(`read_param_file`, "inputTypes") = c('_p_parameters')
class(`read_param_file`) = c("SWIGFunction", class('read_param_file'))

# Start of read_household_demographics_file

`read_household_demographics_file` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_read_household_demographics_file', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`read_household_demographics_file`, 'returnType') = 'void'
attr(`read_household_demographics_file`, "inputTypes") = c('_p_parameters')
class(`read_household_demographics_file`) = c("SWIGFunction", class('read_household_demographics_file'))

# Start of read_hospital_param_file

`read_hospital_param_file` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_read_hospital_param_file', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`read_hospital_param_file`, 'returnType') = 'void'
attr(`read_hospital_param_file`, "inputTypes") = c('_p_parameters')
class(`read_hospital_param_file`) = c("SWIGFunction", class('read_hospital_param_file'))

# Start of set_up_reference_household_memory

`set_up_reference_household_memory` = function(params)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_set_up_reference_household_memory', params, PACKAGE='OpenABMCovid19');
  
}

attr(`set_up_reference_household_memory`, 'returnType') = 'void'
attr(`set_up_reference_household_memory`, "inputTypes") = c('_p_parameters')
class(`set_up_reference_household_memory`) = c("SWIGFunction", class('set_up_reference_household_memory'))

# Start of write_output_files

`write_output_files` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_write_output_files', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`write_output_files`, 'returnType') = 'void'
attr(`write_output_files`, "inputTypes") = c('_p_model', '_p_parameters')
class(`write_output_files`) = c("SWIGFunction", class('write_output_files'))

# Start of write_individual_file

`write_individual_file` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_write_individual_file', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`write_individual_file`, 'returnType') = 'void'
attr(`write_individual_file`, "inputTypes") = c('_p_model', '_p_parameters')
class(`write_individual_file`) = c("SWIGFunction", class('write_individual_file'))

# Start of write_interactions

`write_interactions` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_write_interactions', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`write_interactions`, 'returnType') = 'void'
attr(`write_interactions`, "inputTypes") = c('_p_model')
class(`write_interactions`) = c("SWIGFunction", class('write_interactions'))

# Start of write_transmissions

`write_transmissions` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_write_transmissions', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`write_transmissions`, 'returnType') = 'void'
attr(`write_transmissions`, "inputTypes") = c('_p_model')
class(`write_transmissions`) = c("SWIGFunction", class('write_transmissions'))

# Start of write_trace_tokens

`write_trace_tokens` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_write_trace_tokens', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`write_trace_tokens`, 'returnType') = 'void'
attr(`write_trace_tokens`, "inputTypes") = c('_p_model')
class(`write_trace_tokens`) = c("SWIGFunction", class('write_trace_tokens'))

# Start of write_trace_tokens_ts

`write_trace_tokens_ts` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  ;.Call('R_swig_write_trace_tokens_ts', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`write_trace_tokens_ts`, 'returnType') = 'void'
attr(`write_trace_tokens_ts`, "inputTypes") = c('_p_model', 'integer')
class(`write_trace_tokens_ts`) = c("SWIGFunction", class('write_trace_tokens_ts'))

# Start of write_quarantine_reasons

`write_quarantine_reasons` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_write_quarantine_reasons', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`write_quarantine_reasons`, 'returnType') = 'void'
attr(`write_quarantine_reasons`, "inputTypes") = c('_p_model', '_p_parameters')
class(`write_quarantine_reasons`) = c("SWIGFunction", class('write_quarantine_reasons'))

# Start of write_ward_data

`write_ward_data` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_write_ward_data', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`write_ward_data`, 'returnType') = 'void'
attr(`write_ward_data`, "inputTypes") = c('_p_model')
class(`write_ward_data`) = c("SWIGFunction", class('write_ward_data'))

# Start of get_worker_ward_type

`get_worker_ward_type` = function(pmodel, pdx, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  pdx = as.integer(pdx);
  
  if(length(pdx) > 1) {
    warning("using only the first element of pdx");
  };
  
  ;.Call('R_swig_get_worker_ward_type', pmodel, pdx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_worker_ward_type`, 'returnType') = 'integer'
attr(`get_worker_ward_type`, "inputTypes") = c('_p_model', 'integer')
class(`get_worker_ward_type`) = c("SWIGFunction", class('get_worker_ward_type'))

# Start of write_time_step_hospital_data

`write_time_step_hospital_data` = function(pmodel)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_write_time_step_hospital_data', pmodel, PACKAGE='OpenABMCovid19');
  
}

attr(`write_time_step_hospital_data`, 'returnType') = 'void'
attr(`write_time_step_hospital_data`, "inputTypes") = c('_p_model')
class(`write_time_step_hospital_data`) = c("SWIGFunction", class('write_time_step_hospital_data'))

# Start of write_hospital_interactions

`write_hospital_interactions` = function(pmodel)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  ;.Call('R_swig_write_hospital_interactions', pmodel, PACKAGE='OpenABMCovid19');
  
}

attr(`write_hospital_interactions`, 'returnType') = 'void'
attr(`write_hospital_interactions`, "inputTypes") = c('_p_model')
class(`write_hospital_interactions`) = c("SWIGFunction", class('write_hospital_interactions'))

# Start of write_occupation_network

`write_occupation_network` = function(s_arg1, s_arg2, s_arg3)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;.Call('R_swig_write_occupation_network', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`write_occupation_network`, 'returnType') = 'void'
attr(`write_occupation_network`, "inputTypes") = c('_p_model', '_p_parameters', 'integer')
class(`write_occupation_network`) = c("SWIGFunction", class('write_occupation_network'))

# Start of write_household_network

`write_household_network` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_write_household_network', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`write_household_network`, 'returnType') = 'void'
attr(`write_household_network`, "inputTypes") = c('_p_model', '_p_parameters')
class(`write_household_network`) = c("SWIGFunction", class('write_household_network'))

# Start of write_random_network

`write_random_network` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_write_random_network', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`write_random_network`, 'returnType') = 'void'
attr(`write_random_network`, "inputTypes") = c('_p_model', '_p_parameters')
class(`write_random_network`) = c("SWIGFunction", class('write_random_network'))

# Start of write_network

`write_network` = function(s_arg1, s_arg2)
{
  s_arg1 = as(s_arg1, "character"); 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_write_network', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`write_network`, 'returnType') = 'void'
attr(`write_network`, "inputTypes") = c('character', '_p_network')
class(`write_network`) = c("SWIGFunction", class('write_network'))

# Start of print_interactions_averages

`print_interactions_averages` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  ;.Call('R_swig_print_interactions_averages', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`print_interactions_averages`, 'returnType') = 'void'
attr(`print_interactions_averages`, "inputTypes") = c('_p_model', 'integer')
class(`print_interactions_averages`) = c("SWIGFunction", class('print_interactions_averages'))

# Start of get_n_transmissions

`get_n_transmissions` = function(s_arg1, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_get_n_transmissions', s_arg1, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_n_transmissions`, 'returnType') = 'integer'
attr(`get_n_transmissions`, "inputTypes") = c('_p_model')
class(`get_n_transmissions`) = c("SWIGFunction", class('get_n_transmissions'))

# Start of get_transmissions

`get_transmissions` = function(s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, s_arg6, s_arg7, s_arg8, s_arg9, s_arg10, s_arg11, s_arg12, s_arg13, s_arg14, s_arg15, s_arg16, s_arg17, s_arg18, s_arg19, s_arg20, s_arg21, s_arg22, s_arg23, s_arg24, s_arg25, s_arg26, s_arg27, s_arg28, s_arg29, s_arg30, s_arg31, s_arg32, s_arg33, s_arg34, s_arg35, s_arg36)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  s_arg3 = as.integer(s_arg3);
  s_arg4 = as.integer(s_arg4);
  s_arg5 = as.integer(s_arg5);
  s_arg6 = as.integer(s_arg6);
  s_arg7 = as.integer(s_arg7);
  s_arg8 = as.integer(s_arg8);
  s_arg9 = as.integer(s_arg9);
  s_arg10 = as.integer(s_arg10);
  s_arg11 = as.integer(s_arg11);
  s_arg12 = as.integer(s_arg12);
  s_arg13 = as.integer(s_arg13);
  s_arg14 = as.integer(s_arg14);
  s_arg15 = as.integer(s_arg15);
  s_arg16 = as.integer(s_arg16);
  s_arg17 = as.integer(s_arg17);
  s_arg18 = as.integer(s_arg18);
  s_arg19 = as.integer(s_arg19);
  s_arg20 = as.integer(s_arg20);
  s_arg21 = as.integer(s_arg21);
  s_arg22 = as.integer(s_arg22);
  s_arg23 = as.integer(s_arg23);
  s_arg24 = as.integer(s_arg24);
  s_arg25 = as.integer(s_arg25);
  s_arg26 = as.integer(s_arg26);
  s_arg27 = as.integer(s_arg27);
  s_arg28 = as.integer(s_arg28);
  s_arg29 = as.integer(s_arg29);
  s_arg30 = as.integer(s_arg30);
  s_arg31 = as.integer(s_arg31);
  s_arg32 = as.integer(s_arg32);
  s_arg33 = as.integer(s_arg33);
  s_arg34 = as.integer(s_arg34);
  
  
  ;.Call('R_swig_get_transmissions', s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, s_arg6, s_arg7, s_arg8, s_arg9, s_arg10, s_arg11, s_arg12, s_arg13, s_arg14, s_arg15, s_arg16, s_arg17, s_arg18, s_arg19, s_arg20, s_arg21, s_arg22, s_arg23, s_arg24, s_arg25, s_arg26, s_arg27, s_arg28, s_arg29, s_arg30, s_arg31, s_arg32, s_arg33, s_arg34, s_arg35, s_arg36, PACKAGE='OpenABMCovid19');
  
}

attr(`get_transmissions`, 'returnType') = 'void'
attr(`get_transmissions`, "inputTypes") = c('_p_model', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'numeric', 'numeric')
class(`get_transmissions`) = c("SWIGFunction", class('get_transmissions'))

# Start of individual_idx_set

`individual_idx_set` = function(self, s_idx)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_idx = as.integer(s_idx);
  
  if(length(s_idx) > 1) {
    warning("using only the first element of s_idx");
  };
  
  ;.Call('R_swig_individual_idx_set', self, s_idx, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_idx_set`, 'returnType') = 'void'
attr(`individual_idx_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_idx_set`) = c("SWIGFunction", class('individual_idx_set'))

# Start of individual_idx_get

`individual_idx_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_individual_idx_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`individual_idx_get`, 'returnType') = 'integer'
attr(`individual_idx_get`, "inputTypes") = c('_p_individual')
class(`individual_idx_get`) = c("SWIGFunction", class('individual_idx_get'))

# Start of individual_house_no_set

`individual_house_no_set` = function(self, s_house_no)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_house_no = as.integer(s_house_no);
  
  if(length(s_house_no) > 1) {
    warning("using only the first element of s_house_no");
  };
  
  ;.Call('R_swig_individual_house_no_set', self, s_house_no, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_house_no_set`, 'returnType') = 'void'
attr(`individual_house_no_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_house_no_set`) = c("SWIGFunction", class('individual_house_no_set'))

# Start of individual_house_no_get

`individual_house_no_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_individual_house_no_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`individual_house_no_get`, 'returnType') = 'integer'
attr(`individual_house_no_get`, "inputTypes") = c('_p_individual')
class(`individual_house_no_get`) = c("SWIGFunction", class('individual_house_no_get'))

# Start of individual_age_group_set

`individual_age_group_set` = function(self, s_age_group)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_age_group = as.integer(s_age_group);
  
  if(length(s_age_group) > 1) {
    warning("using only the first element of s_age_group");
  };
  
  ;.Call('R_swig_individual_age_group_set', self, s_age_group, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_age_group_set`, 'returnType') = 'void'
attr(`individual_age_group_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_age_group_set`) = c("SWIGFunction", class('individual_age_group_set'))

# Start of individual_age_group_get

`individual_age_group_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_individual_age_group_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`individual_age_group_get`, 'returnType') = 'integer'
attr(`individual_age_group_get`, "inputTypes") = c('_p_individual')
class(`individual_age_group_get`) = c("SWIGFunction", class('individual_age_group_get'))

# Start of individual_age_type_set

`individual_age_type_set` = function(self, s_age_type)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_age_type = as.integer(s_age_type);
  
  if(length(s_age_type) > 1) {
    warning("using only the first element of s_age_type");
  };
  
  ;.Call('R_swig_individual_age_type_set', self, s_age_type, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_age_type_set`, 'returnType') = 'void'
attr(`individual_age_type_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_age_type_set`) = c("SWIGFunction", class('individual_age_type_set'))

# Start of individual_age_type_get

`individual_age_type_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_individual_age_type_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`individual_age_type_get`, 'returnType') = 'integer'
attr(`individual_age_type_get`, "inputTypes") = c('_p_individual')
class(`individual_age_type_get`) = c("SWIGFunction", class('individual_age_type_get'))

# Start of individual_occupation_network_set

`individual_occupation_network_set` = function(self, s_occupation_network)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_occupation_network = as.integer(s_occupation_network);
  
  if(length(s_occupation_network) > 1) {
    warning("using only the first element of s_occupation_network");
  };
  
  ;.Call('R_swig_individual_occupation_network_set', self, s_occupation_network, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_occupation_network_set`, 'returnType') = 'void'
attr(`individual_occupation_network_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_occupation_network_set`) = c("SWIGFunction", class('individual_occupation_network_set'))

# Start of individual_occupation_network_get

`individual_occupation_network_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_individual_occupation_network_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`individual_occupation_network_get`, 'returnType') = 'integer'
attr(`individual_occupation_network_get`, "inputTypes") = c('_p_individual')
class(`individual_occupation_network_get`) = c("SWIGFunction", class('individual_occupation_network_get'))

# Start of individual_base_random_interactions_set

`individual_base_random_interactions_set` = function(self, s_base_random_interactions)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_base_random_interactions = as.integer(s_base_random_interactions);
  
  if(length(s_base_random_interactions) > 1) {
    warning("using only the first element of s_base_random_interactions");
  };
  
  ;.Call('R_swig_individual_base_random_interactions_set', self, s_base_random_interactions, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_base_random_interactions_set`, 'returnType') = 'void'
attr(`individual_base_random_interactions_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_base_random_interactions_set`) = c("SWIGFunction", class('individual_base_random_interactions_set'))

# Start of individual_base_random_interactions_get

`individual_base_random_interactions_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_individual_base_random_interactions_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`individual_base_random_interactions_get`, 'returnType') = 'integer'
attr(`individual_base_random_interactions_get`, "inputTypes") = c('_p_individual')
class(`individual_base_random_interactions_get`) = c("SWIGFunction", class('individual_base_random_interactions_get'))

# Start of individual_random_interactions_set

`individual_random_interactions_set` = function(self, s_random_interactions)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_random_interactions = as.integer(s_random_interactions);
  
  if(length(s_random_interactions) > 1) {
    warning("using only the first element of s_random_interactions");
  };
  
  ;.Call('R_swig_individual_random_interactions_set', self, s_random_interactions, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_random_interactions_set`, 'returnType') = 'void'
attr(`individual_random_interactions_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_random_interactions_set`) = c("SWIGFunction", class('individual_random_interactions_set'))

# Start of individual_random_interactions_get

`individual_random_interactions_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_individual_random_interactions_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`individual_random_interactions_get`, 'returnType') = 'integer'
attr(`individual_random_interactions_get`, "inputTypes") = c('_p_individual')
class(`individual_random_interactions_get`) = c("SWIGFunction", class('individual_random_interactions_get'))

# Start of individual_n_interactions_set

`individual_n_interactions_set` = function(self, s_n_interactions)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_interactions = as.integer(s_n_interactions);
  ;.Call('R_swig_individual_n_interactions_set', self, s_n_interactions, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_n_interactions_set`, 'returnType') = 'void'
attr(`individual_n_interactions_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_n_interactions_set`) = c("SWIGFunction", class('individual_n_interactions_set'))

# Start of individual_n_interactions_get

`individual_n_interactions_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_individual_n_interactions_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_short", ref=ans) ;
  
  ans
  
}

attr(`individual_n_interactions_get`, 'returnType') = 'integer'
attr(`individual_n_interactions_get`, "inputTypes") = c('_p_individual')
class(`individual_n_interactions_get`) = c("SWIGFunction", class('individual_n_interactions_get'))

# Start of individual_interactions_set

`individual_interactions_set` = function(self, s_interactions)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_interactions, "ExternalReference")) s_interactions = slot(s_interactions,"ref") 
  ;.Call('R_swig_individual_interactions_set', self, s_interactions, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_interactions_set`, 'returnType') = 'void'
attr(`individual_interactions_set`, "inputTypes") = c('_p_individual', '_p_p_interaction')
class(`individual_interactions_set`) = c("SWIGFunction", class('individual_interactions_set'))

# Start of individual_interactions_get

`individual_interactions_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_individual_interactions_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_p_interaction", ref=ans) ;
  
  ans
  
}

attr(`individual_interactions_get`, 'returnType') = '_p_p_interaction'
attr(`individual_interactions_get`, "inputTypes") = c('_p_individual')
class(`individual_interactions_get`) = c("SWIGFunction", class('individual_interactions_get'))

# Start of individual_status_set

`individual_status_set` = function(self, s_status)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_status = as.integer(s_status);
  
  if(length(s_status) > 1) {
    warning("using only the first element of s_status");
  };
  
  ;.Call('R_swig_individual_status_set', self, s_status, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_status_set`, 'returnType') = 'void'
attr(`individual_status_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_status_set`) = c("SWIGFunction", class('individual_status_set'))

# Start of individual_status_get

`individual_status_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_individual_status_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`individual_status_get`, 'returnType') = 'integer'
attr(`individual_status_get`, "inputTypes") = c('_p_individual')
class(`individual_status_get`) = c("SWIGFunction", class('individual_status_get'))

# Start of individual_hazard_set

`individual_hazard_set` = function(self, s_hazard)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_individual_hazard_set', self, s_hazard, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_hazard_set`, 'returnType') = 'void'
attr(`individual_hazard_set`, "inputTypes") = c('_p_individual', 'numeric')
class(`individual_hazard_set`) = c("SWIGFunction", class('individual_hazard_set'))

# Start of individual_hazard_get

`individual_hazard_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_individual_hazard_get', self, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_hazard_get`, 'returnType') = 'numeric'
attr(`individual_hazard_get`, "inputTypes") = c('_p_individual')
class(`individual_hazard_get`) = c("SWIGFunction", class('individual_hazard_get'))

# Start of individual_infectiousness_multiplier_set

`individual_infectiousness_multiplier_set` = function(self, s_infectiousness_multiplier)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_individual_infectiousness_multiplier_set', self, s_infectiousness_multiplier, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_infectiousness_multiplier_set`, 'returnType') = 'void'
attr(`individual_infectiousness_multiplier_set`, "inputTypes") = c('_p_individual', 'numeric')
class(`individual_infectiousness_multiplier_set`) = c("SWIGFunction", class('individual_infectiousness_multiplier_set'))

# Start of individual_infectiousness_multiplier_get

`individual_infectiousness_multiplier_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_individual_infectiousness_multiplier_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`individual_infectiousness_multiplier_get`, 'returnType') = 'numeric'
attr(`individual_infectiousness_multiplier_get`, "inputTypes") = c('_p_individual')
class(`individual_infectiousness_multiplier_get`) = c("SWIGFunction", class('individual_infectiousness_multiplier_get'))

# Start of individual_current_disease_event_set

`individual_current_disease_event_set` = function(self, s_current_disease_event)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_current_disease_event, "ExternalReference")) s_current_disease_event = slot(s_current_disease_event,"ref") 
  ;.Call('R_swig_individual_current_disease_event_set', self, s_current_disease_event, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_current_disease_event_set`, 'returnType') = 'void'
attr(`individual_current_disease_event_set`, "inputTypes") = c('_p_individual', '_p_event')
class(`individual_current_disease_event_set`) = c("SWIGFunction", class('individual_current_disease_event_set'))

# Start of individual_current_disease_event_get

`individual_current_disease_event_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_individual_current_disease_event_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_event", ref=ans) ;
  
  ans
  
}

attr(`individual_current_disease_event_get`, 'returnType') = '_p_event'
attr(`individual_current_disease_event_get`, "inputTypes") = c('_p_individual')
class(`individual_current_disease_event_get`) = c("SWIGFunction", class('individual_current_disease_event_get'))

# Start of individual_next_disease_event_set

`individual_next_disease_event_set` = function(self, s_next_disease_event)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_next_disease_event, "ExternalReference")) s_next_disease_event = slot(s_next_disease_event,"ref") 
  ;.Call('R_swig_individual_next_disease_event_set', self, s_next_disease_event, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_next_disease_event_set`, 'returnType') = 'void'
attr(`individual_next_disease_event_set`, "inputTypes") = c('_p_individual', '_p_event')
class(`individual_next_disease_event_set`) = c("SWIGFunction", class('individual_next_disease_event_set'))

# Start of individual_next_disease_event_get

`individual_next_disease_event_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_individual_next_disease_event_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_event", ref=ans) ;
  
  ans
  
}

attr(`individual_next_disease_event_get`, 'returnType') = '_p_event'
attr(`individual_next_disease_event_get`, "inputTypes") = c('_p_individual')
class(`individual_next_disease_event_get`) = c("SWIGFunction", class('individual_next_disease_event_get'))

# Start of individual_infection_events_set

`individual_infection_events_set` = function(self, s_infection_events)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_infection_events, "ExternalReference")) s_infection_events = slot(s_infection_events,"ref") 
  ;.Call('R_swig_individual_infection_events_set', self, s_infection_events, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_infection_events_set`, 'returnType') = 'void'
attr(`individual_infection_events_set`, "inputTypes") = c('_p_individual', '_p_infection_event')
class(`individual_infection_events_set`) = c("SWIGFunction", class('individual_infection_events_set'))

# Start of individual_infection_events_get

`individual_infection_events_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_individual_infection_events_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_infection_event", ref=ans) ;
  
  ans
  
}

attr(`individual_infection_events_get`, 'returnType') = '_p_infection_event'
attr(`individual_infection_events_get`, "inputTypes") = c('_p_individual')
class(`individual_infection_events_get`) = c("SWIGFunction", class('individual_infection_events_get'))

# Start of individual_quarantined_set

`individual_quarantined_set` = function(self, s_quarantined)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_quarantined = as.integer(s_quarantined);
  
  if(length(s_quarantined) > 1) {
    warning("using only the first element of s_quarantined");
  };
  
  ;.Call('R_swig_individual_quarantined_set', self, s_quarantined, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_quarantined_set`, 'returnType') = 'void'
attr(`individual_quarantined_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_quarantined_set`) = c("SWIGFunction", class('individual_quarantined_set'))

# Start of individual_quarantined_get

`individual_quarantined_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_individual_quarantined_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`individual_quarantined_get`, 'returnType') = 'integer'
attr(`individual_quarantined_get`, "inputTypes") = c('_p_individual')
class(`individual_quarantined_get`) = c("SWIGFunction", class('individual_quarantined_get'))

# Start of individual_quarantine_event_set

`individual_quarantine_event_set` = function(self, s_quarantine_event)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_quarantine_event, "ExternalReference")) s_quarantine_event = slot(s_quarantine_event,"ref") 
  ;.Call('R_swig_individual_quarantine_event_set', self, s_quarantine_event, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_quarantine_event_set`, 'returnType') = 'void'
attr(`individual_quarantine_event_set`, "inputTypes") = c('_p_individual', '_p_event')
class(`individual_quarantine_event_set`) = c("SWIGFunction", class('individual_quarantine_event_set'))

# Start of individual_quarantine_event_get

`individual_quarantine_event_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_individual_quarantine_event_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_event", ref=ans) ;
  
  ans
  
}

attr(`individual_quarantine_event_get`, 'returnType') = '_p_event'
attr(`individual_quarantine_event_get`, "inputTypes") = c('_p_individual')
class(`individual_quarantine_event_get`) = c("SWIGFunction", class('individual_quarantine_event_get'))

# Start of individual_quarantine_release_event_set

`individual_quarantine_release_event_set` = function(self, s_quarantine_release_event)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_quarantine_release_event, "ExternalReference")) s_quarantine_release_event = slot(s_quarantine_release_event,"ref") 
  ;.Call('R_swig_individual_quarantine_release_event_set', self, s_quarantine_release_event, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_quarantine_release_event_set`, 'returnType') = 'void'
attr(`individual_quarantine_release_event_set`, "inputTypes") = c('_p_individual', '_p_event')
class(`individual_quarantine_release_event_set`) = c("SWIGFunction", class('individual_quarantine_release_event_set'))

# Start of individual_quarantine_release_event_get

`individual_quarantine_release_event_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_individual_quarantine_release_event_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_event", ref=ans) ;
  
  ans
  
}

attr(`individual_quarantine_release_event_get`, 'returnType') = '_p_event'
attr(`individual_quarantine_release_event_get`, "inputTypes") = c('_p_individual')
class(`individual_quarantine_release_event_get`) = c("SWIGFunction", class('individual_quarantine_release_event_get'))

# Start of individual_quarantine_test_result_set

`individual_quarantine_test_result_set` = function(self, s_quarantine_test_result)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_quarantine_test_result = as.integer(s_quarantine_test_result);
  
  if(length(s_quarantine_test_result) > 1) {
    warning("using only the first element of s_quarantine_test_result");
  };
  
  ;.Call('R_swig_individual_quarantine_test_result_set', self, s_quarantine_test_result, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_quarantine_test_result_set`, 'returnType') = 'void'
attr(`individual_quarantine_test_result_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_quarantine_test_result_set`) = c("SWIGFunction", class('individual_quarantine_test_result_set'))

# Start of individual_quarantine_test_result_get

`individual_quarantine_test_result_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_individual_quarantine_test_result_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`individual_quarantine_test_result_get`, 'returnType') = 'integer'
attr(`individual_quarantine_test_result_get`, "inputTypes") = c('_p_individual')
class(`individual_quarantine_test_result_get`) = c("SWIGFunction", class('individual_quarantine_test_result_get'))

# Start of individual_trace_tokens_set

`individual_trace_tokens_set` = function(self, s_trace_tokens)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_trace_tokens, "ExternalReference")) s_trace_tokens = slot(s_trace_tokens,"ref") 
  ;.Call('R_swig_individual_trace_tokens_set', self, s_trace_tokens, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_trace_tokens_set`, 'returnType') = 'void'
attr(`individual_trace_tokens_set`, "inputTypes") = c('_p_individual', '_p_trace_token')
class(`individual_trace_tokens_set`) = c("SWIGFunction", class('individual_trace_tokens_set'))

# Start of individual_trace_tokens_get

`individual_trace_tokens_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_individual_trace_tokens_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_trace_token", ref=ans) ;
  
  ans
  
}

attr(`individual_trace_tokens_get`, 'returnType') = '_p_trace_token'
attr(`individual_trace_tokens_get`, "inputTypes") = c('_p_individual')
class(`individual_trace_tokens_get`) = c("SWIGFunction", class('individual_trace_tokens_get'))

# Start of individual_index_trace_token_set

`individual_index_trace_token_set` = function(self, s_index_trace_token)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_index_trace_token, "ExternalReference")) s_index_trace_token = slot(s_index_trace_token,"ref") 
  ;.Call('R_swig_individual_index_trace_token_set', self, s_index_trace_token, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_index_trace_token_set`, 'returnType') = 'void'
attr(`individual_index_trace_token_set`, "inputTypes") = c('_p_individual', '_p_trace_token')
class(`individual_index_trace_token_set`) = c("SWIGFunction", class('individual_index_trace_token_set'))

# Start of individual_index_trace_token_get

`individual_index_trace_token_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_individual_index_trace_token_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_trace_token", ref=ans) ;
  
  ans
  
}

attr(`individual_index_trace_token_get`, 'returnType') = '_p_trace_token'
attr(`individual_index_trace_token_get`, "inputTypes") = c('_p_individual')
class(`individual_index_trace_token_get`) = c("SWIGFunction", class('individual_index_trace_token_get'))

# Start of individual_index_token_release_event_set

`individual_index_token_release_event_set` = function(self, s_index_token_release_event)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_index_token_release_event, "ExternalReference")) s_index_token_release_event = slot(s_index_token_release_event,"ref") 
  ;.Call('R_swig_individual_index_token_release_event_set', self, s_index_token_release_event, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_index_token_release_event_set`, 'returnType') = 'void'
attr(`individual_index_token_release_event_set`, "inputTypes") = c('_p_individual', '_p_event')
class(`individual_index_token_release_event_set`) = c("SWIGFunction", class('individual_index_token_release_event_set'))

# Start of individual_index_token_release_event_get

`individual_index_token_release_event_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_individual_index_token_release_event_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_event", ref=ans) ;
  
  ans
  
}

attr(`individual_index_token_release_event_get`, 'returnType') = '_p_event'
attr(`individual_index_token_release_event_get`, "inputTypes") = c('_p_individual')
class(`individual_index_token_release_event_get`) = c("SWIGFunction", class('individual_index_token_release_event_get'))

# Start of individual_traced_on_this_trace_set

`individual_traced_on_this_trace_set` = function(self, s_traced_on_this_trace)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_individual_traced_on_this_trace_set', self, s_traced_on_this_trace, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_traced_on_this_trace_set`, 'returnType') = 'void'
attr(`individual_traced_on_this_trace_set`, "inputTypes") = c('_p_individual', 'numeric')
class(`individual_traced_on_this_trace_set`) = c("SWIGFunction", class('individual_traced_on_this_trace_set'))

# Start of individual_traced_on_this_trace_get

`individual_traced_on_this_trace_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_individual_traced_on_this_trace_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`individual_traced_on_this_trace_get`, 'returnType') = 'numeric'
attr(`individual_traced_on_this_trace_get`, "inputTypes") = c('_p_individual')
class(`individual_traced_on_this_trace_get`) = c("SWIGFunction", class('individual_traced_on_this_trace_get'))

# Start of individual_app_user_set

`individual_app_user_set` = function(self, s_app_user)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_app_user = as.integer(s_app_user);
  
  if(length(s_app_user) > 1) {
    warning("using only the first element of s_app_user");
  };
  
  ;.Call('R_swig_individual_app_user_set', self, s_app_user, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_app_user_set`, 'returnType') = 'void'
attr(`individual_app_user_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_app_user_set`) = c("SWIGFunction", class('individual_app_user_set'))

# Start of individual_app_user_get

`individual_app_user_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_individual_app_user_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`individual_app_user_get`, 'returnType') = 'integer'
attr(`individual_app_user_get`, "inputTypes") = c('_p_individual')
class(`individual_app_user_get`) = c("SWIGFunction", class('individual_app_user_get'))

# Start of individual_ward_idx_set

`individual_ward_idx_set` = function(self, s_ward_idx)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_ward_idx = as.integer(s_ward_idx);
  
  if(length(s_ward_idx) > 1) {
    warning("using only the first element of s_ward_idx");
  };
  
  ;.Call('R_swig_individual_ward_idx_set', self, s_ward_idx, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_ward_idx_set`, 'returnType') = 'void'
attr(`individual_ward_idx_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_ward_idx_set`) = c("SWIGFunction", class('individual_ward_idx_set'))

# Start of individual_ward_idx_get

`individual_ward_idx_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_individual_ward_idx_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`individual_ward_idx_get`, 'returnType') = 'integer'
attr(`individual_ward_idx_get`, "inputTypes") = c('_p_individual')
class(`individual_ward_idx_get`) = c("SWIGFunction", class('individual_ward_idx_get'))

# Start of individual_ward_type_set

`individual_ward_type_set` = function(self, s_ward_type)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_ward_type = as.integer(s_ward_type);
  
  if(length(s_ward_type) > 1) {
    warning("using only the first element of s_ward_type");
  };
  
  ;.Call('R_swig_individual_ward_type_set', self, s_ward_type, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_ward_type_set`, 'returnType') = 'void'
attr(`individual_ward_type_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_ward_type_set`) = c("SWIGFunction", class('individual_ward_type_set'))

# Start of individual_ward_type_get

`individual_ward_type_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_individual_ward_type_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`individual_ward_type_get`, 'returnType') = 'integer'
attr(`individual_ward_type_get`, "inputTypes") = c('_p_individual')
class(`individual_ward_type_get`) = c("SWIGFunction", class('individual_ward_type_get'))

# Start of individual_hospital_idx_set

`individual_hospital_idx_set` = function(self, s_hospital_idx)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_hospital_idx = as.integer(s_hospital_idx);
  
  if(length(s_hospital_idx) > 1) {
    warning("using only the first element of s_hospital_idx");
  };
  
  ;.Call('R_swig_individual_hospital_idx_set', self, s_hospital_idx, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_hospital_idx_set`, 'returnType') = 'void'
attr(`individual_hospital_idx_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_hospital_idx_set`) = c("SWIGFunction", class('individual_hospital_idx_set'))

# Start of individual_hospital_idx_get

`individual_hospital_idx_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_individual_hospital_idx_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`individual_hospital_idx_get`, 'returnType') = 'integer'
attr(`individual_hospital_idx_get`, "inputTypes") = c('_p_individual')
class(`individual_hospital_idx_get`) = c("SWIGFunction", class('individual_hospital_idx_get'))

# Start of individual_hospital_state_set

`individual_hospital_state_set` = function(self, s_hospital_state)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_hospital_state = as.integer(s_hospital_state);
  
  if(length(s_hospital_state) > 1) {
    warning("using only the first element of s_hospital_state");
  };
  
  ;.Call('R_swig_individual_hospital_state_set', self, s_hospital_state, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_hospital_state_set`, 'returnType') = 'void'
attr(`individual_hospital_state_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_hospital_state_set`) = c("SWIGFunction", class('individual_hospital_state_set'))

# Start of individual_hospital_state_get

`individual_hospital_state_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_individual_hospital_state_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`individual_hospital_state_get`, 'returnType') = 'integer'
attr(`individual_hospital_state_get`, "inputTypes") = c('_p_individual')
class(`individual_hospital_state_get`) = c("SWIGFunction", class('individual_hospital_state_get'))

# Start of individual_disease_progression_predicted_set

`individual_disease_progression_predicted_set` = function(self, s_disease_progression_predicted)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_disease_progression_predicted = as.integer(s_disease_progression_predicted);
  
#  assert(length(s_disease_progression_predicted) >= N_HOSPITAL_WARD_TYPES)
  
  ;.Call('R_swig_individual_disease_progression_predicted_set', self, s_disease_progression_predicted, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_disease_progression_predicted_set`, 'returnType') = 'void'
attr(`individual_disease_progression_predicted_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_disease_progression_predicted_set`) = c("SWIGFunction", class('individual_disease_progression_predicted_set'))

# Start of individual_disease_progression_predicted_get

`individual_disease_progression_predicted_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_individual_disease_progression_predicted_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  ans <- new("_p_short", ref=ans) ;
  
  ans
  
}

attr(`individual_disease_progression_predicted_get`, 'returnType') = 'integer'
attr(`individual_disease_progression_predicted_get`, "inputTypes") = c('_p_individual')
class(`individual_disease_progression_predicted_get`) = c("SWIGFunction", class('individual_disease_progression_predicted_get'))

# Start of individual_current_hospital_event_set

`individual_current_hospital_event_set` = function(self, s_current_hospital_event)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_current_hospital_event, "ExternalReference")) s_current_hospital_event = slot(s_current_hospital_event,"ref") 
  ;.Call('R_swig_individual_current_hospital_event_set', self, s_current_hospital_event, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_current_hospital_event_set`, 'returnType') = 'void'
attr(`individual_current_hospital_event_set`, "inputTypes") = c('_p_individual', '_p_event')
class(`individual_current_hospital_event_set`) = c("SWIGFunction", class('individual_current_hospital_event_set'))

# Start of individual_current_hospital_event_get

`individual_current_hospital_event_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_individual_current_hospital_event_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_event", ref=ans) ;
  
  ans
  
}

attr(`individual_current_hospital_event_get`, 'returnType') = '_p_event'
attr(`individual_current_hospital_event_get`, "inputTypes") = c('_p_individual')
class(`individual_current_hospital_event_get`) = c("SWIGFunction", class('individual_current_hospital_event_get'))

# Start of individual_next_hospital_event_set

`individual_next_hospital_event_set` = function(self, s_next_hospital_event)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_next_hospital_event, "ExternalReference")) s_next_hospital_event = slot(s_next_hospital_event,"ref") 
  ;.Call('R_swig_individual_next_hospital_event_set', self, s_next_hospital_event, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_next_hospital_event_set`, 'returnType') = 'void'
attr(`individual_next_hospital_event_set`, "inputTypes") = c('_p_individual', '_p_event')
class(`individual_next_hospital_event_set`) = c("SWIGFunction", class('individual_next_hospital_event_set'))

# Start of individual_next_hospital_event_get

`individual_next_hospital_event_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_individual_next_hospital_event_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_event", ref=ans) ;
  
  ans
  
}

attr(`individual_next_hospital_event_get`, 'returnType') = '_p_event'
attr(`individual_next_hospital_event_get`, "inputTypes") = c('_p_individual')
class(`individual_next_hospital_event_get`) = c("SWIGFunction", class('individual_next_hospital_event_get'))

# Start of individual_worker_type_set

`individual_worker_type_set` = function(self, s_worker_type)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_worker_type = as.integer(s_worker_type);
  
  if(length(s_worker_type) > 1) {
    warning("using only the first element of s_worker_type");
  };
  
  ;.Call('R_swig_individual_worker_type_set', self, s_worker_type, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_worker_type_set`, 'returnType') = 'void'
attr(`individual_worker_type_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_worker_type_set`) = c("SWIGFunction", class('individual_worker_type_set'))

# Start of individual_worker_type_get

`individual_worker_type_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_individual_worker_type_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`individual_worker_type_get`, 'returnType') = 'integer'
attr(`individual_worker_type_get`, "inputTypes") = c('_p_individual')
class(`individual_worker_type_get`) = c("SWIGFunction", class('individual_worker_type_get'))

# Start of individual_vaccine_status_set

`individual_vaccine_status_set` = function(self, s_vaccine_status)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_vaccine_status = as.integer(s_vaccine_status);
  
  if(length(s_vaccine_status) > 1) {
    warning("using only the first element of s_vaccine_status");
  };
  
  ;.Call('R_swig_individual_vaccine_status_set', self, s_vaccine_status, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_vaccine_status_set`, 'returnType') = 'void'
attr(`individual_vaccine_status_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_vaccine_status_set`) = c("SWIGFunction", class('individual_vaccine_status_set'))

# Start of individual_vaccine_status_get

`individual_vaccine_status_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_individual_vaccine_status_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`individual_vaccine_status_get`, 'returnType') = 'integer'
attr(`individual_vaccine_status_get`, "inputTypes") = c('_p_individual')
class(`individual_vaccine_status_get`) = c("SWIGFunction", class('individual_vaccine_status_get'))

# Start of individual_immune_full_set

`individual_immune_full_set` = function(self, s_immune_full)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_immune_full = as.integer(s_immune_full);
  ;.Call('R_swig_individual_immune_full_set', self, s_immune_full, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_immune_full_set`, 'returnType') = 'void'
attr(`individual_immune_full_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_immune_full_set`) = c("SWIGFunction", class('individual_immune_full_set'))

# Start of individual_immune_full_get

`individual_immune_full_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_individual_immune_full_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_short", ref=ans) ;
  
  ans
  
}

attr(`individual_immune_full_get`, 'returnType') = 'integer'
attr(`individual_immune_full_get`, "inputTypes") = c('_p_individual')
class(`individual_immune_full_get`) = c("SWIGFunction", class('individual_immune_full_get'))

# Start of individual_immune_to_symptoms_set

`individual_immune_to_symptoms_set` = function(self, s_immune_to_symptoms)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_immune_to_symptoms = as.integer(s_immune_to_symptoms);
  ;.Call('R_swig_individual_immune_to_symptoms_set', self, s_immune_to_symptoms, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_immune_to_symptoms_set`, 'returnType') = 'void'
attr(`individual_immune_to_symptoms_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_immune_to_symptoms_set`) = c("SWIGFunction", class('individual_immune_to_symptoms_set'))

# Start of individual_immune_to_symptoms_get

`individual_immune_to_symptoms_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_individual_immune_to_symptoms_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_short", ref=ans) ;
  
  ans
  
}

attr(`individual_immune_to_symptoms_get`, 'returnType') = 'integer'
attr(`individual_immune_to_symptoms_get`, "inputTypes") = c('_p_individual')
class(`individual_immune_to_symptoms_get`) = c("SWIGFunction", class('individual_immune_to_symptoms_get'))

# Start of individual_immune_to_severe_set

`individual_immune_to_severe_set` = function(self, s_immune_to_severe)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_immune_to_severe = as.integer(s_immune_to_severe);
  ;.Call('R_swig_individual_immune_to_severe_set', self, s_immune_to_severe, PACKAGE='OpenABMCovid19');
  
}

attr(`individual_immune_to_severe_set`, 'returnType') = 'void'
attr(`individual_immune_to_severe_set`, "inputTypes") = c('_p_individual', 'integer')
class(`individual_immune_to_severe_set`) = c("SWIGFunction", class('individual_immune_to_severe_set'))

# Start of individual_immune_to_severe_get

`individual_immune_to_severe_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_individual_immune_to_severe_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_short", ref=ans) ;
  
  ans
  
}

attr(`individual_immune_to_severe_get`, 'returnType') = 'integer'
attr(`individual_immune_to_severe_get`, "inputTypes") = c('_p_individual')
class(`individual_immune_to_severe_get`) = c("SWIGFunction", class('individual_immune_to_severe_get'))

# Start of accessor method for individual
setMethod('$', '_p_individual', function(x, name)

{
  accessorFuns = list('idx' = individual_idx_get, 'house_no' = individual_house_no_get, 'age_group' = individual_age_group_get, 'age_type' = individual_age_type_get, 'occupation_network' = individual_occupation_network_get, 'base_random_interactions' = individual_base_random_interactions_get, 'random_interactions' = individual_random_interactions_get, 'n_interactions' = individual_n_interactions_get, 'interactions' = individual_interactions_get, 'status' = individual_status_get, 'hazard' = individual_hazard_get, 'infectiousness_multiplier' = individual_infectiousness_multiplier_get, 'current_disease_event' = individual_current_disease_event_get, 'next_disease_event' = individual_next_disease_event_get, 'infection_events' = individual_infection_events_get, 'quarantined' = individual_quarantined_get, 'quarantine_event' = individual_quarantine_event_get, 'quarantine_release_event' = individual_quarantine_release_event_get, 'quarantine_test_result' = individual_quarantine_test_result_get, 'trace_tokens' = individual_trace_tokens_get, 'index_trace_token' = individual_index_trace_token_get, 'index_token_release_event' = individual_index_token_release_event_get, 'traced_on_this_trace' = individual_traced_on_this_trace_get, 'app_user' = individual_app_user_get, 'ward_idx' = individual_ward_idx_get, 'ward_type' = individual_ward_type_get, 'hospital_idx' = individual_hospital_idx_get, 'hospital_state' = individual_hospital_state_get, 'disease_progression_predicted' = individual_disease_progression_predicted_get, 'current_hospital_event' = individual_current_hospital_event_get, 'next_hospital_event' = individual_next_hospital_event_get, 'worker_type' = individual_worker_type_get, 'vaccine_status' = individual_vaccine_status_get, 'immune_full' = individual_immune_full_get, 'immune_to_symptoms' = individual_immune_to_symptoms_get, 'immune_to_severe' = individual_immune_to_severe_get);
  vaccessors = c('idx', 'house_no', 'age_group', 'age_type', 'occupation_network', 'base_random_interactions', 'random_interactions', 'n_interactions', 'interactions', 'status', 'hazard', 'infectiousness_multiplier', 'current_disease_event', 'next_disease_event', 'infection_events', 'quarantined', 'quarantine_event', 'quarantine_release_event', 'quarantine_test_result', 'trace_tokens', 'index_trace_token', 'index_token_release_event', 'traced_on_this_trace', 'app_user', 'ward_idx', 'ward_type', 'hospital_idx', 'hospital_state', 'disease_progression_predicted', 'current_hospital_event', 'next_hospital_event', 'worker_type', 'vaccine_status', 'immune_full', 'immune_to_symptoms', 'immune_to_severe');
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  if (is.na(match(name, vaccessors))) function(...){
    f(x, ...)
  } else f(x);
}


);
# end of accessor method for individual
# Start of accessor method for individual
setMethod('$<-', '_p_individual', function(x, name, value)

{
  accessorFuns = list('idx' = individual_idx_set, 'house_no' = individual_house_no_set, 'age_group' = individual_age_group_set, 'age_type' = individual_age_type_set, 'occupation_network' = individual_occupation_network_set, 'base_random_interactions' = individual_base_random_interactions_set, 'random_interactions' = individual_random_interactions_set, 'n_interactions' = individual_n_interactions_set, 'interactions' = individual_interactions_set, 'status' = individual_status_set, 'hazard' = individual_hazard_set, 'infectiousness_multiplier' = individual_infectiousness_multiplier_set, 'current_disease_event' = individual_current_disease_event_set, 'next_disease_event' = individual_next_disease_event_set, 'infection_events' = individual_infection_events_set, 'quarantined' = individual_quarantined_set, 'quarantine_event' = individual_quarantine_event_set, 'quarantine_release_event' = individual_quarantine_release_event_set, 'quarantine_test_result' = individual_quarantine_test_result_set, 'trace_tokens' = individual_trace_tokens_set, 'index_trace_token' = individual_index_trace_token_set, 'index_token_release_event' = individual_index_token_release_event_set, 'traced_on_this_trace' = individual_traced_on_this_trace_set, 'app_user' = individual_app_user_set, 'ward_idx' = individual_ward_idx_set, 'ward_type' = individual_ward_type_set, 'hospital_idx' = individual_hospital_idx_set, 'hospital_state' = individual_hospital_state_set, 'disease_progression_predicted' = individual_disease_progression_predicted_set, 'current_hospital_event' = individual_current_hospital_event_set, 'next_hospital_event' = individual_next_hospital_event_set, 'worker_type' = individual_worker_type_set, 'vaccine_status' = individual_vaccine_status_set, 'immune_full' = individual_immune_full_set, 'immune_to_symptoms' = individual_immune_to_symptoms_set, 'immune_to_severe' = individual_immune_to_severe_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
setMethod('[[<-', c('_p_individual', 'character'),function(x, i, j, ..., value)

{
  name = i;
  accessorFuns = list('idx' = individual_idx_set, 'house_no' = individual_house_no_set, 'age_group' = individual_age_group_set, 'age_type' = individual_age_type_set, 'occupation_network' = individual_occupation_network_set, 'base_random_interactions' = individual_base_random_interactions_set, 'random_interactions' = individual_random_interactions_set, 'n_interactions' = individual_n_interactions_set, 'interactions' = individual_interactions_set, 'status' = individual_status_set, 'hazard' = individual_hazard_set, 'infectiousness_multiplier' = individual_infectiousness_multiplier_set, 'current_disease_event' = individual_current_disease_event_set, 'next_disease_event' = individual_next_disease_event_set, 'infection_events' = individual_infection_events_set, 'quarantined' = individual_quarantined_set, 'quarantine_event' = individual_quarantine_event_set, 'quarantine_release_event' = individual_quarantine_release_event_set, 'quarantine_test_result' = individual_quarantine_test_result_set, 'trace_tokens' = individual_trace_tokens_set, 'index_trace_token' = individual_index_trace_token_set, 'index_token_release_event' = individual_index_token_release_event_set, 'traced_on_this_trace' = individual_traced_on_this_trace_set, 'app_user' = individual_app_user_set, 'ward_idx' = individual_ward_idx_set, 'ward_type' = individual_ward_type_set, 'hospital_idx' = individual_hospital_idx_set, 'hospital_state' = individual_hospital_state_set, 'disease_progression_predicted' = individual_disease_progression_predicted_set, 'current_hospital_event' = individual_current_hospital_event_set, 'next_hospital_event' = individual_next_hospital_event_set, 'worker_type' = individual_worker_type_set, 'vaccine_status' = individual_vaccine_status_set, 'immune_full' = individual_immune_full_set, 'immune_to_symptoms' = individual_immune_to_symptoms_set, 'immune_to_severe' = individual_immune_to_severe_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
# end of accessor method for individual
# Start definition of copy functions & methods for individual
CopyToR_individual = function(value, obj = new("individual"))
{
  obj@idx = value$idx;
  obj@house_no = value$house_no;
  obj@age_group = value$age_group;
  obj@age_type = value$age_type;
  obj@occupation_network = value$occupation_network;
  obj@base_random_interactions = value$base_random_interactions;
  obj@random_interactions = value$random_interactions;
  obj@status = value$status;
  obj@infectiousness_multiplier = value$infectiousness_multiplier;
  obj@quarantined = value$quarantined;
  obj@quarantine_test_result = value$quarantine_test_result;
  obj@traced_on_this_trace = value$traced_on_this_trace;
  obj@app_user = value$app_user;
  obj@ward_idx = value$ward_idx;
  obj@ward_type = value$ward_type;
  obj@hospital_idx = value$hospital_idx;
  obj@hospital_state = value$hospital_state;
  obj@disease_progression_predicted = value$disease_progression_predicted;
  obj@worker_type = value$worker_type;
  obj@vaccine_status = value$vaccine_status;
  obj;
}



CopyToC_individual = function(value, obj)
{
  obj$idx = value@idx;
  obj$house_no = value@house_no;
  obj$age_group = value@age_group;
  obj$age_type = value@age_type;
  obj$occupation_network = value@occupation_network;
  obj$base_random_interactions = value@base_random_interactions;
  obj$random_interactions = value@random_interactions;
  obj$status = value@status;
  obj$infectiousness_multiplier = value@infectiousness_multiplier;
  obj$quarantined = value@quarantined;
  obj$quarantine_test_result = value@quarantine_test_result;
  obj$traced_on_this_trace = value@traced_on_this_trace;
  obj$app_user = value@app_user;
  obj$ward_idx = value@ward_idx;
  obj$ward_type = value@ward_type;
  obj$hospital_idx = value@hospital_idx;
  obj$hospital_state = value@hospital_state;
  obj$disease_progression_predicted = value@disease_progression_predicted;
  obj$worker_type = value@worker_type;
  obj$vaccine_status = value@vaccine_status;
  obj
}



# Start definition of copy methods for individual
setMethod('copyToR', '_p_individual', CopyToR_individual);
setMethod('copyToC', 'individual', CopyToC_individual);

# End definition of copy methods for individual
# End definition of copy functions & methods for individual
# Start of interaction_type_set

`interaction_type_set` = function(self, s_type)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_type = as.integer(s_type);
  
  if(length(s_type) > 1) {
    warning("using only the first element of s_type");
  };
  
  ;.Call('R_swig_interaction_type_set', self, s_type, PACKAGE='OpenABMCovid19');
  
}

attr(`interaction_type_set`, 'returnType') = 'void'
attr(`interaction_type_set`, "inputTypes") = c('_p_interaction', 'integer')
class(`interaction_type_set`) = c("SWIGFunction", class('interaction_type_set'))

# Start of interaction_type_get

`interaction_type_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_interaction_type_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`interaction_type_get`, 'returnType') = 'integer'
attr(`interaction_type_get`, "inputTypes") = c('_p_interaction')
class(`interaction_type_get`) = c("SWIGFunction", class('interaction_type_get'))

# Start of interaction_network_id_set

`interaction_network_id_set` = function(self, s_network_id)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_network_id = as.integer(s_network_id);
  
  if(length(s_network_id) > 1) {
    warning("using only the first element of s_network_id");
  };
  
  ;.Call('R_swig_interaction_network_id_set', self, s_network_id, PACKAGE='OpenABMCovid19');
  
}

attr(`interaction_network_id_set`, 'returnType') = 'void'
attr(`interaction_network_id_set`, "inputTypes") = c('_p_interaction', 'integer')
class(`interaction_network_id_set`) = c("SWIGFunction", class('interaction_network_id_set'))

# Start of interaction_network_id_get

`interaction_network_id_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_interaction_network_id_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`interaction_network_id_get`, 'returnType') = 'integer'
attr(`interaction_network_id_get`, "inputTypes") = c('_p_interaction')
class(`interaction_network_id_get`) = c("SWIGFunction", class('interaction_network_id_get'))

# Start of interaction_traceable_set

`interaction_traceable_set` = function(self, s_traceable)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_traceable = as.integer(s_traceable);
  
  if(length(s_traceable) > 1) {
    warning("using only the first element of s_traceable");
  };
  
  ;.Call('R_swig_interaction_traceable_set', self, s_traceable, PACKAGE='OpenABMCovid19');
  
}

attr(`interaction_traceable_set`, 'returnType') = 'void'
attr(`interaction_traceable_set`, "inputTypes") = c('_p_interaction', 'integer')
class(`interaction_traceable_set`) = c("SWIGFunction", class('interaction_traceable_set'))

# Start of interaction_traceable_get

`interaction_traceable_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_interaction_traceable_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`interaction_traceable_get`, 'returnType') = 'integer'
attr(`interaction_traceable_get`, "inputTypes") = c('_p_interaction')
class(`interaction_traceable_get`) = c("SWIGFunction", class('interaction_traceable_get'))

# Start of interaction_manual_traceable_set

`interaction_manual_traceable_set` = function(self, s_manual_traceable)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_manual_traceable = as.integer(s_manual_traceable);
  
  if(length(s_manual_traceable) > 1) {
    warning("using only the first element of s_manual_traceable");
  };
  
  ;.Call('R_swig_interaction_manual_traceable_set', self, s_manual_traceable, PACKAGE='OpenABMCovid19');
  
}

attr(`interaction_manual_traceable_set`, 'returnType') = 'void'
attr(`interaction_manual_traceable_set`, "inputTypes") = c('_p_interaction', 'integer')
class(`interaction_manual_traceable_set`) = c("SWIGFunction", class('interaction_manual_traceable_set'))

# Start of interaction_manual_traceable_get

`interaction_manual_traceable_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_interaction_manual_traceable_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`interaction_manual_traceable_get`, 'returnType') = 'integer'
attr(`interaction_manual_traceable_get`, "inputTypes") = c('_p_interaction')
class(`interaction_manual_traceable_get`) = c("SWIGFunction", class('interaction_manual_traceable_get'))

# Start of interaction_individual_set

`interaction_individual_set` = function(self, s_individual)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_individual, "ExternalReference")) s_individual = slot(s_individual,"ref") 
  ;.Call('R_swig_interaction_individual_set', self, s_individual, PACKAGE='OpenABMCovid19');
  
}

attr(`interaction_individual_set`, 'returnType') = 'void'
attr(`interaction_individual_set`, "inputTypes") = c('_p_interaction', '_p_individual')
class(`interaction_individual_set`) = c("SWIGFunction", class('interaction_individual_set'))

# Start of interaction_individual_get

`interaction_individual_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_interaction_individual_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_individual", ref=ans) ;
  
  ans
  
}

attr(`interaction_individual_get`, 'returnType') = '_p_individual'
attr(`interaction_individual_get`, "inputTypes") = c('_p_interaction')
class(`interaction_individual_get`) = c("SWIGFunction", class('interaction_individual_get'))

# Start of interaction__next_set

`interaction__next_set` = function(self, s_arg2)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_interaction__next_set', self, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`interaction__next_set`, 'returnType') = 'void'
attr(`interaction__next_set`, "inputTypes") = c('_p_interaction', '_p_interaction')
class(`interaction__next_set`) = c("SWIGFunction", class('interaction__next_set'))

# Start of interaction__next_get

`interaction__next_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_interaction__next_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_interaction", ref=ans) ;
  
  ans
  
}

attr(`interaction__next_get`, 'returnType') = '_p_interaction'
attr(`interaction__next_get`, "inputTypes") = c('_p_interaction')
class(`interaction__next_get`) = c("SWIGFunction", class('interaction__next_get'))

# Start of accessor method for interaction
setMethod('$', '_p_interaction', function(x, name)

{
  accessorFuns = list('type' = interaction_type_get, 'network_id' = interaction_network_id_get, 'traceable' = interaction_traceable_get, 'manual_traceable' = interaction_manual_traceable_get, 'individual' = interaction_individual_get, '_next' = interaction__next_get);
  vaccessors = c('type', 'network_id', 'traceable', 'manual_traceable', 'individual', '_next');
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  if (is.na(match(name, vaccessors))) function(...){
    f(x, ...)
  } else f(x);
}


);
# end of accessor method for interaction
# Start of accessor method for interaction
setMethod('$<-', '_p_interaction', function(x, name, value)

{
  accessorFuns = list('type' = interaction_type_set, 'network_id' = interaction_network_id_set, 'traceable' = interaction_traceable_set, 'manual_traceable' = interaction_manual_traceable_set, 'individual' = interaction_individual_set, '_next' = interaction__next_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
setMethod('[[<-', c('_p_interaction', 'character'),function(x, i, j, ..., value)

{
  name = i;
  accessorFuns = list('type' = interaction_type_set, 'network_id' = interaction_network_id_set, 'traceable' = interaction_traceable_set, 'manual_traceable' = interaction_manual_traceable_set, 'individual' = interaction_individual_set, '_next' = interaction__next_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
# end of accessor method for interaction
# Start definition of copy functions & methods for interaction
CopyToR_interaction = function(value, obj = new("interaction"))
{
  obj@type = value$type;
  obj@network_id = value$network_id;
  obj@traceable = value$traceable;
  obj@manual_traceable = value$manual_traceable;
  obj;
}



CopyToC_interaction = function(value, obj)
{
  obj$type = value@type;
  obj$network_id = value@network_id;
  obj$traceable = value@traceable;
  obj$manual_traceable = value@manual_traceable;
  obj
}



# Start definition of copy methods for interaction
setMethod('copyToR', '_p_interaction', CopyToR_interaction);
setMethod('copyToC', 'interaction', CopyToC_interaction);

# End definition of copy methods for interaction
# End definition of copy functions & methods for interaction
# Start of interaction_block_interactions_set

`interaction_block_interactions_set` = function(self, s_interactions)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_interactions, "ExternalReference")) s_interactions = slot(s_interactions,"ref") 
  ;.Call('R_swig_interaction_block_interactions_set', self, s_interactions, PACKAGE='OpenABMCovid19');
  
}

attr(`interaction_block_interactions_set`, 'returnType') = 'void'
attr(`interaction_block_interactions_set`, "inputTypes") = c('_p_interaction_block', '_p_interaction')
class(`interaction_block_interactions_set`) = c("SWIGFunction", class('interaction_block_interactions_set'))

# Start of interaction_block_interactions_get

`interaction_block_interactions_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_interaction_block_interactions_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_interaction", ref=ans) ;
  
  ans
  
}

attr(`interaction_block_interactions_get`, 'returnType') = '_p_interaction'
attr(`interaction_block_interactions_get`, "inputTypes") = c('_p_interaction_block')
class(`interaction_block_interactions_get`) = c("SWIGFunction", class('interaction_block_interactions_get'))

# Start of interaction_block_n_interactions_set

`interaction_block_n_interactions_set` = function(self, s_n_interactions)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_interactions = as.integer(s_n_interactions);
  
  if(length(s_n_interactions) > 1) {
    warning("using only the first element of s_n_interactions");
  };
  
  ;.Call('R_swig_interaction_block_n_interactions_set', self, s_n_interactions, PACKAGE='OpenABMCovid19');
  
}

attr(`interaction_block_n_interactions_set`, 'returnType') = 'void'
attr(`interaction_block_n_interactions_set`, "inputTypes") = c('_p_interaction_block', 'integer')
class(`interaction_block_n_interactions_set`) = c("SWIGFunction", class('interaction_block_n_interactions_set'))

# Start of interaction_block_n_interactions_get

`interaction_block_n_interactions_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_interaction_block_n_interactions_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`interaction_block_n_interactions_get`, 'returnType') = 'integer'
attr(`interaction_block_n_interactions_get`, "inputTypes") = c('_p_interaction_block')
class(`interaction_block_n_interactions_get`) = c("SWIGFunction", class('interaction_block_n_interactions_get'))

# Start of interaction_block_idx_set

`interaction_block_idx_set` = function(self, s_idx)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_idx = as.integer(s_idx);
  
  if(length(s_idx) > 1) {
    warning("using only the first element of s_idx");
  };
  
  ;.Call('R_swig_interaction_block_idx_set', self, s_idx, PACKAGE='OpenABMCovid19');
  
}

attr(`interaction_block_idx_set`, 'returnType') = 'void'
attr(`interaction_block_idx_set`, "inputTypes") = c('_p_interaction_block', 'integer')
class(`interaction_block_idx_set`) = c("SWIGFunction", class('interaction_block_idx_set'))

# Start of interaction_block_idx_get

`interaction_block_idx_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_interaction_block_idx_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`interaction_block_idx_get`, 'returnType') = 'integer'
attr(`interaction_block_idx_get`, "inputTypes") = c('_p_interaction_block')
class(`interaction_block_idx_get`) = c("SWIGFunction", class('interaction_block_idx_get'))

# Start of interaction_block__next_set

`interaction_block__next_set` = function(self, s_arg2)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_interaction_block__next_set', self, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`interaction_block__next_set`, 'returnType') = 'void'
attr(`interaction_block__next_set`, "inputTypes") = c('_p_interaction_block', '_p_interaction_block')
class(`interaction_block__next_set`) = c("SWIGFunction", class('interaction_block__next_set'))

# Start of interaction_block__next_get

`interaction_block__next_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_interaction_block__next_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_interaction_block", ref=ans) ;
  
  ans
  
}

attr(`interaction_block__next_get`, 'returnType') = '_p_interaction_block'
attr(`interaction_block__next_get`, "inputTypes") = c('_p_interaction_block')
class(`interaction_block__next_get`) = c("SWIGFunction", class('interaction_block__next_get'))

# Start of accessor method for interaction_block
setMethod('$', '_p_interaction_block', function(x, name)

{
  accessorFuns = list('interactions' = interaction_block_interactions_get, 'n_interactions' = interaction_block_n_interactions_get, 'idx' = interaction_block_idx_get, '_next' = interaction_block__next_get);
  vaccessors = c('interactions', 'n_interactions', 'idx', '_next');
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  if (is.na(match(name, vaccessors))) function(...){
    f(x, ...)
  } else f(x);
}


);
# end of accessor method for interaction_block
# Start of accessor method for interaction_block
setMethod('$<-', '_p_interaction_block', function(x, name, value)

{
  accessorFuns = list('interactions' = interaction_block_interactions_set, 'n_interactions' = interaction_block_n_interactions_set, 'idx' = interaction_block_idx_set, '_next' = interaction_block__next_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
setMethod('[[<-', c('_p_interaction_block', 'character'),function(x, i, j, ..., value)

{
  name = i;
  accessorFuns = list('interactions' = interaction_block_interactions_set, 'n_interactions' = interaction_block_n_interactions_set, 'idx' = interaction_block_idx_set, '_next' = interaction_block__next_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
# end of accessor method for interaction_block
# Start definition of copy functions & methods for interaction_block
CopyToR_interaction_block = function(value, obj = new("interaction_block"))
{
  obj@n_interactions = value$n_interactions;
  obj@idx = value$idx;
  obj;
}



CopyToC_interaction_block = function(value, obj)
{
  obj$n_interactions = value@n_interactions;
  obj$idx = value@idx;
  obj
}



# Start definition of copy methods for interaction_block
setMethod('copyToR', '_p_interaction_block', CopyToR_interaction_block);
setMethod('copyToC', 'interaction_block', CopyToC_interaction_block);

# End definition of copy methods for interaction_block
# End definition of copy functions & methods for interaction_block
# Start of infection_event_times_set

`infection_event_times_set` = function(self, s_times)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_times = as.integer(s_times);
  ;.Call('R_swig_infection_event_times_set', self, s_times, PACKAGE='OpenABMCovid19');
  
}

attr(`infection_event_times_set`, 'returnType') = 'void'
attr(`infection_event_times_set`, "inputTypes") = c('_p_infection_event', 'integer')
class(`infection_event_times_set`) = c("SWIGFunction", class('infection_event_times_set'))

# Start of infection_event_times_get

`infection_event_times_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_infection_event_times_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_short", ref=ans) ;
  
  ans
  
}

attr(`infection_event_times_get`, 'returnType') = 'integer'
attr(`infection_event_times_get`, "inputTypes") = c('_p_infection_event')
class(`infection_event_times_get`) = c("SWIGFunction", class('infection_event_times_get'))

# Start of infection_event_infector_set

`infection_event_infector_set` = function(self, s_infector)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_infector, "ExternalReference")) s_infector = slot(s_infector,"ref") 
  ;.Call('R_swig_infection_event_infector_set', self, s_infector, PACKAGE='OpenABMCovid19');
  
}

attr(`infection_event_infector_set`, 'returnType') = 'void'
attr(`infection_event_infector_set`, "inputTypes") = c('_p_infection_event', '_p_individual')
class(`infection_event_infector_set`) = c("SWIGFunction", class('infection_event_infector_set'))

# Start of infection_event_infector_get

`infection_event_infector_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_infection_event_infector_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_individual", ref=ans) ;
  
  ans
  
}

attr(`infection_event_infector_get`, 'returnType') = '_p_individual'
attr(`infection_event_infector_get`, "inputTypes") = c('_p_infection_event')
class(`infection_event_infector_get`) = c("SWIGFunction", class('infection_event_infector_get'))

# Start of infection_event_infector_status_set

`infection_event_infector_status_set` = function(self, s_infector_status)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_infector_status = as.integer(s_infector_status);
  
  if(length(s_infector_status) > 1) {
    warning("using only the first element of s_infector_status");
  };
  
  ;.Call('R_swig_infection_event_infector_status_set', self, s_infector_status, PACKAGE='OpenABMCovid19');
  
}

attr(`infection_event_infector_status_set`, 'returnType') = 'void'
attr(`infection_event_infector_status_set`, "inputTypes") = c('_p_infection_event', 'integer')
class(`infection_event_infector_status_set`) = c("SWIGFunction", class('infection_event_infector_status_set'))

# Start of infection_event_infector_status_get

`infection_event_infector_status_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_infection_event_infector_status_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`infection_event_infector_status_get`, 'returnType') = 'integer'
attr(`infection_event_infector_status_get`, "inputTypes") = c('_p_infection_event')
class(`infection_event_infector_status_get`) = c("SWIGFunction", class('infection_event_infector_status_get'))

# Start of infection_event_infector_hospital_state_set

`infection_event_infector_hospital_state_set` = function(self, s_infector_hospital_state)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_infector_hospital_state = as.integer(s_infector_hospital_state);
  
  if(length(s_infector_hospital_state) > 1) {
    warning("using only the first element of s_infector_hospital_state");
  };
  
  ;.Call('R_swig_infection_event_infector_hospital_state_set', self, s_infector_hospital_state, PACKAGE='OpenABMCovid19');
  
}

attr(`infection_event_infector_hospital_state_set`, 'returnType') = 'void'
attr(`infection_event_infector_hospital_state_set`, "inputTypes") = c('_p_infection_event', 'integer')
class(`infection_event_infector_hospital_state_set`) = c("SWIGFunction", class('infection_event_infector_hospital_state_set'))

# Start of infection_event_infector_hospital_state_get

`infection_event_infector_hospital_state_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_infection_event_infector_hospital_state_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`infection_event_infector_hospital_state_get`, 'returnType') = 'integer'
attr(`infection_event_infector_hospital_state_get`, "inputTypes") = c('_p_infection_event')
class(`infection_event_infector_hospital_state_get`) = c("SWIGFunction", class('infection_event_infector_hospital_state_get'))

# Start of infection_event_infector_network_set

`infection_event_infector_network_set` = function(self, s_infector_network)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_infector_network = as.integer(s_infector_network);
  
  if(length(s_infector_network) > 1) {
    warning("using only the first element of s_infector_network");
  };
  
  ;.Call('R_swig_infection_event_infector_network_set', self, s_infector_network, PACKAGE='OpenABMCovid19');
  
}

attr(`infection_event_infector_network_set`, 'returnType') = 'void'
attr(`infection_event_infector_network_set`, "inputTypes") = c('_p_infection_event', 'integer')
class(`infection_event_infector_network_set`) = c("SWIGFunction", class('infection_event_infector_network_set'))

# Start of infection_event_infector_network_get

`infection_event_infector_network_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_infection_event_infector_network_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`infection_event_infector_network_get`, 'returnType') = 'integer'
attr(`infection_event_infector_network_get`, "inputTypes") = c('_p_infection_event')
class(`infection_event_infector_network_get`) = c("SWIGFunction", class('infection_event_infector_network_get'))

# Start of infection_event_time_infected_infector_set

`infection_event_time_infected_infector_set` = function(self, s_time_infected_infector)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_time_infected_infector = as.integer(s_time_infected_infector);
  
  if(length(s_time_infected_infector) > 1) {
    warning("using only the first element of s_time_infected_infector");
  };
  
  ;.Call('R_swig_infection_event_time_infected_infector_set', self, s_time_infected_infector, PACKAGE='OpenABMCovid19');
  
}

attr(`infection_event_time_infected_infector_set`, 'returnType') = 'void'
attr(`infection_event_time_infected_infector_set`, "inputTypes") = c('_p_infection_event', 'integer')
class(`infection_event_time_infected_infector_set`) = c("SWIGFunction", class('infection_event_time_infected_infector_set'))

# Start of infection_event_time_infected_infector_get

`infection_event_time_infected_infector_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_infection_event_time_infected_infector_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`infection_event_time_infected_infector_get`, 'returnType') = 'integer'
attr(`infection_event_time_infected_infector_get`, "inputTypes") = c('_p_infection_event')
class(`infection_event_time_infected_infector_get`) = c("SWIGFunction", class('infection_event_time_infected_infector_get'))

# Start of infection_event__next_set

`infection_event__next_set` = function(self, s_arg2)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_infection_event__next_set', self, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`infection_event__next_set`, 'returnType') = 'void'
attr(`infection_event__next_set`, "inputTypes") = c('_p_infection_event', '_p_infection_event')
class(`infection_event__next_set`) = c("SWIGFunction", class('infection_event__next_set'))

# Start of infection_event__next_get

`infection_event__next_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_infection_event__next_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_infection_event", ref=ans) ;
  
  ans
  
}

attr(`infection_event__next_get`, 'returnType') = '_p_infection_event'
attr(`infection_event__next_get`, "inputTypes") = c('_p_infection_event')
class(`infection_event__next_get`) = c("SWIGFunction", class('infection_event__next_get'))

# Start of infection_event_is_case_set

`infection_event_is_case_set` = function(self, s_is_case)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_is_case = as.integer(s_is_case);
  
  if(length(s_is_case) > 1) {
    warning("using only the first element of s_is_case");
  };
  
  ;.Call('R_swig_infection_event_is_case_set', self, s_is_case, PACKAGE='OpenABMCovid19');
  
}

attr(`infection_event_is_case_set`, 'returnType') = 'void'
attr(`infection_event_is_case_set`, "inputTypes") = c('_p_infection_event', 'integer')
class(`infection_event_is_case_set`) = c("SWIGFunction", class('infection_event_is_case_set'))

# Start of infection_event_is_case_get

`infection_event_is_case_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_infection_event_is_case_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`infection_event_is_case_get`, 'returnType') = 'integer'
attr(`infection_event_is_case_get`, "inputTypes") = c('_p_infection_event')
class(`infection_event_is_case_get`) = c("SWIGFunction", class('infection_event_is_case_get'))

# Start of infection_event_network_id_set

`infection_event_network_id_set` = function(self, s_network_id)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_network_id = as.integer(s_network_id);
  
  if(length(s_network_id) > 1) {
    warning("using only the first element of s_network_id");
  };
  
  ;.Call('R_swig_infection_event_network_id_set', self, s_network_id, PACKAGE='OpenABMCovid19');
  
}

attr(`infection_event_network_id_set`, 'returnType') = 'void'
attr(`infection_event_network_id_set`, "inputTypes") = c('_p_infection_event', 'integer')
class(`infection_event_network_id_set`) = c("SWIGFunction", class('infection_event_network_id_set'))

# Start of infection_event_network_id_get

`infection_event_network_id_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_infection_event_network_id_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`infection_event_network_id_get`, 'returnType') = 'integer'
attr(`infection_event_network_id_get`, "inputTypes") = c('_p_infection_event')
class(`infection_event_network_id_get`) = c("SWIGFunction", class('infection_event_network_id_get'))

# Start of infection_event_expected_hospitalisation_set

`infection_event_expected_hospitalisation_set` = function(self, s_expected_hospitalisation)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_infection_event_expected_hospitalisation_set', self, s_expected_hospitalisation, PACKAGE='OpenABMCovid19');
  
}

attr(`infection_event_expected_hospitalisation_set`, 'returnType') = 'void'
attr(`infection_event_expected_hospitalisation_set`, "inputTypes") = c('_p_infection_event', 'numeric')
class(`infection_event_expected_hospitalisation_set`) = c("SWIGFunction", class('infection_event_expected_hospitalisation_set'))

# Start of infection_event_expected_hospitalisation_get

`infection_event_expected_hospitalisation_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_infection_event_expected_hospitalisation_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`infection_event_expected_hospitalisation_get`, 'returnType') = 'numeric'
attr(`infection_event_expected_hospitalisation_get`, "inputTypes") = c('_p_infection_event')
class(`infection_event_expected_hospitalisation_get`) = c("SWIGFunction", class('infection_event_expected_hospitalisation_get'))

# Start of infection_event_strain_set

`infection_event_strain_set` = function(self, s_strain)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_strain, "ExternalReference")) s_strain = slot(s_strain,"ref") 
  ;.Call('R_swig_infection_event_strain_set', self, s_strain, PACKAGE='OpenABMCovid19');
  
}

attr(`infection_event_strain_set`, 'returnType') = 'void'
attr(`infection_event_strain_set`, "inputTypes") = c('_p_infection_event', '_p_strain')
class(`infection_event_strain_set`) = c("SWIGFunction", class('infection_event_strain_set'))

# Start of infection_event_strain_get

`infection_event_strain_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_infection_event_strain_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_strain", ref=ans) ;
  
  ans
  
}

attr(`infection_event_strain_get`, 'returnType') = '_p_strain'
attr(`infection_event_strain_get`, "inputTypes") = c('_p_infection_event')
class(`infection_event_strain_get`) = c("SWIGFunction", class('infection_event_strain_get'))

# Start of accessor method for infection_event
setMethod('$', '_p_infection_event', function(x, name)

{
  accessorFuns = list('times' = infection_event_times_get, 'infector' = infection_event_infector_get, 'infector_status' = infection_event_infector_status_get, 'infector_hospital_state' = infection_event_infector_hospital_state_get, 'infector_network' = infection_event_infector_network_get, 'time_infected_infector' = infection_event_time_infected_infector_get, '_next' = infection_event__next_get, 'is_case' = infection_event_is_case_get, 'network_id' = infection_event_network_id_get, 'expected_hospitalisation' = infection_event_expected_hospitalisation_get, 'strain' = infection_event_strain_get);
  vaccessors = c('times', 'infector', 'infector_status', 'infector_hospital_state', 'infector_network', 'time_infected_infector', '_next', 'is_case', 'network_id', 'expected_hospitalisation', 'strain');
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  if (is.na(match(name, vaccessors))) function(...){
    f(x, ...)
  } else f(x);
}


);
# end of accessor method for infection_event
# Start of accessor method for infection_event
setMethod('$<-', '_p_infection_event', function(x, name, value)

{
  accessorFuns = list('times' = infection_event_times_set, 'infector' = infection_event_infector_set, 'infector_status' = infection_event_infector_status_set, 'infector_hospital_state' = infection_event_infector_hospital_state_set, 'infector_network' = infection_event_infector_network_set, 'time_infected_infector' = infection_event_time_infected_infector_set, '_next' = infection_event__next_set, 'is_case' = infection_event_is_case_set, 'network_id' = infection_event_network_id_set, 'expected_hospitalisation' = infection_event_expected_hospitalisation_set, 'strain' = infection_event_strain_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
setMethod('[[<-', c('_p_infection_event', 'character'),function(x, i, j, ..., value)

{
  name = i;
  accessorFuns = list('times' = infection_event_times_set, 'infector' = infection_event_infector_set, 'infector_status' = infection_event_infector_status_set, 'infector_hospital_state' = infection_event_infector_hospital_state_set, 'infector_network' = infection_event_infector_network_set, 'time_infected_infector' = infection_event_time_infected_infector_set, '_next' = infection_event__next_set, 'is_case' = infection_event_is_case_set, 'network_id' = infection_event_network_id_set, 'expected_hospitalisation' = infection_event_expected_hospitalisation_set, 'strain' = infection_event_strain_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
# end of accessor method for infection_event
# Start definition of copy functions & methods for infection_event
CopyToR_infection_event = function(value, obj = new("infection_event"))
{
  obj@infector_status = value$infector_status;
  obj@infector_hospital_state = value$infector_hospital_state;
  obj@infector_network = value$infector_network;
  obj@time_infected_infector = value$time_infected_infector;
  obj@is_case = value$is_case;
  obj@network_id = value$network_id;
  obj@expected_hospitalisation = value$expected_hospitalisation;
  obj;
}



CopyToC_infection_event = function(value, obj)
{
  obj$infector_status = value@infector_status;
  obj$infector_hospital_state = value@infector_hospital_state;
  obj$infector_network = value@infector_network;
  obj$time_infected_infector = value@time_infected_infector;
  obj$is_case = value@is_case;
  obj$network_id = value@network_id;
  obj$expected_hospitalisation = value@expected_hospitalisation;
  obj
}



# Start definition of copy methods for infection_event
setMethod('copyToR', '_p_infection_event', CopyToR_infection_event);
setMethod('copyToC', 'infection_event', CopyToC_infection_event);

# End definition of copy methods for infection_event
# End definition of copy functions & methods for infection_event
# Start of initialize_individual

`initialize_individual` = function(s_arg1, s_arg2, s_arg3)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;.Call('R_swig_initialize_individual', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`initialize_individual`, 'returnType') = 'void'
attr(`initialize_individual`, "inputTypes") = c('_p_individual', '_p_parameters', 'integer')
class(`initialize_individual`) = c("SWIGFunction", class('initialize_individual'))

# Start of initialize_hazard

`initialize_hazard` = function(s_arg1, s_arg2, s_arg3)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;.Call('R_swig_initialize_hazard', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`initialize_hazard`, 'returnType') = 'void'
attr(`initialize_hazard`, "inputTypes") = c('_p_individual', '_p_parameters', 'integer')
class(`initialize_hazard`) = c("SWIGFunction", class('initialize_hazard'))

# Start of add_infection_event

`add_infection_event` = function(s_arg1, s_arg2, s_arg3, s_arg4, s_arg5)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  if (inherits(s_arg4, "ExternalReference")) s_arg4 = slot(s_arg4,"ref") 
  s_arg5 = as.integer(s_arg5);
  
  if(length(s_arg5) > 1) {
    warning("using only the first element of s_arg5");
  };
  
  ;.Call('R_swig_add_infection_event', s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, PACKAGE='OpenABMCovid19');
  
}

attr(`add_infection_event`, 'returnType') = 'void'
attr(`add_infection_event`, "inputTypes") = c('_p_individual', '_p_individual', 'integer', '_p_strain', 'integer')
class(`add_infection_event`) = c("SWIGFunction", class('add_infection_event'))

# Start of set_age_group

`set_age_group` = function(s_arg1, s_arg2, s_arg3)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;.Call('R_swig_set_age_group', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`set_age_group`, 'returnType') = 'void'
attr(`set_age_group`, "inputTypes") = c('_p_individual', '_p_parameters', 'integer')
class(`set_age_group`) = c("SWIGFunction", class('set_age_group'))

# Start of set_house_no

`set_house_no` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  ;.Call('R_swig_set_house_no', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`set_house_no`, 'returnType') = 'void'
attr(`set_house_no`, "inputTypes") = c('_p_individual', 'integer')
class(`set_house_no`) = c("SWIGFunction", class('set_house_no'))

# Start of set_quarantine_status

`set_quarantine_status` = function(s_arg1, s_arg2, s_arg3, s_arg4, s_arg5)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  s_arg4 = as.integer(s_arg4);
  
  if(length(s_arg4) > 1) {
    warning("using only the first element of s_arg4");
  };
  
  if (inherits(s_arg5, "ExternalReference")) s_arg5 = slot(s_arg5,"ref") 
  ;.Call('R_swig_set_quarantine_status', s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, PACKAGE='OpenABMCovid19');
  
}

attr(`set_quarantine_status`, 'returnType') = 'void'
attr(`set_quarantine_status`, "inputTypes") = c('_p_individual', '_p_parameters', 'integer', 'integer', '_p_model')
class(`set_quarantine_status`) = c("SWIGFunction", class('set_quarantine_status'))

# Start of set_recovered

`set_recovered` = function(s_arg1, s_arg2, s_arg3, s_arg4)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  if (inherits(s_arg4, "ExternalReference")) s_arg4 = slot(s_arg4,"ref") 
  ;.Call('R_swig_set_recovered', s_arg1, s_arg2, s_arg3, s_arg4, PACKAGE='OpenABMCovid19');
  
}

attr(`set_recovered`, 'returnType') = 'void'
attr(`set_recovered`, "inputTypes") = c('_p_individual', '_p_parameters', 'integer', '_p_model')
class(`set_recovered`) = c("SWIGFunction", class('set_recovered'))

# Start of set_susceptible

`set_susceptible` = function(s_arg1, s_arg2, s_arg3)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;.Call('R_swig_set_susceptible', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`set_susceptible`, 'returnType') = 'void'
attr(`set_susceptible`, "inputTypes") = c('_p_individual', '_p_parameters', 'integer')
class(`set_susceptible`) = c("SWIGFunction", class('set_susceptible'))

# Start of set_hospitalised

`set_hospitalised` = function(s_arg1, s_arg2, s_arg3)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;.Call('R_swig_set_hospitalised', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`set_hospitalised`, 'returnType') = 'void'
attr(`set_hospitalised`, "inputTypes") = c('_p_individual', '_p_parameters', 'integer')
class(`set_hospitalised`) = c("SWIGFunction", class('set_hospitalised'))

# Start of set_hospitalised_recovering

`set_hospitalised_recovering` = function(s_arg1, s_arg2, s_arg3)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;.Call('R_swig_set_hospitalised_recovering', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`set_hospitalised_recovering`, 'returnType') = 'void'
attr(`set_hospitalised_recovering`, "inputTypes") = c('_p_individual', '_p_parameters', 'integer')
class(`set_hospitalised_recovering`) = c("SWIGFunction", class('set_hospitalised_recovering'))

# Start of set_critical

`set_critical` = function(s_arg1, s_arg2, s_arg3)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;.Call('R_swig_set_critical', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`set_critical`, 'returnType') = 'void'
attr(`set_critical`, "inputTypes") = c('_p_individual', '_p_parameters', 'integer')
class(`set_critical`) = c("SWIGFunction", class('set_critical'))

# Start of set_dead

`set_dead` = function(s_arg1, s_arg2, s_arg3)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;.Call('R_swig_set_dead', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`set_dead`, 'returnType') = 'void'
attr(`set_dead`, "inputTypes") = c('_p_individual', '_p_parameters', 'integer')
class(`set_dead`) = c("SWIGFunction", class('set_dead'))

# Start of set_case

`set_case` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  ;.Call('R_swig_set_case', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`set_case`, 'returnType') = 'void'
attr(`set_case`, "inputTypes") = c('_p_individual', 'integer')
class(`set_case`) = c("SWIGFunction", class('set_case'))

# Start of set_waiting

`set_waiting` = function(s_arg1, s_arg2, s_arg3)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;.Call('R_swig_set_waiting', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`set_waiting`, 'returnType') = 'void'
attr(`set_waiting`, "inputTypes") = c('_p_individual', '_p_parameters', 'integer')
class(`set_waiting`) = c("SWIGFunction", class('set_waiting'))

# Start of set_general_admission

`set_general_admission` = function(s_arg1, s_arg2, s_arg3)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;.Call('R_swig_set_general_admission', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`set_general_admission`, 'returnType') = 'void'
attr(`set_general_admission`, "inputTypes") = c('_p_individual', '_p_parameters', 'integer')
class(`set_general_admission`) = c("SWIGFunction", class('set_general_admission'))

# Start of set_icu_admission

`set_icu_admission` = function(s_arg1, s_arg2, s_arg3)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;.Call('R_swig_set_icu_admission', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`set_icu_admission`, 'returnType') = 'void'
attr(`set_icu_admission`, "inputTypes") = c('_p_individual', '_p_parameters', 'integer')
class(`set_icu_admission`) = c("SWIGFunction", class('set_icu_admission'))

# Start of set_mortuary_admission

`set_mortuary_admission` = function(s_arg1, s_arg2, s_arg3)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;.Call('R_swig_set_mortuary_admission', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`set_mortuary_admission`, 'returnType') = 'void'
attr(`set_mortuary_admission`, "inputTypes") = c('_p_individual', '_p_parameters', 'integer')
class(`set_mortuary_admission`) = c("SWIGFunction", class('set_mortuary_admission'))

# Start of set_discharged

`set_discharged` = function(s_arg1, s_arg2, s_arg3)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;.Call('R_swig_set_discharged', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`set_discharged`, 'returnType') = 'void'
attr(`set_discharged`, "inputTypes") = c('_p_individual', '_p_parameters', 'integer')
class(`set_discharged`) = c("SWIGFunction", class('set_discharged'))

# Start of set_immune

`set_immune` = function(s_arg1, s_arg2, s_arg3, s_arg4)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  s_arg4 = as.integer(s_arg4);
  
  if(length(s_arg4) > 1) {
    warning("using only the first element of s_arg4");
  };
  
  ;.Call('R_swig_set_immune', s_arg1, s_arg2, s_arg3, s_arg4, PACKAGE='OpenABMCovid19');
  
}

attr(`set_immune`, 'returnType') = 'void'
attr(`set_immune`, "inputTypes") = c('_p_individual', 'integer', 'integer', 'integer')
class(`set_immune`) = c("SWIGFunction", class('set_immune'))

# Start of wane_immunity

`wane_immunity` = function(s_arg1, s_arg2, s_arg3)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;.Call('R_swig_wane_immunity', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`wane_immunity`, 'returnType') = 'void'
attr(`wane_immunity`, "inputTypes") = c('_p_individual', '_p_parameters', 'integer')
class(`wane_immunity`) = c("SWIGFunction", class('wane_immunity'))

# Start of set_vaccine_status

`set_vaccine_status` = function(s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, s_arg6)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  s_arg4 = as.integer(s_arg4);
  
  if(length(s_arg4) > 1) {
    warning("using only the first element of s_arg4");
  };
  
  s_arg5 = as.integer(s_arg5);
  
  if(length(s_arg5) > 1) {
    warning("using only the first element of s_arg5");
  };
  
  s_arg6 = as.integer(s_arg6);
  
  if(length(s_arg6) > 1) {
    warning("using only the first element of s_arg6");
  };
  
  ;.Call('R_swig_set_vaccine_status', s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, s_arg6, PACKAGE='OpenABMCovid19');
  
}

attr(`set_vaccine_status`, 'returnType') = 'void'
attr(`set_vaccine_status`, "inputTypes") = c('_p_individual', '_p_parameters', 'integer', 'integer', 'integer', 'integer')
class(`set_vaccine_status`) = c("SWIGFunction", class('set_vaccine_status'))

# Start of update_random_interactions

`update_random_interactions` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_update_random_interactions', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`update_random_interactions`, 'returnType') = 'void'
attr(`update_random_interactions`, "inputTypes") = c('_p_individual', '_p_parameters')
class(`update_random_interactions`) = c("SWIGFunction", class('update_random_interactions'))

# Start of count_infection_events

`count_infection_events` = function(s_arg1, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_count_infection_events', s_arg1, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`count_infection_events`, 'returnType') = 'integer'
attr(`count_infection_events`, "inputTypes") = c('_p_individual')
class(`count_infection_events`) = c("SWIGFunction", class('count_infection_events'))

# Start of destroy_individual

`destroy_individual` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_destroy_individual', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`destroy_individual`, 'returnType') = 'void'
attr(`destroy_individual`, "inputTypes") = c('_p_individual')
class(`destroy_individual`) = c("SWIGFunction", class('destroy_individual'))

# Start of print_individual

`print_individual` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  ;.Call('R_swig_print_individual', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`print_individual`, 'returnType') = 'void'
attr(`print_individual`, "inputTypes") = c('_p_model', 'integer')
class(`print_individual`) = c("SWIGFunction", class('print_individual'))

# Start of trace_token_block_trace_tokens_set

`trace_token_block_trace_tokens_set` = function(self, s_trace_tokens)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_trace_tokens, "ExternalReference")) s_trace_tokens = slot(s_trace_tokens,"ref") 
  ;.Call('R_swig_trace_token_block_trace_tokens_set', self, s_trace_tokens, PACKAGE='OpenABMCovid19');
  
}

attr(`trace_token_block_trace_tokens_set`, 'returnType') = 'void'
attr(`trace_token_block_trace_tokens_set`, "inputTypes") = c('_p_trace_token_block', '_p_trace_token')
class(`trace_token_block_trace_tokens_set`) = c("SWIGFunction", class('trace_token_block_trace_tokens_set'))

# Start of trace_token_block_trace_tokens_get

`trace_token_block_trace_tokens_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_trace_token_block_trace_tokens_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_trace_token", ref=ans) ;
  
  ans
  
}

attr(`trace_token_block_trace_tokens_get`, 'returnType') = '_p_trace_token'
attr(`trace_token_block_trace_tokens_get`, "inputTypes") = c('_p_trace_token_block')
class(`trace_token_block_trace_tokens_get`) = c("SWIGFunction", class('trace_token_block_trace_tokens_get'))

# Start of trace_token_block__next_set

`trace_token_block__next_set` = function(self, s_arg2)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_trace_token_block__next_set', self, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`trace_token_block__next_set`, 'returnType') = 'void'
attr(`trace_token_block__next_set`, "inputTypes") = c('_p_trace_token_block', '_p_trace_token_block')
class(`trace_token_block__next_set`) = c("SWIGFunction", class('trace_token_block__next_set'))

# Start of trace_token_block__next_get

`trace_token_block__next_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_trace_token_block__next_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_trace_token_block", ref=ans) ;
  
  ans
  
}

attr(`trace_token_block__next_get`, 'returnType') = '_p_trace_token_block'
attr(`trace_token_block__next_get`, "inputTypes") = c('_p_trace_token_block')
class(`trace_token_block__next_get`) = c("SWIGFunction", class('trace_token_block__next_get'))

# Start of accessor method for trace_token_block
setMethod('$', '_p_trace_token_block', function(x, name)

{
  accessorFuns = list('trace_tokens' = trace_token_block_trace_tokens_get, '_next' = trace_token_block__next_get);
  vaccessors = c('trace_tokens', '_next');
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  if (is.na(match(name, vaccessors))) function(...){
    f(x, ...)
  } else f(x);
}


);
# end of accessor method for trace_token_block
# Start of accessor method for trace_token_block
setMethod('$<-', '_p_trace_token_block', function(x, name, value)

{
  accessorFuns = list('trace_tokens' = trace_token_block_trace_tokens_set, '_next' = trace_token_block__next_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
setMethod('[[<-', c('_p_trace_token_block', 'character'),function(x, i, j, ..., value)

{
  name = i;
  accessorFuns = list('trace_tokens' = trace_token_block_trace_tokens_set, '_next' = trace_token_block__next_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
# end of accessor method for trace_token_block
# Start definition of copy functions & methods for trace_token_block
CopyToR_trace_token_block = function(value, obj = new("trace_token_block"))
{
  obj;
}



CopyToC_trace_token_block = function(value, obj)
{
  obj
}



# Start definition of copy methods for trace_token_block
setMethod('copyToR', '_p_trace_token_block', CopyToR_trace_token_block);
setMethod('copyToC', 'trace_token_block', CopyToC_trace_token_block);

# End definition of copy methods for trace_token_block
# End definition of copy functions & methods for trace_token_block
# Start of trace_token_individual_set

`trace_token_individual_set` = function(self, s_individual)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_individual, "ExternalReference")) s_individual = slot(s_individual,"ref") 
  ;.Call('R_swig_trace_token_individual_set', self, s_individual, PACKAGE='OpenABMCovid19');
  
}

attr(`trace_token_individual_set`, 'returnType') = 'void'
attr(`trace_token_individual_set`, "inputTypes") = c('_p_trace_token', '_p_individual')
class(`trace_token_individual_set`) = c("SWIGFunction", class('trace_token_individual_set'))

# Start of trace_token_individual_get

`trace_token_individual_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_trace_token_individual_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_individual", ref=ans) ;
  
  ans
  
}

attr(`trace_token_individual_get`, 'returnType') = '_p_individual'
attr(`trace_token_individual_get`, "inputTypes") = c('_p_trace_token')
class(`trace_token_individual_get`) = c("SWIGFunction", class('trace_token_individual_get'))

# Start of trace_token_traced_from_set

`trace_token_traced_from_set` = function(self, s_traced_from)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_traced_from, "ExternalReference")) s_traced_from = slot(s_traced_from,"ref") 
  ;.Call('R_swig_trace_token_traced_from_set', self, s_traced_from, PACKAGE='OpenABMCovid19');
  
}

attr(`trace_token_traced_from_set`, 'returnType') = 'void'
attr(`trace_token_traced_from_set`, "inputTypes") = c('_p_trace_token', '_p_individual')
class(`trace_token_traced_from_set`) = c("SWIGFunction", class('trace_token_traced_from_set'))

# Start of trace_token_traced_from_get

`trace_token_traced_from_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_trace_token_traced_from_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_individual", ref=ans) ;
  
  ans
  
}

attr(`trace_token_traced_from_get`, 'returnType') = '_p_individual'
attr(`trace_token_traced_from_get`, "inputTypes") = c('_p_trace_token')
class(`trace_token_traced_from_get`) = c("SWIGFunction", class('trace_token_traced_from_get'))

# Start of trace_token_next_index_set

`trace_token_next_index_set` = function(self, s_next_index)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_next_index, "ExternalReference")) s_next_index = slot(s_next_index,"ref") 
  ;.Call('R_swig_trace_token_next_index_set', self, s_next_index, PACKAGE='OpenABMCovid19');
  
}

attr(`trace_token_next_index_set`, 'returnType') = 'void'
attr(`trace_token_next_index_set`, "inputTypes") = c('_p_trace_token', '_p_trace_token')
class(`trace_token_next_index_set`) = c("SWIGFunction", class('trace_token_next_index_set'))

# Start of trace_token_next_index_get

`trace_token_next_index_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_trace_token_next_index_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_trace_token", ref=ans) ;
  
  ans
  
}

attr(`trace_token_next_index_get`, 'returnType') = '_p_trace_token'
attr(`trace_token_next_index_get`, "inputTypes") = c('_p_trace_token')
class(`trace_token_next_index_get`) = c("SWIGFunction", class('trace_token_next_index_get'))

# Start of trace_token_last_index_set

`trace_token_last_index_set` = function(self, s_last_index)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_last_index, "ExternalReference")) s_last_index = slot(s_last_index,"ref") 
  ;.Call('R_swig_trace_token_last_index_set', self, s_last_index, PACKAGE='OpenABMCovid19');
  
}

attr(`trace_token_last_index_set`, 'returnType') = 'void'
attr(`trace_token_last_index_set`, "inputTypes") = c('_p_trace_token', '_p_trace_token')
class(`trace_token_last_index_set`) = c("SWIGFunction", class('trace_token_last_index_set'))

# Start of trace_token_last_index_get

`trace_token_last_index_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_trace_token_last_index_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_trace_token", ref=ans) ;
  
  ans
  
}

attr(`trace_token_last_index_get`, 'returnType') = '_p_trace_token'
attr(`trace_token_last_index_get`, "inputTypes") = c('_p_trace_token')
class(`trace_token_last_index_get`) = c("SWIGFunction", class('trace_token_last_index_get'))

# Start of trace_token__next_set

`trace_token__next_set` = function(self, s_arg2)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_trace_token__next_set', self, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`trace_token__next_set`, 'returnType') = 'void'
attr(`trace_token__next_set`, "inputTypes") = c('_p_trace_token', '_p_trace_token')
class(`trace_token__next_set`) = c("SWIGFunction", class('trace_token__next_set'))

# Start of trace_token__next_get

`trace_token__next_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_trace_token__next_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_trace_token", ref=ans) ;
  
  ans
  
}

attr(`trace_token__next_get`, 'returnType') = '_p_trace_token'
attr(`trace_token__next_get`, "inputTypes") = c('_p_trace_token')
class(`trace_token__next_get`) = c("SWIGFunction", class('trace_token__next_get'))

# Start of trace_token_last_set

`trace_token_last_set` = function(self, s_last)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_last, "ExternalReference")) s_last = slot(s_last,"ref") 
  ;.Call('R_swig_trace_token_last_set', self, s_last, PACKAGE='OpenABMCovid19');
  
}

attr(`trace_token_last_set`, 'returnType') = 'void'
attr(`trace_token_last_set`, "inputTypes") = c('_p_trace_token', '_p_trace_token')
class(`trace_token_last_set`) = c("SWIGFunction", class('trace_token_last_set'))

# Start of trace_token_last_get

`trace_token_last_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_trace_token_last_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_trace_token", ref=ans) ;
  
  ans
  
}

attr(`trace_token_last_get`, 'returnType') = '_p_trace_token'
attr(`trace_token_last_get`, "inputTypes") = c('_p_trace_token')
class(`trace_token_last_get`) = c("SWIGFunction", class('trace_token_last_get'))

# Start of trace_token_contact_time_set

`trace_token_contact_time_set` = function(self, s_contact_time)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_contact_time = as.integer(s_contact_time);
  
  if(length(s_contact_time) > 1) {
    warning("using only the first element of s_contact_time");
  };
  
  ;.Call('R_swig_trace_token_contact_time_set', self, s_contact_time, PACKAGE='OpenABMCovid19');
  
}

attr(`trace_token_contact_time_set`, 'returnType') = 'void'
attr(`trace_token_contact_time_set`, "inputTypes") = c('_p_trace_token', 'integer')
class(`trace_token_contact_time_set`) = c("SWIGFunction", class('trace_token_contact_time_set'))

# Start of trace_token_contact_time_get

`trace_token_contact_time_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_trace_token_contact_time_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`trace_token_contact_time_get`, 'returnType') = 'integer'
attr(`trace_token_contact_time_get`, "inputTypes") = c('_p_trace_token')
class(`trace_token_contact_time_get`) = c("SWIGFunction", class('trace_token_contact_time_get'))

# Start of trace_token_index_status_set

`trace_token_index_status_set` = function(self, s_index_status)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_index_status = as.integer(s_index_status);
  
  if(length(s_index_status) > 1) {
    warning("using only the first element of s_index_status");
  };
  
  ;.Call('R_swig_trace_token_index_status_set', self, s_index_status, PACKAGE='OpenABMCovid19');
  
}

attr(`trace_token_index_status_set`, 'returnType') = 'void'
attr(`trace_token_index_status_set`, "inputTypes") = c('_p_trace_token', 'integer')
class(`trace_token_index_status_set`) = c("SWIGFunction", class('trace_token_index_status_set'))

# Start of trace_token_index_status_get

`trace_token_index_status_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_trace_token_index_status_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`trace_token_index_status_get`, 'returnType') = 'integer'
attr(`trace_token_index_status_get`, "inputTypes") = c('_p_trace_token')
class(`trace_token_index_status_get`) = c("SWIGFunction", class('trace_token_index_status_get'))

# Start of accessor method for trace_token
setMethod('$', '_p_trace_token', function(x, name)

{
  accessorFuns = list('individual' = trace_token_individual_get, 'traced_from' = trace_token_traced_from_get, 'next_index' = trace_token_next_index_get, 'last_index' = trace_token_last_index_get, '_next' = trace_token__next_get, 'last' = trace_token_last_get, 'contact_time' = trace_token_contact_time_get, 'index_status' = trace_token_index_status_get);
  vaccessors = c('individual', 'traced_from', 'next_index', 'last_index', '_next', 'last', 'contact_time', 'index_status');
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  if (is.na(match(name, vaccessors))) function(...){
    f(x, ...)
  } else f(x);
}


);
# end of accessor method for trace_token
# Start of accessor method for trace_token
setMethod('$<-', '_p_trace_token', function(x, name, value)

{
  accessorFuns = list('individual' = trace_token_individual_set, 'traced_from' = trace_token_traced_from_set, 'next_index' = trace_token_next_index_set, 'last_index' = trace_token_last_index_set, '_next' = trace_token__next_set, 'last' = trace_token_last_set, 'contact_time' = trace_token_contact_time_set, 'index_status' = trace_token_index_status_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
setMethod('[[<-', c('_p_trace_token', 'character'),function(x, i, j, ..., value)

{
  name = i;
  accessorFuns = list('individual' = trace_token_individual_set, 'traced_from' = trace_token_traced_from_set, 'next_index' = trace_token_next_index_set, 'last_index' = trace_token_last_index_set, '_next' = trace_token__next_set, 'last' = trace_token_last_set, 'contact_time' = trace_token_contact_time_set, 'index_status' = trace_token_index_status_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
# end of accessor method for trace_token
# Start definition of copy functions & methods for trace_token
CopyToR_trace_token = function(value, obj = new("trace_token"))
{
  obj@contact_time = value$contact_time;
  obj@index_status = value$index_status;
  obj;
}



CopyToC_trace_token = function(value, obj)
{
  obj$contact_time = value@contact_time;
  obj$index_status = value@index_status;
  obj
}



# Start definition of copy methods for trace_token
setMethod('copyToR', '_p_trace_token', CopyToR_trace_token);
setMethod('copyToC', 'trace_token', CopyToC_trace_token);

# End definition of copy methods for trace_token
# End definition of copy functions & methods for trace_token
# Start of vaccine_idx_set

`vaccine_idx_set` = function(self, s_idx)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_idx = as.integer(s_idx);
  
  if(length(s_idx) > 1) {
    warning("using only the first element of s_idx");
  };
  
  ;.Call('R_swig_vaccine_idx_set', self, s_idx, PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_idx_set`, 'returnType') = 'void'
attr(`vaccine_idx_set`, "inputTypes") = c('_p_vaccine', 'integer')
class(`vaccine_idx_set`) = c("SWIGFunction", class('vaccine_idx_set'))

# Start of vaccine_idx_get

`vaccine_idx_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_vaccine_idx_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_idx_get`, 'returnType') = 'integer'
attr(`vaccine_idx_get`, "inputTypes") = c('_p_vaccine')
class(`vaccine_idx_get`) = c("SWIGFunction", class('vaccine_idx_get'))

# Start of vaccine_full_efficacy_set

`vaccine_full_efficacy_set` = function(self, s_full_efficacy)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_vaccine_full_efficacy_set', self, s_full_efficacy, PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_full_efficacy_set`, 'returnType') = 'void'
attr(`vaccine_full_efficacy_set`, "inputTypes") = c('_p_vaccine', 'numeric')
class(`vaccine_full_efficacy_set`) = c("SWIGFunction", class('vaccine_full_efficacy_set'))

# Start of vaccine_full_efficacy_get

`vaccine_full_efficacy_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_vaccine_full_efficacy_get', self, PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_full_efficacy_get`, 'returnType') = 'numeric'
attr(`vaccine_full_efficacy_get`, "inputTypes") = c('_p_vaccine')
class(`vaccine_full_efficacy_get`) = c("SWIGFunction", class('vaccine_full_efficacy_get'))

# Start of vaccine_symptoms_efficacy_set

`vaccine_symptoms_efficacy_set` = function(self, s_symptoms_efficacy)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_vaccine_symptoms_efficacy_set', self, s_symptoms_efficacy, PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_symptoms_efficacy_set`, 'returnType') = 'void'
attr(`vaccine_symptoms_efficacy_set`, "inputTypes") = c('_p_vaccine', 'numeric')
class(`vaccine_symptoms_efficacy_set`) = c("SWIGFunction", class('vaccine_symptoms_efficacy_set'))

# Start of vaccine_symptoms_efficacy_get

`vaccine_symptoms_efficacy_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_vaccine_symptoms_efficacy_get', self, PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_symptoms_efficacy_get`, 'returnType') = 'numeric'
attr(`vaccine_symptoms_efficacy_get`, "inputTypes") = c('_p_vaccine')
class(`vaccine_symptoms_efficacy_get`) = c("SWIGFunction", class('vaccine_symptoms_efficacy_get'))

# Start of vaccine_severe_efficacy_set

`vaccine_severe_efficacy_set` = function(self, s_severe_efficacy)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_vaccine_severe_efficacy_set', self, s_severe_efficacy, PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_severe_efficacy_set`, 'returnType') = 'void'
attr(`vaccine_severe_efficacy_set`, "inputTypes") = c('_p_vaccine', 'numeric')
class(`vaccine_severe_efficacy_set`) = c("SWIGFunction", class('vaccine_severe_efficacy_set'))

# Start of vaccine_severe_efficacy_get

`vaccine_severe_efficacy_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_vaccine_severe_efficacy_get', self, PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_severe_efficacy_get`, 'returnType') = 'numeric'
attr(`vaccine_severe_efficacy_get`, "inputTypes") = c('_p_vaccine')
class(`vaccine_severe_efficacy_get`) = c("SWIGFunction", class('vaccine_severe_efficacy_get'))

# Start of vaccine_time_to_protect_set

`vaccine_time_to_protect_set` = function(self, s_time_to_protect)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_time_to_protect = as.integer(s_time_to_protect);
  
  if(length(s_time_to_protect) > 1) {
    warning("using only the first element of s_time_to_protect");
  };
  
  ;.Call('R_swig_vaccine_time_to_protect_set', self, s_time_to_protect, PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_time_to_protect_set`, 'returnType') = 'void'
attr(`vaccine_time_to_protect_set`, "inputTypes") = c('_p_vaccine', 'integer')
class(`vaccine_time_to_protect_set`) = c("SWIGFunction", class('vaccine_time_to_protect_set'))

# Start of vaccine_time_to_protect_get

`vaccine_time_to_protect_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_vaccine_time_to_protect_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_time_to_protect_get`, 'returnType') = 'integer'
attr(`vaccine_time_to_protect_get`, "inputTypes") = c('_p_vaccine')
class(`vaccine_time_to_protect_get`) = c("SWIGFunction", class('vaccine_time_to_protect_get'))

# Start of vaccine_vaccine_protection_period_set

`vaccine_vaccine_protection_period_set` = function(self, s_vaccine_protection_period)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_vaccine_protection_period = as.integer(s_vaccine_protection_period);
  
  if(length(s_vaccine_protection_period) > 1) {
    warning("using only the first element of s_vaccine_protection_period");
  };
  
  ;.Call('R_swig_vaccine_vaccine_protection_period_set', self, s_vaccine_protection_period, PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_vaccine_protection_period_set`, 'returnType') = 'void'
attr(`vaccine_vaccine_protection_period_set`, "inputTypes") = c('_p_vaccine', 'integer')
class(`vaccine_vaccine_protection_period_set`) = c("SWIGFunction", class('vaccine_vaccine_protection_period_set'))

# Start of vaccine_vaccine_protection_period_get

`vaccine_vaccine_protection_period_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_vaccine_vaccine_protection_period_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_vaccine_protection_period_get`, 'returnType') = 'integer'
attr(`vaccine_vaccine_protection_period_get`, "inputTypes") = c('_p_vaccine')
class(`vaccine_vaccine_protection_period_get`) = c("SWIGFunction", class('vaccine_vaccine_protection_period_get'))

# Start of vaccine_is_full_set

`vaccine_is_full_set` = function(self, s_is_full)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_is_full = as.integer(s_is_full);
  
  if(length(s_is_full) > 1) {
    warning("using only the first element of s_is_full");
  };
  
  ;.Call('R_swig_vaccine_is_full_set', self, s_is_full, PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_is_full_set`, 'returnType') = 'void'
attr(`vaccine_is_full_set`, "inputTypes") = c('_p_vaccine', 'integer')
class(`vaccine_is_full_set`) = c("SWIGFunction", class('vaccine_is_full_set'))

# Start of vaccine_is_full_get

`vaccine_is_full_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_vaccine_is_full_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_is_full_get`, 'returnType') = 'integer'
attr(`vaccine_is_full_get`, "inputTypes") = c('_p_vaccine')
class(`vaccine_is_full_get`) = c("SWIGFunction", class('vaccine_is_full_get'))

# Start of vaccine_is_symptoms_set

`vaccine_is_symptoms_set` = function(self, s_is_symptoms)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_is_symptoms = as.integer(s_is_symptoms);
  
  if(length(s_is_symptoms) > 1) {
    warning("using only the first element of s_is_symptoms");
  };
  
  ;.Call('R_swig_vaccine_is_symptoms_set', self, s_is_symptoms, PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_is_symptoms_set`, 'returnType') = 'void'
attr(`vaccine_is_symptoms_set`, "inputTypes") = c('_p_vaccine', 'integer')
class(`vaccine_is_symptoms_set`) = c("SWIGFunction", class('vaccine_is_symptoms_set'))

# Start of vaccine_is_symptoms_get

`vaccine_is_symptoms_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_vaccine_is_symptoms_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_is_symptoms_get`, 'returnType') = 'integer'
attr(`vaccine_is_symptoms_get`, "inputTypes") = c('_p_vaccine')
class(`vaccine_is_symptoms_get`) = c("SWIGFunction", class('vaccine_is_symptoms_get'))

# Start of vaccine_is_severe_set

`vaccine_is_severe_set` = function(self, s_is_severe)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_is_severe = as.integer(s_is_severe);
  
  if(length(s_is_severe) > 1) {
    warning("using only the first element of s_is_severe");
  };
  
  ;.Call('R_swig_vaccine_is_severe_set', self, s_is_severe, PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_is_severe_set`, 'returnType') = 'void'
attr(`vaccine_is_severe_set`, "inputTypes") = c('_p_vaccine', 'integer')
class(`vaccine_is_severe_set`) = c("SWIGFunction", class('vaccine_is_severe_set'))

# Start of vaccine_is_severe_get

`vaccine_is_severe_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_vaccine_is_severe_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_is_severe_get`, 'returnType') = 'integer'
attr(`vaccine_is_severe_get`, "inputTypes") = c('_p_vaccine')
class(`vaccine_is_severe_get`) = c("SWIGFunction", class('vaccine_is_severe_get'))

# Start of vaccine_n_strains_set

`vaccine_n_strains_set` = function(self, s_n_strains)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_strains = as.integer(s_n_strains);
  
  if(length(s_n_strains) > 1) {
    warning("using only the first element of s_n_strains");
  };
  
  ;.Call('R_swig_vaccine_n_strains_set', self, s_n_strains, PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_n_strains_set`, 'returnType') = 'void'
attr(`vaccine_n_strains_set`, "inputTypes") = c('_p_vaccine', 'integer')
class(`vaccine_n_strains_set`) = c("SWIGFunction", class('vaccine_n_strains_set'))

# Start of vaccine_n_strains_get

`vaccine_n_strains_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_vaccine_n_strains_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_n_strains_get`, 'returnType') = 'integer'
attr(`vaccine_n_strains_get`, "inputTypes") = c('_p_vaccine')
class(`vaccine_n_strains_get`) = c("SWIGFunction", class('vaccine_n_strains_get'))

# Start of vaccine_name_set

`vaccine_name_set` = function(self, s_name)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  if(is.list(s_name))
  assert(all(sapply(s_name, class) == "_p_char"));
  
  
#  assert(length(s_name) >= 300)
  
  ;.Call('R_swig_vaccine_name_set', self, s_name, PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_name_set`, 'returnType') = 'void'
attr(`vaccine_name_set`, "inputTypes") = c('_p_vaccine', '_p_char')
class(`vaccine_name_set`) = c("SWIGFunction", class('vaccine_name_set'))

# Start of vaccine_name_get

`vaccine_name_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_vaccine_name_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  #ans <- new("_p_char", ref=ans) ;
  
  ans
  
}

attr(`vaccine_name_get`, 'returnType') = '_p_char'
attr(`vaccine_name_get`, "inputTypes") = c('_p_vaccine')
class(`vaccine_name_get`) = c("SWIGFunction", class('vaccine_name_get'))

# Start of vaccine__next_set

`vaccine__next_set` = function(self, s_arg2)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_vaccine__next_set', self, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine__next_set`, 'returnType') = 'void'
attr(`vaccine__next_set`, "inputTypes") = c('_p_vaccine', '_p_vaccine')
class(`vaccine__next_set`) = c("SWIGFunction", class('vaccine__next_set'))

# Start of vaccine__next_get

`vaccine__next_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_vaccine__next_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_vaccine", ref=ans) ;
  
  ans
  
}

attr(`vaccine__next_get`, 'returnType') = '_p_vaccine'
attr(`vaccine__next_get`, "inputTypes") = c('_p_vaccine')
class(`vaccine__next_get`) = c("SWIGFunction", class('vaccine__next_get'))

# Start of accessor method for vaccine
setMethod('$', '_p_vaccine', function(x, name)

{
  accessorFuns = list('idx' = vaccine_idx_get, 'full_efficacy' = vaccine_full_efficacy_get, 'symptoms_efficacy' = vaccine_symptoms_efficacy_get, 'severe_efficacy' = vaccine_severe_efficacy_get, 'time_to_protect' = vaccine_time_to_protect_get, 'vaccine_protection_period' = vaccine_vaccine_protection_period_get, 'is_full' = vaccine_is_full_get, 'is_symptoms' = vaccine_is_symptoms_get, 'is_severe' = vaccine_is_severe_get, 'n_strains' = vaccine_n_strains_get, 'name' = vaccine_name_get, '_next' = vaccine__next_get);
  vaccessors = c('idx', 'full_efficacy', 'symptoms_efficacy', 'severe_efficacy', 'time_to_protect', 'vaccine_protection_period', 'is_full', 'is_symptoms', 'is_severe', 'n_strains', 'name', '_next');
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  if (is.na(match(name, vaccessors))) function(...){
    f(x, ...)
  } else f(x);
}


);
# end of accessor method for vaccine
# Start of accessor method for vaccine
setMethod('$<-', '_p_vaccine', function(x, name, value)

{
  accessorFuns = list('idx' = vaccine_idx_set, 'full_efficacy' = vaccine_full_efficacy_set, 'symptoms_efficacy' = vaccine_symptoms_efficacy_set, 'severe_efficacy' = vaccine_severe_efficacy_set, 'time_to_protect' = vaccine_time_to_protect_set, 'vaccine_protection_period' = vaccine_vaccine_protection_period_set, 'is_full' = vaccine_is_full_set, 'is_symptoms' = vaccine_is_symptoms_set, 'is_severe' = vaccine_is_severe_set, 'n_strains' = vaccine_n_strains_set, 'name' = vaccine_name_set, '_next' = vaccine__next_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
setMethod('[[<-', c('_p_vaccine', 'character'),function(x, i, j, ..., value)

{
  name = i;
  accessorFuns = list('idx' = vaccine_idx_set, 'full_efficacy' = vaccine_full_efficacy_set, 'symptoms_efficacy' = vaccine_symptoms_efficacy_set, 'severe_efficacy' = vaccine_severe_efficacy_set, 'time_to_protect' = vaccine_time_to_protect_set, 'vaccine_protection_period' = vaccine_vaccine_protection_period_set, 'is_full' = vaccine_is_full_set, 'is_symptoms' = vaccine_is_symptoms_set, 'is_severe' = vaccine_is_severe_set, 'n_strains' = vaccine_n_strains_set, 'name' = vaccine_name_set, '_next' = vaccine__next_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
# end of accessor method for vaccine
# Start definition of copy functions & methods for vaccine
CopyToR_vaccine = function(value, obj = new("vaccine"))
{
  obj@idx = value$idx;
  obj@time_to_protect = value$time_to_protect;
  obj@vaccine_protection_period = value$vaccine_protection_period;
  obj@is_full = value$is_full;
  obj@is_symptoms = value$is_symptoms;
  obj@is_severe = value$is_severe;
  obj@n_strains = value$n_strains;
  obj@name = value$name;
  obj;
}



CopyToC_vaccine = function(value, obj)
{
  obj$idx = value@idx;
  obj$time_to_protect = value@time_to_protect;
  obj$vaccine_protection_period = value@vaccine_protection_period;
  obj$is_full = value@is_full;
  obj$is_symptoms = value@is_symptoms;
  obj$is_severe = value@is_severe;
  obj$n_strains = value@n_strains;
  obj$name = value@name;
  obj
}



# Start definition of copy methods for vaccine
setMethod('copyToR', '_p_vaccine', CopyToR_vaccine);
setMethod('copyToC', 'vaccine', CopyToC_vaccine);

# End definition of copy methods for vaccine
# End definition of copy functions & methods for vaccine
# Start of set_up_transition_times_intervention

`set_up_transition_times_intervention` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_set_up_transition_times_intervention', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`set_up_transition_times_intervention`, 'returnType') = 'void'
attr(`set_up_transition_times_intervention`, "inputTypes") = c('_p_model')
class(`set_up_transition_times_intervention`) = c("SWIGFunction", class('set_up_transition_times_intervention'))

# Start of set_up_app_users

`set_up_app_users` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_set_up_app_users', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`set_up_app_users`, 'returnType') = 'void'
attr(`set_up_app_users`, "inputTypes") = c('_p_model')
class(`set_up_app_users`) = c("SWIGFunction", class('set_up_app_users'))

# Start of set_up_risk_scores

`set_up_risk_scores` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_set_up_risk_scores', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`set_up_risk_scores`, 'returnType') = 'void'
attr(`set_up_risk_scores`, "inputTypes") = c('_p_model')
class(`set_up_risk_scores`) = c("SWIGFunction", class('set_up_risk_scores'))

# Start of destroy_risk_scores

`destroy_risk_scores` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_destroy_risk_scores', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`destroy_risk_scores`, 'returnType') = 'void'
attr(`destroy_risk_scores`, "inputTypes") = c('_p_model')
class(`destroy_risk_scores`) = c("SWIGFunction", class('destroy_risk_scores'))

# Start of update_intervention_policy

`update_intervention_policy` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  ;.Call('R_swig_update_intervention_policy', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`update_intervention_policy`, 'returnType') = 'void'
attr(`update_intervention_policy`, "inputTypes") = c('_p_model', 'integer')
class(`update_intervention_policy`) = c("SWIGFunction", class('update_intervention_policy'))

# Start of set_up_trace_tokens

`set_up_trace_tokens` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  
  ;.Call('R_swig_set_up_trace_tokens', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`set_up_trace_tokens`, 'returnType') = 'void'
attr(`set_up_trace_tokens`, "inputTypes") = c('_p_model', 'numeric')
class(`set_up_trace_tokens`) = c("SWIGFunction", class('set_up_trace_tokens'))

# Start of add_trace_tokens

`add_trace_tokens` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  
  ;.Call('R_swig_add_trace_tokens', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`add_trace_tokens`, 'returnType') = 'void'
attr(`add_trace_tokens`, "inputTypes") = c('_p_model', 'numeric')
class(`add_trace_tokens`) = c("SWIGFunction", class('add_trace_tokens'))

# Start of create_trace_token

`create_trace_token` = function(s_arg1, s_arg2, s_arg3)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;ans = .Call('R_swig_create_trace_token', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  ans <- new("_p_trace_token", ref=ans) ;
  
  ans
  
}

attr(`create_trace_token`, 'returnType') = '_p_trace_token'
attr(`create_trace_token`, "inputTypes") = c('_p_model', '_p_individual', 'integer')
class(`create_trace_token`) = c("SWIGFunction", class('create_trace_token'))

# Start of index_trace_token

`index_trace_token` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;ans = .Call('R_swig_index_trace_token', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  ans <- new("_p_trace_token", ref=ans) ;
  
  ans
  
}

attr(`index_trace_token`, 'returnType') = '_p_trace_token'
attr(`index_trace_token`, "inputTypes") = c('_p_model', '_p_individual')
class(`index_trace_token`) = c("SWIGFunction", class('index_trace_token'))

# Start of remove_one_trace_token

`remove_one_trace_token` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_remove_one_trace_token', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`remove_one_trace_token`, 'returnType') = 'void'
attr(`remove_one_trace_token`, "inputTypes") = c('_p_model', '_p_trace_token')
class(`remove_one_trace_token`) = c("SWIGFunction", class('remove_one_trace_token'))

# Start of remove_traced_on_this_trace

`remove_traced_on_this_trace` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_remove_traced_on_this_trace', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`remove_traced_on_this_trace`, 'returnType') = 'void'
attr(`remove_traced_on_this_trace`, "inputTypes") = c('_p_model', '_p_individual')
class(`remove_traced_on_this_trace`) = c("SWIGFunction", class('remove_traced_on_this_trace'))

# Start of remove_traces_on_individual

`remove_traces_on_individual` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_remove_traces_on_individual', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`remove_traces_on_individual`, 'returnType') = 'void'
attr(`remove_traces_on_individual`, "inputTypes") = c('_p_model', '_p_individual')
class(`remove_traces_on_individual`) = c("SWIGFunction", class('remove_traces_on_individual'))

# Start of intervention_trace_token_release

`intervention_trace_token_release` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_intervention_trace_token_release', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`intervention_trace_token_release`, 'returnType') = 'void'
attr(`intervention_trace_token_release`, "inputTypes") = c('_p_model', '_p_individual')
class(`intervention_trace_token_release`) = c("SWIGFunction", class('intervention_trace_token_release'))

# Start of intervention_quarantine_until

`intervention_quarantine_until` = function(s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, s_arg6, s_arg7, s_arg8, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  if (inherits(s_arg3, "ExternalReference")) s_arg3 = slot(s_arg3,"ref") 
  s_arg4 = as.integer(s_arg4);
  
  if(length(s_arg4) > 1) {
    warning("using only the first element of s_arg4");
  };
  
  s_arg5 = as.integer(s_arg5);
  
  if(length(s_arg5) > 1) {
    warning("using only the first element of s_arg5");
  };
  
  if (inherits(s_arg6, "ExternalReference")) s_arg6 = slot(s_arg6,"ref") 
  s_arg7 = as.integer(s_arg7);
  
  if(length(s_arg7) > 1) {
    warning("using only the first element of s_arg7");
  };
  
  
  ;.Call('R_swig_intervention_quarantine_until', s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, s_arg6, s_arg7, s_arg8, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`intervention_quarantine_until`, 'returnType') = 'integer'
attr(`intervention_quarantine_until`, "inputTypes") = c('_p_model', '_p_individual', '_p_individual', 'integer', 'integer', '_p_trace_token', 'integer', 'numeric')
class(`intervention_quarantine_until`) = c("SWIGFunction", class('intervention_quarantine_until'))

# Start of intervention_quarantine_release

`intervention_quarantine_release` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_intervention_quarantine_release', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`intervention_quarantine_release`, 'returnType') = 'void'
attr(`intervention_quarantine_release`, "inputTypes") = c('_p_model', '_p_individual')
class(`intervention_quarantine_release`) = c("SWIGFunction", class('intervention_quarantine_release'))

# Start of intervention_quarantine_household

`intervention_quarantine_household` = function(s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, s_arg6)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  s_arg4 = as.integer(s_arg4);
  
  if(length(s_arg4) > 1) {
    warning("using only the first element of s_arg4");
  };
  
  if (inherits(s_arg5, "ExternalReference")) s_arg5 = slot(s_arg5,"ref") 
  s_arg6 = as.integer(s_arg6);
  
  if(length(s_arg6) > 1) {
    warning("using only the first element of s_arg6");
  };
  
  ;.Call('R_swig_intervention_quarantine_household', s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, s_arg6, PACKAGE='OpenABMCovid19');
  
}

attr(`intervention_quarantine_household`, 'returnType') = 'void'
attr(`intervention_quarantine_household`, "inputTypes") = c('_p_model', '_p_individual', 'integer', 'integer', '_p_trace_token', 'integer')
class(`intervention_quarantine_household`) = c("SWIGFunction", class('intervention_quarantine_household'))

# Start of intervention_test_take

`intervention_test_take` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_intervention_test_take', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`intervention_test_take`, 'returnType') = 'void'
attr(`intervention_test_take`, "inputTypes") = c('_p_model', '_p_individual')
class(`intervention_test_take`) = c("SWIGFunction", class('intervention_test_take'))

# Start of intervention_test_result

`intervention_test_result` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_intervention_test_result', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`intervention_test_result`, 'returnType') = 'void'
attr(`intervention_test_result`, "inputTypes") = c('_p_model', '_p_individual')
class(`intervention_test_result`) = c("SWIGFunction", class('intervention_test_result'))

# Start of intervention_manual_trace

`intervention_manual_trace` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_intervention_manual_trace', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`intervention_manual_trace`, 'returnType') = 'void'
attr(`intervention_manual_trace`, "inputTypes") = c('_p_model', '_p_individual')
class(`intervention_manual_trace`) = c("SWIGFunction", class('intervention_manual_trace'))

# Start of intervention_notify_contacts

`intervention_notify_contacts` = function(s_arg1, s_arg2, s_arg3, s_arg4, s_arg5)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  if (inherits(s_arg4, "ExternalReference")) s_arg4 = slot(s_arg4,"ref") 
  s_arg5 = as.integer(s_arg5);
  
  if(length(s_arg5) > 1) {
    warning("using only the first element of s_arg5");
  };
  
  ;.Call('R_swig_intervention_notify_contacts', s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, PACKAGE='OpenABMCovid19');
  
}

attr(`intervention_notify_contacts`, 'returnType') = 'void'
attr(`intervention_notify_contacts`, "inputTypes") = c('_p_model', '_p_individual', 'integer', '_p_trace_token', 'integer')
class(`intervention_notify_contacts`) = c("SWIGFunction", class('intervention_notify_contacts'))

# Start of intervention_index_case_symptoms_to_positive

`intervention_index_case_symptoms_to_positive` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_intervention_index_case_symptoms_to_positive', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`intervention_index_case_symptoms_to_positive`, 'returnType') = 'void'
attr(`intervention_index_case_symptoms_to_positive`, "inputTypes") = c('_p_model', '_p_trace_token')
class(`intervention_index_case_symptoms_to_positive`) = c("SWIGFunction", class('intervention_index_case_symptoms_to_positive'))

# Start of add_vaccine

`add_vaccine` = function(s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, s_arg6, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  
  
  
  s_arg5 = as.integer(s_arg5);
  
  if(length(s_arg5) > 1) {
    warning("using only the first element of s_arg5");
  };
  
  s_arg6 = as.integer(s_arg6);
  
  if(length(s_arg6) > 1) {
    warning("using only the first element of s_arg6");
  };
  
  ;.Call('R_swig_add_vaccine', s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, s_arg6, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`add_vaccine`, 'returnType') = 'integer'
attr(`add_vaccine`, "inputTypes") = c('_p_model', 'numeric', 'numeric', 'numeric', 'integer', 'integer')
class(`add_vaccine`) = c("SWIGFunction", class('add_vaccine'))

# Start of get_vaccine_by_id

`get_vaccine_by_id` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  ;ans = .Call('R_swig_get_vaccine_by_id', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  ans <- new("_p_vaccine", ref=ans) ;
  
  ans
  
}

attr(`get_vaccine_by_id`, 'returnType') = '_p_vaccine'
attr(`get_vaccine_by_id`, "inputTypes") = c('_p_model', 'integer')
class(`get_vaccine_by_id`) = c("SWIGFunction", class('get_vaccine_by_id'))

# Start of intervention_vaccinate

`intervention_vaccinate` = function(s_arg1, s_arg2, s_arg3, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  if (inherits(s_arg3, "ExternalReference")) s_arg3 = slot(s_arg3,"ref") 
  ;.Call('R_swig_intervention_vaccinate', s_arg1, s_arg2, s_arg3, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`intervention_vaccinate`, 'returnType') = 'integer'
attr(`intervention_vaccinate`, "inputTypes") = c('_p_model', '_p_individual', '_p_vaccine')
class(`intervention_vaccinate`) = c("SWIGFunction", class('intervention_vaccinate'))

# Start of intervention_vaccinate_by_idx

`intervention_vaccinate_by_idx` = function(s_arg1, s_arg2, s_arg3, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  if (inherits(s_arg3, "ExternalReference")) s_arg3 = slot(s_arg3,"ref") 
  ;.Call('R_swig_intervention_vaccinate_by_idx', s_arg1, s_arg2, s_arg3, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`intervention_vaccinate_by_idx`, 'returnType') = 'integer'
attr(`intervention_vaccinate_by_idx`, "inputTypes") = c('_p_model', 'integer', '_p_vaccine')
class(`intervention_vaccinate_by_idx`) = c("SWIGFunction", class('intervention_vaccinate_by_idx'))

# Start of intervention_vaccinate_age_group

`intervention_vaccinate_age_group` = function(s_arg1, s_arg2, s_arg3, s_arg4, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  
  
#  assert(length(s_arg2) >= N_AGE_GROUPS)
  
  if (inherits(s_arg3, "ExternalReference")) s_arg3 = slot(s_arg3,"ref") 
  s_arg4 = as.integer(s_arg4);
  
#  assert(length(s_arg4) >= N_AGE_GROUPS)
  
  ;.Call('R_swig_intervention_vaccinate_age_group', s_arg1, s_arg2, s_arg3, s_arg4, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`intervention_vaccinate_age_group`, 'returnType') = 'integer'
attr(`intervention_vaccinate_age_group`, "inputTypes") = c('_p_model', 'numeric', '_p_vaccine', 'integer')
class(`intervention_vaccinate_age_group`) = c("SWIGFunction", class('intervention_vaccinate_age_group'))

# Start of intervention_vaccine_protect

`intervention_vaccine_protect` = function(s_arg1, s_arg2, s_arg3)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  if (inherits(s_arg3, "ExternalReference")) s_arg3 = slot(s_arg3,"ref") 
  ;.Call('R_swig_intervention_vaccine_protect', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`intervention_vaccine_protect`, 'returnType') = 'void'
attr(`intervention_vaccine_protect`, "inputTypes") = c('_p_model', '_p_individual', '_p_void')
class(`intervention_vaccine_protect`) = c("SWIGFunction", class('intervention_vaccine_protect'))

# Start of intervention_vaccine_wane

`intervention_vaccine_wane` = function(s_arg1, s_arg2, s_arg3)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  if (inherits(s_arg3, "ExternalReference")) s_arg3 = slot(s_arg3,"ref") 
  ;.Call('R_swig_intervention_vaccine_wane', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`intervention_vaccine_wane`, 'returnType') = 'void'
attr(`intervention_vaccine_wane`, "inputTypes") = c('_p_model', '_p_individual', '_p_void')
class(`intervention_vaccine_wane`) = c("SWIGFunction", class('intervention_vaccine_wane'))

# Start of intervention_on_symptoms

`intervention_on_symptoms` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_intervention_on_symptoms', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`intervention_on_symptoms`, 'returnType') = 'void'
attr(`intervention_on_symptoms`, "inputTypes") = c('_p_model', '_p_individual')
class(`intervention_on_symptoms`) = c("SWIGFunction", class('intervention_on_symptoms'))

# Start of intervention_on_hospitalised

`intervention_on_hospitalised` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_intervention_on_hospitalised', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`intervention_on_hospitalised`, 'returnType') = 'void'
attr(`intervention_on_hospitalised`, "inputTypes") = c('_p_model', '_p_individual')
class(`intervention_on_hospitalised`) = c("SWIGFunction", class('intervention_on_hospitalised'))

# Start of intervention_on_critical

`intervention_on_critical` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_intervention_on_critical', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`intervention_on_critical`, 'returnType') = 'void'
attr(`intervention_on_critical`, "inputTypes") = c('_p_model', '_p_individual')
class(`intervention_on_critical`) = c("SWIGFunction", class('intervention_on_critical'))

# Start of intervention_on_positive_result

`intervention_on_positive_result` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_intervention_on_positive_result', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`intervention_on_positive_result`, 'returnType') = 'void'
attr(`intervention_on_positive_result`, "inputTypes") = c('_p_model', '_p_individual')
class(`intervention_on_positive_result`) = c("SWIGFunction", class('intervention_on_positive_result'))

# Start of intervention_on_traced

`intervention_on_traced` = function(s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, s_arg6, s_arg7)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  s_arg4 = as.integer(s_arg4);
  
  if(length(s_arg4) > 1) {
    warning("using only the first element of s_arg4");
  };
  
  if (inherits(s_arg5, "ExternalReference")) s_arg5 = slot(s_arg5,"ref") 
  
  s_arg7 = as.integer(s_arg7);
  
  if(length(s_arg7) > 1) {
    warning("using only the first element of s_arg7");
  };
  
  ;.Call('R_swig_intervention_on_traced', s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, s_arg6, s_arg7, PACKAGE='OpenABMCovid19');
  
}

attr(`intervention_on_traced`, 'returnType') = 'void'
attr(`intervention_on_traced`, "inputTypes") = c('_p_model', '_p_individual', 'integer', 'integer', '_p_trace_token', 'numeric', 'integer')
class(`intervention_on_traced`) = c("SWIGFunction", class('intervention_on_traced'))

# Start of intervention_smart_release

`intervention_smart_release` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_intervention_smart_release', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`intervention_smart_release`, 'returnType') = 'void'
attr(`intervention_smart_release`, "inputTypes") = c('_p_model')
class(`intervention_smart_release`) = c("SWIGFunction", class('intervention_smart_release'))

# Start of resolve_quarantine_reasons

`resolve_quarantine_reasons` = function(s_arg1, .copy = FALSE)
{
  s_arg1 = as.integer(s_arg1);
  ;.Call('R_swig_resolve_quarantine_reasons', s_arg1, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`resolve_quarantine_reasons`, 'returnType') = 'integer'
attr(`resolve_quarantine_reasons`, "inputTypes") = c('integer')
class(`resolve_quarantine_reasons`) = c("SWIGFunction", class('resolve_quarantine_reasons'))

# Start of printf_w

`printf_w` = function(s_arg1, .copy = FALSE)
{
  s_arg1 = as(s_arg1, "character"); 
  ;.Call('R_swig_printf_w', s_arg1, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`printf_w`, 'returnType') = 'integer'
attr(`printf_w`, "inputTypes") = c('character')
class(`printf_w`) = c("SWIGFunction", class('printf_w'))

# Start of print_now

`print_now` = function(s_arg1)
{
  s_arg1 = as(s_arg1, "character"); 
  ;.Call('R_swig_print_now', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`print_now`, 'returnType') = 'void'
attr(`print_now`, "inputTypes") = c('character')
class(`print_now`) = c("SWIGFunction", class('print_now'))

# Start of print_exit

`print_exit` = function(s_arg1)
{
  s_arg1 = as(s_arg1, "character"); 
  ;.Call('R_swig_print_exit', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`print_exit`, 'returnType') = 'void'
attr(`print_exit`, "inputTypes") = c('character')
class(`print_exit`) = c("SWIGFunction", class('print_exit'))

# Start of fflush_stdout

`fflush_stdout` = function()
{
  ;.Call('R_swig_fflush_stdout', PACKAGE='OpenABMCovid19');
  
}

attr(`fflush_stdout`, 'returnType') = 'void'
class(`fflush_stdout`) = c("SWIGFunction", class('fflush_stdout'))

# Start of gamma_draw_list

`gamma_draw_list` = function(s_arg1, s_arg2, s_arg3, s_arg4)
{
  s_arg1 = as.integer(s_arg1);
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  
  
  ;.Call('R_swig_gamma_draw_list', s_arg1, s_arg2, s_arg3, s_arg4, PACKAGE='OpenABMCovid19');
  
}

attr(`gamma_draw_list`, 'returnType') = 'void'
attr(`gamma_draw_list`, "inputTypes") = c('integer', 'integer', 'numeric', 'numeric')
class(`gamma_draw_list`) = c("SWIGFunction", class('gamma_draw_list'))

# Start of bernoulli_draw_list

`bernoulli_draw_list` = function(s_arg1, s_arg2, s_arg3)
{
  s_arg1 = as.integer(s_arg1);
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  
  ;.Call('R_swig_bernoulli_draw_list', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`bernoulli_draw_list`, 'returnType') = 'void'
attr(`bernoulli_draw_list`, "inputTypes") = c('integer', 'integer', 'numeric')
class(`bernoulli_draw_list`) = c("SWIGFunction", class('bernoulli_draw_list'))

# Start of geometric_max_draw_list

`geometric_max_draw_list` = function(s_arg1, s_arg2, s_arg3, s_arg4)
{
  s_arg1 = as.integer(s_arg1);
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  
  s_arg4 = as.integer(s_arg4);
  
  if(length(s_arg4) > 1) {
    warning("using only the first element of s_arg4");
  };
  
  ;.Call('R_swig_geometric_max_draw_list', s_arg1, s_arg2, s_arg3, s_arg4, PACKAGE='OpenABMCovid19');
  
}

attr(`geometric_max_draw_list`, 'returnType') = 'void'
attr(`geometric_max_draw_list`, "inputTypes") = c('integer', 'integer', 'numeric', 'integer')
class(`geometric_max_draw_list`) = c("SWIGFunction", class('geometric_max_draw_list'))

# Start of shifted_geometric_draw_list

`shifted_geometric_draw_list` = function(s_arg1, s_arg2, s_arg3, s_arg4)
{
  s_arg1 = as.integer(s_arg1);
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  
  s_arg4 = as.integer(s_arg4);
  
  if(length(s_arg4) > 1) {
    warning("using only the first element of s_arg4");
  };
  
  ;.Call('R_swig_shifted_geometric_draw_list', s_arg1, s_arg2, s_arg3, s_arg4, PACKAGE='OpenABMCovid19');
  
}

attr(`shifted_geometric_draw_list`, 'returnType') = 'void'
attr(`shifted_geometric_draw_list`, "inputTypes") = c('integer', 'integer', 'numeric', 'integer')
class(`shifted_geometric_draw_list`) = c("SWIGFunction", class('shifted_geometric_draw_list'))

# Start of geometric_draw_list

`geometric_draw_list` = function(s_arg1, s_arg2, s_arg3)
{
  s_arg1 = as.integer(s_arg1);
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  
  ;.Call('R_swig_geometric_draw_list', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`geometric_draw_list`, 'returnType') = 'void'
attr(`geometric_draw_list`, "inputTypes") = c('integer', 'integer', 'numeric')
class(`geometric_draw_list`) = c("SWIGFunction", class('geometric_draw_list'))

# Start of gamma_rate_curve

`gamma_rate_curve` = function(s_arg1, s_arg2, s_arg3, s_arg4, s_arg5)
{
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  
  
  
  ;.Call('R_swig_gamma_rate_curve', s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, PACKAGE='OpenABMCovid19');
  
}

attr(`gamma_rate_curve`, 'returnType') = 'void'
attr(`gamma_rate_curve`, "inputTypes") = c('numeric', 'integer', 'numeric', 'numeric', 'numeric')
class(`gamma_rate_curve`) = c("SWIGFunction", class('gamma_rate_curve'))

# Start of negative_binomial_draw

`negative_binomial_draw` = function(s_arg1, s_arg2, .copy = FALSE)
{
  ;.Call('R_swig_negative_binomial_draw', s_arg1, s_arg2, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`negative_binomial_draw`, 'returnType') = 'integer'
attr(`negative_binomial_draw`, "inputTypes") = c('numeric', 'numeric')
class(`negative_binomial_draw`) = c("SWIGFunction", class('negative_binomial_draw'))

# Start of discrete_draw

`discrete_draw` = function(s_arg1, s_arg2, .copy = FALSE)
{
  s_arg1 = as.integer(s_arg1);
  
  if(length(s_arg1) > 1) {
    warning("using only the first element of s_arg1");
  };
  
  
  ;.Call('R_swig_discrete_draw', s_arg1, s_arg2, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`discrete_draw`, 'returnType') = 'integer'
attr(`discrete_draw`, "inputTypes") = c('integer', 'numeric')
class(`discrete_draw`) = c("SWIGFunction", class('discrete_draw'))

# Start of normalize_array

`normalize_array` = function(s_arg1, s_arg2)
{
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  ;.Call('R_swig_normalize_array', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`normalize_array`, 'returnType') = 'void'
attr(`normalize_array`, "inputTypes") = c('numeric', 'integer')
class(`normalize_array`) = c("SWIGFunction", class('normalize_array'))

# Start of copy_array

`copy_array` = function(s_arg1, s_arg2, s_arg3)
{
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;.Call('R_swig_copy_array', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`copy_array`, 'returnType') = 'void'
attr(`copy_array`, "inputTypes") = c('numeric', 'numeric', 'integer')
class(`copy_array`) = c("SWIGFunction", class('copy_array'))

# Start of copy_normalize_array

`copy_normalize_array` = function(s_arg1, s_arg2, s_arg3)
{
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;.Call('R_swig_copy_normalize_array', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`copy_normalize_array`, 'returnType') = 'void'
attr(`copy_normalize_array`, "inputTypes") = c('numeric', 'numeric', 'integer')
class(`copy_normalize_array`) = c("SWIGFunction", class('copy_normalize_array'))

# Start of sum_square_diff_array

`sum_square_diff_array` = function(s_arg1, s_arg2, s_arg3, .copy = FALSE)
{
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  ;.Call('R_swig_sum_square_diff_array', s_arg1, s_arg2, s_arg3, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`sum_square_diff_array`, 'returnType') = 'numeric'
attr(`sum_square_diff_array`, "inputTypes") = c('numeric', 'numeric', 'integer')
class(`sum_square_diff_array`) = c("SWIGFunction", class('sum_square_diff_array'))

# Start of n_unique_elements

`n_unique_elements` = function(s_arg1, s_arg2, .copy = FALSE)
{
  s_arg1 = as.integer(s_arg1);
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  ;.Call('R_swig_n_unique_elements', s_arg1, s_arg2, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`n_unique_elements`, 'returnType') = 'integer'
attr(`n_unique_elements`, "inputTypes") = c('integer', 'integer')
class(`n_unique_elements`) = c("SWIGFunction", class('n_unique_elements'))

# Start of setup_gsl_rng

`setup_gsl_rng` = function(s_arg1)
{
  s_arg1 = as.integer(s_arg1);
  
  if(length(s_arg1) > 1) {
    warning("using only the first element of s_arg1");
  };
  
  ;.Call('R_swig_setup_gsl_rng', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`setup_gsl_rng`, 'returnType') = 'void'
attr(`setup_gsl_rng`, "inputTypes") = c('integer')
class(`setup_gsl_rng`) = c("SWIGFunction", class('setup_gsl_rng'))

# Start of free_gsl_rng

`free_gsl_rng` = function()
{
  ;.Call('R_swig_free_gsl_rng', PACKAGE='OpenABMCovid19');
  
}

attr(`free_gsl_rng`, 'returnType') = 'void'
class(`free_gsl_rng`) = c("SWIGFunction", class('free_gsl_rng'))

# Start of incomplete_gamma_p_params_n_set

`incomplete_gamma_p_params_n_set` = function(self, s_n)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n = as.integer(s_n);
  
  if(length(s_n) > 1) {
    warning("using only the first element of s_n");
  };
  
  ;.Call('R_swig_incomplete_gamma_p_params_n_set', self, s_n, PACKAGE='OpenABMCovid19');
  
}

attr(`incomplete_gamma_p_params_n_set`, 'returnType') = 'void'
attr(`incomplete_gamma_p_params_n_set`, "inputTypes") = c('_p_incomplete_gamma_p_params', 'integer')
class(`incomplete_gamma_p_params_n_set`) = c("SWIGFunction", class('incomplete_gamma_p_params_n_set'))

# Start of incomplete_gamma_p_params_n_get

`incomplete_gamma_p_params_n_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_incomplete_gamma_p_params_n_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`incomplete_gamma_p_params_n_get`, 'returnType') = 'integer'
attr(`incomplete_gamma_p_params_n_get`, "inputTypes") = c('_p_incomplete_gamma_p_params')
class(`incomplete_gamma_p_params_n_get`) = c("SWIGFunction", class('incomplete_gamma_p_params_n_get'))

# Start of incomplete_gamma_p_params_percentile_set

`incomplete_gamma_p_params_percentile_set` = function(self, s_percentile)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_incomplete_gamma_p_params_percentile_set', self, s_percentile, PACKAGE='OpenABMCovid19');
  
}

attr(`incomplete_gamma_p_params_percentile_set`, 'returnType') = 'void'
attr(`incomplete_gamma_p_params_percentile_set`, "inputTypes") = c('_p_incomplete_gamma_p_params', 'numeric')
class(`incomplete_gamma_p_params_percentile_set`) = c("SWIGFunction", class('incomplete_gamma_p_params_percentile_set'))

# Start of incomplete_gamma_p_params_percentile_get

`incomplete_gamma_p_params_percentile_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_incomplete_gamma_p_params_percentile_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`incomplete_gamma_p_params_percentile_get`, 'returnType') = 'numeric'
attr(`incomplete_gamma_p_params_percentile_get`, "inputTypes") = c('_p_incomplete_gamma_p_params')
class(`incomplete_gamma_p_params_percentile_get`) = c("SWIGFunction", class('incomplete_gamma_p_params_percentile_get'))

# Start of accessor method for incomplete_gamma_p_params
setMethod('$', '_p_incomplete_gamma_p_params', function(x, name)

{
  accessorFuns = list('n' = incomplete_gamma_p_params_n_get, 'percentile' = incomplete_gamma_p_params_percentile_get);
  vaccessors = c('n', 'percentile');
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  if (is.na(match(name, vaccessors))) function(...){
    f(x, ...)
  } else f(x);
}


);
# end of accessor method for incomplete_gamma_p_params
# Start of accessor method for incomplete_gamma_p_params
setMethod('$<-', '_p_incomplete_gamma_p_params', function(x, name, value)

{
  accessorFuns = list('n' = incomplete_gamma_p_params_n_set, 'percentile' = incomplete_gamma_p_params_percentile_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
setMethod('[[<-', c('_p_incomplete_gamma_p_params', 'character'),function(x, i, j, ..., value)

{
  name = i;
  accessorFuns = list('n' = incomplete_gamma_p_params_n_set, 'percentile' = incomplete_gamma_p_params_percentile_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
# end of accessor method for incomplete_gamma_p_params
# Start definition of copy functions & methods for incomplete_gamma_p_params
CopyToR_incomplete_gamma_p_params = function(value, obj = new("incomplete_gamma_p_params"))
{
  obj@n = value$n;
  obj@percentile = value$percentile;
  obj;
}



CopyToC_incomplete_gamma_p_params = function(value, obj)
{
  obj$n = value@n;
  obj$percentile = value@percentile;
  obj
}



# Start definition of copy methods for incomplete_gamma_p_params
setMethod('copyToR', '_p_incomplete_gamma_p_params', CopyToR_incomplete_gamma_p_params);
setMethod('copyToC', 'incomplete_gamma_p_params', CopyToC_incomplete_gamma_p_params);

# End definition of copy methods for incomplete_gamma_p_params
# End definition of copy functions & methods for incomplete_gamma_p_params
# Start of incomplete_gamma_p

`incomplete_gamma_p` = function(s_arg1, params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_incomplete_gamma_p', s_arg1, params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`incomplete_gamma_p`, 'returnType') = 'numeric'
attr(`incomplete_gamma_p`, "inputTypes") = c('numeric', '_p_void')
class(`incomplete_gamma_p`) = c("SWIGFunction", class('incomplete_gamma_p'))

# Start of inv_incomplete_gamma_p

`inv_incomplete_gamma_p` = function(s_arg1, s_arg2, .copy = FALSE)
{
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  ;.Call('R_swig_inv_incomplete_gamma_p', s_arg1, s_arg2, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`inv_incomplete_gamma_p`, 'returnType') = 'numeric'
attr(`inv_incomplete_gamma_p`, "inputTypes") = c('numeric', 'integer')
class(`inv_incomplete_gamma_p`) = c("SWIGFunction", class('inv_incomplete_gamma_p'))

# Start of set_up_transition_times

`set_up_transition_times` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_set_up_transition_times', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`set_up_transition_times`, 'returnType') = 'void'
attr(`set_up_transition_times`, "inputTypes") = c('_p_model')
class(`set_up_transition_times`) = c("SWIGFunction", class('set_up_transition_times'))

# Start of set_up_infectious_curves

`set_up_infectious_curves` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_set_up_infectious_curves', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`set_up_infectious_curves`, 'returnType') = 'void'
attr(`set_up_infectious_curves`, "inputTypes") = c('_p_model')
class(`set_up_infectious_curves`) = c("SWIGFunction", class('set_up_infectious_curves'))

# Start of estimate_mean_interactions_by_age

`estimate_mean_interactions_by_age` = function(pmodel, age, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  age = as.integer(age);
  
  if(length(age) > 1) {
    warning("using only the first element of age");
  };
  
  ;.Call('R_swig_estimate_mean_interactions_by_age', pmodel, age, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`estimate_mean_interactions_by_age`, 'returnType') = 'numeric'
attr(`estimate_mean_interactions_by_age`, "inputTypes") = c('_p_model', 'integer')
class(`estimate_mean_interactions_by_age`) = c("SWIGFunction", class('estimate_mean_interactions_by_age'))

# Start of transmit_virus

`transmit_virus` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_transmit_virus', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`transmit_virus`, 'returnType') = 'void'
attr(`transmit_virus`, "inputTypes") = c('_p_model')
class(`transmit_virus`) = c("SWIGFunction", class('transmit_virus'))

# Start of transmit_virus_by_type

`transmit_virus_by_type` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  ;.Call('R_swig_transmit_virus_by_type', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`transmit_virus_by_type`, 'returnType') = 'void'
attr(`transmit_virus_by_type`, "inputTypes") = c('_p_model', 'integer')
class(`transmit_virus_by_type`) = c("SWIGFunction", class('transmit_virus_by_type'))

# Start of new_infection

`new_infection` = function(s_arg1, s_arg2, s_arg3, s_arg4, s_arg5)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  if (inherits(s_arg3, "ExternalReference")) s_arg3 = slot(s_arg3,"ref") 
  s_arg4 = as.integer(s_arg4);
  
  if(length(s_arg4) > 1) {
    warning("using only the first element of s_arg4");
  };
  
  if (inherits(s_arg5, "ExternalReference")) s_arg5 = slot(s_arg5,"ref") 
  ;.Call('R_swig_new_infection', s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, PACKAGE='OpenABMCovid19');
  
}

attr(`new_infection`, 'returnType') = 'void'
attr(`new_infection`, "inputTypes") = c('_p_model', '_p_individual', '_p_individual', 'integer', '_p_strain')
class(`new_infection`) = c("SWIGFunction", class('new_infection'))

# Start of seed_infect_by_idx

`seed_infect_by_idx` = function(s_arg1, s_arg2, s_arg3, s_arg4, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  s_arg4 = as.integer(s_arg4);
  
  if(length(s_arg4) > 1) {
    warning("using only the first element of s_arg4");
  };
  
  ;.Call('R_swig_seed_infect_by_idx', s_arg1, s_arg2, s_arg3, s_arg4, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`seed_infect_by_idx`, 'returnType') = 'integer'
attr(`seed_infect_by_idx`, "inputTypes") = c('_p_model', 'integer', 'integer', 'integer')
class(`seed_infect_by_idx`) = c("SWIGFunction", class('seed_infect_by_idx'))

# Start of transition_to_symptomatic

`transition_to_symptomatic` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_transition_to_symptomatic', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`transition_to_symptomatic`, 'returnType') = 'void'
attr(`transition_to_symptomatic`, "inputTypes") = c('_p_model', '_p_individual')
class(`transition_to_symptomatic`) = c("SWIGFunction", class('transition_to_symptomatic'))

# Start of transition_to_symptomatic_mild

`transition_to_symptomatic_mild` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_transition_to_symptomatic_mild', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`transition_to_symptomatic_mild`, 'returnType') = 'void'
attr(`transition_to_symptomatic_mild`, "inputTypes") = c('_p_model', '_p_individual')
class(`transition_to_symptomatic_mild`) = c("SWIGFunction", class('transition_to_symptomatic_mild'))

# Start of transition_to_hospitalised

`transition_to_hospitalised` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_transition_to_hospitalised', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`transition_to_hospitalised`, 'returnType') = 'void'
attr(`transition_to_hospitalised`, "inputTypes") = c('_p_model', '_p_individual')
class(`transition_to_hospitalised`) = c("SWIGFunction", class('transition_to_hospitalised'))

# Start of transition_to_hospitalised_recovering

`transition_to_hospitalised_recovering` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_transition_to_hospitalised_recovering', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`transition_to_hospitalised_recovering`, 'returnType') = 'void'
attr(`transition_to_hospitalised_recovering`, "inputTypes") = c('_p_model', '_p_individual')
class(`transition_to_hospitalised_recovering`) = c("SWIGFunction", class('transition_to_hospitalised_recovering'))

# Start of transition_to_critical

`transition_to_critical` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_transition_to_critical', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`transition_to_critical`, 'returnType') = 'void'
attr(`transition_to_critical`, "inputTypes") = c('_p_model', '_p_individual')
class(`transition_to_critical`) = c("SWIGFunction", class('transition_to_critical'))

# Start of transition_to_recovered

`transition_to_recovered` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_transition_to_recovered', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`transition_to_recovered`, 'returnType') = 'void'
attr(`transition_to_recovered`, "inputTypes") = c('_p_model', '_p_individual')
class(`transition_to_recovered`) = c("SWIGFunction", class('transition_to_recovered'))

# Start of transition_to_susceptible

`transition_to_susceptible` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_transition_to_susceptible', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`transition_to_susceptible`, 'returnType') = 'void'
attr(`transition_to_susceptible`, "inputTypes") = c('_p_model', '_p_individual')
class(`transition_to_susceptible`) = c("SWIGFunction", class('transition_to_susceptible'))

# Start of transition_to_death

`transition_to_death` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  ;.Call('R_swig_transition_to_death', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`transition_to_death`, 'returnType') = 'void'
attr(`transition_to_death`, "inputTypes") = c('_p_model', '_p_individual')
class(`transition_to_death`) = c("SWIGFunction", class('transition_to_death'))

# Start of transition_one_disese_event

`transition_one_disese_event` = function(s_arg1, s_arg2, s_arg3, s_arg4, s_arg5)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  s_arg4 = as.integer(s_arg4);
  
  if(length(s_arg4) > 1) {
    warning("using only the first element of s_arg4");
  };
  
  s_arg5 = as.integer(s_arg5);
  
  if(length(s_arg5) > 1) {
    warning("using only the first element of s_arg5");
  };
  
  ;.Call('R_swig_transition_one_disese_event', s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, PACKAGE='OpenABMCovid19');
  
}

attr(`transition_one_disese_event`, 'returnType') = 'void'
attr(`transition_one_disese_event`, "inputTypes") = c('_p_model', '_p_individual', 'integer', 'integer', 'integer')
class(`transition_one_disese_event`) = c("SWIGFunction", class('transition_one_disese_event'))

# Start of apply_cross_immunity

`apply_cross_immunity` = function(s_arg1, s_arg2, s_arg3, s_arg4, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  if (inherits(s_arg2, "ExternalReference")) s_arg2 = slot(s_arg2,"ref") 
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  s_arg4 = as.integer(s_arg4);
  
  if(length(s_arg4) > 1) {
    warning("using only the first element of s_arg4");
  };
  
  ;.Call('R_swig_apply_cross_immunity', s_arg1, s_arg2, s_arg3, s_arg4, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`apply_cross_immunity`, 'returnType') = 'integer'
attr(`apply_cross_immunity`, "inputTypes") = c('_p_model', '_p_individual', 'integer', 'integer')
class(`apply_cross_immunity`) = c("SWIGFunction", class('apply_cross_immunity'))

# Start of n_newly_infected

`n_newly_infected` = function(s_arg1, time, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  time = as.integer(time);
  
  if(length(time) > 1) {
    warning("using only the first element of time");
  };
  
  ;.Call('R_swig_n_newly_infected', s_arg1, time, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`n_newly_infected`, 'returnType') = 'integer'
attr(`n_newly_infected`, "inputTypes") = c('_p_model', 'integer')
class(`n_newly_infected`) = c("SWIGFunction", class('n_newly_infected'))

# Start of calculate_R_instanteous

`calculate_R_instanteous` = function(s_arg1, s_arg2, s_arg3, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  
  ;.Call('R_swig_calculate_R_instanteous', s_arg1, s_arg2, s_arg3, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`calculate_R_instanteous`, 'returnType') = 'numeric'
attr(`calculate_R_instanteous`, "inputTypes") = c('_p_model', 'integer', 'numeric')
class(`calculate_R_instanteous`) = c("SWIGFunction", class('calculate_R_instanteous'))

# Start of set_cross_immunity_probability

`set_cross_immunity_probability` = function(s_arg1, s_arg2, s_arg3, s_arg4)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  s_arg3 = as.integer(s_arg3);
  
  if(length(s_arg3) > 1) {
    warning("using only the first element of s_arg3");
  };
  
  
  ;.Call('R_swig_set_cross_immunity_probability', s_arg1, s_arg2, s_arg3, s_arg4, PACKAGE='OpenABMCovid19');
  
}

attr(`set_cross_immunity_probability`, 'returnType') = 'void'
attr(`set_cross_immunity_probability`, "inputTypes") = c('_p_model', 'integer', 'integer', 'numeric')
class(`set_cross_immunity_probability`) = c("SWIGFunction", class('set_cross_immunity_probability'))

# Start of edge_id1_set

`edge_id1_set` = function(self, s_id1)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_id1 = as.integer(s_id1);
  
  if(length(s_id1) > 1) {
    warning("using only the first element of s_id1");
  };
  
  ;.Call('R_swig_edge_id1_set', self, s_id1, PACKAGE='OpenABMCovid19');
  
}

attr(`edge_id1_set`, 'returnType') = 'void'
attr(`edge_id1_set`, "inputTypes") = c('_p_edge', 'integer')
class(`edge_id1_set`) = c("SWIGFunction", class('edge_id1_set'))

# Start of edge_id1_get

`edge_id1_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_edge_id1_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`edge_id1_get`, 'returnType') = 'integer'
attr(`edge_id1_get`, "inputTypes") = c('_p_edge')
class(`edge_id1_get`) = c("SWIGFunction", class('edge_id1_get'))

# Start of edge_id2_set

`edge_id2_set` = function(self, s_id2)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_id2 = as.integer(s_id2);
  
  if(length(s_id2) > 1) {
    warning("using only the first element of s_id2");
  };
  
  ;.Call('R_swig_edge_id2_set', self, s_id2, PACKAGE='OpenABMCovid19');
  
}

attr(`edge_id2_set`, 'returnType') = 'void'
attr(`edge_id2_set`, "inputTypes") = c('_p_edge', 'integer')
class(`edge_id2_set`) = c("SWIGFunction", class('edge_id2_set'))

# Start of edge_id2_get

`edge_id2_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_edge_id2_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`edge_id2_get`, 'returnType') = 'integer'
attr(`edge_id2_get`, "inputTypes") = c('_p_edge')
class(`edge_id2_get`) = c("SWIGFunction", class('edge_id2_get'))

# Start of accessor method for edge
setMethod('$', '_p_edge', function(x, name)

{
  accessorFuns = list('id1' = edge_id1_get, 'id2' = edge_id2_get);
  vaccessors = c('id1', 'id2');
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  if (is.na(match(name, vaccessors))) function(...){
    f(x, ...)
  } else f(x);
}


);
# end of accessor method for edge
# Start of accessor method for edge
setMethod('$<-', '_p_edge', function(x, name, value)

{
  accessorFuns = list('id1' = edge_id1_set, 'id2' = edge_id2_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
setMethod('[[<-', c('_p_edge', 'character'),function(x, i, j, ..., value)

{
  name = i;
  accessorFuns = list('id1' = edge_id1_set, 'id2' = edge_id2_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
# end of accessor method for edge
# Start definition of copy functions & methods for edge
CopyToR_edge = function(value, obj = new("edge"))
{
  obj@id1 = value$id1;
  obj@id2 = value$id2;
  obj;
}



CopyToC_edge = function(value, obj)
{
  obj$id1 = value@id1;
  obj$id2 = value@id2;
  obj
}



# Start definition of copy methods for edge
setMethod('copyToR', '_p_edge', CopyToR_edge);
setMethod('copyToC', 'edge', CopyToC_edge);

# End definition of copy methods for edge
# End definition of copy functions & methods for edge
# Start of network_edges_set

`network_edges_set` = function(self, s_edges)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_edges, "ExternalReference")) s_edges = slot(s_edges,"ref") 
  ;.Call('R_swig_network_edges_set', self, s_edges, PACKAGE='OpenABMCovid19');
  
}

attr(`network_edges_set`, 'returnType') = 'void'
attr(`network_edges_set`, "inputTypes") = c('_p_network', '_p_edge')
class(`network_edges_set`) = c("SWIGFunction", class('network_edges_set'))

# Start of network_edges_get

`network_edges_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_network_edges_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_edge", ref=ans) ;
  
  ans
  
}

attr(`network_edges_get`, 'returnType') = '_p_edge'
attr(`network_edges_get`, "inputTypes") = c('_p_network')
class(`network_edges_get`) = c("SWIGFunction", class('network_edges_get'))

# Start of network_n_edges_set

`network_n_edges_set` = function(self, s_n_edges)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_edges = as.integer(s_n_edges);
  
  if(length(s_n_edges) > 1) {
    warning("using only the first element of s_n_edges");
  };
  
  ;.Call('R_swig_network_n_edges_set', self, s_n_edges, PACKAGE='OpenABMCovid19');
  
}

attr(`network_n_edges_set`, 'returnType') = 'void'
attr(`network_n_edges_set`, "inputTypes") = c('_p_network', 'integer')
class(`network_n_edges_set`) = c("SWIGFunction", class('network_n_edges_set'))

# Start of network_n_edges_get

`network_n_edges_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_network_n_edges_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`network_n_edges_get`, 'returnType') = 'integer'
attr(`network_n_edges_get`, "inputTypes") = c('_p_network')
class(`network_n_edges_get`) = c("SWIGFunction", class('network_n_edges_get'))

# Start of network_n_vertices_set

`network_n_vertices_set` = function(self, s_n_vertices)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_n_vertices = as.integer(s_n_vertices);
  
  if(length(s_n_vertices) > 1) {
    warning("using only the first element of s_n_vertices");
  };
  
  ;.Call('R_swig_network_n_vertices_set', self, s_n_vertices, PACKAGE='OpenABMCovid19');
  
}

attr(`network_n_vertices_set`, 'returnType') = 'void'
attr(`network_n_vertices_set`, "inputTypes") = c('_p_network', 'integer')
class(`network_n_vertices_set`) = c("SWIGFunction", class('network_n_vertices_set'))

# Start of network_n_vertices_get

`network_n_vertices_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_network_n_vertices_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`network_n_vertices_get`, 'returnType') = 'integer'
attr(`network_n_vertices_get`, "inputTypes") = c('_p_network')
class(`network_n_vertices_get`) = c("SWIGFunction", class('network_n_vertices_get'))

# Start of network_type_set

`network_type_set` = function(self, s_type)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_type = as.integer(s_type);
  
  if(length(s_type) > 1) {
    warning("using only the first element of s_type");
  };
  
  ;.Call('R_swig_network_type_set', self, s_type, PACKAGE='OpenABMCovid19');
  
}

attr(`network_type_set`, 'returnType') = 'void'
attr(`network_type_set`, "inputTypes") = c('_p_network', 'integer')
class(`network_type_set`) = c("SWIGFunction", class('network_type_set'))

# Start of network_type_get

`network_type_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_network_type_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`network_type_get`, 'returnType') = 'integer'
attr(`network_type_get`, "inputTypes") = c('_p_network')
class(`network_type_get`) = c("SWIGFunction", class('network_type_get'))

# Start of network_skip_hospitalised_set

`network_skip_hospitalised_set` = function(self, s_skip_hospitalised)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_skip_hospitalised = as.integer(s_skip_hospitalised);
  
  if(length(s_skip_hospitalised) > 1) {
    warning("using only the first element of s_skip_hospitalised");
  };
  
  ;.Call('R_swig_network_skip_hospitalised_set', self, s_skip_hospitalised, PACKAGE='OpenABMCovid19');
  
}

attr(`network_skip_hospitalised_set`, 'returnType') = 'void'
attr(`network_skip_hospitalised_set`, "inputTypes") = c('_p_network', 'integer')
class(`network_skip_hospitalised_set`) = c("SWIGFunction", class('network_skip_hospitalised_set'))

# Start of network_skip_hospitalised_get

`network_skip_hospitalised_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_network_skip_hospitalised_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`network_skip_hospitalised_get`, 'returnType') = 'integer'
attr(`network_skip_hospitalised_get`, "inputTypes") = c('_p_network')
class(`network_skip_hospitalised_get`) = c("SWIGFunction", class('network_skip_hospitalised_get'))

# Start of network_skip_quarantined_set

`network_skip_quarantined_set` = function(self, s_skip_quarantined)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_skip_quarantined = as.integer(s_skip_quarantined);
  
  if(length(s_skip_quarantined) > 1) {
    warning("using only the first element of s_skip_quarantined");
  };
  
  ;.Call('R_swig_network_skip_quarantined_set', self, s_skip_quarantined, PACKAGE='OpenABMCovid19');
  
}

attr(`network_skip_quarantined_set`, 'returnType') = 'void'
attr(`network_skip_quarantined_set`, "inputTypes") = c('_p_network', 'integer')
class(`network_skip_quarantined_set`) = c("SWIGFunction", class('network_skip_quarantined_set'))

# Start of network_skip_quarantined_get

`network_skip_quarantined_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_network_skip_quarantined_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`network_skip_quarantined_get`, 'returnType') = 'integer'
attr(`network_skip_quarantined_get`, "inputTypes") = c('_p_network')
class(`network_skip_quarantined_get`) = c("SWIGFunction", class('network_skip_quarantined_get'))

# Start of network_daily_fraction_set

`network_daily_fraction_set` = function(self, s_daily_fraction)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_network_daily_fraction_set', self, s_daily_fraction, PACKAGE='OpenABMCovid19');
  
}

attr(`network_daily_fraction_set`, 'returnType') = 'void'
attr(`network_daily_fraction_set`, "inputTypes") = c('_p_network', 'numeric')
class(`network_daily_fraction_set`) = c("SWIGFunction", class('network_daily_fraction_set'))

# Start of network_daily_fraction_get

`network_daily_fraction_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_network_daily_fraction_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`network_daily_fraction_get`, 'returnType') = 'numeric'
attr(`network_daily_fraction_get`, "inputTypes") = c('_p_network')
class(`network_daily_fraction_get`) = c("SWIGFunction", class('network_daily_fraction_get'))

# Start of network_network_id_set

`network_network_id_set` = function(self, s_network_id)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_network_id = as.integer(s_network_id);
  
  if(length(s_network_id) > 1) {
    warning("using only the first element of s_network_id");
  };
  
  ;.Call('R_swig_network_network_id_set', self, s_network_id, PACKAGE='OpenABMCovid19');
  
}

attr(`network_network_id_set`, 'returnType') = 'void'
attr(`network_network_id_set`, "inputTypes") = c('_p_network', 'integer')
class(`network_network_id_set`) = c("SWIGFunction", class('network_network_id_set'))

# Start of network_network_id_get

`network_network_id_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_network_network_id_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`network_network_id_get`, 'returnType') = 'integer'
attr(`network_network_id_get`, "inputTypes") = c('_p_network')
class(`network_network_id_get`) = c("SWIGFunction", class('network_network_id_get'))

# Start of network_name_set

`network_name_set` = function(self, s_name)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  if(is.list(s_name))
  assert(all(sapply(s_name, class) == "_p_char"));
  
  
#  assert(length(s_name) >= 300)
  
  ;.Call('R_swig_network_name_set', self, s_name, PACKAGE='OpenABMCovid19');
  
}

attr(`network_name_set`, 'returnType') = 'void'
attr(`network_name_set`, "inputTypes") = c('_p_network', '_p_char')
class(`network_name_set`) = c("SWIGFunction", class('network_name_set'))

# Start of network_name_get

`network_name_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_network_name_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  #ans <- new("_p_char", ref=ans) ;
  
  ans
  
}

attr(`network_name_get`, 'returnType') = '_p_char'
attr(`network_name_get`, "inputTypes") = c('_p_network')
class(`network_name_get`) = c("SWIGFunction", class('network_name_get'))

# Start of network_transmission_multiplier_set

`network_transmission_multiplier_set` = function(self, s_transmission_multiplier)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_network_transmission_multiplier_set', self, s_transmission_multiplier, PACKAGE='OpenABMCovid19');
  
}

attr(`network_transmission_multiplier_set`, 'returnType') = 'void'
attr(`network_transmission_multiplier_set`, "inputTypes") = c('_p_network', 'numeric')
class(`network_transmission_multiplier_set`) = c("SWIGFunction", class('network_transmission_multiplier_set'))

# Start of network_transmission_multiplier_get

`network_transmission_multiplier_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_network_transmission_multiplier_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`network_transmission_multiplier_get`, 'returnType') = 'numeric'
attr(`network_transmission_multiplier_get`, "inputTypes") = c('_p_network')
class(`network_transmission_multiplier_get`) = c("SWIGFunction", class('network_transmission_multiplier_get'))

# Start of network_construction_set

`network_construction_set` = function(self, s_construction)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_construction = as.integer(s_construction);
  
  if(length(s_construction) > 1) {
    warning("using only the first element of s_construction");
  };
  
  ;.Call('R_swig_network_construction_set', self, s_construction, PACKAGE='OpenABMCovid19');
  
}

attr(`network_construction_set`, 'returnType') = 'void'
attr(`network_construction_set`, "inputTypes") = c('_p_network', 'integer')
class(`network_construction_set`) = c("SWIGFunction", class('network_construction_set'))

# Start of network_construction_get

`network_construction_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_network_construction_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`network_construction_get`, 'returnType') = 'integer'
attr(`network_construction_get`, "inputTypes") = c('_p_network')
class(`network_construction_get`) = c("SWIGFunction", class('network_construction_get'))

# Start of network_opt_n_indiv_set

`network_opt_n_indiv_set` = function(self, s_opt_n_indiv)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_opt_n_indiv = as.integer(s_opt_n_indiv);
  
  if(length(s_opt_n_indiv) > 1) {
    warning("using only the first element of s_opt_n_indiv");
  };
  
  ;.Call('R_swig_network_opt_n_indiv_set', self, s_opt_n_indiv, PACKAGE='OpenABMCovid19');
  
}

attr(`network_opt_n_indiv_set`, 'returnType') = 'void'
attr(`network_opt_n_indiv_set`, "inputTypes") = c('_p_network', 'integer')
class(`network_opt_n_indiv_set`) = c("SWIGFunction", class('network_opt_n_indiv_set'))

# Start of network_opt_n_indiv_get

`network_opt_n_indiv_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_network_opt_n_indiv_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`network_opt_n_indiv_get`, 'returnType') = 'integer'
attr(`network_opt_n_indiv_get`, "inputTypes") = c('_p_network')
class(`network_opt_n_indiv_get`) = c("SWIGFunction", class('network_opt_n_indiv_get'))

# Start of network_opt_pdx_array_set

`network_opt_pdx_array_set` = function(self, s_opt_pdx_array)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_opt_pdx_array = as.integer(s_opt_pdx_array);
  ;.Call('R_swig_network_opt_pdx_array_set', self, s_opt_pdx_array, PACKAGE='OpenABMCovid19');
  
}

attr(`network_opt_pdx_array_set`, 'returnType') = 'void'
attr(`network_opt_pdx_array_set`, "inputTypes") = c('_p_network', 'integer')
class(`network_opt_pdx_array_set`) = c("SWIGFunction", class('network_opt_pdx_array_set'))

# Start of network_opt_pdx_array_get

`network_opt_pdx_array_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_network_opt_pdx_array_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_long", ref=ans) ;
  
  ans
  
}

attr(`network_opt_pdx_array_get`, 'returnType') = 'integer'
attr(`network_opt_pdx_array_get`, "inputTypes") = c('_p_network')
class(`network_opt_pdx_array_get`) = c("SWIGFunction", class('network_opt_pdx_array_get'))

# Start of network_opt_int_array_set

`network_opt_int_array_set` = function(self, s_opt_int_array)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_opt_int_array = as.integer(s_opt_int_array);
  ;.Call('R_swig_network_opt_int_array_set', self, s_opt_int_array, PACKAGE='OpenABMCovid19');
  
}

attr(`network_opt_int_array_set`, 'returnType') = 'void'
attr(`network_opt_int_array_set`, "inputTypes") = c('_p_network', 'integer')
class(`network_opt_int_array_set`) = c("SWIGFunction", class('network_opt_int_array_set'))

# Start of network_opt_int_array_get

`network_opt_int_array_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_network_opt_int_array_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_int", ref=ans) ;
  
  ans
  
}

attr(`network_opt_int_array_get`, 'returnType') = 'integer'
attr(`network_opt_int_array_get`, "inputTypes") = c('_p_network')
class(`network_opt_int_array_get`) = c("SWIGFunction", class('network_opt_int_array_get'))

# Start of network_opt_long_set

`network_opt_long_set` = function(self, s_opt_long)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_opt_long = as.integer(s_opt_long);
  
  if(length(s_opt_long) > 1) {
    warning("using only the first element of s_opt_long");
  };
  
  ;.Call('R_swig_network_opt_long_set', self, s_opt_long, PACKAGE='OpenABMCovid19');
  
}

attr(`network_opt_long_set`, 'returnType') = 'void'
attr(`network_opt_long_set`, "inputTypes") = c('_p_network', 'integer')
class(`network_opt_long_set`) = c("SWIGFunction", class('network_opt_long_set'))

# Start of network_opt_long_get

`network_opt_long_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_network_opt_long_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`network_opt_long_get`, 'returnType') = 'integer'
attr(`network_opt_long_get`, "inputTypes") = c('_p_network')
class(`network_opt_long_get`) = c("SWIGFunction", class('network_opt_long_get'))

# Start of network_opt_long_array_set

`network_opt_long_array_set` = function(self, s_opt_long_array)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_opt_long_array = as.integer(s_opt_long_array);
  ;.Call('R_swig_network_opt_long_array_set', self, s_opt_long_array, PACKAGE='OpenABMCovid19');
  
}

attr(`network_opt_long_array_set`, 'returnType') = 'void'
attr(`network_opt_long_array_set`, "inputTypes") = c('_p_network', 'integer')
class(`network_opt_long_array_set`) = c("SWIGFunction", class('network_opt_long_array_set'))

# Start of network_opt_long_array_get

`network_opt_long_array_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_network_opt_long_array_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_long", ref=ans) ;
  
  ans
  
}

attr(`network_opt_long_array_get`, 'returnType') = 'integer'
attr(`network_opt_long_array_get`, "inputTypes") = c('_p_network')
class(`network_opt_long_array_get`) = c("SWIGFunction", class('network_opt_long_array_get'))

# Start of network_next_network_set

`network_next_network_set` = function(self, s_next_network)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  if (inherits(s_next_network, "ExternalReference")) s_next_network = slot(s_next_network,"ref") 
  ;.Call('R_swig_network_next_network_set', self, s_next_network, PACKAGE='OpenABMCovid19');
  
}

attr(`network_next_network_set`, 'returnType') = 'void'
attr(`network_next_network_set`, "inputTypes") = c('_p_network', '_p_network')
class(`network_next_network_set`) = c("SWIGFunction", class('network_next_network_set'))

# Start of network_next_network_get

`network_next_network_get` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_network_next_network_get', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_network", ref=ans) ;
  
  ans
  
}

attr(`network_next_network_get`, 'returnType') = '_p_network'
attr(`network_next_network_get`, "inputTypes") = c('_p_network')
class(`network_next_network_get`) = c("SWIGFunction", class('network_next_network_get'))

# Start of new_network

`network` = function(.copy = FALSE)
{
  ;ans = .Call('R_swig_new_network', as.logical(.copy), PACKAGE='OpenABMCovid19');
  ans <- new("_p_network", ref=ans) ;
  
  reg.finalizer(ans@ref, delete_network)
  ans
  
}

attr(`network`, 'returnType') = '_p_network'
class(`network`) = c("SWIGFunction", class('network'))

# Start of accessor method for network
setMethod('$', '_p_network', function(x, name)

{
  accessorFuns = list('edges' = network_edges_get, 'n_edges' = network_n_edges_get, 'n_vertices' = network_n_vertices_get, 'type' = network_type_get, 'skip_hospitalised' = network_skip_hospitalised_get, 'skip_quarantined' = network_skip_quarantined_get, 'daily_fraction' = network_daily_fraction_get, 'network_id' = network_network_id_get, 'name' = network_name_get, 'transmission_multiplier' = network_transmission_multiplier_get, 'construction' = network_construction_get, 'opt_n_indiv' = network_opt_n_indiv_get, 'opt_pdx_array' = network_opt_pdx_array_get, 'opt_int_array' = network_opt_int_array_get, 'opt_long' = network_opt_long_get, 'opt_long_array' = network_opt_long_array_get, 'next_network' = network_next_network_get);
  vaccessors = c('edges', 'n_edges', 'n_vertices', 'type', 'skip_hospitalised', 'skip_quarantined', 'daily_fraction', 'network_id', 'name', 'transmission_multiplier', 'construction', 'opt_n_indiv', 'opt_pdx_array', 'opt_int_array', 'opt_long', 'opt_long_array', 'next_network');
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  if (is.na(match(name, vaccessors))) function(...){
    f(x, ...)
  } else f(x);
}


);
# end of accessor method for network
# Start of accessor method for network
setMethod('$<-', '_p_network', function(x, name, value)

{
  accessorFuns = list('edges' = network_edges_set, 'n_edges' = network_n_edges_set, 'n_vertices' = network_n_vertices_set, 'type' = network_type_set, 'skip_hospitalised' = network_skip_hospitalised_set, 'skip_quarantined' = network_skip_quarantined_set, 'daily_fraction' = network_daily_fraction_set, 'network_id' = network_network_id_set, 'name' = network_name_set, 'transmission_multiplier' = network_transmission_multiplier_set, 'construction' = network_construction_set, 'opt_n_indiv' = network_opt_n_indiv_set, 'opt_pdx_array' = network_opt_pdx_array_set, 'opt_int_array' = network_opt_int_array_set, 'opt_long' = network_opt_long_set, 'opt_long_array' = network_opt_long_array_set, 'next_network' = network_next_network_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
setMethod('[[<-', c('_p_network', 'character'),function(x, i, j, ..., value)

{
  name = i;
  accessorFuns = list('edges' = network_edges_set, 'n_edges' = network_n_edges_set, 'n_vertices' = network_n_vertices_set, 'type' = network_type_set, 'skip_hospitalised' = network_skip_hospitalised_set, 'skip_quarantined' = network_skip_quarantined_set, 'daily_fraction' = network_daily_fraction_set, 'network_id' = network_network_id_set, 'name' = network_name_set, 'transmission_multiplier' = network_transmission_multiplier_set, 'construction' = network_construction_set, 'opt_n_indiv' = network_opt_n_indiv_set, 'opt_pdx_array' = network_opt_pdx_array_set, 'opt_int_array' = network_opt_int_array_set, 'opt_long' = network_opt_long_set, 'opt_long_array' = network_opt_long_array_set, 'next_network' = network_next_network_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
# end of accessor method for network
# Start definition of copy functions & methods for network
CopyToR_network = function(value, obj = new("network"))
{
  obj@n_edges = value$n_edges;
  obj@n_vertices = value$n_vertices;
  obj@type = value$type;
  obj@skip_hospitalised = value$skip_hospitalised;
  obj@skip_quarantined = value$skip_quarantined;
  obj@daily_fraction = value$daily_fraction;
  obj@network_id = value$network_id;
  obj@name = value$name;
  obj@transmission_multiplier = value$transmission_multiplier;
  obj@construction = value$construction;
  obj@opt_n_indiv = value$opt_n_indiv;
  obj@opt_long = value$opt_long;
  obj;
}



CopyToC_network = function(value, obj)
{
  obj$n_edges = value@n_edges;
  obj$n_vertices = value@n_vertices;
  obj$type = value@type;
  obj$skip_hospitalised = value@skip_hospitalised;
  obj$skip_quarantined = value@skip_quarantined;
  obj$daily_fraction = value@daily_fraction;
  obj$network_id = value@network_id;
  obj$name = value@name;
  obj$transmission_multiplier = value@transmission_multiplier;
  obj$construction = value@construction;
  obj$opt_n_indiv = value@opt_n_indiv;
  obj$opt_long = value@opt_long;
  obj
}



# Start definition of copy methods for network
setMethod('copyToR', '_p_network', CopyToR_network);
setMethod('copyToC', 'network', CopyToC_network);

# End definition of copy methods for network
# End definition of copy functions & methods for network
# Start of create_network

`create_network` = function(n_total, type)
{
  n_total = as.integer(n_total);
  
  if(length(n_total) > 1) {
    warning("using only the first element of n_total");
  };
  
  type = as.integer(type);
  
  if(length(type) > 1) {
    warning("using only the first element of type");
  };
  
  ;ans = .Call('R_swig_create_network', n_total, type, PACKAGE='OpenABMCovid19');
  ans <- new("_p_network", ref=ans) ;
  
  ans
  
}

attr(`create_network`, 'returnType') = '_p_network'
attr(`create_network`, "inputTypes") = c('integer', 'integer')
class(`create_network`) = c("SWIGFunction", class('create_network'))

# Start of build_watts_strogatz_network

`build_watts_strogatz_network` = function(s_arg1, s_arg2, s_arg3, s_arg4, s_arg5)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  
  
  s_arg5 = as.integer(s_arg5);
  
  if(length(s_arg5) > 1) {
    warning("using only the first element of s_arg5");
  };
  
  ;.Call('R_swig_build_watts_strogatz_network', s_arg1, s_arg2, s_arg3, s_arg4, s_arg5, PACKAGE='OpenABMCovid19');
  
}

attr(`build_watts_strogatz_network`, 'returnType') = 'void'
attr(`build_watts_strogatz_network`, "inputTypes") = c('_p_network', 'integer', 'numeric', 'numeric', 'integer')
class(`build_watts_strogatz_network`) = c("SWIGFunction", class('build_watts_strogatz_network'))

# Start of check_member_or_self

`check_member_or_self` = function(s_arg1, s_arg2, s_arg3, s_arg4, .copy = FALSE)
{
  s_arg1 = as.integer(s_arg1);
  
  if(length(s_arg1) > 1) {
    warning("using only the first element of s_arg1");
  };
  
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  s_arg3 = as.integer(s_arg3);
  s_arg4 = as.integer(s_arg4);
  
  if(length(s_arg4) > 1) {
    warning("using only the first element of s_arg4");
  };
  
  ;.Call('R_swig_check_member_or_self', s_arg1, s_arg2, s_arg3, s_arg4, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`check_member_or_self`, 'returnType') = 'integer'
attr(`check_member_or_self`, "inputTypes") = c('integer', 'integer', 'integer', 'integer')
class(`check_member_or_self`) = c("SWIGFunction", class('check_member_or_self'))

# Start of remove_contact

`remove_contact` = function(s_arg1, s_arg2, s_arg3)
{
  s_arg1 = as.integer(s_arg1);
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  s_arg3 = as.integer(s_arg3);
  ;.Call('R_swig_remove_contact', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`remove_contact`, 'returnType') = 'void'
attr(`remove_contact`, "inputTypes") = c('integer', 'integer', 'integer')
class(`remove_contact`) = c("SWIGFunction", class('remove_contact'))

# Start of add_contact

`add_contact` = function(s_arg1, s_arg2, s_arg3)
{
  s_arg1 = as.integer(s_arg1);
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  s_arg3 = as.integer(s_arg3);
  ;.Call('R_swig_add_contact', s_arg1, s_arg2, s_arg3, PACKAGE='OpenABMCovid19');
  
}

attr(`add_contact`, 'returnType') = 'void'
attr(`add_contact`, "inputTypes") = c('integer', 'integer', 'integer')
class(`add_contact`) = c("SWIGFunction", class('add_contact'))

# Start of relabel_network

`relabel_network` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  ;.Call('R_swig_relabel_network', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  
}

attr(`relabel_network`, 'returnType') = 'void'
attr(`relabel_network`, "inputTypes") = c('_p_network', 'integer')
class(`relabel_network`) = c("SWIGFunction", class('relabel_network'))

# Start of destroy_network

`destroy_network` = function(s_arg1)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  ;.Call('R_swig_destroy_network', s_arg1, PACKAGE='OpenABMCovid19');
  
}

attr(`destroy_network`, 'returnType') = 'void'
attr(`destroy_network`, "inputTypes") = c('_p_network')
class(`destroy_network`) = c("SWIGFunction", class('destroy_network'))

# Start of update_daily_fraction

`update_daily_fraction` = function(s_arg1, s_arg2, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  
  ;.Call('R_swig_update_daily_fraction', s_arg1, s_arg2, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`update_daily_fraction`, 'returnType') = 'integer'
attr(`update_daily_fraction`, "inputTypes") = c('_p_network', 'numeric')
class(`update_daily_fraction`) = c("SWIGFunction", class('update_daily_fraction'))

# Start of strain_idx_set

`strain_idx_set` = function(self, s_idx)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  s_idx = as.integer(s_idx);
  
  if(length(s_idx) > 1) {
    warning("using only the first element of s_idx");
  };
  
  ;.Call('R_swig_strain_idx_set', self, s_idx, PACKAGE='OpenABMCovid19');
  
}

attr(`strain_idx_set`, 'returnType') = 'void'
attr(`strain_idx_set`, "inputTypes") = c('_p_strain', 'integer')
class(`strain_idx_set`) = c("SWIGFunction", class('strain_idx_set'))

# Start of strain_idx_get

`strain_idx_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_strain_idx_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`strain_idx_get`, 'returnType') = 'integer'
attr(`strain_idx_get`, "inputTypes") = c('_p_strain')
class(`strain_idx_get`) = c("SWIGFunction", class('strain_idx_get'))

# Start of strain_transmission_multiplier_set

`strain_transmission_multiplier_set` = function(self, s_transmission_multiplier)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  ;.Call('R_swig_strain_transmission_multiplier_set', self, s_transmission_multiplier, PACKAGE='OpenABMCovid19');
  
}

attr(`strain_transmission_multiplier_set`, 'returnType') = 'void'
attr(`strain_transmission_multiplier_set`, "inputTypes") = c('_p_strain', 'numeric')
class(`strain_transmission_multiplier_set`) = c("SWIGFunction", class('strain_transmission_multiplier_set'))

# Start of strain_transmission_multiplier_get

`strain_transmission_multiplier_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_strain_transmission_multiplier_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`strain_transmission_multiplier_get`, 'returnType') = 'numeric'
attr(`strain_transmission_multiplier_get`, "inputTypes") = c('_p_strain')
class(`strain_transmission_multiplier_get`) = c("SWIGFunction", class('strain_transmission_multiplier_get'))

# Start of strain_hospitalised_fraction_set

`strain_hospitalised_fraction_set` = function(self, s_hospitalised_fraction)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  
  
#  assert(length(s_hospitalised_fraction) >= N_AGE_GROUPS)
  
  ;.Call('R_swig_strain_hospitalised_fraction_set', self, s_hospitalised_fraction, PACKAGE='OpenABMCovid19');
  
}

attr(`strain_hospitalised_fraction_set`, 'returnType') = 'void'
attr(`strain_hospitalised_fraction_set`, "inputTypes") = c('_p_strain', 'numeric')
class(`strain_hospitalised_fraction_set`) = c("SWIGFunction", class('strain_hospitalised_fraction_set'))

# Start of strain_hospitalised_fraction_get

`strain_hospitalised_fraction_get` = function(self, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_strain_hospitalised_fraction_get', self, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`strain_hospitalised_fraction_get`, 'returnType') = 'numeric'
attr(`strain_hospitalised_fraction_get`, "inputTypes") = c('_p_strain')
class(`strain_hospitalised_fraction_get`) = c("SWIGFunction", class('strain_hospitalised_fraction_get'))

# Start of accessor method for strain
setMethod('$', '_p_strain', function(x, name)

{
  accessorFuns = list('idx' = strain_idx_get, 'transmission_multiplier' = strain_transmission_multiplier_get, 'hospitalised_fraction' = strain_hospitalised_fraction_get);
  vaccessors = c('idx', 'transmission_multiplier', 'hospitalised_fraction');
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  if (is.na(match(name, vaccessors))) function(...){
    f(x, ...)
  } else f(x);
}


);
# end of accessor method for strain
# Start of accessor method for strain
setMethod('$<-', '_p_strain', function(x, name, value)

{
  accessorFuns = list('idx' = strain_idx_set, 'transmission_multiplier' = strain_transmission_multiplier_set, 'hospitalised_fraction' = strain_hospitalised_fraction_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
setMethod('[[<-', c('_p_strain', 'character'),function(x, i, j, ..., value)

{
  name = i;
  accessorFuns = list('idx' = strain_idx_set, 'transmission_multiplier' = strain_transmission_multiplier_set, 'hospitalised_fraction' = strain_hospitalised_fraction_set);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name, value));
  f = accessorFuns[[idx]];
  f(x, value);
  x;
}


);
# end of accessor method for strain
# Start definition of copy functions & methods for strain
CopyToR_strain = function(value, obj = new("strain"))
{
  obj@idx = value$idx;
  obj@transmission_multiplier = value$transmission_multiplier;
  obj@hospitalised_fraction = value$hospitalised_fraction;
  obj;
}



CopyToC_strain = function(value, obj)
{
  obj$idx = value@idx;
  obj$transmission_multiplier = value@transmission_multiplier;
  obj$hospitalised_fraction = value@hospitalised_fraction;
  obj
}



# Start definition of copy methods for strain
setMethod('copyToR', '_p_strain', CopyToR_strain);
setMethod('copyToC', 'strain', CopyToC_strain);

# End definition of copy methods for strain
# End definition of copy functions & methods for strain
# Start of add_new_strain

`add_new_strain` = function(s_arg1, s_arg2, s_arg3, .copy = FALSE)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  
  
  ;.Call('R_swig_add_new_strain', s_arg1, s_arg2, s_arg3, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`add_new_strain`, 'returnType') = 'integer'
attr(`add_new_strain`, "inputTypes") = c('_p_model', 'numeric', 'numeric')
class(`add_new_strain`) = c("SWIGFunction", class('add_new_strain'))

# Start of get_strain_by_id

`get_strain_by_id` = function(s_arg1, s_arg2)
{
  if (inherits(s_arg1, "ExternalReference")) s_arg1 = slot(s_arg1,"ref") 
  s_arg2 = as.integer(s_arg2);
  
  if(length(s_arg2) > 1) {
    warning("using only the first element of s_arg2");
  };
  
  ;ans = .Call('R_swig_get_strain_by_id', s_arg1, s_arg2, PACKAGE='OpenABMCovid19');
  ans <- new("_p_strain", ref=ans) ;
  
  ans
  
}

attr(`get_strain_by_id`, 'returnType') = '_p_strain'
attr(`get_strain_by_id`, "inputTypes") = c('_p_model', 'integer')
class(`get_strain_by_id`) = c("SWIGFunction", class('get_strain_by_id'))

# Start of utils_n_current

`utils_n_current` = function(pmodel, type, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  type = as.integer(type);
  
  if(length(type) > 1) {
    warning("using only the first element of type");
  };
  
  ;.Call('R_swig_utils_n_current', pmodel, type, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`utils_n_current`, 'returnType') = 'integer'
attr(`utils_n_current`, "inputTypes") = c('_p_model', 'integer')
class(`utils_n_current`) = c("SWIGFunction", class('utils_n_current'))

# Start of utils_n_total

`utils_n_total` = function(pmodel, type, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  type = as.integer(type);
  
  if(length(type) > 1) {
    warning("using only the first element of type");
  };
  
  ;.Call('R_swig_utils_n_total', pmodel, type, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`utils_n_total`, 'returnType') = 'integer'
attr(`utils_n_total`, "inputTypes") = c('_p_model', 'integer')
class(`utils_n_total`) = c("SWIGFunction", class('utils_n_total'))

# Start of utils_n_total_by_day

`utils_n_total_by_day` = function(pmodel, type, day, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  type = as.integer(type);
  
  if(length(type) > 1) {
    warning("using only the first element of type");
  };
  
  day = as.integer(day);
  
  if(length(day) > 1) {
    warning("using only the first element of day");
  };
  
  ;.Call('R_swig_utils_n_total_by_day', pmodel, type, day, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`utils_n_total_by_day`, 'returnType') = 'integer'
attr(`utils_n_total_by_day`, "inputTypes") = c('_p_model', 'integer', 'integer')
class(`utils_n_total_by_day`) = c("SWIGFunction", class('utils_n_total_by_day'))

# Start of utils_n_total_age

`utils_n_total_age` = function(pmodel, type, age, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  type = as.integer(type);
  
  if(length(type) > 1) {
    warning("using only the first element of type");
  };
  
  age = as.integer(age);
  
  if(length(age) > 1) {
    warning("using only the first element of age");
  };
  
  ;.Call('R_swig_utils_n_total_age', pmodel, type, age, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`utils_n_total_age`, 'returnType') = 'integer'
attr(`utils_n_total_age`, "inputTypes") = c('_p_model', 'integer', 'integer')
class(`utils_n_total_age`) = c("SWIGFunction", class('utils_n_total_age'))

# Start of utils_n_daily

`utils_n_daily` = function(pmodel, type, day, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  type = as.integer(type);
  
  if(length(type) > 1) {
    warning("using only the first element of type");
  };
  
  day = as.integer(day);
  
  if(length(day) > 1) {
    warning("using only the first element of day");
  };
  
  ;.Call('R_swig_utils_n_daily', pmodel, type, day, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`utils_n_daily`, 'returnType') = 'integer'
attr(`utils_n_daily`, "inputTypes") = c('_p_model', 'integer', 'integer')
class(`utils_n_daily`) = c("SWIGFunction", class('utils_n_daily'))

# Start of utils_n_daily_age

`utils_n_daily_age` = function(pmodel, type, day, age, .copy = FALSE)
{
  if (inherits(pmodel, "ExternalReference")) pmodel = slot(pmodel,"ref") 
  type = as.integer(type);
  
  if(length(type) > 1) {
    warning("using only the first element of type");
  };
  
  day = as.integer(day);
  
  if(length(day) > 1) {
    warning("using only the first element of day");
  };
  
  age = as.integer(age);
  
  if(length(age) > 1) {
    warning("using only the first element of age");
  };
  
  ;.Call('R_swig_utils_n_daily_age', pmodel, type, day, age, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`utils_n_daily_age`, 'returnType') = 'integer'
attr(`utils_n_daily_age`, "inputTypes") = c('_p_model', 'integer', 'integer', 'integer')
class(`utils_n_daily_age`) = c("SWIGFunction", class('utils_n_daily_age'))

# Start of get_param_quarantine_days

`get_param_quarantine_days` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_quarantine_days', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_quarantine_days`, 'returnType') = 'integer'
attr(`get_param_quarantine_days`, "inputTypes") = c('_p_parameters')
class(`get_param_quarantine_days`) = c("SWIGFunction", class('get_param_quarantine_days'))

# Start of get_param_hospital_on

`get_param_hospital_on` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_hospital_on', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_hospital_on`, 'returnType') = 'integer'
attr(`get_param_hospital_on`, "inputTypes") = c('_p_parameters')
class(`get_param_hospital_on`) = c("SWIGFunction", class('get_param_hospital_on'))

# Start of get_param_rng_seed

`get_param_rng_seed` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_rng_seed', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_rng_seed`, 'returnType') = 'integer'
attr(`get_param_rng_seed`, "inputTypes") = c('_p_parameters')
class(`get_param_rng_seed`) = c("SWIGFunction", class('get_param_rng_seed'))

# Start of get_param_param_id

`get_param_param_id` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_param_id', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_param_id`, 'returnType') = 'integer'
attr(`get_param_param_id`, "inputTypes") = c('_p_parameters')
class(`get_param_param_id`) = c("SWIGFunction", class('get_param_param_id'))

# Start of get_param_n_total

`get_param_n_total` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_n_total', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_n_total`, 'returnType') = 'integer'
attr(`get_param_n_total`, "inputTypes") = c('_p_parameters')
class(`get_param_n_total`) = c("SWIGFunction", class('get_param_n_total'))

# Start of get_param_days_of_interactions

`get_param_days_of_interactions` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_days_of_interactions', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_days_of_interactions`, 'returnType') = 'integer'
attr(`get_param_days_of_interactions`, "inputTypes") = c('_p_parameters')
class(`get_param_days_of_interactions`) = c("SWIGFunction", class('get_param_days_of_interactions'))

# Start of get_param_mean_random_interactions

`get_param_mean_random_interactions` = function(params, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_param_mean_random_interactions', params, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_mean_random_interactions`, 'returnType') = 'numeric'
attr(`get_param_mean_random_interactions`, "inputTypes") = c('_p_parameters', 'integer')
class(`get_param_mean_random_interactions`) = c("SWIGFunction", class('get_param_mean_random_interactions'))

# Start of get_param_sd_random_interactions

`get_param_sd_random_interactions` = function(params, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_param_sd_random_interactions', params, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_sd_random_interactions`, 'returnType') = 'numeric'
attr(`get_param_sd_random_interactions`, "inputTypes") = c('_p_parameters', 'integer')
class(`get_param_sd_random_interactions`) = c("SWIGFunction", class('get_param_sd_random_interactions'))

# Start of get_param_random_interaction_distribution

`get_param_random_interaction_distribution` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_random_interaction_distribution', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_random_interaction_distribution`, 'returnType') = 'integer'
attr(`get_param_random_interaction_distribution`, "inputTypes") = c('_p_parameters')
class(`get_param_random_interaction_distribution`) = c("SWIGFunction", class('get_param_random_interaction_distribution'))

# Start of get_param_mean_work_interactions

`get_param_mean_work_interactions` = function(params, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_param_mean_work_interactions', params, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_mean_work_interactions`, 'returnType') = 'numeric'
attr(`get_param_mean_work_interactions`, "inputTypes") = c('_p_parameters', 'integer')
class(`get_param_mean_work_interactions`) = c("SWIGFunction", class('get_param_mean_work_interactions'))

# Start of get_param_daily_fraction_work

`get_param_daily_fraction_work` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_daily_fraction_work', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_daily_fraction_work`, 'returnType') = 'numeric'
attr(`get_param_daily_fraction_work`, "inputTypes") = c('_p_parameters')
class(`get_param_daily_fraction_work`) = c("SWIGFunction", class('get_param_daily_fraction_work'))

# Start of get_param_child_network_adults

`get_param_child_network_adults` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_child_network_adults', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_child_network_adults`, 'returnType') = 'numeric'
attr(`get_param_child_network_adults`, "inputTypes") = c('_p_parameters')
class(`get_param_child_network_adults`) = c("SWIGFunction", class('get_param_child_network_adults'))

# Start of get_param_elderly_network_adults

`get_param_elderly_network_adults` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_elderly_network_adults', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_elderly_network_adults`, 'returnType') = 'numeric'
attr(`get_param_elderly_network_adults`, "inputTypes") = c('_p_parameters')
class(`get_param_elderly_network_adults`) = c("SWIGFunction", class('get_param_elderly_network_adults'))

# Start of get_param_mean_infectious_period

`get_param_mean_infectious_period` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_mean_infectious_period', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_mean_infectious_period`, 'returnType') = 'numeric'
attr(`get_param_mean_infectious_period`, "inputTypes") = c('_p_parameters')
class(`get_param_mean_infectious_period`) = c("SWIGFunction", class('get_param_mean_infectious_period'))

# Start of get_param_sd_infectious_period

`get_param_sd_infectious_period` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_sd_infectious_period', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_sd_infectious_period`, 'returnType') = 'numeric'
attr(`get_param_sd_infectious_period`, "inputTypes") = c('_p_parameters')
class(`get_param_sd_infectious_period`) = c("SWIGFunction", class('get_param_sd_infectious_period'))

# Start of get_param_infectious_rate

`get_param_infectious_rate` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_infectious_rate', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_infectious_rate`, 'returnType') = 'numeric'
attr(`get_param_infectious_rate`, "inputTypes") = c('_p_parameters')
class(`get_param_infectious_rate`) = c("SWIGFunction", class('get_param_infectious_rate'))

# Start of get_param_rebuild_networks

`get_param_rebuild_networks` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_rebuild_networks', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_rebuild_networks`, 'returnType') = 'integer'
attr(`get_param_rebuild_networks`, "inputTypes") = c('_p_parameters')
class(`get_param_rebuild_networks`) = c("SWIGFunction", class('get_param_rebuild_networks'))

# Start of get_param_max_n_strains

`get_param_max_n_strains` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_max_n_strains', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_max_n_strains`, 'returnType') = 'integer'
attr(`get_param_max_n_strains`, "inputTypes") = c('_p_parameters')
class(`get_param_max_n_strains`) = c("SWIGFunction", class('get_param_max_n_strains'))

# Start of get_param_sd_infectiousness_multiplier

`get_param_sd_infectiousness_multiplier` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_sd_infectiousness_multiplier', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_sd_infectiousness_multiplier`, 'returnType') = 'numeric'
attr(`get_param_sd_infectiousness_multiplier`, "inputTypes") = c('_p_parameters')
class(`get_param_sd_infectiousness_multiplier`) = c("SWIGFunction", class('get_param_sd_infectiousness_multiplier'))

# Start of get_param_relative_susceptibility

`get_param_relative_susceptibility` = function(params, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_param_relative_susceptibility', params, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_relative_susceptibility`, 'returnType') = 'numeric'
attr(`get_param_relative_susceptibility`, "inputTypes") = c('_p_parameters', 'integer')
class(`get_param_relative_susceptibility`) = c("SWIGFunction", class('get_param_relative_susceptibility'))

# Start of get_param_adjusted_susceptibility

`get_param_adjusted_susceptibility` = function(params, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_param_adjusted_susceptibility', params, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_adjusted_susceptibility`, 'returnType') = 'numeric'
attr(`get_param_adjusted_susceptibility`, "inputTypes") = c('_p_parameters', 'integer')
class(`get_param_adjusted_susceptibility`) = c("SWIGFunction", class('get_param_adjusted_susceptibility'))

# Start of get_param_relative_transmission

`get_param_relative_transmission` = function(params, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_param_relative_transmission', params, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_relative_transmission`, 'returnType') = 'numeric'
attr(`get_param_relative_transmission`, "inputTypes") = c('_p_parameters', 'integer')
class(`get_param_relative_transmission`) = c("SWIGFunction", class('get_param_relative_transmission'))

# Start of get_param_relative_transmission_used

`get_param_relative_transmission_used` = function(params, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_param_relative_transmission_used', params, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_relative_transmission_used`, 'returnType') = 'numeric'
attr(`get_param_relative_transmission_used`, "inputTypes") = c('_p_parameters', 'integer')
class(`get_param_relative_transmission_used`) = c("SWIGFunction", class('get_param_relative_transmission_used'))

# Start of get_param_manual_traceable_fraction

`get_param_manual_traceable_fraction` = function(params, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_param_manual_traceable_fraction', params, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_manual_traceable_fraction`, 'returnType') = 'numeric'
attr(`get_param_manual_traceable_fraction`, "inputTypes") = c('_p_parameters', 'integer')
class(`get_param_manual_traceable_fraction`) = c("SWIGFunction", class('get_param_manual_traceable_fraction'))

# Start of get_param_mean_time_to_symptoms

`get_param_mean_time_to_symptoms` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_mean_time_to_symptoms', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_mean_time_to_symptoms`, 'returnType') = 'numeric'
attr(`get_param_mean_time_to_symptoms`, "inputTypes") = c('_p_parameters')
class(`get_param_mean_time_to_symptoms`) = c("SWIGFunction", class('get_param_mean_time_to_symptoms'))

# Start of get_param_sd_time_to_symptoms

`get_param_sd_time_to_symptoms` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_sd_time_to_symptoms', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_sd_time_to_symptoms`, 'returnType') = 'numeric'
attr(`get_param_sd_time_to_symptoms`, "inputTypes") = c('_p_parameters')
class(`get_param_sd_time_to_symptoms`) = c("SWIGFunction", class('get_param_sd_time_to_symptoms'))

# Start of get_param_hospitalised_fraction

`get_param_hospitalised_fraction` = function(params, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_param_hospitalised_fraction', params, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_hospitalised_fraction`, 'returnType') = 'numeric'
attr(`get_param_hospitalised_fraction`, "inputTypes") = c('_p_parameters', 'integer')
class(`get_param_hospitalised_fraction`) = c("SWIGFunction", class('get_param_hospitalised_fraction'))

# Start of get_param_critical_fraction

`get_param_critical_fraction` = function(params, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_param_critical_fraction', params, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_critical_fraction`, 'returnType') = 'numeric'
attr(`get_param_critical_fraction`, "inputTypes") = c('_p_parameters', 'integer')
class(`get_param_critical_fraction`) = c("SWIGFunction", class('get_param_critical_fraction'))

# Start of get_param_fatality_fraction

`get_param_fatality_fraction` = function(params, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_param_fatality_fraction', params, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_fatality_fraction`, 'returnType') = 'numeric'
attr(`get_param_fatality_fraction`, "inputTypes") = c('_p_parameters', 'integer')
class(`get_param_fatality_fraction`) = c("SWIGFunction", class('get_param_fatality_fraction'))

# Start of get_param_mean_time_to_hospital

`get_param_mean_time_to_hospital` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_mean_time_to_hospital', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_mean_time_to_hospital`, 'returnType') = 'numeric'
attr(`get_param_mean_time_to_hospital`, "inputTypes") = c('_p_parameters')
class(`get_param_mean_time_to_hospital`) = c("SWIGFunction", class('get_param_mean_time_to_hospital'))

# Start of get_param_mean_time_to_critical

`get_param_mean_time_to_critical` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_mean_time_to_critical', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_mean_time_to_critical`, 'returnType') = 'numeric'
attr(`get_param_mean_time_to_critical`, "inputTypes") = c('_p_parameters')
class(`get_param_mean_time_to_critical`) = c("SWIGFunction", class('get_param_mean_time_to_critical'))

# Start of get_param_sd_time_to_critical

`get_param_sd_time_to_critical` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_sd_time_to_critical', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_sd_time_to_critical`, 'returnType') = 'numeric'
attr(`get_param_sd_time_to_critical`, "inputTypes") = c('_p_parameters')
class(`get_param_sd_time_to_critical`) = c("SWIGFunction", class('get_param_sd_time_to_critical'))

# Start of get_param_mean_time_to_recover

`get_param_mean_time_to_recover` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_mean_time_to_recover', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_mean_time_to_recover`, 'returnType') = 'numeric'
attr(`get_param_mean_time_to_recover`, "inputTypes") = c('_p_parameters')
class(`get_param_mean_time_to_recover`) = c("SWIGFunction", class('get_param_mean_time_to_recover'))

# Start of get_param_mean_sd_to_recover

`get_param_mean_sd_to_recover` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_mean_sd_to_recover', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_mean_sd_to_recover`, 'returnType') = 'numeric'
attr(`get_param_mean_sd_to_recover`, "inputTypes") = c('_p_parameters')
class(`get_param_mean_sd_to_recover`) = c("SWIGFunction", class('get_param_mean_sd_to_recover'))

# Start of get_param_mean_time_to_death

`get_param_mean_time_to_death` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_mean_time_to_death', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_mean_time_to_death`, 'returnType') = 'numeric'
attr(`get_param_mean_time_to_death`, "inputTypes") = c('_p_parameters')
class(`get_param_mean_time_to_death`) = c("SWIGFunction", class('get_param_mean_time_to_death'))

# Start of get_param_mean_sd_to_death

`get_param_mean_sd_to_death` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_mean_sd_to_death', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_mean_sd_to_death`, 'returnType') = 'numeric'
attr(`get_param_mean_sd_to_death`, "inputTypes") = c('_p_parameters')
class(`get_param_mean_sd_to_death`) = c("SWIGFunction", class('get_param_mean_sd_to_death'))

# Start of get_param_household_size

`get_param_household_size` = function(params, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_param_household_size', params, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_household_size`, 'returnType') = 'numeric'
attr(`get_param_household_size`, "inputTypes") = c('_p_parameters', 'integer')
class(`get_param_household_size`) = c("SWIGFunction", class('get_param_household_size'))

# Start of get_param_population

`get_param_population` = function(params, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_param_population', params, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_population`, 'returnType') = 'numeric'
attr(`get_param_population`, "inputTypes") = c('_p_parameters', 'integer')
class(`get_param_population`) = c("SWIGFunction", class('get_param_population'))

# Start of get_param_fraction_asymptomatic

`get_param_fraction_asymptomatic` = function(params, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_param_fraction_asymptomatic', params, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_fraction_asymptomatic`, 'returnType') = 'numeric'
attr(`get_param_fraction_asymptomatic`, "inputTypes") = c('_p_parameters', 'integer')
class(`get_param_fraction_asymptomatic`) = c("SWIGFunction", class('get_param_fraction_asymptomatic'))

# Start of get_param_asymptomatic_infectious_factor

`get_param_asymptomatic_infectious_factor` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_asymptomatic_infectious_factor', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_asymptomatic_infectious_factor`, 'returnType') = 'numeric'
attr(`get_param_asymptomatic_infectious_factor`, "inputTypes") = c('_p_parameters')
class(`get_param_asymptomatic_infectious_factor`) = c("SWIGFunction", class('get_param_asymptomatic_infectious_factor'))

# Start of get_param_mean_asymptomatic_to_recover

`get_param_mean_asymptomatic_to_recover` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_mean_asymptomatic_to_recover', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_mean_asymptomatic_to_recover`, 'returnType') = 'numeric'
attr(`get_param_mean_asymptomatic_to_recover`, "inputTypes") = c('_p_parameters')
class(`get_param_mean_asymptomatic_to_recover`) = c("SWIGFunction", class('get_param_mean_asymptomatic_to_recover'))

# Start of get_param_mild_fraction

`get_param_mild_fraction` = function(params, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_param_mild_fraction', params, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_mild_fraction`, 'returnType') = 'numeric'
attr(`get_param_mild_fraction`, "inputTypes") = c('_p_parameters', 'integer')
class(`get_param_mild_fraction`) = c("SWIGFunction", class('get_param_mild_fraction'))

# Start of get_param_sd_asymptomatic_to_recover

`get_param_sd_asymptomatic_to_recover` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_sd_asymptomatic_to_recover', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_sd_asymptomatic_to_recover`, 'returnType') = 'numeric'
attr(`get_param_sd_asymptomatic_to_recover`, "inputTypes") = c('_p_parameters')
class(`get_param_sd_asymptomatic_to_recover`) = c("SWIGFunction", class('get_param_sd_asymptomatic_to_recover'))

# Start of get_param_quarantine_daily_interactions

`get_param_quarantine_daily_interactions` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_quarantine_daily_interactions', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_quarantine_daily_interactions`, 'returnType') = 'integer'
attr(`get_param_quarantine_daily_interactions`, "inputTypes") = c('_p_parameters')
class(`get_param_quarantine_daily_interactions`) = c("SWIGFunction", class('get_param_quarantine_daily_interactions'))

# Start of get_param_hospitalised_daily_interactions

`get_param_hospitalised_daily_interactions` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_hospitalised_daily_interactions', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_hospitalised_daily_interactions`, 'returnType') = 'integer'
attr(`get_param_hospitalised_daily_interactions`, "inputTypes") = c('_p_parameters')
class(`get_param_hospitalised_daily_interactions`) = c("SWIGFunction", class('get_param_hospitalised_daily_interactions'))

# Start of get_param_self_quarantine_fraction

`get_param_self_quarantine_fraction` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_self_quarantine_fraction', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_self_quarantine_fraction`, 'returnType') = 'numeric'
attr(`get_param_self_quarantine_fraction`, "inputTypes") = c('_p_parameters')
class(`get_param_self_quarantine_fraction`) = c("SWIGFunction", class('get_param_self_quarantine_fraction'))

# Start of get_param_trace_on_symptoms

`get_param_trace_on_symptoms` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_trace_on_symptoms', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_trace_on_symptoms`, 'returnType') = 'integer'
attr(`get_param_trace_on_symptoms`, "inputTypes") = c('_p_parameters')
class(`get_param_trace_on_symptoms`) = c("SWIGFunction", class('get_param_trace_on_symptoms'))

# Start of get_param_trace_on_positive

`get_param_trace_on_positive` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_trace_on_positive', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_trace_on_positive`, 'returnType') = 'integer'
attr(`get_param_trace_on_positive`, "inputTypes") = c('_p_parameters')
class(`get_param_trace_on_positive`) = c("SWIGFunction", class('get_param_trace_on_positive'))

# Start of get_param_quarantine_length_self

`get_param_quarantine_length_self` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_quarantine_length_self', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_quarantine_length_self`, 'returnType') = 'integer'
attr(`get_param_quarantine_length_self`, "inputTypes") = c('_p_parameters')
class(`get_param_quarantine_length_self`) = c("SWIGFunction", class('get_param_quarantine_length_self'))

# Start of get_param_quarantine_length_traced_symptoms

`get_param_quarantine_length_traced_symptoms` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_quarantine_length_traced_symptoms', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_quarantine_length_traced_symptoms`, 'returnType') = 'integer'
attr(`get_param_quarantine_length_traced_symptoms`, "inputTypes") = c('_p_parameters')
class(`get_param_quarantine_length_traced_symptoms`) = c("SWIGFunction", class('get_param_quarantine_length_traced_symptoms'))

# Start of get_param_quarantine_length_traced_positive

`get_param_quarantine_length_traced_positive` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_quarantine_length_traced_positive', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_quarantine_length_traced_positive`, 'returnType') = 'integer'
attr(`get_param_quarantine_length_traced_positive`, "inputTypes") = c('_p_parameters')
class(`get_param_quarantine_length_traced_positive`) = c("SWIGFunction", class('get_param_quarantine_length_traced_positive'))

# Start of get_param_quarantine_length_positive

`get_param_quarantine_length_positive` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_quarantine_length_positive', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_quarantine_length_positive`, 'returnType') = 'integer'
attr(`get_param_quarantine_length_positive`, "inputTypes") = c('_p_parameters')
class(`get_param_quarantine_length_positive`) = c("SWIGFunction", class('get_param_quarantine_length_positive'))

# Start of get_param_quarantine_dropout_self

`get_param_quarantine_dropout_self` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_quarantine_dropout_self', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_quarantine_dropout_self`, 'returnType') = 'numeric'
attr(`get_param_quarantine_dropout_self`, "inputTypes") = c('_p_parameters')
class(`get_param_quarantine_dropout_self`) = c("SWIGFunction", class('get_param_quarantine_dropout_self'))

# Start of get_param_quarantine_dropout_traced_positive

`get_param_quarantine_dropout_traced_positive` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_quarantine_dropout_traced_positive', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_quarantine_dropout_traced_positive`, 'returnType') = 'numeric'
attr(`get_param_quarantine_dropout_traced_positive`, "inputTypes") = c('_p_parameters')
class(`get_param_quarantine_dropout_traced_positive`) = c("SWIGFunction", class('get_param_quarantine_dropout_traced_positive'))

# Start of get_param_quarantine_dropout_traced_symptoms

`get_param_quarantine_dropout_traced_symptoms` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_quarantine_dropout_traced_symptoms', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_quarantine_dropout_traced_symptoms`, 'returnType') = 'numeric'
attr(`get_param_quarantine_dropout_traced_symptoms`, "inputTypes") = c('_p_parameters')
class(`get_param_quarantine_dropout_traced_symptoms`) = c("SWIGFunction", class('get_param_quarantine_dropout_traced_symptoms'))

# Start of get_param_quarantine_dropout_positive

`get_param_quarantine_dropout_positive` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_quarantine_dropout_positive', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_quarantine_dropout_positive`, 'returnType') = 'numeric'
attr(`get_param_quarantine_dropout_positive`, "inputTypes") = c('_p_parameters')
class(`get_param_quarantine_dropout_positive`) = c("SWIGFunction", class('get_param_quarantine_dropout_positive'))

# Start of get_param_quarantine_compliance_traced_symptoms

`get_param_quarantine_compliance_traced_symptoms` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_quarantine_compliance_traced_symptoms', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_quarantine_compliance_traced_symptoms`, 'returnType') = 'numeric'
attr(`get_param_quarantine_compliance_traced_symptoms`, "inputTypes") = c('_p_parameters')
class(`get_param_quarantine_compliance_traced_symptoms`) = c("SWIGFunction", class('get_param_quarantine_compliance_traced_symptoms'))

# Start of get_param_quarantine_compliance_traced_positive

`get_param_quarantine_compliance_traced_positive` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_quarantine_compliance_traced_positive', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_quarantine_compliance_traced_positive`, 'returnType') = 'numeric'
attr(`get_param_quarantine_compliance_traced_positive`, "inputTypes") = c('_p_parameters')
class(`get_param_quarantine_compliance_traced_positive`) = c("SWIGFunction", class('get_param_quarantine_compliance_traced_positive'))

# Start of get_param_quarantine_on_traced

`get_param_quarantine_on_traced` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_quarantine_on_traced', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_quarantine_on_traced`, 'returnType') = 'integer'
attr(`get_param_quarantine_on_traced`, "inputTypes") = c('_p_parameters')
class(`get_param_quarantine_on_traced`) = c("SWIGFunction", class('get_param_quarantine_on_traced'))

# Start of get_param_traceable_interaction_fraction

`get_param_traceable_interaction_fraction` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_traceable_interaction_fraction', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_traceable_interaction_fraction`, 'returnType') = 'numeric'
attr(`get_param_traceable_interaction_fraction`, "inputTypes") = c('_p_parameters')
class(`get_param_traceable_interaction_fraction`) = c("SWIGFunction", class('get_param_traceable_interaction_fraction'))

# Start of get_param_tracing_network_depth

`get_param_tracing_network_depth` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_tracing_network_depth', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_tracing_network_depth`, 'returnType') = 'integer'
attr(`get_param_tracing_network_depth`, "inputTypes") = c('_p_parameters')
class(`get_param_tracing_network_depth`) = c("SWIGFunction", class('get_param_tracing_network_depth'))

# Start of get_param_allow_clinical_diagnosis

`get_param_allow_clinical_diagnosis` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_allow_clinical_diagnosis', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_allow_clinical_diagnosis`, 'returnType') = 'integer'
attr(`get_param_allow_clinical_diagnosis`, "inputTypes") = c('_p_parameters')
class(`get_param_allow_clinical_diagnosis`) = c("SWIGFunction", class('get_param_allow_clinical_diagnosis'))

# Start of get_param_quarantine_household_on_symptoms

`get_param_quarantine_household_on_symptoms` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_quarantine_household_on_symptoms', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_quarantine_household_on_symptoms`, 'returnType') = 'integer'
attr(`get_param_quarantine_household_on_symptoms`, "inputTypes") = c('_p_parameters')
class(`get_param_quarantine_household_on_symptoms`) = c("SWIGFunction", class('get_param_quarantine_household_on_symptoms'))

# Start of get_param_quarantine_household_on_positive

`get_param_quarantine_household_on_positive` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_quarantine_household_on_positive', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_quarantine_household_on_positive`, 'returnType') = 'integer'
attr(`get_param_quarantine_household_on_positive`, "inputTypes") = c('_p_parameters')
class(`get_param_quarantine_household_on_positive`) = c("SWIGFunction", class('get_param_quarantine_household_on_positive'))

# Start of get_param_quarantine_household_on_traced_positive

`get_param_quarantine_household_on_traced_positive` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_quarantine_household_on_traced_positive', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_quarantine_household_on_traced_positive`, 'returnType') = 'integer'
attr(`get_param_quarantine_household_on_traced_positive`, "inputTypes") = c('_p_parameters')
class(`get_param_quarantine_household_on_traced_positive`) = c("SWIGFunction", class('get_param_quarantine_household_on_traced_positive'))

# Start of get_param_quarantine_household_on_traced_symptoms

`get_param_quarantine_household_on_traced_symptoms` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_quarantine_household_on_traced_symptoms', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_quarantine_household_on_traced_symptoms`, 'returnType') = 'integer'
attr(`get_param_quarantine_household_on_traced_symptoms`, "inputTypes") = c('_p_parameters')
class(`get_param_quarantine_household_on_traced_symptoms`) = c("SWIGFunction", class('get_param_quarantine_household_on_traced_symptoms'))

# Start of get_param_quarantine_household_contacts_on_positive

`get_param_quarantine_household_contacts_on_positive` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_quarantine_household_contacts_on_positive', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_quarantine_household_contacts_on_positive`, 'returnType') = 'integer'
attr(`get_param_quarantine_household_contacts_on_positive`, "inputTypes") = c('_p_parameters')
class(`get_param_quarantine_household_contacts_on_positive`) = c("SWIGFunction", class('get_param_quarantine_household_contacts_on_positive'))

# Start of get_param_test_on_symptoms

`get_param_test_on_symptoms` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_test_on_symptoms', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_test_on_symptoms`, 'returnType') = 'integer'
attr(`get_param_test_on_symptoms`, "inputTypes") = c('_p_parameters')
class(`get_param_test_on_symptoms`) = c("SWIGFunction", class('get_param_test_on_symptoms'))

# Start of get_param_test_on_traced

`get_param_test_on_traced` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_test_on_traced', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_test_on_traced`, 'returnType') = 'integer'
attr(`get_param_test_on_traced`, "inputTypes") = c('_p_parameters')
class(`get_param_test_on_traced`) = c("SWIGFunction", class('get_param_test_on_traced'))

# Start of get_param_test_release_on_negative

`get_param_test_release_on_negative` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_test_release_on_negative', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_test_release_on_negative`, 'returnType') = 'integer'
attr(`get_param_test_release_on_negative`, "inputTypes") = c('_p_parameters')
class(`get_param_test_release_on_negative`) = c("SWIGFunction", class('get_param_test_release_on_negative'))

# Start of get_param_test_insensitive_period

`get_param_test_insensitive_period` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_test_insensitive_period', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_test_insensitive_period`, 'returnType') = 'integer'
attr(`get_param_test_insensitive_period`, "inputTypes") = c('_p_parameters')
class(`get_param_test_insensitive_period`) = c("SWIGFunction", class('get_param_test_insensitive_period'))

# Start of get_param_test_sensitive_period

`get_param_test_sensitive_period` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_test_sensitive_period', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_test_sensitive_period`, 'returnType') = 'integer'
attr(`get_param_test_sensitive_period`, "inputTypes") = c('_p_parameters')
class(`get_param_test_sensitive_period`) = c("SWIGFunction", class('get_param_test_sensitive_period'))

# Start of get_param_test_sensitivity

`get_param_test_sensitivity` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_test_sensitivity', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_test_sensitivity`, 'returnType') = 'numeric'
attr(`get_param_test_sensitivity`, "inputTypes") = c('_p_parameters')
class(`get_param_test_sensitivity`) = c("SWIGFunction", class('get_param_test_sensitivity'))

# Start of get_param_test_specificity

`get_param_test_specificity` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_test_specificity', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_test_specificity`, 'returnType') = 'numeric'
attr(`get_param_test_specificity`, "inputTypes") = c('_p_parameters')
class(`get_param_test_specificity`) = c("SWIGFunction", class('get_param_test_specificity'))

# Start of get_param_test_result_wait

`get_param_test_result_wait` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_test_result_wait', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_test_result_wait`, 'returnType') = 'integer'
attr(`get_param_test_result_wait`, "inputTypes") = c('_p_parameters')
class(`get_param_test_result_wait`) = c("SWIGFunction", class('get_param_test_result_wait'))

# Start of get_param_test_order_wait

`get_param_test_order_wait` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_test_order_wait', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_test_order_wait`, 'returnType') = 'integer'
attr(`get_param_test_order_wait`, "inputTypes") = c('_p_parameters')
class(`get_param_test_order_wait`) = c("SWIGFunction", class('get_param_test_order_wait'))

# Start of get_param_test_order_wait_priority

`get_param_test_order_wait_priority` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_test_order_wait_priority', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_test_order_wait_priority`, 'returnType') = 'integer'
attr(`get_param_test_order_wait_priority`, "inputTypes") = c('_p_parameters')
class(`get_param_test_order_wait_priority`) = c("SWIGFunction", class('get_param_test_order_wait_priority'))

# Start of get_param_test_result_wait_priority

`get_param_test_result_wait_priority` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_test_result_wait_priority', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_test_result_wait_priority`, 'returnType') = 'integer'
attr(`get_param_test_result_wait_priority`, "inputTypes") = c('_p_parameters')
class(`get_param_test_result_wait_priority`) = c("SWIGFunction", class('get_param_test_result_wait_priority'))

# Start of get_param_priority_test_contacts

`get_param_priority_test_contacts` = function(params, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_param_priority_test_contacts', params, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_priority_test_contacts`, 'returnType') = 'integer'
attr(`get_param_priority_test_contacts`, "inputTypes") = c('_p_parameters', 'integer')
class(`get_param_priority_test_contacts`) = c("SWIGFunction", class('get_param_priority_test_contacts'))

# Start of get_param_app_users_fraction

`get_param_app_users_fraction` = function(params, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_param_app_users_fraction', params, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_app_users_fraction`, 'returnType') = 'numeric'
attr(`get_param_app_users_fraction`, "inputTypes") = c('_p_parameters', 'integer')
class(`get_param_app_users_fraction`) = c("SWIGFunction", class('get_param_app_users_fraction'))

# Start of get_param_app_turned_on

`get_param_app_turned_on` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_app_turned_on', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_app_turned_on`, 'returnType') = 'integer'
attr(`get_param_app_turned_on`, "inputTypes") = c('_p_parameters')
class(`get_param_app_turned_on`) = c("SWIGFunction", class('get_param_app_turned_on'))

# Start of get_param_app_turn_on_time

`get_param_app_turn_on_time` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_app_turn_on_time', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_app_turn_on_time`, 'returnType') = 'integer'
attr(`get_param_app_turn_on_time`, "inputTypes") = c('_p_parameters')
class(`get_param_app_turn_on_time`) = c("SWIGFunction", class('get_param_app_turn_on_time'))

# Start of get_param_daily_non_cov_symptoms_rate

`get_param_daily_non_cov_symptoms_rate` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_daily_non_cov_symptoms_rate', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_daily_non_cov_symptoms_rate`, 'returnType') = 'numeric'
attr(`get_param_daily_non_cov_symptoms_rate`, "inputTypes") = c('_p_parameters')
class(`get_param_daily_non_cov_symptoms_rate`) = c("SWIGFunction", class('get_param_daily_non_cov_symptoms_rate'))

# Start of get_param_lockdown_occupation_multiplier

`get_param_lockdown_occupation_multiplier` = function(params, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_param_lockdown_occupation_multiplier', params, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_lockdown_occupation_multiplier`, 'returnType') = 'numeric'
attr(`get_param_lockdown_occupation_multiplier`, "inputTypes") = c('_p_parameters', 'integer')
class(`get_param_lockdown_occupation_multiplier`) = c("SWIGFunction", class('get_param_lockdown_occupation_multiplier'))

# Start of get_param_lockdown_random_network_multiplier

`get_param_lockdown_random_network_multiplier` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_lockdown_random_network_multiplier', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_lockdown_random_network_multiplier`, 'returnType') = 'numeric'
attr(`get_param_lockdown_random_network_multiplier`, "inputTypes") = c('_p_parameters')
class(`get_param_lockdown_random_network_multiplier`) = c("SWIGFunction", class('get_param_lockdown_random_network_multiplier'))

# Start of get_param_lockdown_house_interaction_multiplier

`get_param_lockdown_house_interaction_multiplier` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_lockdown_house_interaction_multiplier', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_lockdown_house_interaction_multiplier`, 'returnType') = 'numeric'
attr(`get_param_lockdown_house_interaction_multiplier`, "inputTypes") = c('_p_parameters')
class(`get_param_lockdown_house_interaction_multiplier`) = c("SWIGFunction", class('get_param_lockdown_house_interaction_multiplier'))

# Start of get_param_lockdown_time_on

`get_param_lockdown_time_on` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_lockdown_time_on', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_lockdown_time_on`, 'returnType') = 'integer'
attr(`get_param_lockdown_time_on`, "inputTypes") = c('_p_parameters')
class(`get_param_lockdown_time_on`) = c("SWIGFunction", class('get_param_lockdown_time_on'))

# Start of get_param_lockdown_time_off

`get_param_lockdown_time_off` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_lockdown_time_off', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_lockdown_time_off`, 'returnType') = 'integer'
attr(`get_param_lockdown_time_off`, "inputTypes") = c('_p_parameters')
class(`get_param_lockdown_time_off`) = c("SWIGFunction", class('get_param_lockdown_time_off'))

# Start of get_param_lockdown_on

`get_param_lockdown_on` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_lockdown_on', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_lockdown_on`, 'returnType') = 'integer'
attr(`get_param_lockdown_on`, "inputTypes") = c('_p_parameters')
class(`get_param_lockdown_on`) = c("SWIGFunction", class('get_param_lockdown_on'))

# Start of get_param_lockdown_elderly_time_on

`get_param_lockdown_elderly_time_on` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_lockdown_elderly_time_on', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_lockdown_elderly_time_on`, 'returnType') = 'integer'
attr(`get_param_lockdown_elderly_time_on`, "inputTypes") = c('_p_parameters')
class(`get_param_lockdown_elderly_time_on`) = c("SWIGFunction", class('get_param_lockdown_elderly_time_on'))

# Start of get_param_lockdown_elderly_time_off

`get_param_lockdown_elderly_time_off` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_lockdown_elderly_time_off', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_lockdown_elderly_time_off`, 'returnType') = 'integer'
attr(`get_param_lockdown_elderly_time_off`, "inputTypes") = c('_p_parameters')
class(`get_param_lockdown_elderly_time_off`) = c("SWIGFunction", class('get_param_lockdown_elderly_time_off'))

# Start of get_param_lockdown_elderly_on

`get_param_lockdown_elderly_on` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_lockdown_elderly_on', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_lockdown_elderly_on`, 'returnType') = 'integer'
attr(`get_param_lockdown_elderly_on`, "inputTypes") = c('_p_parameters')
class(`get_param_lockdown_elderly_on`) = c("SWIGFunction", class('get_param_lockdown_elderly_on'))

# Start of get_param_symptoms_time_on

`get_param_symptoms_time_on` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_symptoms_time_on', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_symptoms_time_on`, 'returnType') = 'integer'
attr(`get_param_symptoms_time_on`, "inputTypes") = c('_p_parameters')
class(`get_param_symptoms_time_on`) = c("SWIGFunction", class('get_param_symptoms_time_on'))

# Start of get_param_testing_symptoms_time_off

`get_param_testing_symptoms_time_off` = function(params, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  ;.Call('R_swig_get_param_testing_symptoms_time_off', params, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_testing_symptoms_time_off`, 'returnType') = 'integer'
attr(`get_param_testing_symptoms_time_off`, "inputTypes") = c('_p_parameters')
class(`get_param_testing_symptoms_time_off`) = c("SWIGFunction", class('get_param_testing_symptoms_time_off'))

# Start of get_param_location_death_icu

`get_param_location_death_icu` = function(params, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_get_param_location_death_icu', params, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_location_death_icu`, 'returnType') = 'numeric'
attr(`get_param_location_death_icu`, "inputTypes") = c('_p_parameters', 'integer')
class(`get_param_location_death_icu`) = c("SWIGFunction", class('get_param_location_death_icu'))

# Start of set_param_rng_seed

`set_param_rng_seed` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_rng_seed', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_rng_seed`, 'returnType') = 'integer'
attr(`set_param_rng_seed`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_rng_seed`) = c("SWIGFunction", class('set_param_rng_seed'))

# Start of set_param_param_id

`set_param_param_id` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_param_id', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_param_id`, 'returnType') = 'integer'
attr(`set_param_param_id`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_param_id`) = c("SWIGFunction", class('set_param_param_id'))

# Start of set_param_n_total

`set_param_n_total` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_n_total', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_n_total`, 'returnType') = 'integer'
attr(`set_param_n_total`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_n_total`) = c("SWIGFunction", class('set_param_n_total'))

# Start of set_param_days_of_interactions

`set_param_days_of_interactions` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_days_of_interactions', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_days_of_interactions`, 'returnType') = 'integer'
attr(`set_param_days_of_interactions`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_days_of_interactions`) = c("SWIGFunction", class('set_param_days_of_interactions'))

# Start of set_param_mean_random_interactions

`set_param_mean_random_interactions` = function(params, value, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_set_param_mean_random_interactions', params, value, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_mean_random_interactions`, 'returnType') = 'integer'
attr(`set_param_mean_random_interactions`, "inputTypes") = c('_p_parameters', 'numeric', 'integer')
class(`set_param_mean_random_interactions`) = c("SWIGFunction", class('set_param_mean_random_interactions'))

# Start of set_param_sd_random_interactions

`set_param_sd_random_interactions` = function(params, value, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_set_param_sd_random_interactions', params, value, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_sd_random_interactions`, 'returnType') = 'integer'
attr(`set_param_sd_random_interactions`, "inputTypes") = c('_p_parameters', 'numeric', 'integer')
class(`set_param_sd_random_interactions`) = c("SWIGFunction", class('set_param_sd_random_interactions'))

# Start of set_param_random_interaction_distribution

`set_param_random_interaction_distribution` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_random_interaction_distribution', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_random_interaction_distribution`, 'returnType') = 'integer'
attr(`set_param_random_interaction_distribution`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_random_interaction_distribution`) = c("SWIGFunction", class('set_param_random_interaction_distribution'))

# Start of set_param_mean_work_interactions

`set_param_mean_work_interactions` = function(params, value, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_set_param_mean_work_interactions', params, value, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_mean_work_interactions`, 'returnType') = 'integer'
attr(`set_param_mean_work_interactions`, "inputTypes") = c('_p_parameters', 'numeric', 'integer')
class(`set_param_mean_work_interactions`) = c("SWIGFunction", class('set_param_mean_work_interactions'))

# Start of set_param_daily_fraction_work

`set_param_daily_fraction_work` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_daily_fraction_work', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_daily_fraction_work`, 'returnType') = 'integer'
attr(`set_param_daily_fraction_work`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_daily_fraction_work`) = c("SWIGFunction", class('set_param_daily_fraction_work'))

# Start of set_param_child_network_adults

`set_param_child_network_adults` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_child_network_adults', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_child_network_adults`, 'returnType') = 'integer'
attr(`set_param_child_network_adults`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_child_network_adults`) = c("SWIGFunction", class('set_param_child_network_adults'))

# Start of set_param_elderly_network_adults

`set_param_elderly_network_adults` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_elderly_network_adults', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_elderly_network_adults`, 'returnType') = 'integer'
attr(`set_param_elderly_network_adults`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_elderly_network_adults`) = c("SWIGFunction", class('set_param_elderly_network_adults'))

# Start of set_param_mean_infectious_period

`set_param_mean_infectious_period` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_mean_infectious_period', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_mean_infectious_period`, 'returnType') = 'integer'
attr(`set_param_mean_infectious_period`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_mean_infectious_period`) = c("SWIGFunction", class('set_param_mean_infectious_period'))

# Start of set_param_sd_infectious_period

`set_param_sd_infectious_period` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_sd_infectious_period', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_sd_infectious_period`, 'returnType') = 'integer'
attr(`set_param_sd_infectious_period`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_sd_infectious_period`) = c("SWIGFunction", class('set_param_sd_infectious_period'))

# Start of set_param_infectious_rate

`set_param_infectious_rate` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_infectious_rate', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_infectious_rate`, 'returnType') = 'integer'
attr(`set_param_infectious_rate`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_infectious_rate`) = c("SWIGFunction", class('set_param_infectious_rate'))

# Start of set_param_rebuild_networks

`set_param_rebuild_networks` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_rebuild_networks', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_rebuild_networks`, 'returnType') = 'integer'
attr(`set_param_rebuild_networks`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_rebuild_networks`) = c("SWIGFunction", class('set_param_rebuild_networks'))

# Start of set_param_max_n_strains

`set_param_max_n_strains` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_max_n_strains', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_max_n_strains`, 'returnType') = 'integer'
attr(`set_param_max_n_strains`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_max_n_strains`) = c("SWIGFunction", class('set_param_max_n_strains'))

# Start of set_param_sd_infectiousness_multiplier

`set_param_sd_infectiousness_multiplier` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_sd_infectiousness_multiplier', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_sd_infectiousness_multiplier`, 'returnType') = 'integer'
attr(`set_param_sd_infectiousness_multiplier`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_sd_infectiousness_multiplier`) = c("SWIGFunction", class('set_param_sd_infectiousness_multiplier'))

# Start of set_param_relative_susceptibility

`set_param_relative_susceptibility` = function(params, value, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_set_param_relative_susceptibility', params, value, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_relative_susceptibility`, 'returnType') = 'integer'
attr(`set_param_relative_susceptibility`, "inputTypes") = c('_p_parameters', 'numeric', 'integer')
class(`set_param_relative_susceptibility`) = c("SWIGFunction", class('set_param_relative_susceptibility'))

# Start of set_param_adjusted_susceptibility

`set_param_adjusted_susceptibility` = function(params, value, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_set_param_adjusted_susceptibility', params, value, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_adjusted_susceptibility`, 'returnType') = 'integer'
attr(`set_param_adjusted_susceptibility`, "inputTypes") = c('_p_parameters', 'numeric', 'integer')
class(`set_param_adjusted_susceptibility`) = c("SWIGFunction", class('set_param_adjusted_susceptibility'))

# Start of set_param_relative_transmission

`set_param_relative_transmission` = function(params, value, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_set_param_relative_transmission', params, value, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_relative_transmission`, 'returnType') = 'integer'
attr(`set_param_relative_transmission`, "inputTypes") = c('_p_parameters', 'numeric', 'integer')
class(`set_param_relative_transmission`) = c("SWIGFunction", class('set_param_relative_transmission'))

# Start of set_param_manual_traceable_fraction

`set_param_manual_traceable_fraction` = function(params, value, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_set_param_manual_traceable_fraction', params, value, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_manual_traceable_fraction`, 'returnType') = 'integer'
attr(`set_param_manual_traceable_fraction`, "inputTypes") = c('_p_parameters', 'numeric', 'integer')
class(`set_param_manual_traceable_fraction`) = c("SWIGFunction", class('set_param_manual_traceable_fraction'))

# Start of set_param_mean_time_to_symptoms

`set_param_mean_time_to_symptoms` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_mean_time_to_symptoms', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_mean_time_to_symptoms`, 'returnType') = 'integer'
attr(`set_param_mean_time_to_symptoms`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_mean_time_to_symptoms`) = c("SWIGFunction", class('set_param_mean_time_to_symptoms'))

# Start of set_param_sd_time_to_symptoms

`set_param_sd_time_to_symptoms` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_sd_time_to_symptoms', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_sd_time_to_symptoms`, 'returnType') = 'integer'
attr(`set_param_sd_time_to_symptoms`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_sd_time_to_symptoms`) = c("SWIGFunction", class('set_param_sd_time_to_symptoms'))

# Start of set_param_hospitalised_fraction

`set_param_hospitalised_fraction` = function(params, value, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_set_param_hospitalised_fraction', params, value, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_hospitalised_fraction`, 'returnType') = 'integer'
attr(`set_param_hospitalised_fraction`, "inputTypes") = c('_p_parameters', 'numeric', 'integer')
class(`set_param_hospitalised_fraction`) = c("SWIGFunction", class('set_param_hospitalised_fraction'))

# Start of set_param_critical_fraction

`set_param_critical_fraction` = function(params, value, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_set_param_critical_fraction', params, value, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_critical_fraction`, 'returnType') = 'integer'
attr(`set_param_critical_fraction`, "inputTypes") = c('_p_parameters', 'numeric', 'integer')
class(`set_param_critical_fraction`) = c("SWIGFunction", class('set_param_critical_fraction'))

# Start of set_param_fatality_fraction

`set_param_fatality_fraction` = function(params, value, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_set_param_fatality_fraction', params, value, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_fatality_fraction`, 'returnType') = 'integer'
attr(`set_param_fatality_fraction`, "inputTypes") = c('_p_parameters', 'numeric', 'integer')
class(`set_param_fatality_fraction`) = c("SWIGFunction", class('set_param_fatality_fraction'))

# Start of set_param_mean_time_to_hospital

`set_param_mean_time_to_hospital` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_mean_time_to_hospital', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_mean_time_to_hospital`, 'returnType') = 'integer'
attr(`set_param_mean_time_to_hospital`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_mean_time_to_hospital`) = c("SWIGFunction", class('set_param_mean_time_to_hospital'))

# Start of set_param_mean_time_to_critical

`set_param_mean_time_to_critical` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_mean_time_to_critical', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_mean_time_to_critical`, 'returnType') = 'integer'
attr(`set_param_mean_time_to_critical`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_mean_time_to_critical`) = c("SWIGFunction", class('set_param_mean_time_to_critical'))

# Start of set_param_sd_time_to_critical

`set_param_sd_time_to_critical` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_sd_time_to_critical', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_sd_time_to_critical`, 'returnType') = 'integer'
attr(`set_param_sd_time_to_critical`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_sd_time_to_critical`) = c("SWIGFunction", class('set_param_sd_time_to_critical'))

# Start of set_param_mean_time_to_recover

`set_param_mean_time_to_recover` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_mean_time_to_recover', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_mean_time_to_recover`, 'returnType') = 'integer'
attr(`set_param_mean_time_to_recover`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_mean_time_to_recover`) = c("SWIGFunction", class('set_param_mean_time_to_recover'))

# Start of set_param_sd_time_to_recover

`set_param_sd_time_to_recover` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_sd_time_to_recover', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_sd_time_to_recover`, 'returnType') = 'integer'
attr(`set_param_sd_time_to_recover`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_sd_time_to_recover`) = c("SWIGFunction", class('set_param_sd_time_to_recover'))

# Start of set_param_mean_time_to_death

`set_param_mean_time_to_death` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_mean_time_to_death', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_mean_time_to_death`, 'returnType') = 'integer'
attr(`set_param_mean_time_to_death`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_mean_time_to_death`) = c("SWIGFunction", class('set_param_mean_time_to_death'))

# Start of set_param_household_size

`set_param_household_size` = function(params, value, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_set_param_household_size', params, value, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_household_size`, 'returnType') = 'integer'
attr(`set_param_household_size`, "inputTypes") = c('_p_parameters', 'numeric', 'integer')
class(`set_param_household_size`) = c("SWIGFunction", class('set_param_household_size'))

# Start of set_param_population

`set_param_population` = function(params, value, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_set_param_population', params, value, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_population`, 'returnType') = 'integer'
attr(`set_param_population`, "inputTypes") = c('_p_parameters', 'numeric', 'integer')
class(`set_param_population`) = c("SWIGFunction", class('set_param_population'))

# Start of set_param_fraction_asymptomatic

`set_param_fraction_asymptomatic` = function(params, value, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_set_param_fraction_asymptomatic', params, value, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_fraction_asymptomatic`, 'returnType') = 'integer'
attr(`set_param_fraction_asymptomatic`, "inputTypes") = c('_p_parameters', 'numeric', 'integer')
class(`set_param_fraction_asymptomatic`) = c("SWIGFunction", class('set_param_fraction_asymptomatic'))

# Start of set_param_asymptomatic_infectious_factor

`set_param_asymptomatic_infectious_factor` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_asymptomatic_infectious_factor', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_asymptomatic_infectious_factor`, 'returnType') = 'integer'
attr(`set_param_asymptomatic_infectious_factor`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_asymptomatic_infectious_factor`) = c("SWIGFunction", class('set_param_asymptomatic_infectious_factor'))

# Start of set_param_mean_asymptomatic_to_recovery

`set_param_mean_asymptomatic_to_recovery` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_mean_asymptomatic_to_recovery', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_mean_asymptomatic_to_recovery`, 'returnType') = 'integer'
attr(`set_param_mean_asymptomatic_to_recovery`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_mean_asymptomatic_to_recovery`) = c("SWIGFunction", class('set_param_mean_asymptomatic_to_recovery'))

# Start of set_param_sd_asymptomatic_to_recovery

`set_param_sd_asymptomatic_to_recovery` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_sd_asymptomatic_to_recovery', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_sd_asymptomatic_to_recovery`, 'returnType') = 'integer'
attr(`set_param_sd_asymptomatic_to_recovery`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_sd_asymptomatic_to_recovery`) = c("SWIGFunction", class('set_param_sd_asymptomatic_to_recovery'))

# Start of set_param_quarantined_daily_interactions

`set_param_quarantined_daily_interactions` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_quarantined_daily_interactions', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_quarantined_daily_interactions`, 'returnType') = 'integer'
attr(`set_param_quarantined_daily_interactions`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_quarantined_daily_interactions`) = c("SWIGFunction", class('set_param_quarantined_daily_interactions'))

# Start of set_param_hospitalised_daily_interactions

`set_param_hospitalised_daily_interactions` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_hospitalised_daily_interactions', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_hospitalised_daily_interactions`, 'returnType') = 'integer'
attr(`set_param_hospitalised_daily_interactions`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_hospitalised_daily_interactions`) = c("SWIGFunction", class('set_param_hospitalised_daily_interactions'))

# Start of set_param_quarantine_days

`set_param_quarantine_days` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_quarantine_days', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_quarantine_days`, 'returnType') = 'integer'
attr(`set_param_quarantine_days`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_quarantine_days`) = c("SWIGFunction", class('set_param_quarantine_days'))

# Start of set_param_self_quarantine_fraction

`set_param_self_quarantine_fraction` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_self_quarantine_fraction', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_self_quarantine_fraction`, 'returnType') = 'integer'
attr(`set_param_self_quarantine_fraction`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_self_quarantine_fraction`) = c("SWIGFunction", class('set_param_self_quarantine_fraction'))

# Start of set_param_trace_on_symptoms

`set_param_trace_on_symptoms` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_trace_on_symptoms', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_trace_on_symptoms`, 'returnType') = 'integer'
attr(`set_param_trace_on_symptoms`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_trace_on_symptoms`) = c("SWIGFunction", class('set_param_trace_on_symptoms'))

# Start of set_param_trace_on_positive

`set_param_trace_on_positive` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_trace_on_positive', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_trace_on_positive`, 'returnType') = 'integer'
attr(`set_param_trace_on_positive`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_trace_on_positive`) = c("SWIGFunction", class('set_param_trace_on_positive'))

# Start of set_param_quarantine_length_self

`set_param_quarantine_length_self` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_quarantine_length_self', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_quarantine_length_self`, 'returnType') = 'integer'
attr(`set_param_quarantine_length_self`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_quarantine_length_self`) = c("SWIGFunction", class('set_param_quarantine_length_self'))

# Start of set_param_quarantine_length_traced_symptoms

`set_param_quarantine_length_traced_symptoms` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_quarantine_length_traced_symptoms', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_quarantine_length_traced_symptoms`, 'returnType') = 'integer'
attr(`set_param_quarantine_length_traced_symptoms`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_quarantine_length_traced_symptoms`) = c("SWIGFunction", class('set_param_quarantine_length_traced_symptoms'))

# Start of set_param_quarantine_length_traced_positive

`set_param_quarantine_length_traced_positive` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_quarantine_length_traced_positive', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_quarantine_length_traced_positive`, 'returnType') = 'integer'
attr(`set_param_quarantine_length_traced_positive`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_quarantine_length_traced_positive`) = c("SWIGFunction", class('set_param_quarantine_length_traced_positive'))

# Start of set_param_quarantine_length_positive

`set_param_quarantine_length_positive` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_quarantine_length_positive', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_quarantine_length_positive`, 'returnType') = 'integer'
attr(`set_param_quarantine_length_positive`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_quarantine_length_positive`) = c("SWIGFunction", class('set_param_quarantine_length_positive'))

# Start of set_param_quarantine_dropout_self

`set_param_quarantine_dropout_self` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_quarantine_dropout_self', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_quarantine_dropout_self`, 'returnType') = 'integer'
attr(`set_param_quarantine_dropout_self`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_quarantine_dropout_self`) = c("SWIGFunction", class('set_param_quarantine_dropout_self'))

# Start of set_param_quarantine_dropout_traced_positive

`set_param_quarantine_dropout_traced_positive` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_quarantine_dropout_traced_positive', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_quarantine_dropout_traced_positive`, 'returnType') = 'integer'
attr(`set_param_quarantine_dropout_traced_positive`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_quarantine_dropout_traced_positive`) = c("SWIGFunction", class('set_param_quarantine_dropout_traced_positive'))

# Start of set_param_quarantine_dropout_traced_symptoms

`set_param_quarantine_dropout_traced_symptoms` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_quarantine_dropout_traced_symptoms', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_quarantine_dropout_traced_symptoms`, 'returnType') = 'integer'
attr(`set_param_quarantine_dropout_traced_symptoms`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_quarantine_dropout_traced_symptoms`) = c("SWIGFunction", class('set_param_quarantine_dropout_traced_symptoms'))

# Start of set_param_quarantine_dropout_positive

`set_param_quarantine_dropout_positive` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_quarantine_dropout_positive', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_quarantine_dropout_positive`, 'returnType') = 'integer'
attr(`set_param_quarantine_dropout_positive`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_quarantine_dropout_positive`) = c("SWIGFunction", class('set_param_quarantine_dropout_positive'))

# Start of set_param_quarantine_compliance_traced_symptoms

`set_param_quarantine_compliance_traced_symptoms` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_quarantine_compliance_traced_symptoms', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_quarantine_compliance_traced_symptoms`, 'returnType') = 'integer'
attr(`set_param_quarantine_compliance_traced_symptoms`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_quarantine_compliance_traced_symptoms`) = c("SWIGFunction", class('set_param_quarantine_compliance_traced_symptoms'))

# Start of set_param_quarantine_compliance_traced_positive

`set_param_quarantine_compliance_traced_positive` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_quarantine_compliance_traced_positive', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_quarantine_compliance_traced_positive`, 'returnType') = 'integer'
attr(`set_param_quarantine_compliance_traced_positive`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_quarantine_compliance_traced_positive`) = c("SWIGFunction", class('set_param_quarantine_compliance_traced_positive'))

# Start of set_param_quarantine_on_traced

`set_param_quarantine_on_traced` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_quarantine_on_traced', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_quarantine_on_traced`, 'returnType') = 'integer'
attr(`set_param_quarantine_on_traced`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_quarantine_on_traced`) = c("SWIGFunction", class('set_param_quarantine_on_traced'))

# Start of set_param_traceable_interaction_fraction

`set_param_traceable_interaction_fraction` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_traceable_interaction_fraction', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_traceable_interaction_fraction`, 'returnType') = 'integer'
attr(`set_param_traceable_interaction_fraction`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_traceable_interaction_fraction`) = c("SWIGFunction", class('set_param_traceable_interaction_fraction'))

# Start of set_param_tracing_network_depth

`set_param_tracing_network_depth` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_tracing_network_depth', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_tracing_network_depth`, 'returnType') = 'integer'
attr(`set_param_tracing_network_depth`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_tracing_network_depth`) = c("SWIGFunction", class('set_param_tracing_network_depth'))

# Start of set_param_allow_clinical_diagnosis

`set_param_allow_clinical_diagnosis` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_allow_clinical_diagnosis', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_allow_clinical_diagnosis`, 'returnType') = 'integer'
attr(`set_param_allow_clinical_diagnosis`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_allow_clinical_diagnosis`) = c("SWIGFunction", class('set_param_allow_clinical_diagnosis'))

# Start of set_param_quarantine_household_on_symptoms

`set_param_quarantine_household_on_symptoms` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_quarantine_household_on_symptoms', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_quarantine_household_on_symptoms`, 'returnType') = 'integer'
attr(`set_param_quarantine_household_on_symptoms`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_quarantine_household_on_symptoms`) = c("SWIGFunction", class('set_param_quarantine_household_on_symptoms'))

# Start of set_param_quarantine_household_on_positive

`set_param_quarantine_household_on_positive` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_quarantine_household_on_positive', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_quarantine_household_on_positive`, 'returnType') = 'integer'
attr(`set_param_quarantine_household_on_positive`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_quarantine_household_on_positive`) = c("SWIGFunction", class('set_param_quarantine_household_on_positive'))

# Start of set_param_quarantine_household_on_traced_positive

`set_param_quarantine_household_on_traced_positive` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_quarantine_household_on_traced_positive', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_quarantine_household_on_traced_positive`, 'returnType') = 'integer'
attr(`set_param_quarantine_household_on_traced_positive`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_quarantine_household_on_traced_positive`) = c("SWIGFunction", class('set_param_quarantine_household_on_traced_positive'))

# Start of set_param_quarantine_household_on_traced_symptoms

`set_param_quarantine_household_on_traced_symptoms` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_quarantine_household_on_traced_symptoms', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_quarantine_household_on_traced_symptoms`, 'returnType') = 'integer'
attr(`set_param_quarantine_household_on_traced_symptoms`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_quarantine_household_on_traced_symptoms`) = c("SWIGFunction", class('set_param_quarantine_household_on_traced_symptoms'))

# Start of set_param_quarantine_household_contacts_on_positive

`set_param_quarantine_household_contacts_on_positive` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_quarantine_household_contacts_on_positive', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_quarantine_household_contacts_on_positive`, 'returnType') = 'integer'
attr(`set_param_quarantine_household_contacts_on_positive`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_quarantine_household_contacts_on_positive`) = c("SWIGFunction", class('set_param_quarantine_household_contacts_on_positive'))

# Start of set_param_test_on_symptoms

`set_param_test_on_symptoms` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_test_on_symptoms', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_test_on_symptoms`, 'returnType') = 'integer'
attr(`set_param_test_on_symptoms`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_test_on_symptoms`) = c("SWIGFunction", class('set_param_test_on_symptoms'))

# Start of set_param_test_on_traced

`set_param_test_on_traced` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_test_on_traced', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_test_on_traced`, 'returnType') = 'integer'
attr(`set_param_test_on_traced`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_test_on_traced`) = c("SWIGFunction", class('set_param_test_on_traced'))

# Start of set_param_test_release_on_negative

`set_param_test_release_on_negative` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_test_release_on_negative', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_test_release_on_negative`, 'returnType') = 'integer'
attr(`set_param_test_release_on_negative`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_test_release_on_negative`) = c("SWIGFunction", class('set_param_test_release_on_negative'))

# Start of set_param_test_insensitive_period

`set_param_test_insensitive_period` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_test_insensitive_period', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_test_insensitive_period`, 'returnType') = 'integer'
attr(`set_param_test_insensitive_period`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_test_insensitive_period`) = c("SWIGFunction", class('set_param_test_insensitive_period'))

# Start of set_param_test_sensitive_period

`set_param_test_sensitive_period` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_test_sensitive_period', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_test_sensitive_period`, 'returnType') = 'integer'
attr(`set_param_test_sensitive_period`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_test_sensitive_period`) = c("SWIGFunction", class('set_param_test_sensitive_period'))

# Start of set_param_test_sensitivity

`set_param_test_sensitivity` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_test_sensitivity', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_test_sensitivity`, 'returnType') = 'integer'
attr(`set_param_test_sensitivity`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_test_sensitivity`) = c("SWIGFunction", class('set_param_test_sensitivity'))

# Start of set_param_test_specificity

`set_param_test_specificity` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_test_specificity', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_test_specificity`, 'returnType') = 'integer'
attr(`set_param_test_specificity`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_test_specificity`) = c("SWIGFunction", class('set_param_test_specificity'))

# Start of set_param_test_result_wait

`set_param_test_result_wait` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_test_result_wait', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_test_result_wait`, 'returnType') = 'integer'
attr(`set_param_test_result_wait`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_test_result_wait`) = c("SWIGFunction", class('set_param_test_result_wait'))

# Start of set_param_test_order_wait

`set_param_test_order_wait` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_test_order_wait', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_test_order_wait`, 'returnType') = 'integer'
attr(`set_param_test_order_wait`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_test_order_wait`) = c("SWIGFunction", class('set_param_test_order_wait'))

# Start of set_param_test_order_wait_priority

`set_param_test_order_wait_priority` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_test_order_wait_priority', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_test_order_wait_priority`, 'returnType') = 'integer'
attr(`set_param_test_order_wait_priority`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_test_order_wait_priority`) = c("SWIGFunction", class('set_param_test_order_wait_priority'))

# Start of set_param_test_result_wait_priority

`set_param_test_result_wait_priority` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_test_result_wait_priority', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_test_result_wait_priority`, 'returnType') = 'integer'
attr(`set_param_test_result_wait_priority`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_test_result_wait_priority`) = c("SWIGFunction", class('set_param_test_result_wait_priority'))

# Start of set_param_priority_test_contacts

`set_param_priority_test_contacts` = function(params, value, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_set_param_priority_test_contacts', params, value, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_priority_test_contacts`, 'returnType') = 'integer'
attr(`set_param_priority_test_contacts`, "inputTypes") = c('_p_parameters', 'integer', 'integer')
class(`set_param_priority_test_contacts`) = c("SWIGFunction", class('set_param_priority_test_contacts'))

# Start of set_param_app_users_fraction

`set_param_app_users_fraction` = function(params, value, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_set_param_app_users_fraction', params, value, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_app_users_fraction`, 'returnType') = 'integer'
attr(`set_param_app_users_fraction`, "inputTypes") = c('_p_parameters', 'numeric', 'integer')
class(`set_param_app_users_fraction`) = c("SWIGFunction", class('set_param_app_users_fraction'))

# Start of set_param_app_turn_on_time

`set_param_app_turn_on_time` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_app_turn_on_time', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_app_turn_on_time`, 'returnType') = 'integer'
attr(`set_param_app_turn_on_time`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_app_turn_on_time`) = c("SWIGFunction", class('set_param_app_turn_on_time'))

# Start of set_param_app_turned_on

`set_param_app_turned_on` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_app_turned_on', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_app_turned_on`, 'returnType') = 'integer'
attr(`set_param_app_turned_on`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_app_turned_on`) = c("SWIGFunction", class('set_param_app_turned_on'))

# Start of set_param_daily_non_cov_symptoms_rate

`set_param_daily_non_cov_symptoms_rate` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_daily_non_cov_symptoms_rate', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_daily_non_cov_symptoms_rate`, 'returnType') = 'integer'
attr(`set_param_daily_non_cov_symptoms_rate`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_daily_non_cov_symptoms_rate`) = c("SWIGFunction", class('set_param_daily_non_cov_symptoms_rate'))

# Start of set_param_lockdown_occupation_multiplier

`set_param_lockdown_occupation_multiplier` = function(params, value, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_set_param_lockdown_occupation_multiplier', params, value, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_lockdown_occupation_multiplier`, 'returnType') = 'integer'
attr(`set_param_lockdown_occupation_multiplier`, "inputTypes") = c('_p_parameters', 'numeric', 'integer')
class(`set_param_lockdown_occupation_multiplier`) = c("SWIGFunction", class('set_param_lockdown_occupation_multiplier'))

# Start of set_param_random_network_multiplier

`set_param_random_network_multiplier` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_random_network_multiplier', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_random_network_multiplier`, 'returnType') = 'integer'
attr(`set_param_random_network_multiplier`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_random_network_multiplier`) = c("SWIGFunction", class('set_param_random_network_multiplier'))

# Start of set_param_lockdown_house_interaction_multiplier

`set_param_lockdown_house_interaction_multiplier` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_lockdown_house_interaction_multiplier', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_lockdown_house_interaction_multiplier`, 'returnType') = 'integer'
attr(`set_param_lockdown_house_interaction_multiplier`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_lockdown_house_interaction_multiplier`) = c("SWIGFunction", class('set_param_lockdown_house_interaction_multiplier'))

# Start of set_param_lockdown_time_on

`set_param_lockdown_time_on` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_lockdown_time_on', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_lockdown_time_on`, 'returnType') = 'integer'
attr(`set_param_lockdown_time_on`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_lockdown_time_on`) = c("SWIGFunction", class('set_param_lockdown_time_on'))

# Start of set_param_lockdown_time_off

`set_param_lockdown_time_off` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_lockdown_time_off', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_lockdown_time_off`, 'returnType') = 'integer'
attr(`set_param_lockdown_time_off`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_lockdown_time_off`) = c("SWIGFunction", class('set_param_lockdown_time_off'))

# Start of set_param_lockdown_on

`set_param_lockdown_on` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_lockdown_on', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_lockdown_on`, 'returnType') = 'integer'
attr(`set_param_lockdown_on`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_lockdown_on`) = c("SWIGFunction", class('set_param_lockdown_on'))

# Start of set_param_lockdown_elderly_time_on

`set_param_lockdown_elderly_time_on` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_lockdown_elderly_time_on', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_lockdown_elderly_time_on`, 'returnType') = 'integer'
attr(`set_param_lockdown_elderly_time_on`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_lockdown_elderly_time_on`) = c("SWIGFunction", class('set_param_lockdown_elderly_time_on'))

# Start of set_param_lockdown_elderly_time_off

`set_param_lockdown_elderly_time_off` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_lockdown_elderly_time_off', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_lockdown_elderly_time_off`, 'returnType') = 'integer'
attr(`set_param_lockdown_elderly_time_off`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_lockdown_elderly_time_off`) = c("SWIGFunction", class('set_param_lockdown_elderly_time_off'))

# Start of set_param_lockdown_elderly_on

`set_param_lockdown_elderly_on` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_lockdown_elderly_on', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_lockdown_elderly_on`, 'returnType') = 'integer'
attr(`set_param_lockdown_elderly_on`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_lockdown_elderly_on`) = c("SWIGFunction", class('set_param_lockdown_elderly_on'))

# Start of set_param_testing_symptoms_time_on

`set_param_testing_symptoms_time_on` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_testing_symptoms_time_on', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_testing_symptoms_time_on`, 'returnType') = 'integer'
attr(`set_param_testing_symptoms_time_on`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_testing_symptoms_time_on`) = c("SWIGFunction", class('set_param_testing_symptoms_time_on'))

# Start of set_param_testing_symptoms_time_off

`set_param_testing_symptoms_time_off` = function(params, value, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_set_param_testing_symptoms_time_off', params, value, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_testing_symptoms_time_off`, 'returnType') = 'integer'
attr(`set_param_testing_symptoms_time_off`, "inputTypes") = c('_p_parameters', 'integer')
class(`set_param_testing_symptoms_time_off`) = c("SWIGFunction", class('set_param_testing_symptoms_time_off'))

# Start of set_param_mild_fraction

`set_param_mild_fraction` = function(params, value, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_set_param_mild_fraction', params, value, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_mild_fraction`, 'returnType') = 'numeric'
attr(`set_param_mild_fraction`, "inputTypes") = c('_p_parameters', 'numeric', 'integer')
class(`set_param_mild_fraction`) = c("SWIGFunction", class('set_param_mild_fraction'))

# Start of set_param_location_death_icu

`set_param_location_death_icu` = function(params, value, idx, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  ;.Call('R_swig_set_param_location_death_icu', params, value, idx, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_location_death_icu`, 'returnType') = 'numeric'
attr(`set_param_location_death_icu`, "inputTypes") = c('_p_parameters', 'numeric', 'integer')
class(`set_param_location_death_icu`) = c("SWIGFunction", class('set_param_location_death_icu'))

# Start of add_household_to_ref_households

`add_household_to_ref_households` = function(params, idx, i_0_9, i_10_19, i_20_29, i_30_39, i_40_49, i_50_59, i_60_69, i_70_79, i_80)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  idx = as.integer(idx);
  
  if(length(idx) > 1) {
    warning("using only the first element of idx");
  };
  
  i_0_9 = as.integer(i_0_9);
  
  if(length(i_0_9) > 1) {
    warning("using only the first element of i_0_9");
  };
  
  i_10_19 = as.integer(i_10_19);
  
  if(length(i_10_19) > 1) {
    warning("using only the first element of i_10_19");
  };
  
  i_20_29 = as.integer(i_20_29);
  
  if(length(i_20_29) > 1) {
    warning("using only the first element of i_20_29");
  };
  
  i_30_39 = as.integer(i_30_39);
  
  if(length(i_30_39) > 1) {
    warning("using only the first element of i_30_39");
  };
  
  i_40_49 = as.integer(i_40_49);
  
  if(length(i_40_49) > 1) {
    warning("using only the first element of i_40_49");
  };
  
  i_50_59 = as.integer(i_50_59);
  
  if(length(i_50_59) > 1) {
    warning("using only the first element of i_50_59");
  };
  
  i_60_69 = as.integer(i_60_69);
  
  if(length(i_60_69) > 1) {
    warning("using only the first element of i_60_69");
  };
  
  i_70_79 = as.integer(i_70_79);
  
  if(length(i_70_79) > 1) {
    warning("using only the first element of i_70_79");
  };
  
  i_80 = as.integer(i_80);
  
  if(length(i_80) > 1) {
    warning("using only the first element of i_80");
  };
  
  ;.Call('R_swig_add_household_to_ref_households', params, idx, i_0_9, i_10_19, i_20_29, i_30_39, i_40_49, i_50_59, i_60_69, i_70_79, i_80, PACKAGE='OpenABMCovid19');
  
}

attr(`add_household_to_ref_households`, 'returnType') = 'void'
attr(`add_household_to_ref_households`, "inputTypes") = c('_p_parameters', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer', 'integer')
class(`add_household_to_ref_households`) = c("SWIGFunction", class('add_household_to_ref_households'))

# Start of get_household_value

`get_household_value` = function(params, row, col, .copy = FALSE)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  row = as.integer(row);
  
  if(length(row) > 1) {
    warning("using only the first element of row");
  };
  
  col = as.integer(col);
  
  if(length(col) > 1) {
    warning("using only the first element of col");
  };
  
  ;.Call('R_swig_get_household_value', params, row, col, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_household_value`, 'returnType') = 'integer'
attr(`get_household_value`, "inputTypes") = c('_p_parameters', 'integer', 'integer')
class(`get_household_value`) = c("SWIGFunction", class('get_household_value'))

# Start of new_doubleArray

`doubleArray` = function(nelements)
{
  nelements = as.integer(nelements);
  
  if(length(nelements) > 1) {
    warning("using only the first element of nelements");
  };
  
  ;ans = .Call('R_swig_new_doubleArray', nelements, PACKAGE='OpenABMCovid19');
  ans <- new("_p_doubleArray", ref=ans) ;
  
  reg.finalizer(ans@ref, delete_doubleArray)
  ans
  
}

attr(`doubleArray`, 'returnType') = '_p_doubleArray'
attr(`doubleArray`, "inputTypes") = c('integer')
class(`doubleArray`) = c("SWIGFunction", class('doubleArray'))

# Start of delete_doubleArray

`delete_doubleArray` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_delete_doubleArray', self, PACKAGE='OpenABMCovid19');
  
}

attr(`delete_doubleArray`, 'returnType') = 'void'
attr(`delete_doubleArray`, "inputTypes") = c('_p_doubleArray')
class(`delete_doubleArray`) = c("SWIGFunction", class('delete_doubleArray'))

# Start of doubleArray_getitem

`doubleArray_getitem` = function(self, index, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  index = as.integer(index);
  
  if(length(index) > 1) {
    warning("using only the first element of index");
  };
  
  ;.Call('R_swig_doubleArray_getitem', self, index, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`doubleArray_getitem`, 'returnType') = 'numeric'
attr(`doubleArray_getitem`, "inputTypes") = c('_p_doubleArray', 'integer')
class(`doubleArray_getitem`) = c("SWIGFunction", class('doubleArray_getitem'))

# Start of doubleArray_setitem

`doubleArray_setitem` = function(self, index, value)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  index = as.integer(index);
  
  if(length(index) > 1) {
    warning("using only the first element of index");
  };
  
  
  ;.Call('R_swig_doubleArray_setitem', self, index, value, PACKAGE='OpenABMCovid19');
  
}

attr(`doubleArray_setitem`, 'returnType') = 'void'
attr(`doubleArray_setitem`, "inputTypes") = c('_p_doubleArray', 'integer', 'numeric')
class(`doubleArray_setitem`) = c("SWIGFunction", class('doubleArray_setitem'))

# Start of doubleArray_cast

`doubleArray_cast` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_doubleArray_cast', self, PACKAGE='OpenABMCovid19');
  
}

attr(`doubleArray_cast`, 'returnType') = 'numeric'
attr(`doubleArray_cast`, "inputTypes") = c('_p_doubleArray')
class(`doubleArray_cast`) = c("SWIGFunction", class('doubleArray_cast'))

# Start of doubleArray_frompointer

`doubleArray_frompointer` = function(t)
{
  ;ans = .Call('R_swig_doubleArray_frompointer', t, PACKAGE='OpenABMCovid19');
  ans <- new("_p_doubleArray", ref=ans) ;
  
  ans
  
}

attr(`doubleArray_frompointer`, 'returnType') = '_p_doubleArray'
attr(`doubleArray_frompointer`, "inputTypes") = c('numeric')
class(`doubleArray_frompointer`) = c("SWIGFunction", class('doubleArray_frompointer'))

# Start of accessor method for doubleArray
setMethod('$', '_p_doubleArray', function(x, name)

{
  accessorFuns = list('getitem' = doubleArray_getitem, 'setitem' = doubleArray_setitem, 'cast' = doubleArray_cast);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  function(...){
    f(x, ...)
  };
}


);
# end of accessor method for doubleArray
setMethod('delete', '_p_doubleArray', function(obj) {delete_doubleArray(obj)})
# Start definition of copy functions & methods for doubleArray
CopyToR_doubleArray = function(value, obj = new("doubleArray"))
{
  obj;
}



CopyToC_doubleArray = function(value, obj)
{
  obj
}



# Start definition of copy methods for doubleArray
setMethod('copyToR', '_p_doubleArray', CopyToR_doubleArray);
setMethod('copyToC', 'doubleArray', CopyToC_doubleArray);

# End definition of copy methods for doubleArray
# End definition of copy functions & methods for doubleArray
# Start of new_intArray

`intArray` = function(nelements)
{
  nelements = as.integer(nelements);
  
  if(length(nelements) > 1) {
    warning("using only the first element of nelements");
  };
  
  ;ans = .Call('R_swig_new_intArray', nelements, PACKAGE='OpenABMCovid19');
  ans <- new("_p_intArray", ref=ans) ;
  
  reg.finalizer(ans@ref, delete_intArray)
  ans
  
}

attr(`intArray`, 'returnType') = '_p_intArray'
attr(`intArray`, "inputTypes") = c('integer')
class(`intArray`) = c("SWIGFunction", class('intArray'))

# Start of delete_intArray

`delete_intArray` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_delete_intArray', self, PACKAGE='OpenABMCovid19');
  
}

attr(`delete_intArray`, 'returnType') = 'void'
attr(`delete_intArray`, "inputTypes") = c('_p_intArray')
class(`delete_intArray`) = c("SWIGFunction", class('delete_intArray'))

# Start of intArray_getitem

`intArray_getitem` = function(self, index, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  index = as.integer(index);
  
  if(length(index) > 1) {
    warning("using only the first element of index");
  };
  
  ;.Call('R_swig_intArray_getitem', self, index, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`intArray_getitem`, 'returnType') = 'integer'
attr(`intArray_getitem`, "inputTypes") = c('_p_intArray', 'integer')
class(`intArray_getitem`) = c("SWIGFunction", class('intArray_getitem'))

# Start of intArray_setitem

`intArray_setitem` = function(self, index, value)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  index = as.integer(index);
  
  if(length(index) > 1) {
    warning("using only the first element of index");
  };
  
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_intArray_setitem', self, index, value, PACKAGE='OpenABMCovid19');
  
}

attr(`intArray_setitem`, 'returnType') = 'void'
attr(`intArray_setitem`, "inputTypes") = c('_p_intArray', 'integer', 'integer')
class(`intArray_setitem`) = c("SWIGFunction", class('intArray_setitem'))

# Start of intArray_cast

`intArray_cast` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_intArray_cast', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_int", ref=ans) ;
  
  ans
  
}

attr(`intArray_cast`, 'returnType') = 'integer'
attr(`intArray_cast`, "inputTypes") = c('_p_intArray')
class(`intArray_cast`) = c("SWIGFunction", class('intArray_cast'))

# Start of intArray_frompointer

`intArray_frompointer` = function(t)
{
  t = as.integer(t);
  ;ans = .Call('R_swig_intArray_frompointer', t, PACKAGE='OpenABMCovid19');
  ans <- new("_p_intArray", ref=ans) ;
  
  ans
  
}

attr(`intArray_frompointer`, 'returnType') = '_p_intArray'
attr(`intArray_frompointer`, "inputTypes") = c('integer')
class(`intArray_frompointer`) = c("SWIGFunction", class('intArray_frompointer'))

# Start of accessor method for intArray
setMethod('$', '_p_intArray', function(x, name)

{
  accessorFuns = list('getitem' = intArray_getitem, 'setitem' = intArray_setitem, 'cast' = intArray_cast);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  function(...){
    f(x, ...)
  };
}


);
# end of accessor method for intArray
setMethod('delete', '_p_intArray', function(obj) {delete_intArray(obj)})
# Start definition of copy functions & methods for intArray
CopyToR_intArray = function(value, obj = new("intArray"))
{
  obj;
}



CopyToC_intArray = function(value, obj)
{
  obj
}



# Start definition of copy methods for intArray
setMethod('copyToR', '_p_intArray', CopyToR_intArray);
setMethod('copyToC', 'intArray', CopyToC_intArray);

# End definition of copy methods for intArray
# End definition of copy functions & methods for intArray
# Start of new_longArray

`longArray` = function(nelements)
{
  nelements = as.integer(nelements);
  
  if(length(nelements) > 1) {
    warning("using only the first element of nelements");
  };
  
  ;ans = .Call('R_swig_new_longArray', nelements, PACKAGE='OpenABMCovid19');
  ans <- new("_p_longArray", ref=ans) ;
  
  reg.finalizer(ans@ref, delete_longArray)
  ans
  
}

attr(`longArray`, 'returnType') = '_p_longArray'
attr(`longArray`, "inputTypes") = c('integer')
class(`longArray`) = c("SWIGFunction", class('longArray'))

# Start of delete_longArray

`delete_longArray` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_delete_longArray', self, PACKAGE='OpenABMCovid19');
  
}

attr(`delete_longArray`, 'returnType') = 'void'
attr(`delete_longArray`, "inputTypes") = c('_p_longArray')
class(`delete_longArray`) = c("SWIGFunction", class('delete_longArray'))

# Start of longArray_getitem

`longArray_getitem` = function(self, index, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  index = as.integer(index);
  
  if(length(index) > 1) {
    warning("using only the first element of index");
  };
  
  ;.Call('R_swig_longArray_getitem', self, index, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`longArray_getitem`, 'returnType') = 'integer'
attr(`longArray_getitem`, "inputTypes") = c('_p_longArray', 'integer')
class(`longArray_getitem`) = c("SWIGFunction", class('longArray_getitem'))

# Start of longArray_setitem

`longArray_setitem` = function(self, index, value)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  index = as.integer(index);
  
  if(length(index) > 1) {
    warning("using only the first element of index");
  };
  
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_longArray_setitem', self, index, value, PACKAGE='OpenABMCovid19');
  
}

attr(`longArray_setitem`, 'returnType') = 'void'
attr(`longArray_setitem`, "inputTypes") = c('_p_longArray', 'integer', 'integer')
class(`longArray_setitem`) = c("SWIGFunction", class('longArray_setitem'))

# Start of longArray_cast

`longArray_cast` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_longArray_cast', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_long", ref=ans) ;
  
  ans
  
}

attr(`longArray_cast`, 'returnType') = 'integer'
attr(`longArray_cast`, "inputTypes") = c('_p_longArray')
class(`longArray_cast`) = c("SWIGFunction", class('longArray_cast'))

# Start of longArray_frompointer

`longArray_frompointer` = function(t)
{
  t = as.integer(t);
  ;ans = .Call('R_swig_longArray_frompointer', t, PACKAGE='OpenABMCovid19');
  ans <- new("_p_longArray", ref=ans) ;
  
  ans
  
}

attr(`longArray_frompointer`, 'returnType') = '_p_longArray'
attr(`longArray_frompointer`, "inputTypes") = c('integer')
class(`longArray_frompointer`) = c("SWIGFunction", class('longArray_frompointer'))

# Start of accessor method for longArray
setMethod('$', '_p_longArray', function(x, name)

{
  accessorFuns = list('getitem' = longArray_getitem, 'setitem' = longArray_setitem, 'cast' = longArray_cast);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  function(...){
    f(x, ...)
  };
}


);
# end of accessor method for longArray
setMethod('delete', '_p_longArray', function(obj) {delete_longArray(obj)})
# Start definition of copy functions & methods for longArray
CopyToR_longArray = function(value, obj = new("longArray"))
{
  obj;
}



CopyToC_longArray = function(value, obj)
{
  obj
}



# Start definition of copy methods for longArray
setMethod('copyToR', '_p_longArray', CopyToR_longArray);
setMethod('copyToC', 'longArray', CopyToC_longArray);

# End definition of copy methods for longArray
# End definition of copy functions & methods for longArray
# Start of new_shortArray

`shortArray` = function(nelements)
{
  nelements = as.integer(nelements);
  
  if(length(nelements) > 1) {
    warning("using only the first element of nelements");
  };
  
  ;ans = .Call('R_swig_new_shortArray', nelements, PACKAGE='OpenABMCovid19');
  ans <- new("_p_shortArray", ref=ans) ;
  
  reg.finalizer(ans@ref, delete_shortArray)
  ans
  
}

attr(`shortArray`, 'returnType') = '_p_shortArray'
attr(`shortArray`, "inputTypes") = c('integer')
class(`shortArray`) = c("SWIGFunction", class('shortArray'))

# Start of delete_shortArray

`delete_shortArray` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_delete_shortArray', self, PACKAGE='OpenABMCovid19');
  
}

attr(`delete_shortArray`, 'returnType') = 'void'
attr(`delete_shortArray`, "inputTypes") = c('_p_shortArray')
class(`delete_shortArray`) = c("SWIGFunction", class('delete_shortArray'))

# Start of shortArray_getitem

`shortArray_getitem` = function(self, index, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  index = as.integer(index);
  
  if(length(index) > 1) {
    warning("using only the first element of index");
  };
  
  ;.Call('R_swig_shortArray_getitem', self, index, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`shortArray_getitem`, 'returnType') = 'integer'
attr(`shortArray_getitem`, "inputTypes") = c('_p_shortArray', 'integer')
class(`shortArray_getitem`) = c("SWIGFunction", class('shortArray_getitem'))

# Start of shortArray_setitem

`shortArray_setitem` = function(self, index, value)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  index = as.integer(index);
  
  if(length(index) > 1) {
    warning("using only the first element of index");
  };
  
  value = as.integer(value);
  
  if(length(value) > 1) {
    warning("using only the first element of value");
  };
  
  ;.Call('R_swig_shortArray_setitem', self, index, value, PACKAGE='OpenABMCovid19');
  
}

attr(`shortArray_setitem`, 'returnType') = 'void'
attr(`shortArray_setitem`, "inputTypes") = c('_p_shortArray', 'integer', 'integer')
class(`shortArray_setitem`) = c("SWIGFunction", class('shortArray_setitem'))

# Start of shortArray_cast

`shortArray_cast` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;ans = .Call('R_swig_shortArray_cast', self, PACKAGE='OpenABMCovid19');
  ans <- new("_p_short", ref=ans) ;
  
  ans
  
}

attr(`shortArray_cast`, 'returnType') = 'integer'
attr(`shortArray_cast`, "inputTypes") = c('_p_shortArray')
class(`shortArray_cast`) = c("SWIGFunction", class('shortArray_cast'))

# Start of shortArray_frompointer

`shortArray_frompointer` = function(t)
{
  t = as.integer(t);
  ;ans = .Call('R_swig_shortArray_frompointer', t, PACKAGE='OpenABMCovid19');
  ans <- new("_p_shortArray", ref=ans) ;
  
  ans
  
}

attr(`shortArray_frompointer`, 'returnType') = '_p_shortArray'
attr(`shortArray_frompointer`, "inputTypes") = c('integer')
class(`shortArray_frompointer`) = c("SWIGFunction", class('shortArray_frompointer'))

# Start of accessor method for shortArray
setMethod('$', '_p_shortArray', function(x, name)

{
  accessorFuns = list('getitem' = shortArray_getitem, 'setitem' = shortArray_setitem, 'cast' = shortArray_cast);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  function(...){
    f(x, ...)
  };
}


);
# end of accessor method for shortArray
setMethod('delete', '_p_shortArray', function(obj) {delete_shortArray(obj)})
# Start definition of copy functions & methods for shortArray
CopyToR_shortArray = function(value, obj = new("shortArray"))
{
  obj;
}



CopyToC_shortArray = function(value, obj)
{
  obj
}



# Start definition of copy methods for shortArray
setMethod('copyToR', '_p_shortArray', CopyToR_shortArray);
setMethod('copyToC', 'shortArray', CopyToC_shortArray);

# End definition of copy methods for shortArray
# End definition of copy functions & methods for shortArray
# Start of new_floatArray

`floatArray` = function(nelements)
{
  nelements = as.integer(nelements);
  
  if(length(nelements) > 1) {
    warning("using only the first element of nelements");
  };
  
  ;ans = .Call('R_swig_new_floatArray', nelements, PACKAGE='OpenABMCovid19');
  ans <- new("_p_floatArray", ref=ans) ;
  
  reg.finalizer(ans@ref, delete_floatArray)
  ans
  
}

attr(`floatArray`, 'returnType') = '_p_floatArray'
attr(`floatArray`, "inputTypes") = c('integer')
class(`floatArray`) = c("SWIGFunction", class('floatArray'))

# Start of delete_floatArray

`delete_floatArray` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_delete_floatArray', self, PACKAGE='OpenABMCovid19');
  
}

attr(`delete_floatArray`, 'returnType') = 'void'
attr(`delete_floatArray`, "inputTypes") = c('_p_floatArray')
class(`delete_floatArray`) = c("SWIGFunction", class('delete_floatArray'))

# Start of floatArray_getitem

`floatArray_getitem` = function(self, index, .copy = FALSE)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  index = as.integer(index);
  
  if(length(index) > 1) {
    warning("using only the first element of index");
  };
  
  ;.Call('R_swig_floatArray_getitem', self, index, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`floatArray_getitem`, 'returnType') = 'numeric'
attr(`floatArray_getitem`, "inputTypes") = c('_p_floatArray', 'integer')
class(`floatArray_getitem`) = c("SWIGFunction", class('floatArray_getitem'))

# Start of floatArray_setitem

`floatArray_setitem` = function(self, index, value)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  index = as.integer(index);
  
  if(length(index) > 1) {
    warning("using only the first element of index");
  };
  
  
  ;.Call('R_swig_floatArray_setitem', self, index, value, PACKAGE='OpenABMCovid19');
  
}

attr(`floatArray_setitem`, 'returnType') = 'void'
attr(`floatArray_setitem`, "inputTypes") = c('_p_floatArray', 'integer', 'numeric')
class(`floatArray_setitem`) = c("SWIGFunction", class('floatArray_setitem'))

# Start of floatArray_cast

`floatArray_cast` = function(self)
{
  if (inherits(self, "ExternalReference")) self = slot(self,"ref") 
  ;.Call('R_swig_floatArray_cast', self, PACKAGE='OpenABMCovid19');
  
}

attr(`floatArray_cast`, 'returnType') = 'numeric'
attr(`floatArray_cast`, "inputTypes") = c('_p_floatArray')
class(`floatArray_cast`) = c("SWIGFunction", class('floatArray_cast'))

# Start of floatArray_frompointer

`floatArray_frompointer` = function(t)
{
  ;ans = .Call('R_swig_floatArray_frompointer', t, PACKAGE='OpenABMCovid19');
  ans <- new("_p_floatArray", ref=ans) ;
  
  ans
  
}

attr(`floatArray_frompointer`, 'returnType') = '_p_floatArray'
attr(`floatArray_frompointer`, "inputTypes") = c('numeric')
class(`floatArray_frompointer`) = c("SWIGFunction", class('floatArray_frompointer'))

# Start of accessor method for floatArray
setMethod('$', '_p_floatArray', function(x, name)

{
  accessorFuns = list('getitem' = floatArray_getitem, 'setitem' = floatArray_setitem, 'cast' = floatArray_cast);
  ;        idx = pmatch(name, names(accessorFuns));
  if(is.na(idx)) 
  return(callNextMethod(x, name));
  f = accessorFuns[[idx]];
  function(...){
    f(x, ...)
  };
}


);
# end of accessor method for floatArray
setMethod('delete', '_p_floatArray', function(obj) {delete_floatArray(obj)})
# Start definition of copy functions & methods for floatArray
CopyToR_floatArray = function(value, obj = new("floatArray"))
{
  obj;
}



CopyToC_floatArray = function(value, obj)
{
  obj
}



# Start definition of copy methods for floatArray
setMethod('copyToR', '_p_floatArray', CopyToR_floatArray);
setMethod('copyToC', 'floatArray', CopyToC_floatArray);

# End definition of copy methods for floatArray
# End definition of copy functions & methods for floatArray
# Start of get_param_array_mean_random_interactions

`get_param_array_mean_random_interactions` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_get_param_array_mean_random_interactions', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_array_mean_random_interactions`, 'returnType') = 'void'
attr(`get_param_array_mean_random_interactions`, "inputTypes") = c('_p_parameters', 'numeric')
class(`get_param_array_mean_random_interactions`) = c("SWIGFunction", class('get_param_array_mean_random_interactions'))

# Start of get_param_array_sd_random_interactions

`get_param_array_sd_random_interactions` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_get_param_array_sd_random_interactions', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_array_sd_random_interactions`, 'returnType') = 'void'
attr(`get_param_array_sd_random_interactions`, "inputTypes") = c('_p_parameters', 'numeric')
class(`get_param_array_sd_random_interactions`) = c("SWIGFunction", class('get_param_array_sd_random_interactions'))

# Start of get_param_array_mean_work_interactions

`get_param_array_mean_work_interactions` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_get_param_array_mean_work_interactions', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_array_mean_work_interactions`, 'returnType') = 'void'
attr(`get_param_array_mean_work_interactions`, "inputTypes") = c('_p_parameters', 'numeric')
class(`get_param_array_mean_work_interactions`) = c("SWIGFunction", class('get_param_array_mean_work_interactions'))

# Start of get_param_array_relative_susceptibility

`get_param_array_relative_susceptibility` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_get_param_array_relative_susceptibility', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_array_relative_susceptibility`, 'returnType') = 'void'
attr(`get_param_array_relative_susceptibility`, "inputTypes") = c('_p_parameters', 'numeric')
class(`get_param_array_relative_susceptibility`) = c("SWIGFunction", class('get_param_array_relative_susceptibility'))

# Start of get_param_array_adjusted_susceptibility

`get_param_array_adjusted_susceptibility` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_get_param_array_adjusted_susceptibility', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_array_adjusted_susceptibility`, 'returnType') = 'void'
attr(`get_param_array_adjusted_susceptibility`, "inputTypes") = c('_p_parameters', 'numeric')
class(`get_param_array_adjusted_susceptibility`) = c("SWIGFunction", class('get_param_array_adjusted_susceptibility'))

# Start of get_param_array_relative_transmission

`get_param_array_relative_transmission` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_get_param_array_relative_transmission', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_array_relative_transmission`, 'returnType') = 'void'
attr(`get_param_array_relative_transmission`, "inputTypes") = c('_p_parameters', 'numeric')
class(`get_param_array_relative_transmission`) = c("SWIGFunction", class('get_param_array_relative_transmission'))

# Start of get_param_array_relative_transmission_used

`get_param_array_relative_transmission_used` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_get_param_array_relative_transmission_used', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_array_relative_transmission_used`, 'returnType') = 'void'
attr(`get_param_array_relative_transmission_used`, "inputTypes") = c('_p_parameters', 'numeric')
class(`get_param_array_relative_transmission_used`) = c("SWIGFunction", class('get_param_array_relative_transmission_used'))

# Start of get_param_array_hospitalised_fraction

`get_param_array_hospitalised_fraction` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_get_param_array_hospitalised_fraction', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_array_hospitalised_fraction`, 'returnType') = 'void'
attr(`get_param_array_hospitalised_fraction`, "inputTypes") = c('_p_parameters', 'numeric')
class(`get_param_array_hospitalised_fraction`) = c("SWIGFunction", class('get_param_array_hospitalised_fraction'))

# Start of get_param_array_critical_fraction

`get_param_array_critical_fraction` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_get_param_array_critical_fraction', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_array_critical_fraction`, 'returnType') = 'void'
attr(`get_param_array_critical_fraction`, "inputTypes") = c('_p_parameters', 'numeric')
class(`get_param_array_critical_fraction`) = c("SWIGFunction", class('get_param_array_critical_fraction'))

# Start of get_param_array_fatality_fraction

`get_param_array_fatality_fraction` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_get_param_array_fatality_fraction', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_array_fatality_fraction`, 'returnType') = 'void'
attr(`get_param_array_fatality_fraction`, "inputTypes") = c('_p_parameters', 'numeric')
class(`get_param_array_fatality_fraction`) = c("SWIGFunction", class('get_param_array_fatality_fraction'))

# Start of get_param_array_household_size

`get_param_array_household_size` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_get_param_array_household_size', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_array_household_size`, 'returnType') = 'void'
attr(`get_param_array_household_size`, "inputTypes") = c('_p_parameters', 'numeric')
class(`get_param_array_household_size`) = c("SWIGFunction", class('get_param_array_household_size'))

# Start of get_param_array_population

`get_param_array_population` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_get_param_array_population', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_array_population`, 'returnType') = 'void'
attr(`get_param_array_population`, "inputTypes") = c('_p_parameters', 'numeric')
class(`get_param_array_population`) = c("SWIGFunction", class('get_param_array_population'))

# Start of get_param_array_fraction_asymptomatic

`get_param_array_fraction_asymptomatic` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_get_param_array_fraction_asymptomatic', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_array_fraction_asymptomatic`, 'returnType') = 'void'
attr(`get_param_array_fraction_asymptomatic`, "inputTypes") = c('_p_parameters', 'numeric')
class(`get_param_array_fraction_asymptomatic`) = c("SWIGFunction", class('get_param_array_fraction_asymptomatic'))

# Start of get_param_array_mild_fraction

`get_param_array_mild_fraction` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_get_param_array_mild_fraction', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_array_mild_fraction`, 'returnType') = 'void'
attr(`get_param_array_mild_fraction`, "inputTypes") = c('_p_parameters', 'numeric')
class(`get_param_array_mild_fraction`) = c("SWIGFunction", class('get_param_array_mild_fraction'))

# Start of get_param_array_location_death_icu

`get_param_array_location_death_icu` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_get_param_array_location_death_icu', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_array_location_death_icu`, 'returnType') = 'void'
attr(`get_param_array_location_death_icu`, "inputTypes") = c('_p_parameters', 'numeric')
class(`get_param_array_location_death_icu`) = c("SWIGFunction", class('get_param_array_location_death_icu'))

# Start of get_param_array_app_users_fraction

`get_param_array_app_users_fraction` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_get_param_array_app_users_fraction', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`get_param_array_app_users_fraction`, 'returnType') = 'void'
attr(`get_param_array_app_users_fraction`, "inputTypes") = c('_p_parameters', 'numeric')
class(`get_param_array_app_users_fraction`) = c("SWIGFunction", class('get_param_array_app_users_fraction'))

# Start of set_param_array_mean_random_interactions

`set_param_array_mean_random_interactions` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_array_mean_random_interactions', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_array_mean_random_interactions`, 'returnType') = 'void'
attr(`set_param_array_mean_random_interactions`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_array_mean_random_interactions`) = c("SWIGFunction", class('set_param_array_mean_random_interactions'))

# Start of set_param_array_sd_random_interactions

`set_param_array_sd_random_interactions` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_array_sd_random_interactions', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_array_sd_random_interactions`, 'returnType') = 'void'
attr(`set_param_array_sd_random_interactions`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_array_sd_random_interactions`) = c("SWIGFunction", class('set_param_array_sd_random_interactions'))

# Start of set_param_array_mean_work_interactions

`set_param_array_mean_work_interactions` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_array_mean_work_interactions', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_array_mean_work_interactions`, 'returnType') = 'void'
attr(`set_param_array_mean_work_interactions`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_array_mean_work_interactions`) = c("SWIGFunction", class('set_param_array_mean_work_interactions'))

# Start of set_param_array_relative_susceptibility

`set_param_array_relative_susceptibility` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_array_relative_susceptibility', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_array_relative_susceptibility`, 'returnType') = 'void'
attr(`set_param_array_relative_susceptibility`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_array_relative_susceptibility`) = c("SWIGFunction", class('set_param_array_relative_susceptibility'))

# Start of set_param_array_adjusted_susceptibility

`set_param_array_adjusted_susceptibility` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_array_adjusted_susceptibility', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_array_adjusted_susceptibility`, 'returnType') = 'void'
attr(`set_param_array_adjusted_susceptibility`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_array_adjusted_susceptibility`) = c("SWIGFunction", class('set_param_array_adjusted_susceptibility'))

# Start of set_param_array_relative_transmission

`set_param_array_relative_transmission` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_array_relative_transmission', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_array_relative_transmission`, 'returnType') = 'void'
attr(`set_param_array_relative_transmission`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_array_relative_transmission`) = c("SWIGFunction", class('set_param_array_relative_transmission'))

# Start of set_param_array_relative_transmission_used

`set_param_array_relative_transmission_used` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_array_relative_transmission_used', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_array_relative_transmission_used`, 'returnType') = 'void'
attr(`set_param_array_relative_transmission_used`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_array_relative_transmission_used`) = c("SWIGFunction", class('set_param_array_relative_transmission_used'))

# Start of set_param_array_hospitalised_fraction

`set_param_array_hospitalised_fraction` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_array_hospitalised_fraction', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_array_hospitalised_fraction`, 'returnType') = 'void'
attr(`set_param_array_hospitalised_fraction`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_array_hospitalised_fraction`) = c("SWIGFunction", class('set_param_array_hospitalised_fraction'))

# Start of set_param_array_critical_fraction

`set_param_array_critical_fraction` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_array_critical_fraction', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_array_critical_fraction`, 'returnType') = 'void'
attr(`set_param_array_critical_fraction`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_array_critical_fraction`) = c("SWIGFunction", class('set_param_array_critical_fraction'))

# Start of set_param_array_fatality_fraction

`set_param_array_fatality_fraction` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_array_fatality_fraction', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_array_fatality_fraction`, 'returnType') = 'void'
attr(`set_param_array_fatality_fraction`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_array_fatality_fraction`) = c("SWIGFunction", class('set_param_array_fatality_fraction'))

# Start of set_param_array_household_size

`set_param_array_household_size` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_array_household_size', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_array_household_size`, 'returnType') = 'void'
attr(`set_param_array_household_size`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_array_household_size`) = c("SWIGFunction", class('set_param_array_household_size'))

# Start of set_param_array_population

`set_param_array_population` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_array_population', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_array_population`, 'returnType') = 'void'
attr(`set_param_array_population`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_array_population`) = c("SWIGFunction", class('set_param_array_population'))

# Start of set_param_array_fraction_asymptomatic

`set_param_array_fraction_asymptomatic` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_array_fraction_asymptomatic', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_array_fraction_asymptomatic`, 'returnType') = 'void'
attr(`set_param_array_fraction_asymptomatic`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_array_fraction_asymptomatic`) = c("SWIGFunction", class('set_param_array_fraction_asymptomatic'))

# Start of set_param_array_mild_fraction

`set_param_array_mild_fraction` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_array_mild_fraction', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_array_mild_fraction`, 'returnType') = 'void'
attr(`set_param_array_mild_fraction`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_array_mild_fraction`) = c("SWIGFunction", class('set_param_array_mild_fraction'))

# Start of set_param_array_app_users_fraction

`set_param_array_app_users_fraction` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_array_app_users_fraction', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_array_app_users_fraction`, 'returnType') = 'void'
attr(`set_param_array_app_users_fraction`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_array_app_users_fraction`) = c("SWIGFunction", class('set_param_array_app_users_fraction'))

# Start of set_param_array_location_death_icu

`set_param_array_location_death_icu` = function(params, value)
{
  if (inherits(params, "ExternalReference")) params = slot(params,"ref") 
  
  ;.Call('R_swig_set_param_array_location_death_icu', params, value, PACKAGE='OpenABMCovid19');
  
}

attr(`set_param_array_location_death_icu`, 'returnType') = 'void'
attr(`set_param_array_location_death_icu`, "inputTypes") = c('_p_parameters', 'numeric')
class(`set_param_array_location_death_icu`) = c("SWIGFunction", class('set_param_array_location_death_icu'))

# Start of network_n_edges

`network_n_edges` = function(pnetwork, .copy = FALSE)
{
  if (inherits(pnetwork, "ExternalReference")) pnetwork = slot(pnetwork,"ref") 
  ;.Call('R_swig_network_n_edges', pnetwork, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`network_n_edges`, 'returnType') = 'integer'
attr(`network_n_edges`, "inputTypes") = c('_p_network')
class(`network_n_edges`) = c("SWIGFunction", class('network_n_edges'))

# Start of network_n_vertices

`network_n_vertices` = function(pnetwork, .copy = FALSE)
{
  if (inherits(pnetwork, "ExternalReference")) pnetwork = slot(pnetwork,"ref") 
  ;.Call('R_swig_network_n_vertices', pnetwork, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`network_n_vertices`, 'returnType') = 'integer'
attr(`network_n_vertices`, "inputTypes") = c('_p_network')
class(`network_n_vertices`) = c("SWIGFunction", class('network_n_vertices'))

# Start of network_name

`network_name` = function(pnetwork)
{
  if (inherits(pnetwork, "ExternalReference")) pnetwork = slot(pnetwork,"ref") 
  ;.Call('R_swig_network_name', pnetwork, PACKAGE='OpenABMCovid19');
  
}

attr(`network_name`, 'returnType') = 'character'
attr(`network_name`, "inputTypes") = c('_p_network')
class(`network_name`) = c("SWIGFunction", class('network_name'))

# Start of network_skip_hospitalised

`network_skip_hospitalised` = function(pnetwork, .copy = FALSE)
{
  if (inherits(pnetwork, "ExternalReference")) pnetwork = slot(pnetwork,"ref") 
  ;.Call('R_swig_network_skip_hospitalised', pnetwork, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`network_skip_hospitalised`, 'returnType') = 'integer'
attr(`network_skip_hospitalised`, "inputTypes") = c('_p_network')
class(`network_skip_hospitalised`) = c("SWIGFunction", class('network_skip_hospitalised'))

# Start of network_skip_quarantined

`network_skip_quarantined` = function(pnetwork, .copy = FALSE)
{
  if (inherits(pnetwork, "ExternalReference")) pnetwork = slot(pnetwork,"ref") 
  ;.Call('R_swig_network_skip_quarantined', pnetwork, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`network_skip_quarantined`, 'returnType') = 'integer'
attr(`network_skip_quarantined`, "inputTypes") = c('_p_network')
class(`network_skip_quarantined`) = c("SWIGFunction", class('network_skip_quarantined'))

# Start of network_type

`network_type` = function(pnetwork, .copy = FALSE)
{
  if (inherits(pnetwork, "ExternalReference")) pnetwork = slot(pnetwork,"ref") 
  ;.Call('R_swig_network_type', pnetwork, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`network_type`, 'returnType') = 'integer'
attr(`network_type`, "inputTypes") = c('_p_network')
class(`network_type`) = c("SWIGFunction", class('network_type'))

# Start of network_daily_fraction

`network_daily_fraction` = function(pnetwork, .copy = FALSE)
{
  if (inherits(pnetwork, "ExternalReference")) pnetwork = slot(pnetwork,"ref") 
  ;.Call('R_swig_network_daily_fraction', pnetwork, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`network_daily_fraction`, 'returnType') = 'numeric'
attr(`network_daily_fraction`, "inputTypes") = c('_p_network')
class(`network_daily_fraction`) = c("SWIGFunction", class('network_daily_fraction'))

# Start of network_transmission_multiplier

`network_transmission_multiplier` = function(pnetwork, .copy = FALSE)
{
  if (inherits(pnetwork, "ExternalReference")) pnetwork = slot(pnetwork,"ref") 
  ;.Call('R_swig_network_transmission_multiplier', pnetwork, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`network_transmission_multiplier`, 'returnType') = 'numeric'
attr(`network_transmission_multiplier`, "inputTypes") = c('_p_network')
class(`network_transmission_multiplier`) = c("SWIGFunction", class('network_transmission_multiplier'))

# Start of set_network_transmission_multiplier

`set_network_transmission_multiplier` = function(pnetwork, val)
{
  if (inherits(pnetwork, "ExternalReference")) pnetwork = slot(pnetwork,"ref") 
  
  ;.Call('R_swig_set_network_transmission_multiplier', pnetwork, val, PACKAGE='OpenABMCovid19');
  
}

attr(`set_network_transmission_multiplier`, 'returnType') = 'void'
attr(`set_network_transmission_multiplier`, "inputTypes") = c('_p_network', 'numeric')
class(`set_network_transmission_multiplier`) = c("SWIGFunction", class('set_network_transmission_multiplier'))

# Start of get_network

`get_network` = function(pnetwork, id1_array, id2_array, .copy = FALSE)
{
  if (inherits(pnetwork, "ExternalReference")) pnetwork = slot(pnetwork,"ref") 
  id1_array = as.integer(id1_array);
  id2_array = as.integer(id2_array);
  ;.Call('R_swig_get_network', pnetwork, id1_array, id2_array, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`get_network`, 'returnType') = 'integer'
attr(`get_network`, "inputTypes") = c('_p_network', 'integer', 'integer')
class(`get_network`) = c("SWIGFunction", class('get_network'))

# Start of vaccine_idx

`vaccine_idx` = function(pvaccine, .copy = FALSE)
{
  if (inherits(pvaccine, "ExternalReference")) pvaccine = slot(pvaccine,"ref") 
  ;.Call('R_swig_vaccine_idx', pvaccine, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_idx`, 'returnType') = 'integer'
attr(`vaccine_idx`, "inputTypes") = c('_p_vaccine')
class(`vaccine_idx`) = c("SWIGFunction", class('vaccine_idx'))

# Start of vaccine_full_efficacy

`vaccine_full_efficacy` = function(pvaccine, efficacy)
{
  if (inherits(pvaccine, "ExternalReference")) pvaccine = slot(pvaccine,"ref") 
  
  ;.Call('R_swig_vaccine_full_efficacy', pvaccine, efficacy, PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_full_efficacy`, 'returnType') = 'void'
attr(`vaccine_full_efficacy`, "inputTypes") = c('_p_vaccine', 'numeric')
class(`vaccine_full_efficacy`) = c("SWIGFunction", class('vaccine_full_efficacy'))

# Start of vaccine_symptoms_efficacy

`vaccine_symptoms_efficacy` = function(pvaccine, efficacy)
{
  if (inherits(pvaccine, "ExternalReference")) pvaccine = slot(pvaccine,"ref") 
  
  ;.Call('R_swig_vaccine_symptoms_efficacy', pvaccine, efficacy, PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_symptoms_efficacy`, 'returnType') = 'void'
attr(`vaccine_symptoms_efficacy`, "inputTypes") = c('_p_vaccine', 'numeric')
class(`vaccine_symptoms_efficacy`) = c("SWIGFunction", class('vaccine_symptoms_efficacy'))

# Start of vaccine_severe_efficacy

`vaccine_severe_efficacy` = function(pvaccine, efficacy)
{
  if (inherits(pvaccine, "ExternalReference")) pvaccine = slot(pvaccine,"ref") 
  
  ;.Call('R_swig_vaccine_severe_efficacy', pvaccine, efficacy, PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_severe_efficacy`, 'returnType') = 'void'
attr(`vaccine_severe_efficacy`, "inputTypes") = c('_p_vaccine', 'numeric')
class(`vaccine_severe_efficacy`) = c("SWIGFunction", class('vaccine_severe_efficacy'))

# Start of vaccine_time_to_protect

`vaccine_time_to_protect` = function(pvaccine, .copy = FALSE)
{
  if (inherits(pvaccine, "ExternalReference")) pvaccine = slot(pvaccine,"ref") 
  ;.Call('R_swig_vaccine_time_to_protect', pvaccine, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_time_to_protect`, 'returnType') = 'integer'
attr(`vaccine_time_to_protect`, "inputTypes") = c('_p_vaccine')
class(`vaccine_time_to_protect`) = c("SWIGFunction", class('vaccine_time_to_protect'))

# Start of vaccine_vaccine_protection_period

`vaccine_vaccine_protection_period` = function(pvaccine, .copy = FALSE)
{
  if (inherits(pvaccine, "ExternalReference")) pvaccine = slot(pvaccine,"ref") 
  ;.Call('R_swig_vaccine_vaccine_protection_period', pvaccine, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_vaccine_protection_period`, 'returnType') = 'integer'
attr(`vaccine_vaccine_protection_period`, "inputTypes") = c('_p_vaccine')
class(`vaccine_vaccine_protection_period`) = c("SWIGFunction", class('vaccine_vaccine_protection_period'))

# Start of vaccine_name

`vaccine_name` = function(pvaccine)
{
  if (inherits(pvaccine, "ExternalReference")) pvaccine = slot(pvaccine,"ref") 
  ;.Call('R_swig_vaccine_name', pvaccine, PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_name`, 'returnType') = 'character'
attr(`vaccine_name`, "inputTypes") = c('_p_vaccine')
class(`vaccine_name`) = c("SWIGFunction", class('vaccine_name'))

# Start of vaccine_n_strains

`vaccine_n_strains` = function(pvaccine, .copy = FALSE)
{
  if (inherits(pvaccine, "ExternalReference")) pvaccine = slot(pvaccine,"ref") 
  ;.Call('R_swig_vaccine_n_strains', pvaccine, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`vaccine_n_strains`, 'returnType') = 'integer'
attr(`vaccine_n_strains`, "inputTypes") = c('_p_vaccine')
class(`vaccine_n_strains`) = c("SWIGFunction", class('vaccine_n_strains'))

# Start of strain_idx

`strain_idx` = function(pstrain, .copy = FALSE)
{
  if (inherits(pstrain, "ExternalReference")) pstrain = slot(pstrain,"ref") 
  ;.Call('R_swig_strain_idx', pstrain, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`strain_idx`, 'returnType') = 'integer'
attr(`strain_idx`, "inputTypes") = c('_p_strain')
class(`strain_idx`) = c("SWIGFunction", class('strain_idx'))

# Start of strain_transmission_multiplier

`strain_transmission_multiplier` = function(pstrain, .copy = FALSE)
{
  if (inherits(pstrain, "ExternalReference")) pstrain = slot(pstrain,"ref") 
  ;.Call('R_swig_strain_transmission_multiplier', pstrain, as.logical(.copy), PACKAGE='OpenABMCovid19');
  
}

attr(`strain_transmission_multiplier`, 'returnType') = 'numeric'
attr(`strain_transmission_multiplier`, "inputTypes") = c('_p_strain')
class(`strain_transmission_multiplier`) = c("SWIGFunction", class('strain_transmission_multiplier'))

Try the OpenABMCovid19 package in your browser

Any scripts or data that you put into this service are public.

OpenABMCovid19 documentation built on July 20, 2021, 5:08 p.m.

R Package Documentation

rdrr.io home R language documentation Run R code online

Browse R Packages

CRAN packages Bioconductor packages R-Forge packages GitHub packages

We want your feedback!

Note that we can't provide technical support on individual packages. You should contact the package authors for that.
GitHub issue tracker
ian@mutexlabs.com
Personal blog

 
Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.

Close