xroad_objects.h

Go to the documentation of this file.

 
#pragma once
 
#include "xroad_objects_types.h"
#include <node/xroad_node_types.h>
#include <common/xroad_common_types.h>
#include <common/xroad_aux.h>
#include <common/xroad_datetime.h>
#include <common/xroad_lock.h>
#include <stdint.h>
#include <string.h>
#include <stdbool.h>
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#define xroad_mk_ref(type, id) (xroad_object_ref_t){type, id}
 
xroad_object_type_t xroad_object_get_type(const void* obj);
 
xroad_object_id_t xroad_object_get_id(const void* obj);
 
xroad_object_ref_t xroad_object_get_ref(const void* obj);
 
size_t xroad_object_get_size(int32_t type);
 
bool xroad_object_is_valid(void* obj);
 
int32_t xroad_object_print(const void* obj, char* buf, uint32_t len);
 
uint64_t xroad_object_calc_hash(const void* obj);
 
xroad_str_t xroad_object_calc_uniq_id(const void* obj);
 
xroad_object_storage_type_t xroad_object_get_storage_type(xroad_object_type_t type);
 
void* xroad_object_lock(void* obj);
 
#define __xroad_object_lock_dtor__ __dtor__(xroad_object_lock_dtor)
void xroad_object_lock_dtor(void **obj);
 
void xroad_object_unlock(void* obj);
 
void xroad_object_reset_lock(void* obj);
 
bool xroad_object_is_locked(void* obj);
 
int32_t xroad_object_get_lock_version(void* obj);
 
int32_t xroad_object_get_lock_pid(void* obj);
 
void* xroad_object_clone(const void* obj);
 
void xroad_object_destroy(void* obj);
 
#define __xroad_object_dtor__ __dtor__(xroad_object_destructor)
void xroad_object_destructor(void* obj);
 
typedef struct xroad_start_s xroad_start_t;
 
typedef struct xroad_stop_s xroad_stop_t;
 
typedef struct xroad_reconfig_s xroad_reconfig_t;
 
typedef struct xroad_activate_s xroad_activate_t;
 
typedef struct xroad_deactivate_s xroad_deactivate_t;
 
typedef struct xroad_date_changed_s xroad_date_changed_t;
 
typedef struct xroad_reset_s xroad_reset_t;
 
typedef struct xroad_alarm_s xroad_alarm_t;
 
typedef struct xroad_node_event_s xroad_node_event_t;
 
typedef struct xroad_ping_s xroad_ping_t;
 
typedef struct xroad_alarm_enable_s xroad_alarm_enable_t;
 
typedef struct xroad_pong_s xroad_pong_t;
 
typedef struct xroad_currency_s xroad_currency_t;
 
typedef struct xroad_exchange_s xroad_exchange_t;
 
typedef struct xroad_fix_session_s xroad_fix_session_t;
 
typedef struct xroad_order_s xroad_order_t;
 
typedef struct xroad_pos_s xroad_pos_t;
 
typedef struct xroad_order_stat_s xroad_order_stat_t;
 
typedef struct xroad_iceberg_s xroad_iceberg_t;
 
typedef struct xroad_twap_s xroad_twap_t;
 
typedef struct xroad_pov_s xroad_pov_t;
 
typedef struct xroad_vwap_s xroad_vwap_t;
 
typedef struct xroad_instr_s xroad_instr_t;
 
typedef struct xroad_tick_info_s xroad_tick_info_t;
 
typedef struct xroad_timesheet_s xroad_timesheet_t;
 
typedef struct xroad_mdstat_s xroad_mdstat_t;
 
typedef struct xroad_order_sql_s xroad_order_sql_t;
 
typedef struct xroad_cancel_sql_s xroad_cancel_sql_t;
 
typedef struct xroad_replace_sql_s xroad_replace_sql_t;
 
typedef struct xroad_order_rabbit_s xroad_order_rabbit_t;
 
typedef struct xroad_rake_s xroad_rake_t;
 
typedef struct xroad_stealth_s xroad_stealth_t;
 
typedef struct xroad_spread_s xroad_spread_t;
 
typedef struct xroad_leg_s xroad_leg_t;
 
typedef struct xroad_spread_trade_s xroad_spread_trade_t;
 
typedef struct xroad_cgate_session_s xroad_cgate_session_t;
 
typedef struct xroad_cgate_table_s xroad_cgate_table_t;
 
typedef struct xroad_cgate_order_s xroad_cgate_order_t;
 
typedef struct xroad_obj_uuid_s xroad_obj_uuid_t;
 
typedef struct xroad_free_form_s xroad_free_form_t;
 
typedef struct xroad_order_fix_s xroad_order_fix_t;
 
typedef struct xroad_fix_msg_in_s xroad_fix_msg_in_t;
 
typedef struct xroad_fix_msg_out_s xroad_fix_msg_out_t;
 
typedef struct xroad_trade_fix_s xroad_trade_fix_t;
 
typedef struct xroad_lock_by_pid_s xroad_lock_by_pid_t;
 
typedef struct xroad_system_role_changed_s xroad_system_role_changed_t;
 
typedef struct xroad_cancel_s xroad_cancel_t;
 
typedef struct xroad_remove_s xroad_remove_t;
 
typedef struct xroad_replace_s xroad_replace_t;
 
typedef struct xroad_accepted_s xroad_accepted_t;
 
typedef struct xroad_rejected_s xroad_rejected_t;
 
typedef struct xroad_canceled_s xroad_canceled_t;
 
typedef struct xroad_trade_s xroad_trade_t;
 
typedef struct xroad_cancel_rejected_s xroad_cancel_rejected_t;
 
typedef struct xroad_replace_rejected_s xroad_replace_rejected_t;
 
typedef struct xroad_replaced_s xroad_replaced_t;
 
typedef struct xroad_subscribe_s xroad_subscribe_t;
 
typedef struct xroad_unsubscribe_s xroad_unsubscribe_t;
 
typedef struct xroad_update_s xroad_update_t;
 
typedef struct xroad_money_limit_s xroad_money_limit_t;
 
typedef struct xroad_order_limit_s xroad_order_limit_t;
 
typedef struct xroad_security_short_s xroad_security_short_t;
 
typedef struct xroad_client_short_s xroad_client_short_t;
 
typedef struct xroad_opt_mm_s xroad_opt_mm_t;
 
typedef struct xroad_field_s xroad_field_t;
 
typedef struct xroad_prop_s xroad_prop_t;
 
typedef struct xroad_prop_row_s xroad_prop_row_t;
 
typedef struct xroad_mmaker_s xroad_mmaker_t;
 
typedef struct xroad_sniper_s xroad_sniper_t;
 
typedef struct xroad_pmaker_s xroad_pmaker_t;
 
typedef struct xroad_trd_capt_s xroad_trd_capt_t;
 
typedef struct xroad_props_s xroad_props_t;
 
typedef struct xroad_resolve_s xroad_resolve_t;
 
typedef struct xroad_resolve_ack_s xroad_resolve_ack_t;
 
typedef struct xroad_mdata_subs_s xroad_mdata_subs_t;
 
typedef struct xroad_reload_s xroad_reload_t;
 
typedef struct xroad_sbe_session_s xroad_sbe_session_t;
 
typedef struct xroad_order_crypto_s xroad_order_crypto_t;
 
typedef struct xroad_crypto_session_s xroad_crypto_session_t;
 
typedef struct xroad_acc_pos_s xroad_acc_pos_t;
 
typedef struct xroad_acc_balance_s xroad_acc_balance_t;
 
typedef struct xroad_order_ws_s xroad_order_ws_t;
 
typedef struct xroad_order_sbe_s xroad_order_sbe_t;
 
typedef struct xroad_pmaker_total_s xroad_pmaker_total_t;
 
typedef struct xroad_cancel_all_s xroad_cancel_all_t;
 
typedef struct xroad_pos_reset_s xroad_pos_reset_t;
 
typedef struct xroad_acc_int_request_s xroad_acc_int_request_t;
 
typedef struct xroad_acc_int_response_s xroad_acc_int_response_t;
 
typedef struct xroad_fund_asset_s xroad_fund_asset_t;
 
typedef struct xroad_rps_robot_s xroad_rps_robot_t;
 
typedef struct xroad_rps_filter_s xroad_rps_filter_t;
 
typedef struct xroad_fi_bot_s xroad_fi_bot_t;
 
typedef struct xroad_mdsource_s xroad_mdsource_t;
 
typedef struct xroad_instr_mdsource_s xroad_instr_mdsource_t;
 
typedef struct xroad_instr_basket_s xroad_instr_basket_t;
 
typedef struct xroad_broker_s xroad_broker_t;
 
typedef struct xroad_spbex_bin_session_s xroad_spbex_bin_session_t;
 
typedef struct xroad_order_spbex_s xroad_order_spbex_t;
 
typedef struct xroad_scheduled_s xroad_scheduled_t;
 
typedef struct xroad_mdconsumer_s xroad_mdconsumer_t;
 
typedef struct xroad_pre_trade_s xroad_pre_trade_t;
 
typedef struct xroad_pre_trade_ack_s xroad_pre_trade_ack_t;
 
typedef struct xroad_speedway_s xroad_speedway_t;
 
typedef struct xroad_top_book_s xroad_top_book_t;
 
 
/* algo interface */
 
xroad_errno_t xroad_algo_set_start(void* obj, xroad_int32_t val);
 
xroad_int32_t xroad_algo_get_start(const void* obj);
 
void xroad_algo_reset_start(void* obj);
 
bool xroad_algo_start_is_set(const void* obj);
 
xroad_errno_t xroad_algo_set_stop(void* obj, xroad_int32_t val);
 
xroad_int32_t xroad_algo_get_stop(const void* obj);
 
void xroad_algo_reset_stop(void* obj);
 
bool xroad_algo_stop_is_set(const void* obj);
 
xroad_errno_t xroad_algo_set_agression_level(void* obj, xroad_int32_t val);
 
xroad_int32_t xroad_algo_get_agression_level(const void* obj);
 
void xroad_algo_reset_agression_level(void* obj);
 
bool xroad_algo_agression_level_is_set(const void* obj);
 
xroad_errno_t xroad_algo_set_mid_time(void* obj, xroad_int32_t val);
 
xroad_int32_t xroad_algo_get_mid_time(const void* obj);
 
void xroad_algo_reset_mid_time(void* obj);
 
bool xroad_algo_mid_time_is_set(const void* obj);
 
xroad_errno_t xroad_algo_set_agression_time(void* obj, xroad_int32_t val);
 
xroad_int32_t xroad_algo_get_agression_time(const void* obj);
 
void xroad_algo_reset_agression_time(void* obj);
 
bool xroad_algo_agression_time_is_set(const void* obj);
 
xroad_errno_t xroad_algo_set_book_depth(void* obj, xroad_int32_t val);
 
xroad_int32_t xroad_algo_get_book_depth(const void* obj);
 
void xroad_algo_reset_book_depth(void* obj);
 
bool xroad_algo_book_depth_is_set(const void* obj);
 
xroad_errno_t xroad_algo_set_min_qty(void* obj, xroad_int32_t val);
 
xroad_int32_t xroad_algo_get_min_qty(const void* obj);
 
void xroad_algo_reset_min_qty(void* obj);
 
bool xroad_algo_min_qty_is_set(const void* obj);
 
 
/* order_base interface */
 
xroad_errno_t xroad_order_base_set_side(void* obj, xroad_side_t val);
 
xroad_side_t xroad_order_base_get_side(const void* obj);
 
void xroad_order_base_reset_side(void* obj);
 
bool xroad_order_base_side_is_set(const void* obj);
 
xroad_errno_t xroad_order_base_set_tif(void* obj, xroad_tif_t val);
 
xroad_tif_t xroad_order_base_get_tif(const void* obj);
 
void xroad_order_base_reset_tif(void* obj);
 
bool xroad_order_base_tif_is_set(const void* obj);
 
xroad_errno_t xroad_order_base_set_src_node_id(void* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_order_base_get_src_node_id(const void* obj);
 
void xroad_order_base_reset_src_node_id(void* obj);
 
bool xroad_order_base_src_node_id_is_set(const void* obj);
 
xroad_errno_t xroad_order_base_set_dst_node_id(void* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_order_base_get_dst_node_id(const void* obj);
 
void xroad_order_base_reset_dst_node_id(void* obj);
 
bool xroad_order_base_dst_node_id_is_set(const void* obj);
 
xroad_errno_t xroad_order_base_set_ext_ref(void* obj, xroad_str_t val);
 
xroad_str_t xroad_order_base_get_ext_ref(const void* obj);
 
void xroad_order_base_reset_ext_ref(void* obj);
 
bool xroad_order_base_ext_ref_is_set(const void* obj);
 
xroad_errno_t xroad_order_base_set_status(void* obj, xroad_order_status_t val);
 
xroad_order_status_t xroad_order_base_get_status(const void* obj);
 
void xroad_order_base_reset_status(void* obj);
 
bool xroad_order_base_status_is_set(const void* obj);
 
xroad_errno_t xroad_order_base_set_sub_status(void* obj, xroad_sub_status_t val);
 
xroad_sub_status_t xroad_order_base_get_sub_status(const void* obj);
 
void xroad_order_base_reset_sub_status(void* obj);
 
bool xroad_order_base_sub_status_is_set(const void* obj);
 
 
/* order_ref interface */
 
xroad_errno_t xroad_order_ref_set_order(void* obj, void* ref);
 
xroad_errno_t xroad_order_ref_set_order_ref(void* obj, xroad_object_ref_t ref);
 
void* xroad_order_ref_get_order(const void* obj);
 
xroad_object_ref_t xroad_order_ref_get_order_ref(const void* obj);
 
void xroad_order_ref_reset_order(void* obj);
 
bool xroad_order_ref_order_is_set(const void* obj);
 
 
/* owner interface */
 
xroad_errno_t xroad_owner_set_node_id(void* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_owner_get_node_id(const void* obj);
 
void xroad_owner_reset_node_id(void* obj);
 
bool xroad_owner_node_id_is_set(const void* obj);
 
 
/* parent interface */
 
xroad_errno_t xroad_parent_set_parent(void* obj, void* ref);
 
xroad_errno_t xroad_parent_set_parent_ref(void* obj, xroad_object_ref_t ref);
 
void* xroad_parent_get_parent(const void* obj);
 
xroad_object_ref_t xroad_parent_get_parent_ref(const void* obj);
 
void xroad_parent_reset_parent(void* obj);
 
bool xroad_parent_parent_is_set(const void* obj);
 
 
/* removable interface */
 
xroad_errno_t xroad_removable_set_deleted(void* obj, xroad_bool_t val);
 
xroad_bool_t xroad_removable_get_deleted(const void* obj);
 
void xroad_removable_reset_deleted(void* obj);
 
bool xroad_removable_deleted_is_set(const void* obj);
 
 
/* xroad_start_t */
 
void xroad_start_destroy(xroad_start_t* obj);
 
xroad_errno_t xroad_start_send(xroad_start_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_start_route(xroad_start_t* obj, ...);
 
void xroad_start_reset(xroad_start_t* obj);
 
xroad_start_t* xroad_start_clone(const xroad_start_t* obj);
 
bool xroad_start_is_valid(const xroad_start_t* obj);
 
int32_t xroad_start_print(const xroad_start_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_start_calc_hash(const xroad_start_t* obj);
 
xroad_str_t xroad_start_calc_uniq_id(const xroad_start_t* obj);
 
 
 
/* xroad_stop_t */
 
void xroad_stop_destroy(xroad_stop_t* obj);
 
xroad_errno_t xroad_stop_send(xroad_stop_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_stop_route(xroad_stop_t* obj, ...);
 
void xroad_stop_reset(xroad_stop_t* obj);
 
xroad_stop_t* xroad_stop_clone(const xroad_stop_t* obj);
 
bool xroad_stop_is_valid(const xroad_stop_t* obj);
 
int32_t xroad_stop_print(const xroad_stop_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_stop_calc_hash(const xroad_stop_t* obj);
 
xroad_str_t xroad_stop_calc_uniq_id(const xroad_stop_t* obj);
 
 
 
/* xroad_reconfig_t */
 
void xroad_reconfig_destroy(xroad_reconfig_t* obj);
 
xroad_errno_t xroad_reconfig_send(xroad_reconfig_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_reconfig_route(xroad_reconfig_t* obj, ...);
 
void xroad_reconfig_reset(xroad_reconfig_t* obj);
 
xroad_reconfig_t* xroad_reconfig_clone(const xroad_reconfig_t* obj);
 
bool xroad_reconfig_is_valid(const xroad_reconfig_t* obj);
 
int32_t xroad_reconfig_print(const xroad_reconfig_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_reconfig_calc_hash(const xroad_reconfig_t* obj);
 
xroad_str_t xroad_reconfig_calc_uniq_id(const xroad_reconfig_t* obj);
 
 
 
/* xroad_activate_t */
 
void xroad_activate_destroy(xroad_activate_t* obj);
 
xroad_errno_t xroad_activate_send(xroad_activate_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_activate_route(xroad_activate_t* obj, ...);
 
void xroad_activate_reset(xroad_activate_t* obj);
 
xroad_activate_t* xroad_activate_clone(const xroad_activate_t* obj);
 
bool xroad_activate_is_valid(const xroad_activate_t* obj);
 
int32_t xroad_activate_print(const xroad_activate_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_activate_calc_hash(const xroad_activate_t* obj);
 
xroad_str_t xroad_activate_calc_uniq_id(const xroad_activate_t* obj);
 
 
 
/* xroad_deactivate_t */
 
void xroad_deactivate_destroy(xroad_deactivate_t* obj);
 
xroad_errno_t xroad_deactivate_send(xroad_deactivate_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_deactivate_route(xroad_deactivate_t* obj, ...);
 
void xroad_deactivate_reset(xroad_deactivate_t* obj);
 
xroad_deactivate_t* xroad_deactivate_clone(const xroad_deactivate_t* obj);
 
bool xroad_deactivate_is_valid(const xroad_deactivate_t* obj);
 
int32_t xroad_deactivate_print(const xroad_deactivate_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_deactivate_calc_hash(const xroad_deactivate_t* obj);
 
xroad_str_t xroad_deactivate_calc_uniq_id(const xroad_deactivate_t* obj);
 
 
 
/* xroad_date_changed_t */
 
void xroad_date_changed_destroy(xroad_date_changed_t* obj);
 
xroad_errno_t xroad_date_changed_send(xroad_date_changed_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_date_changed_route(xroad_date_changed_t* obj, ...);
 
void xroad_date_changed_reset(xroad_date_changed_t* obj);
 
xroad_date_changed_t* xroad_date_changed_clone(const xroad_date_changed_t* obj);
 
bool xroad_date_changed_is_valid(const xroad_date_changed_t* obj);
 
int32_t xroad_date_changed_print(const xroad_date_changed_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_date_changed_calc_hash(const xroad_date_changed_t* obj);
 
xroad_str_t xroad_date_changed_calc_uniq_id(const xroad_date_changed_t* obj);
 
 
 
/* xroad_reset_t */
 
xroad_errno_t xroad_reset_set_hint(xroad_reset_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_reset_get_hint(const xroad_reset_t* obj);
 
void xroad_reset_reset_hint(xroad_reset_t* obj);
 
bool xroad_reset_hint_is_set(const xroad_reset_t* obj);
 
xroad_errno_t xroad_reset_set_sender_comp_id(xroad_reset_t* obj, xroad_str_t val);
 
xroad_str_t xroad_reset_get_sender_comp_id(const xroad_reset_t* obj);
 
void xroad_reset_reset_sender_comp_id(xroad_reset_t* obj);
 
bool xroad_reset_sender_comp_id_is_set(const xroad_reset_t* obj);
 
xroad_errno_t xroad_reset_set_target_comp_id(xroad_reset_t* obj, xroad_str_t val);
 
xroad_str_t xroad_reset_get_target_comp_id(const xroad_reset_t* obj);
 
void xroad_reset_reset_target_comp_id(xroad_reset_t* obj);
 
bool xroad_reset_target_comp_id_is_set(const xroad_reset_t* obj);
 
void xroad_reset_destroy(xroad_reset_t* obj);
 
xroad_errno_t xroad_reset_send(xroad_reset_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_reset_route(xroad_reset_t* obj, ...);
 
void xroad_reset_reset(xroad_reset_t* obj);
 
xroad_reset_t* xroad_reset_clone(const xroad_reset_t* obj);
 
bool xroad_reset_is_valid(const xroad_reset_t* obj);
 
int32_t xroad_reset_print(const xroad_reset_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_reset_calc_hash(const xroad_reset_t* obj);
 
xroad_str_t xroad_reset_calc_uniq_id(const xroad_reset_t* obj);
 
 
 
/* xroad_alarm_t */
 
xroad_object_id_t xroad_alarm_get_id(const xroad_alarm_t* obj);
 
xroad_object_ref_t xroad_alarm_get_ref(const xroad_alarm_t* obj);
 
xroad_errno_t xroad_alarm_set_node_id(xroad_alarm_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_alarm_get_node_id(const xroad_alarm_t* obj);
 
void xroad_alarm_reset_node_id(xroad_alarm_t* obj);
 
bool xroad_alarm_node_id_is_set(const xroad_alarm_t* obj);
 
xroad_errno_t xroad_alarm_set_logger(xroad_alarm_t* obj, xroad_str_t val);
 
xroad_str_t xroad_alarm_get_logger(const xroad_alarm_t* obj);
 
void xroad_alarm_reset_logger(xroad_alarm_t* obj);
 
bool xroad_alarm_logger_is_set(const xroad_alarm_t* obj);
 
xroad_errno_t xroad_alarm_set_timestamp(xroad_alarm_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_alarm_get_timestamp(const xroad_alarm_t* obj);
 
void xroad_alarm_reset_timestamp(xroad_alarm_t* obj);
 
bool xroad_alarm_timestamp_is_set(const xroad_alarm_t* obj);
 
xroad_errno_t xroad_alarm_set_level(xroad_alarm_t* obj, xroad_alarm_level_t val);
 
xroad_alarm_level_t xroad_alarm_get_level(const xroad_alarm_t* obj);
 
void xroad_alarm_reset_level(xroad_alarm_t* obj);
 
bool xroad_alarm_level_is_set(const xroad_alarm_t* obj);
 
xroad_errno_t xroad_alarm_set_text(xroad_alarm_t* obj, xroad_str_t val);
 
xroad_str_t xroad_alarm_get_text(const xroad_alarm_t* obj);
 
void xroad_alarm_reset_text(xroad_alarm_t* obj);
 
bool xroad_alarm_text_is_set(const xroad_alarm_t* obj);
 
xroad_errno_t xroad_alarm_send(xroad_alarm_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_alarm_route(xroad_alarm_t* obj, ...);
 
void xroad_alarm_reset(xroad_alarm_t* obj);
 
xroad_alarm_t* xroad_alarm_clone(const xroad_alarm_t* obj);
 
bool xroad_alarm_is_valid(const xroad_alarm_t* obj);
 
int32_t xroad_alarm_print(const xroad_alarm_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_alarm_calc_hash(const xroad_alarm_t* obj);
 
xroad_str_t xroad_alarm_calc_uniq_id(const xroad_alarm_t* obj);
 
 
 
/* xroad_node_event_t */
 
xroad_errno_t xroad_node_event_set_node_id(xroad_node_event_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_node_event_get_node_id(const xroad_node_event_t* obj);
 
void xroad_node_event_reset_node_id(xroad_node_event_t* obj);
 
bool xroad_node_event_node_id_is_set(const xroad_node_event_t* obj);
 
xroad_errno_t xroad_node_event_set_event(xroad_node_event_t* obj, xroad_node_event_enum_t val);
 
xroad_node_event_enum_t xroad_node_event_get_event(const xroad_node_event_t* obj);
 
void xroad_node_event_reset_event(xroad_node_event_t* obj);
 
bool xroad_node_event_event_is_set(const xroad_node_event_t* obj);
 
void xroad_node_event_destroy(xroad_node_event_t* obj);
 
xroad_errno_t xroad_node_event_send(xroad_node_event_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_node_event_route(xroad_node_event_t* obj, ...);
 
void xroad_node_event_reset(xroad_node_event_t* obj);
 
xroad_node_event_t* xroad_node_event_clone(const xroad_node_event_t* obj);
 
bool xroad_node_event_is_valid(const xroad_node_event_t* obj);
 
int32_t xroad_node_event_print(const xroad_node_event_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_node_event_calc_hash(const xroad_node_event_t* obj);
 
xroad_str_t xroad_node_event_calc_uniq_id(const xroad_node_event_t* obj);
 
 
 
/* xroad_ping_t */
 
xroad_errno_t xroad_ping_set_request_id(xroad_ping_t* obj, xroad_uint64_t val);
 
xroad_uint64_t xroad_ping_get_request_id(const xroad_ping_t* obj);
 
void xroad_ping_reset_request_id(xroad_ping_t* obj);
 
bool xroad_ping_request_id_is_set(const xroad_ping_t* obj);
 
void xroad_ping_destroy(xroad_ping_t* obj);
 
xroad_errno_t xroad_ping_send(xroad_ping_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_ping_route(xroad_ping_t* obj, ...);
 
void xroad_ping_reset(xroad_ping_t* obj);
 
xroad_ping_t* xroad_ping_clone(const xroad_ping_t* obj);
 
bool xroad_ping_is_valid(const xroad_ping_t* obj);
 
int32_t xroad_ping_print(const xroad_ping_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_ping_calc_hash(const xroad_ping_t* obj);
 
xroad_str_t xroad_ping_calc_uniq_id(const xroad_ping_t* obj);
 
 
 
/* xroad_alarm_enable_t */
 
xroad_errno_t xroad_alarm_enable_set_enable(xroad_alarm_enable_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_alarm_enable_get_enable(const xroad_alarm_enable_t* obj);
 
void xroad_alarm_enable_reset_enable(xroad_alarm_enable_t* obj);
 
bool xroad_alarm_enable_enable_is_set(const xroad_alarm_enable_t* obj);
 
void xroad_alarm_enable_destroy(xroad_alarm_enable_t* obj);
 
xroad_errno_t xroad_alarm_enable_send(xroad_alarm_enable_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_alarm_enable_route(xroad_alarm_enable_t* obj, ...);
 
void xroad_alarm_enable_reset(xroad_alarm_enable_t* obj);
 
xroad_alarm_enable_t* xroad_alarm_enable_clone(const xroad_alarm_enable_t* obj);
 
bool xroad_alarm_enable_is_valid(const xroad_alarm_enable_t* obj);
 
int32_t xroad_alarm_enable_print(const xroad_alarm_enable_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_alarm_enable_calc_hash(const xroad_alarm_enable_t* obj);
 
xroad_str_t xroad_alarm_enable_calc_uniq_id(const xroad_alarm_enable_t* obj);
 
 
 
/* xroad_pong_t */
 
xroad_errno_t xroad_pong_set_request_id(xroad_pong_t* obj, xroad_uint64_t val);
 
xroad_uint64_t xroad_pong_get_request_id(const xroad_pong_t* obj);
 
void xroad_pong_reset_request_id(xroad_pong_t* obj);
 
bool xroad_pong_request_id_is_set(const xroad_pong_t* obj);
 
void xroad_pong_destroy(xroad_pong_t* obj);
 
xroad_errno_t xroad_pong_send(xroad_pong_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_pong_route(xroad_pong_t* obj, ...);
 
void xroad_pong_reset(xroad_pong_t* obj);
 
xroad_pong_t* xroad_pong_clone(const xroad_pong_t* obj);
 
bool xroad_pong_is_valid(const xroad_pong_t* obj);
 
int32_t xroad_pong_print(const xroad_pong_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_pong_calc_hash(const xroad_pong_t* obj);
 
xroad_str_t xroad_pong_calc_uniq_id(const xroad_pong_t* obj);
 
 
 
/* xroad_currency_t */
 
xroad_object_id_t xroad_currency_get_id(const xroad_currency_t* obj);
 
xroad_object_ref_t xroad_currency_get_ref(const xroad_currency_t* obj);
 
xroad_errno_t xroad_currency_set_name(xroad_currency_t* obj, xroad_str_t val);
 
xroad_str_t xroad_currency_get_name(const xroad_currency_t* obj);
 
void xroad_currency_reset_name(xroad_currency_t* obj);
 
bool xroad_currency_name_is_set(const xroad_currency_t* obj);
 
xroad_errno_t xroad_currency_set_iso(xroad_currency_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_currency_get_iso(const xroad_currency_t* obj);
 
void xroad_currency_reset_iso(xroad_currency_t* obj);
 
bool xroad_currency_iso_is_set(const xroad_currency_t* obj);
 
xroad_errno_t xroad_currency_send(xroad_currency_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_currency_route(xroad_currency_t* obj, ...);
 
void xroad_currency_reset(xroad_currency_t* obj);
 
xroad_currency_t* xroad_currency_clone(const xroad_currency_t* obj);
 
bool xroad_currency_is_valid(const xroad_currency_t* obj);
 
int32_t xroad_currency_print(const xroad_currency_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_currency_calc_hash(const xroad_currency_t* obj);
 
xroad_str_t xroad_currency_calc_uniq_id(const xroad_currency_t* obj);
 
 
 
/* xroad_exchange_t */
 
xroad_object_id_t xroad_exchange_get_id(const xroad_exchange_t* obj);
 
xroad_object_ref_t xroad_exchange_get_ref(const xroad_exchange_t* obj);
 
xroad_errno_t xroad_exchange_set_name(xroad_exchange_t* obj, xroad_str_t val);
 
xroad_str_t xroad_exchange_get_name(const xroad_exchange_t* obj);
 
void xroad_exchange_reset_name(xroad_exchange_t* obj);
 
bool xroad_exchange_name_is_set(const xroad_exchange_t* obj);
 
xroad_errno_t xroad_exchange_set_mic(xroad_exchange_t* obj, xroad_str_t val);
 
xroad_str_t xroad_exchange_get_mic(const xroad_exchange_t* obj);
 
void xroad_exchange_reset_mic(xroad_exchange_t* obj);
 
bool xroad_exchange_mic_is_set(const xroad_exchange_t* obj);
 
xroad_errno_t xroad_exchange_send(xroad_exchange_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_exchange_route(xroad_exchange_t* obj, ...);
 
void xroad_exchange_reset(xroad_exchange_t* obj);
 
xroad_exchange_t* xroad_exchange_clone(const xroad_exchange_t* obj);
 
bool xroad_exchange_is_valid(const xroad_exchange_t* obj);
 
int32_t xroad_exchange_print(const xroad_exchange_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_exchange_calc_hash(const xroad_exchange_t* obj);
 
xroad_str_t xroad_exchange_calc_uniq_id(const xroad_exchange_t* obj);
 
 
 
/* xroad_fix_session_t */
 
xroad_object_id_t xroad_fix_session_get_id(const xroad_fix_session_t* obj);
 
xroad_object_ref_t xroad_fix_session_get_ref(const xroad_fix_session_t* obj);
 
xroad_errno_t xroad_fix_session_set_node_id(xroad_fix_session_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_fix_session_get_node_id(const xroad_fix_session_t* obj);
 
void xroad_fix_session_reset_node_id(xroad_fix_session_t* obj);
 
bool xroad_fix_session_node_id_is_set(const xroad_fix_session_t* obj);
 
xroad_errno_t xroad_fix_session_set_sender_comp_id(xroad_fix_session_t* obj, xroad_str_t val);
 
xroad_str_t xroad_fix_session_get_sender_comp_id(const xroad_fix_session_t* obj);
 
void xroad_fix_session_reset_sender_comp_id(xroad_fix_session_t* obj);
 
bool xroad_fix_session_sender_comp_id_is_set(const xroad_fix_session_t* obj);
 
xroad_errno_t xroad_fix_session_set_target_comp_id(xroad_fix_session_t* obj, xroad_str_t val);
 
xroad_str_t xroad_fix_session_get_target_comp_id(const xroad_fix_session_t* obj);
 
void xroad_fix_session_reset_target_comp_id(xroad_fix_session_t* obj);
 
bool xroad_fix_session_target_comp_id_is_set(const xroad_fix_session_t* obj);
 
xroad_errno_t xroad_fix_session_set_tran_cnt(xroad_fix_session_t* obj, xroad_int64_t val);
 
xroad_int64_t xroad_fix_session_get_tran_cnt(const xroad_fix_session_t* obj);
 
void xroad_fix_session_reset_tran_cnt(xroad_fix_session_t* obj);
 
bool xroad_fix_session_tran_cnt_is_set(const xroad_fix_session_t* obj);
 
xroad_errno_t xroad_fix_session_set_logon_attempts(xroad_fix_session_t* obj, xroad_int64_t val);
 
xroad_int64_t xroad_fix_session_get_logon_attempts(const xroad_fix_session_t* obj);
 
void xroad_fix_session_reset_logon_attempts(xroad_fix_session_t* obj);
 
bool xroad_fix_session_logon_attempts_is_set(const xroad_fix_session_t* obj);
 
xroad_errno_t xroad_fix_session_set_expected_seqnum_in(xroad_fix_session_t* obj, xroad_seqnum_t val);
 
xroad_seqnum_t xroad_fix_session_get_expected_seqnum_in(const xroad_fix_session_t* obj);
 
void xroad_fix_session_reset_expected_seqnum_in(xroad_fix_session_t* obj);
 
bool xroad_fix_session_expected_seqnum_in_is_set(const xroad_fix_session_t* obj);
 
xroad_errno_t xroad_fix_session_set_sent_seqnum_out(xroad_fix_session_t* obj, xroad_seqnum_t val);
 
xroad_seqnum_t xroad_fix_session_get_sent_seqnum_out(const xroad_fix_session_t* obj);
 
void xroad_fix_session_reset_sent_seqnum_out(xroad_fix_session_t* obj);
 
bool xroad_fix_session_sent_seqnum_out_is_set(const xroad_fix_session_t* obj);
 
xroad_errno_t xroad_fix_session_set_state(xroad_fix_session_t* obj, xroad_session_state_t val);
 
xroad_session_state_t xroad_fix_session_get_state(const xroad_fix_session_t* obj);
 
void xroad_fix_session_reset_state(xroad_fix_session_t* obj);
 
bool xroad_fix_session_state_is_set(const xroad_fix_session_t* obj);
 
xroad_errno_t xroad_fix_session_set_status(xroad_fix_session_t* obj, xroad_fix_session_status_t val);
 
xroad_fix_session_status_t xroad_fix_session_get_status(const xroad_fix_session_t* obj);
 
void xroad_fix_session_reset_status(xroad_fix_session_t* obj);
 
bool xroad_fix_session_status_is_set(const xroad_fix_session_t* obj);
 
xroad_errno_t xroad_fix_session_set_fix_msg_out(xroad_fix_session_t* obj, void* ref);
 
xroad_errno_t xroad_fix_session_set_fix_msg_out_ref(xroad_fix_session_t* obj, xroad_object_ref_t ref);
 
void* xroad_fix_session_get_fix_msg_out(const xroad_fix_session_t* obj);
 
xroad_object_ref_t xroad_fix_session_get_fix_msg_out_ref(const xroad_fix_session_t* obj);
 
void xroad_fix_session_reset_fix_msg_out(xroad_fix_session_t* obj);
 
bool xroad_fix_session_fix_msg_out_is_set(const xroad_fix_session_t* obj);
 
xroad_errno_t xroad_fix_session_send(xroad_fix_session_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_fix_session_route(xroad_fix_session_t* obj, ...);
 
void xroad_fix_session_reset(xroad_fix_session_t* obj);
 
xroad_fix_session_t* xroad_fix_session_clone(const xroad_fix_session_t* obj);
 
bool xroad_fix_session_is_valid(const xroad_fix_session_t* obj);
 
int32_t xroad_fix_session_print(const xroad_fix_session_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_fix_session_calc_hash(const xroad_fix_session_t* obj);
 
xroad_str_t xroad_fix_session_calc_uniq_id(const xroad_fix_session_t* obj);
 
 
 
/* xroad_order_t */
 
xroad_object_id_t xroad_order_get_id(const xroad_order_t* obj);
 
xroad_object_ref_t xroad_order_get_ref(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_side(xroad_order_t* obj, xroad_side_t val);
 
xroad_side_t xroad_order_get_side(const xroad_order_t* obj);
 
void xroad_order_reset_side(xroad_order_t* obj);
 
bool xroad_order_side_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_tif(xroad_order_t* obj, xroad_tif_t val);
 
xroad_tif_t xroad_order_get_tif(const xroad_order_t* obj);
 
void xroad_order_reset_tif(xroad_order_t* obj);
 
bool xroad_order_tif_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_src_node_id(xroad_order_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_order_get_src_node_id(const xroad_order_t* obj);
 
void xroad_order_reset_src_node_id(xroad_order_t* obj);
 
bool xroad_order_src_node_id_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_dst_node_id(xroad_order_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_order_get_dst_node_id(const xroad_order_t* obj);
 
void xroad_order_reset_dst_node_id(xroad_order_t* obj);
 
bool xroad_order_dst_node_id_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_ext_ref(xroad_order_t* obj, xroad_str_t val);
 
xroad_str_t xroad_order_get_ext_ref(const xroad_order_t* obj);
 
void xroad_order_reset_ext_ref(xroad_order_t* obj);
 
bool xroad_order_ext_ref_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_status(xroad_order_t* obj, xroad_order_status_t val);
 
xroad_order_status_t xroad_order_get_status(const xroad_order_t* obj);
 
void xroad_order_reset_status(xroad_order_t* obj);
 
bool xroad_order_status_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_sub_status(xroad_order_t* obj, xroad_sub_status_t val);
 
xroad_sub_status_t xroad_order_get_sub_status(const xroad_order_t* obj);
 
void xroad_order_reset_sub_status(xroad_order_t* obj);
 
bool xroad_order_sub_status_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_sender(xroad_order_t* obj, xroad_str_t val);
 
xroad_str_t xroad_order_get_sender(const xroad_order_t* obj);
 
void xroad_order_reset_sender(xroad_order_t* obj);
 
bool xroad_order_sender_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_timestamp(xroad_order_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_order_get_timestamp(const xroad_order_t* obj);
 
void xroad_order_reset_timestamp(xroad_order_t* obj);
 
bool xroad_order_timestamp_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_account(xroad_order_t* obj, xroad_str_t val);
 
xroad_str_t xroad_order_get_account(const xroad_order_t* obj);
 
void xroad_order_reset_account(xroad_order_t* obj);
 
bool xroad_order_account_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_client_code(xroad_order_t* obj, xroad_str_t val);
 
xroad_str_t xroad_order_get_client_code(const xroad_order_t* obj);
 
void xroad_order_reset_client_code(xroad_order_t* obj);
 
bool xroad_order_client_code_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_sales(xroad_order_t* obj, xroad_str_t val);
 
xroad_str_t xroad_order_get_sales(const xroad_order_t* obj);
 
void xroad_order_reset_sales(xroad_order_t* obj);
 
bool xroad_order_sales_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_instr(xroad_order_t* obj, void* ref);
 
xroad_errno_t xroad_order_set_instr_ref(xroad_order_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_get_instr(const xroad_order_t* obj);
 
xroad_object_ref_t xroad_order_get_instr_ref(const xroad_order_t* obj);
 
void xroad_order_reset_instr(xroad_order_t* obj);
 
bool xroad_order_instr_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_qty(xroad_order_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_order_get_qty(const xroad_order_t* obj);
 
void xroad_order_reset_qty(xroad_order_t* obj);
 
bool xroad_order_qty_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_leaves_qty(xroad_order_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_order_get_leaves_qty(const xroad_order_t* obj);
 
void xroad_order_reset_leaves_qty(xroad_order_t* obj);
 
bool xroad_order_leaves_qty_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_cum_qty(xroad_order_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_order_get_cum_qty(const xroad_order_t* obj);
 
void xroad_order_reset_cum_qty(xroad_order_t* obj);
 
bool xroad_order_cum_qty_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_type(xroad_order_t* obj, xroad_ord_type_t val);
 
xroad_ord_type_t xroad_order_get_type(const xroad_order_t* obj);
 
void xroad_order_reset_type(xroad_order_t* obj);
 
bool xroad_order_type_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_price(xroad_order_t* obj, xroad_price_t val);
 
xroad_price_t xroad_order_get_price(const xroad_order_t* obj);
 
void xroad_order_reset_price(xroad_order_t* obj);
 
bool xroad_order_price_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_exp_date(xroad_order_t* obj, xroad_date_t val);
 
xroad_date_t xroad_order_get_exp_date(const xroad_order_t* obj);
 
void xroad_order_reset_exp_date(xroad_order_t* obj);
 
bool xroad_order_exp_date_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_flags(xroad_order_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_order_get_flags(const xroad_order_t* obj);
 
void xroad_order_reset_flags(xroad_order_t* obj);
 
bool xroad_order_flags_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_snd_time(xroad_order_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_order_get_snd_time(const xroad_order_t* obj);
 
void xroad_order_reset_snd_time(xroad_order_t* obj);
 
bool xroad_order_snd_time_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_parent(xroad_order_t* obj, void* ref);
 
xroad_errno_t xroad_order_set_parent_ref(xroad_order_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_get_parent(const xroad_order_t* obj);
 
xroad_object_ref_t xroad_order_get_parent_ref(const xroad_order_t* obj);
 
void xroad_order_reset_parent(xroad_order_t* obj);
 
bool xroad_order_parent_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_child(xroad_order_t* obj, void* ref);
 
xroad_errno_t xroad_order_set_child_ref(xroad_order_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_get_child(const xroad_order_t* obj);
 
xroad_object_ref_t xroad_order_get_child_ref(const xroad_order_t* obj);
 
void xroad_order_reset_child(xroad_order_t* obj);
 
bool xroad_order_child_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_algo(xroad_order_t* obj, void* ref);
 
xroad_errno_t xroad_order_set_algo_ref(xroad_order_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_get_algo(const xroad_order_t* obj);
 
xroad_object_ref_t xroad_order_get_algo_ref(const xroad_order_t* obj);
 
void xroad_order_reset_algo(xroad_order_t* obj);
 
bool xroad_order_algo_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_hedge_cur(xroad_order_t* obj, void* ref);
 
xroad_errno_t xroad_order_set_hedge_cur_ref(xroad_order_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_get_hedge_cur(const xroad_order_t* obj);
 
xroad_object_ref_t xroad_order_get_hedge_cur_ref(const xroad_order_t* obj);
 
void xroad_order_reset_hedge_cur(xroad_order_t* obj);
 
bool xroad_order_hedge_cur_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_cur(xroad_order_t* obj, void* ref);
 
xroad_errno_t xroad_order_set_cur_ref(xroad_order_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_get_cur(const xroad_order_t* obj);
 
xroad_object_ref_t xroad_order_get_cur_ref(const xroad_order_t* obj);
 
void xroad_order_reset_cur(xroad_order_t* obj);
 
bool xroad_order_cur_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_hedge_rate(xroad_order_t* obj, xroad_price_t val);
 
xroad_price_t xroad_order_get_hedge_rate(const xroad_order_t* obj);
 
void xroad_order_reset_hedge_rate(xroad_order_t* obj);
 
bool xroad_order_hedge_rate_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_comment(xroad_order_t* obj, xroad_str_t val);
 
xroad_str_t xroad_order_get_comment(const xroad_order_t* obj);
 
void xroad_order_reset_comment(xroad_order_t* obj);
 
bool xroad_order_comment_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_set_broker(xroad_order_t* obj, void* ref);
 
xroad_errno_t xroad_order_set_broker_ref(xroad_order_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_get_broker(const xroad_order_t* obj);
 
xroad_object_ref_t xroad_order_get_broker_ref(const xroad_order_t* obj);
 
void xroad_order_reset_broker(xroad_order_t* obj);
 
bool xroad_order_broker_is_set(const xroad_order_t* obj);
 
xroad_errno_t xroad_order_send(xroad_order_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_order_route(xroad_order_t* obj, ...);
 
void xroad_order_reset(xroad_order_t* obj);
 
xroad_order_t* xroad_order_clone(const xroad_order_t* obj);
 
bool xroad_order_is_valid(const xroad_order_t* obj);
 
int32_t xroad_order_print(const xroad_order_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_order_calc_hash(const xroad_order_t* obj);
 
xroad_str_t xroad_order_calc_uniq_id(const xroad_order_t* obj);
 
 
 
/* xroad_pos_t */
 
xroad_object_id_t xroad_pos_get_id(const xroad_pos_t* obj);
 
xroad_object_ref_t xroad_pos_get_ref(const xroad_pos_t* obj);
 
xroad_errno_t xroad_pos_set_deleted(xroad_pos_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_pos_get_deleted(const xroad_pos_t* obj);
 
void xroad_pos_reset_deleted(xroad_pos_t* obj);
 
bool xroad_pos_deleted_is_set(const xroad_pos_t* obj);
 
xroad_errno_t xroad_pos_set_sender(xroad_pos_t* obj, xroad_str_t val);
 
xroad_str_t xroad_pos_get_sender(const xroad_pos_t* obj);
 
void xroad_pos_reset_sender(xroad_pos_t* obj);
 
bool xroad_pos_sender_is_set(const xroad_pos_t* obj);
 
xroad_errno_t xroad_pos_set_instr(xroad_pos_t* obj, void* ref);
 
xroad_errno_t xroad_pos_set_instr_ref(xroad_pos_t* obj, xroad_object_ref_t ref);
 
void* xroad_pos_get_instr(const xroad_pos_t* obj);
 
xroad_object_ref_t xroad_pos_get_instr_ref(const xroad_pos_t* obj);
 
void xroad_pos_reset_instr(xroad_pos_t* obj);
 
bool xroad_pos_instr_is_set(const xroad_pos_t* obj);
 
xroad_errno_t xroad_pos_set_realized_pnl(xroad_pos_t* obj, xroad_price_t val);
 
xroad_price_t xroad_pos_get_realized_pnl(const xroad_pos_t* obj);
 
void xroad_pos_reset_realized_pnl(xroad_pos_t* obj);
 
bool xroad_pos_realized_pnl_is_set(const xroad_pos_t* obj);
 
xroad_errno_t xroad_pos_set_change_pnl(xroad_pos_t* obj, xroad_price_t val);
 
xroad_price_t xroad_pos_get_change_pnl(const xroad_pos_t* obj);
 
void xroad_pos_reset_change_pnl(xroad_pos_t* obj);
 
bool xroad_pos_change_pnl_is_set(const xroad_pos_t* obj);
 
xroad_errno_t xroad_pos_set_unrealized_pnl(xroad_pos_t* obj, xroad_price_t val);
 
xroad_price_t xroad_pos_get_unrealized_pnl(const xroad_pos_t* obj);
 
void xroad_pos_reset_unrealized_pnl(xroad_pos_t* obj);
 
bool xroad_pos_unrealized_pnl_is_set(const xroad_pos_t* obj);
 
xroad_errno_t xroad_pos_set_total_buy(xroad_pos_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_pos_get_total_buy(const xroad_pos_t* obj);
 
void xroad_pos_reset_total_buy(xroad_pos_t* obj);
 
bool xroad_pos_total_buy_is_set(const xroad_pos_t* obj);
 
xroad_errno_t xroad_pos_set_total_sell(xroad_pos_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_pos_get_total_sell(const xroad_pos_t* obj);
 
void xroad_pos_reset_total_sell(xroad_pos_t* obj);
 
bool xroad_pos_total_sell_is_set(const xroad_pos_t* obj);
 
xroad_errno_t xroad_pos_set_avg_price(xroad_pos_t* obj, xroad_price_t val);
 
xroad_price_t xroad_pos_get_avg_price(const xroad_pos_t* obj);
 
void xroad_pos_reset_avg_price(xroad_pos_t* obj);
 
bool xroad_pos_avg_price_is_set(const xroad_pos_t* obj);
 
xroad_errno_t xroad_pos_set_last_trd(xroad_pos_t* obj, void* ref);
 
xroad_errno_t xroad_pos_set_last_trd_ref(xroad_pos_t* obj, xroad_object_ref_t ref);
 
void* xroad_pos_get_last_trd(const xroad_pos_t* obj);
 
xroad_object_ref_t xroad_pos_get_last_trd_ref(const xroad_pos_t* obj);
 
void xroad_pos_reset_last_trd(xroad_pos_t* obj);
 
bool xroad_pos_last_trd_is_set(const xroad_pos_t* obj);
 
xroad_errno_t xroad_pos_send(xroad_pos_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_pos_route(xroad_pos_t* obj, ...);
 
void xroad_pos_reset(xroad_pos_t* obj);
 
xroad_pos_t* xroad_pos_clone(const xroad_pos_t* obj);
 
bool xroad_pos_is_valid(const xroad_pos_t* obj);
 
int32_t xroad_pos_print(const xroad_pos_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_pos_calc_hash(const xroad_pos_t* obj);
 
xroad_str_t xroad_pos_calc_uniq_id(const xroad_pos_t* obj);
 
 
 
/* xroad_order_stat_t */
 
xroad_object_id_t xroad_order_stat_get_id(const xroad_order_stat_t* obj);
 
xroad_object_ref_t xroad_order_stat_get_ref(const xroad_order_stat_t* obj);
 
xroad_errno_t xroad_order_stat_set_sender(xroad_order_stat_t* obj, xroad_str_t val);
 
xroad_str_t xroad_order_stat_get_sender(const xroad_order_stat_t* obj);
 
void xroad_order_stat_reset_sender(xroad_order_stat_t* obj);
 
bool xroad_order_stat_sender_is_set(const xroad_order_stat_t* obj);
 
xroad_errno_t xroad_order_stat_set_order_cnt(xroad_order_stat_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_order_stat_get_order_cnt(const xroad_order_stat_t* obj);
 
void xroad_order_stat_reset_order_cnt(xroad_order_stat_t* obj);
 
bool xroad_order_stat_order_cnt_is_set(const xroad_order_stat_t* obj);
 
xroad_errno_t xroad_order_stat_set_active_order_cnt(xroad_order_stat_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_order_stat_get_active_order_cnt(const xroad_order_stat_t* obj);
 
void xroad_order_stat_reset_active_order_cnt(xroad_order_stat_t* obj);
 
bool xroad_order_stat_active_order_cnt_is_set(const xroad_order_stat_t* obj);
 
xroad_errno_t xroad_order_stat_set_lat_min(xroad_order_stat_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_order_stat_get_lat_min(const xroad_order_stat_t* obj);
 
void xroad_order_stat_reset_lat_min(xroad_order_stat_t* obj);
 
bool xroad_order_stat_lat_min_is_set(const xroad_order_stat_t* obj);
 
xroad_errno_t xroad_order_stat_set_lat_max(xroad_order_stat_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_order_stat_get_lat_max(const xroad_order_stat_t* obj);
 
void xroad_order_stat_reset_lat_max(xroad_order_stat_t* obj);
 
bool xroad_order_stat_lat_max_is_set(const xroad_order_stat_t* obj);
 
xroad_errno_t xroad_order_stat_set_lat_50(xroad_order_stat_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_order_stat_get_lat_50(const xroad_order_stat_t* obj);
 
void xroad_order_stat_reset_lat_50(xroad_order_stat_t* obj);
 
bool xroad_order_stat_lat_50_is_set(const xroad_order_stat_t* obj);
 
xroad_errno_t xroad_order_stat_set_lat_75(xroad_order_stat_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_order_stat_get_lat_75(const xroad_order_stat_t* obj);
 
void xroad_order_stat_reset_lat_75(xroad_order_stat_t* obj);
 
bool xroad_order_stat_lat_75_is_set(const xroad_order_stat_t* obj);
 
xroad_errno_t xroad_order_stat_set_lat_99(xroad_order_stat_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_order_stat_get_lat_99(const xroad_order_stat_t* obj);
 
void xroad_order_stat_reset_lat_99(xroad_order_stat_t* obj);
 
bool xroad_order_stat_lat_99_is_set(const xroad_order_stat_t* obj);
 
xroad_errno_t xroad_order_stat_set_lat_9999(xroad_order_stat_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_order_stat_get_lat_9999(const xroad_order_stat_t* obj);
 
void xroad_order_stat_reset_lat_9999(xroad_order_stat_t* obj);
 
bool xroad_order_stat_lat_9999_is_set(const xroad_order_stat_t* obj);
 
xroad_errno_t xroad_order_stat_set_rtp_min(xroad_order_stat_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_order_stat_get_rtp_min(const xroad_order_stat_t* obj);
 
void xroad_order_stat_reset_rtp_min(xroad_order_stat_t* obj);
 
bool xroad_order_stat_rtp_min_is_set(const xroad_order_stat_t* obj);
 
xroad_errno_t xroad_order_stat_set_rtp_max(xroad_order_stat_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_order_stat_get_rtp_max(const xroad_order_stat_t* obj);
 
void xroad_order_stat_reset_rtp_max(xroad_order_stat_t* obj);
 
bool xroad_order_stat_rtp_max_is_set(const xroad_order_stat_t* obj);
 
xroad_errno_t xroad_order_stat_set_rtp_50(xroad_order_stat_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_order_stat_get_rtp_50(const xroad_order_stat_t* obj);
 
void xroad_order_stat_reset_rtp_50(xroad_order_stat_t* obj);
 
bool xroad_order_stat_rtp_50_is_set(const xroad_order_stat_t* obj);
 
xroad_errno_t xroad_order_stat_set_rtp_75(xroad_order_stat_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_order_stat_get_rtp_75(const xroad_order_stat_t* obj);
 
void xroad_order_stat_reset_rtp_75(xroad_order_stat_t* obj);
 
bool xroad_order_stat_rtp_75_is_set(const xroad_order_stat_t* obj);
 
xroad_errno_t xroad_order_stat_set_rtp_99(xroad_order_stat_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_order_stat_get_rtp_99(const xroad_order_stat_t* obj);
 
void xroad_order_stat_reset_rtp_99(xroad_order_stat_t* obj);
 
bool xroad_order_stat_rtp_99_is_set(const xroad_order_stat_t* obj);
 
xroad_errno_t xroad_order_stat_set_rtp_9999(xroad_order_stat_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_order_stat_get_rtp_9999(const xroad_order_stat_t* obj);
 
void xroad_order_stat_reset_rtp_9999(xroad_order_stat_t* obj);
 
bool xroad_order_stat_rtp_9999_is_set(const xroad_order_stat_t* obj);
 
xroad_errno_t xroad_order_stat_send(xroad_order_stat_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_order_stat_route(xroad_order_stat_t* obj, ...);
 
void xroad_order_stat_reset(xroad_order_stat_t* obj);
 
xroad_order_stat_t* xroad_order_stat_clone(const xroad_order_stat_t* obj);
 
bool xroad_order_stat_is_valid(const xroad_order_stat_t* obj);
 
int32_t xroad_order_stat_print(const xroad_order_stat_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_order_stat_calc_hash(const xroad_order_stat_t* obj);
 
xroad_str_t xroad_order_stat_calc_uniq_id(const xroad_order_stat_t* obj);
 
 
 
/* xroad_iceberg_t */
 
xroad_object_id_t xroad_iceberg_get_id(const xroad_iceberg_t* obj);
 
xroad_object_ref_t xroad_iceberg_get_ref(const xroad_iceberg_t* obj);
 
xroad_errno_t xroad_iceberg_set_display_qty(xroad_iceberg_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_iceberg_get_display_qty(const xroad_iceberg_t* obj);
 
void xroad_iceberg_reset_display_qty(xroad_iceberg_t* obj);
 
bool xroad_iceberg_display_qty_is_set(const xroad_iceberg_t* obj);
 
xroad_errno_t xroad_iceberg_send(xroad_iceberg_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_iceberg_route(xroad_iceberg_t* obj, ...);
 
void xroad_iceberg_reset(xroad_iceberg_t* obj);
 
xroad_iceberg_t* xroad_iceberg_clone(const xroad_iceberg_t* obj);
 
bool xroad_iceberg_is_valid(const xroad_iceberg_t* obj);
 
int32_t xroad_iceberg_print(const xroad_iceberg_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_iceberg_calc_hash(const xroad_iceberg_t* obj);
 
xroad_str_t xroad_iceberg_calc_uniq_id(const xroad_iceberg_t* obj);
 
 
 
/* xroad_twap_t */
 
xroad_object_id_t xroad_twap_get_id(const xroad_twap_t* obj);
 
xroad_object_ref_t xroad_twap_get_ref(const xroad_twap_t* obj);
 
xroad_errno_t xroad_twap_set_start(xroad_twap_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_twap_get_start(const xroad_twap_t* obj);
 
void xroad_twap_reset_start(xroad_twap_t* obj);
 
bool xroad_twap_start_is_set(const xroad_twap_t* obj);
 
xroad_errno_t xroad_twap_set_stop(xroad_twap_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_twap_get_stop(const xroad_twap_t* obj);
 
void xroad_twap_reset_stop(xroad_twap_t* obj);
 
bool xroad_twap_stop_is_set(const xroad_twap_t* obj);
 
xroad_errno_t xroad_twap_set_agression_level(xroad_twap_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_twap_get_agression_level(const xroad_twap_t* obj);
 
void xroad_twap_reset_agression_level(xroad_twap_t* obj);
 
bool xroad_twap_agression_level_is_set(const xroad_twap_t* obj);
 
xroad_errno_t xroad_twap_set_mid_time(xroad_twap_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_twap_get_mid_time(const xroad_twap_t* obj);
 
void xroad_twap_reset_mid_time(xroad_twap_t* obj);
 
bool xroad_twap_mid_time_is_set(const xroad_twap_t* obj);
 
xroad_errno_t xroad_twap_set_agression_time(xroad_twap_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_twap_get_agression_time(const xroad_twap_t* obj);
 
void xroad_twap_reset_agression_time(xroad_twap_t* obj);
 
bool xroad_twap_agression_time_is_set(const xroad_twap_t* obj);
 
xroad_errno_t xroad_twap_set_book_depth(xroad_twap_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_twap_get_book_depth(const xroad_twap_t* obj);
 
void xroad_twap_reset_book_depth(xroad_twap_t* obj);
 
bool xroad_twap_book_depth_is_set(const xroad_twap_t* obj);
 
xroad_errno_t xroad_twap_set_min_qty(xroad_twap_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_twap_get_min_qty(const xroad_twap_t* obj);
 
void xroad_twap_reset_min_qty(xroad_twap_t* obj);
 
bool xroad_twap_min_qty_is_set(const xroad_twap_t* obj);
 
xroad_errno_t xroad_twap_send(xroad_twap_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_twap_route(xroad_twap_t* obj, ...);
 
void xroad_twap_reset(xroad_twap_t* obj);
 
xroad_twap_t* xroad_twap_clone(const xroad_twap_t* obj);
 
bool xroad_twap_is_valid(const xroad_twap_t* obj);
 
int32_t xroad_twap_print(const xroad_twap_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_twap_calc_hash(const xroad_twap_t* obj);
 
xroad_str_t xroad_twap_calc_uniq_id(const xroad_twap_t* obj);
 
 
 
/* xroad_pov_t */
 
xroad_object_id_t xroad_pov_get_id(const xroad_pov_t* obj);
 
xroad_object_ref_t xroad_pov_get_ref(const xroad_pov_t* obj);
 
xroad_errno_t xroad_pov_set_start(xroad_pov_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_pov_get_start(const xroad_pov_t* obj);
 
void xroad_pov_reset_start(xroad_pov_t* obj);
 
bool xroad_pov_start_is_set(const xroad_pov_t* obj);
 
xroad_errno_t xroad_pov_set_stop(xroad_pov_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_pov_get_stop(const xroad_pov_t* obj);
 
void xroad_pov_reset_stop(xroad_pov_t* obj);
 
bool xroad_pov_stop_is_set(const xroad_pov_t* obj);
 
xroad_errno_t xroad_pov_set_agression_level(xroad_pov_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_pov_get_agression_level(const xroad_pov_t* obj);
 
void xroad_pov_reset_agression_level(xroad_pov_t* obj);
 
bool xroad_pov_agression_level_is_set(const xroad_pov_t* obj);
 
xroad_errno_t xroad_pov_set_mid_time(xroad_pov_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_pov_get_mid_time(const xroad_pov_t* obj);
 
void xroad_pov_reset_mid_time(xroad_pov_t* obj);
 
bool xroad_pov_mid_time_is_set(const xroad_pov_t* obj);
 
xroad_errno_t xroad_pov_set_agression_time(xroad_pov_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_pov_get_agression_time(const xroad_pov_t* obj);
 
void xroad_pov_reset_agression_time(xroad_pov_t* obj);
 
bool xroad_pov_agression_time_is_set(const xroad_pov_t* obj);
 
xroad_errno_t xroad_pov_set_book_depth(xroad_pov_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_pov_get_book_depth(const xroad_pov_t* obj);
 
void xroad_pov_reset_book_depth(xroad_pov_t* obj);
 
bool xroad_pov_book_depth_is_set(const xroad_pov_t* obj);
 
xroad_errno_t xroad_pov_set_min_qty(xroad_pov_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_pov_get_min_qty(const xroad_pov_t* obj);
 
void xroad_pov_reset_min_qty(xroad_pov_t* obj);
 
bool xroad_pov_min_qty_is_set(const xroad_pov_t* obj);
 
xroad_errno_t xroad_pov_set_period(xroad_pov_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_pov_get_period(const xroad_pov_t* obj);
 
void xroad_pov_reset_period(xroad_pov_t* obj);
 
bool xroad_pov_period_is_set(const xroad_pov_t* obj);
 
xroad_errno_t xroad_pov_set_rate(xroad_pov_t* obj, xroad_double_t val);
 
xroad_double_t xroad_pov_get_rate(const xroad_pov_t* obj);
 
void xroad_pov_reset_rate(xroad_pov_t* obj);
 
bool xroad_pov_rate_is_set(const xroad_pov_t* obj);
 
xroad_errno_t xroad_pov_set_display_qty(xroad_pov_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_pov_get_display_qty(const xroad_pov_t* obj);
 
void xroad_pov_reset_display_qty(xroad_pov_t* obj);
 
bool xroad_pov_display_qty_is_set(const xroad_pov_t* obj);
 
xroad_errno_t xroad_pov_send(xroad_pov_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_pov_route(xroad_pov_t* obj, ...);
 
void xroad_pov_reset(xroad_pov_t* obj);
 
xroad_pov_t* xroad_pov_clone(const xroad_pov_t* obj);
 
bool xroad_pov_is_valid(const xroad_pov_t* obj);
 
int32_t xroad_pov_print(const xroad_pov_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_pov_calc_hash(const xroad_pov_t* obj);
 
xroad_str_t xroad_pov_calc_uniq_id(const xroad_pov_t* obj);
 
 
 
/* xroad_vwap_t */
 
xroad_object_id_t xroad_vwap_get_id(const xroad_vwap_t* obj);
 
xroad_object_ref_t xroad_vwap_get_ref(const xroad_vwap_t* obj);
 
xroad_errno_t xroad_vwap_set_start(xroad_vwap_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_vwap_get_start(const xroad_vwap_t* obj);
 
void xroad_vwap_reset_start(xroad_vwap_t* obj);
 
bool xroad_vwap_start_is_set(const xroad_vwap_t* obj);
 
xroad_errno_t xroad_vwap_set_stop(xroad_vwap_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_vwap_get_stop(const xroad_vwap_t* obj);
 
void xroad_vwap_reset_stop(xroad_vwap_t* obj);
 
bool xroad_vwap_stop_is_set(const xroad_vwap_t* obj);
 
xroad_errno_t xroad_vwap_set_agression_level(xroad_vwap_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_vwap_get_agression_level(const xroad_vwap_t* obj);
 
void xroad_vwap_reset_agression_level(xroad_vwap_t* obj);
 
bool xroad_vwap_agression_level_is_set(const xroad_vwap_t* obj);
 
xroad_errno_t xroad_vwap_set_mid_time(xroad_vwap_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_vwap_get_mid_time(const xroad_vwap_t* obj);
 
void xroad_vwap_reset_mid_time(xroad_vwap_t* obj);
 
bool xroad_vwap_mid_time_is_set(const xroad_vwap_t* obj);
 
xroad_errno_t xroad_vwap_set_agression_time(xroad_vwap_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_vwap_get_agression_time(const xroad_vwap_t* obj);
 
void xroad_vwap_reset_agression_time(xroad_vwap_t* obj);
 
bool xroad_vwap_agression_time_is_set(const xroad_vwap_t* obj);
 
xroad_errno_t xroad_vwap_set_book_depth(xroad_vwap_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_vwap_get_book_depth(const xroad_vwap_t* obj);
 
void xroad_vwap_reset_book_depth(xroad_vwap_t* obj);
 
bool xroad_vwap_book_depth_is_set(const xroad_vwap_t* obj);
 
xroad_errno_t xroad_vwap_set_min_qty(xroad_vwap_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_vwap_get_min_qty(const xroad_vwap_t* obj);
 
void xroad_vwap_reset_min_qty(xroad_vwap_t* obj);
 
bool xroad_vwap_min_qty_is_set(const xroad_vwap_t* obj);
 
xroad_errno_t xroad_vwap_set_price_move(xroad_vwap_t* obj, xroad_double_t val);
 
xroad_double_t xroad_vwap_get_price_move(const xroad_vwap_t* obj);
 
void xroad_vwap_reset_price_move(xroad_vwap_t* obj);
 
bool xroad_vwap_price_move_is_set(const xroad_vwap_t* obj);
 
xroad_errno_t xroad_vwap_send(xroad_vwap_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_vwap_route(xroad_vwap_t* obj, ...);
 
void xroad_vwap_reset(xroad_vwap_t* obj);
 
xroad_vwap_t* xroad_vwap_clone(const xroad_vwap_t* obj);
 
bool xroad_vwap_is_valid(const xroad_vwap_t* obj);
 
int32_t xroad_vwap_print(const xroad_vwap_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_vwap_calc_hash(const xroad_vwap_t* obj);
 
xroad_str_t xroad_vwap_calc_uniq_id(const xroad_vwap_t* obj);
 
 
 
/* xroad_instr_t */
 
xroad_object_id_t xroad_instr_get_id(const xroad_instr_t* obj);
 
xroad_object_ref_t xroad_instr_get_ref(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_deleted(xroad_instr_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_instr_get_deleted(const xroad_instr_t* obj);
 
void xroad_instr_reset_deleted(xroad_instr_t* obj);
 
bool xroad_instr_deleted_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_alias(xroad_instr_t* obj, xroad_str_t val);
 
xroad_str_t xroad_instr_get_alias(const xroad_instr_t* obj);
 
void xroad_instr_reset_alias(xroad_instr_t* obj);
 
bool xroad_instr_alias_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_name(xroad_instr_t* obj, xroad_str_t val);
 
xroad_str_t xroad_instr_get_name(const xroad_instr_t* obj);
 
void xroad_instr_reset_name(xroad_instr_t* obj);
 
bool xroad_instr_name_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_display_name(xroad_instr_t* obj, xroad_str_t val);
 
xroad_str_t xroad_instr_get_display_name(const xroad_instr_t* obj);
 
void xroad_instr_reset_display_name(xroad_instr_t* obj);
 
bool xroad_instr_display_name_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_cgate_name(xroad_instr_t* obj, xroad_str_t val);
 
xroad_str_t xroad_instr_get_cgate_name(const xroad_instr_t* obj);
 
void xroad_instr_reset_cgate_name(xroad_instr_t* obj);
 
bool xroad_instr_cgate_name_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_cqg_name(xroad_instr_t* obj, xroad_str_t val);
 
xroad_str_t xroad_instr_get_cqg_name(const xroad_instr_t* obj);
 
void xroad_instr_reset_cqg_name(xroad_instr_t* obj);
 
bool xroad_instr_cqg_name_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_exch_id(xroad_instr_t* obj, xroad_int64_t val);
 
xroad_int64_t xroad_instr_get_exch_id(const xroad_instr_t* obj);
 
void xroad_instr_reset_exch_id(xroad_instr_t* obj);
 
bool xroad_instr_exch_id_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_board(xroad_instr_t* obj, xroad_str_t val);
 
xroad_str_t xroad_instr_get_board(const xroad_instr_t* obj);
 
void xroad_instr_reset_board(xroad_instr_t* obj);
 
bool xroad_instr_board_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_exch(xroad_instr_t* obj, void* ref);
 
xroad_errno_t xroad_instr_set_exch_ref(xroad_instr_t* obj, xroad_object_ref_t ref);
 
void* xroad_instr_get_exch(const xroad_instr_t* obj);
 
xroad_object_ref_t xroad_instr_get_exch_ref(const xroad_instr_t* obj);
 
void xroad_instr_reset_exch(xroad_instr_t* obj);
 
bool xroad_instr_exch_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_cfi(xroad_instr_t* obj, xroad_str_t val);
 
xroad_str_t xroad_instr_get_cfi(const xroad_instr_t* obj);
 
void xroad_instr_reset_cfi(xroad_instr_t* obj);
 
bool xroad_instr_cfi_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_cur(xroad_instr_t* obj, void* ref);
 
xroad_errno_t xroad_instr_set_cur_ref(xroad_instr_t* obj, xroad_object_ref_t ref);
 
void* xroad_instr_get_cur(const xroad_instr_t* obj);
 
xroad_object_ref_t xroad_instr_get_cur_ref(const xroad_instr_t* obj);
 
void xroad_instr_reset_cur(xroad_instr_t* obj);
 
bool xroad_instr_cur_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_settl_cur(xroad_instr_t* obj, void* ref);
 
xroad_errno_t xroad_instr_set_settl_cur_ref(xroad_instr_t* obj, xroad_object_ref_t ref);
 
void* xroad_instr_get_settl_cur(const xroad_instr_t* obj);
 
xroad_object_ref_t xroad_instr_get_settl_cur_ref(const xroad_instr_t* obj);
 
void xroad_instr_reset_settl_cur(xroad_instr_t* obj);
 
bool xroad_instr_settl_cur_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_asset(xroad_instr_t* obj, xroad_str_t val);
 
xroad_str_t xroad_instr_get_asset(const xroad_instr_t* obj);
 
void xroad_instr_reset_asset(xroad_instr_t* obj);
 
bool xroad_instr_asset_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_lot_size(xroad_instr_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_instr_get_lot_size(const xroad_instr_t* obj);
 
void xroad_instr_reset_lot_size(xroad_instr_t* obj);
 
bool xroad_instr_lot_size_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_min_qty(xroad_instr_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_instr_get_min_qty(const xroad_instr_t* obj);
 
void xroad_instr_reset_min_qty(xroad_instr_t* obj);
 
bool xroad_instr_min_qty_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_min_vol(xroad_instr_t* obj, xroad_double_t val);
 
xroad_double_t xroad_instr_get_min_vol(const xroad_instr_t* obj);
 
void xroad_instr_reset_min_vol(xroad_instr_t* obj);
 
bool xroad_instr_min_vol_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_change_ts(xroad_instr_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_instr_get_change_ts(const xroad_instr_t* obj);
 
void xroad_instr_reset_change_ts(xroad_instr_t* obj);
 
bool xroad_instr_change_ts_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_strike(xroad_instr_t* obj, xroad_price_t val);
 
xroad_price_t xroad_instr_get_strike(const xroad_instr_t* obj);
 
void xroad_instr_reset_strike(xroad_instr_t* obj);
 
bool xroad_instr_strike_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_initial_fv(xroad_instr_t* obj, xroad_price_t val);
 
xroad_price_t xroad_instr_get_initial_fv(const xroad_instr_t* obj);
 
void xroad_instr_reset_initial_fv(xroad_instr_t* obj);
 
bool xroad_instr_initial_fv_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_face_value(xroad_instr_t* obj, xroad_price_t val);
 
xroad_price_t xroad_instr_get_face_value(const xroad_instr_t* obj);
 
void xroad_instr_reset_face_value(xroad_instr_t* obj);
 
bool xroad_instr_face_value_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_accrued_int(xroad_instr_t* obj, xroad_double_t val);
 
xroad_double_t xroad_instr_get_accrued_int(const xroad_instr_t* obj);
 
void xroad_instr_reset_accrued_int(xroad_instr_t* obj);
 
bool xroad_instr_accrued_int_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_coupon(xroad_instr_t* obj, xroad_double_t val);
 
xroad_double_t xroad_instr_get_coupon(const xroad_instr_t* obj);
 
void xroad_instr_reset_coupon(xroad_instr_t* obj);
 
bool xroad_instr_coupon_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_exp_dtime(xroad_instr_t* obj, xroad_datetime_t val);
 
xroad_datetime_t xroad_instr_get_exp_dtime(const xroad_instr_t* obj);
 
void xroad_instr_reset_exp_dtime(xroad_instr_t* obj);
 
bool xroad_instr_exp_dtime_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_issue_date(xroad_instr_t* obj, xroad_date_t val);
 
xroad_date_t xroad_instr_get_issue_date(const xroad_instr_t* obj);
 
void xroad_instr_reset_issue_date(xroad_instr_t* obj);
 
bool xroad_instr_issue_date_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_maturity(xroad_instr_t* obj, xroad_date_t val);
 
xroad_date_t xroad_instr_get_maturity(const xroad_instr_t* obj);
 
void xroad_instr_reset_maturity(xroad_instr_t* obj);
 
bool xroad_instr_maturity_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_callput(xroad_instr_t* obj, xroad_callput_t val);
 
xroad_callput_t xroad_instr_get_callput(const xroad_instr_t* obj);
 
void xroad_instr_reset_callput(xroad_instr_t* obj);
 
bool xroad_instr_callput_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_isin(xroad_instr_t* obj, xroad_str_t val);
 
xroad_str_t xroad_instr_get_isin(const xroad_instr_t* obj);
 
void xroad_instr_reset_isin(xroad_instr_t* obj);
 
bool xroad_instr_isin_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_bb_source(xroad_instr_t* obj, xroad_str_t val);
 
xroad_str_t xroad_instr_get_bb_source(const xroad_instr_t* obj);
 
void xroad_instr_reset_bb_source(xroad_instr_t* obj);
 
bool xroad_instr_bb_source_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_bb_code(xroad_instr_t* obj, xroad_str_t val);
 
xroad_str_t xroad_instr_get_bb_code(const xroad_instr_t* obj);
 
void xroad_instr_reset_bb_code(xroad_instr_t* obj);
 
bool xroad_instr_bb_code_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_qty_denom(xroad_instr_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_instr_get_qty_denom(const xroad_instr_t* obj);
 
void xroad_instr_reset_qty_denom(xroad_instr_t* obj);
 
bool xroad_instr_qty_denom_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_trading_status(xroad_instr_t* obj, xroad_trading_status_t val);
 
xroad_trading_status_t xroad_instr_get_trading_status(const xroad_instr_t* obj);
 
void xroad_instr_reset_trading_status(xroad_instr_t* obj);
 
bool xroad_instr_trading_status_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_trading_status_ts(xroad_instr_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_instr_get_trading_status_ts(const xroad_instr_t* obj);
 
void xroad_instr_reset_trading_status_ts(xroad_instr_t* obj);
 
bool xroad_instr_trading_status_ts_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_underlying(xroad_instr_t* obj, void* ref);
 
xroad_errno_t xroad_instr_set_underlying_ref(xroad_instr_t* obj, xroad_object_ref_t ref);
 
void* xroad_instr_get_underlying(const xroad_instr_t* obj);
 
xroad_object_ref_t xroad_instr_get_underlying_ref(const xroad_instr_t* obj);
 
void xroad_instr_reset_underlying(xroad_instr_t* obj);
 
bool xroad_instr_underlying_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_leading(xroad_instr_t* obj, void* ref);
 
xroad_errno_t xroad_instr_set_leading_ref(xroad_instr_t* obj, xroad_object_ref_t ref);
 
void* xroad_instr_get_leading(const xroad_instr_t* obj);
 
xroad_object_ref_t xroad_instr_get_leading_ref(const xroad_instr_t* obj);
 
void xroad_instr_reset_leading(xroad_instr_t* obj);
 
bool xroad_instr_leading_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_tick_info(xroad_instr_t* obj, void* ref);
 
xroad_errno_t xroad_instr_set_tick_info_ref(xroad_instr_t* obj, xroad_object_ref_t ref);
 
void* xroad_instr_get_tick_info(const xroad_instr_t* obj);
 
xroad_object_ref_t xroad_instr_get_tick_info_ref(const xroad_instr_t* obj);
 
void xroad_instr_reset_tick_info(xroad_instr_t* obj);
 
bool xroad_instr_tick_info_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_timesheet(xroad_instr_t* obj, void* ref);
 
xroad_errno_t xroad_instr_set_timesheet_ref(xroad_instr_t* obj, xroad_object_ref_t ref);
 
void* xroad_instr_get_timesheet(const xroad_instr_t* obj);
 
xroad_object_ref_t xroad_instr_get_timesheet_ref(const xroad_instr_t* obj);
 
void xroad_instr_reset_timesheet(xroad_instr_t* obj);
 
bool xroad_instr_timesheet_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_mdstat(xroad_instr_t* obj, void* ref);
 
xroad_errno_t xroad_instr_set_mdstat_ref(xroad_instr_t* obj, xroad_object_ref_t ref);
 
void* xroad_instr_get_mdstat(const xroad_instr_t* obj);
 
xroad_object_ref_t xroad_instr_get_mdstat_ref(const xroad_instr_t* obj);
 
void xroad_instr_reset_mdstat(xroad_instr_t* obj);
 
bool xroad_instr_mdstat_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_instr_mdsource(xroad_instr_t* obj, void* ref);
 
xroad_errno_t xroad_instr_set_instr_mdsource_ref(xroad_instr_t* obj, xroad_object_ref_t ref);
 
void* xroad_instr_get_instr_mdsource(const xroad_instr_t* obj);
 
xroad_object_ref_t xroad_instr_get_instr_mdsource_ref(const xroad_instr_t* obj);
 
void xroad_instr_reset_instr_mdsource(xroad_instr_t* obj);
 
bool xroad_instr_instr_mdsource_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_mdconsumer(xroad_instr_t* obj, void* ref);
 
xroad_errno_t xroad_instr_set_mdconsumer_ref(xroad_instr_t* obj, xroad_object_ref_t ref);
 
void* xroad_instr_get_mdconsumer(const xroad_instr_t* obj);
 
xroad_object_ref_t xroad_instr_get_mdconsumer_ref(const xroad_instr_t* obj);
 
void xroad_instr_reset_mdconsumer(xroad_instr_t* obj);
 
bool xroad_instr_mdconsumer_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_instr_basket(xroad_instr_t* obj, void* ref);
 
xroad_errno_t xroad_instr_set_instr_basket_ref(xroad_instr_t* obj, xroad_object_ref_t ref);
 
void* xroad_instr_get_instr_basket(const xroad_instr_t* obj);
 
xroad_object_ref_t xroad_instr_get_instr_basket_ref(const xroad_instr_t* obj);
 
void xroad_instr_reset_instr_basket(xroad_instr_t* obj);
 
bool xroad_instr_instr_basket_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_contract_size(xroad_instr_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_instr_get_contract_size(const xroad_instr_t* obj);
 
void xroad_instr_reset_contract_size(xroad_instr_t* obj);
 
bool xroad_instr_contract_size_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_margin_short(xroad_instr_t* obj, xroad_double_t val);
 
xroad_double_t xroad_instr_get_margin_short(const xroad_instr_t* obj);
 
void xroad_instr_reset_margin_short(xroad_instr_t* obj);
 
bool xroad_instr_margin_short_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_margin_long(xroad_instr_t* obj, xroad_double_t val);
 
xroad_double_t xroad_instr_get_margin_long(const xroad_instr_t* obj);
 
void xroad_instr_reset_margin_long(xroad_instr_t* obj);
 
bool xroad_instr_margin_long_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_dividend_date(xroad_instr_t* obj, xroad_date_t val);
 
xroad_date_t xroad_instr_get_dividend_date(const xroad_instr_t* obj);
 
void xroad_instr_reset_dividend_date(xroad_instr_t* obj);
 
bool xroad_instr_dividend_date_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_dividend_value(xroad_instr_t* obj, xroad_price_t val);
 
xroad_price_t xroad_instr_get_dividend_value(const xroad_instr_t* obj);
 
void xroad_instr_reset_dividend_value(xroad_instr_t* obj);
 
bool xroad_instr_dividend_value_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_j2trade_name(xroad_instr_t* obj, xroad_str_t val);
 
xroad_str_t xroad_instr_get_j2trade_name(const xroad_instr_t* obj);
 
void xroad_instr_reset_j2trade_name(xroad_instr_t* obj);
 
bool xroad_instr_j2trade_name_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_fmp_name(xroad_instr_t* obj, xroad_str_t val);
 
xroad_str_t xroad_instr_get_fmp_name(const xroad_instr_t* obj);
 
void xroad_instr_reset_fmp_name(xroad_instr_t* obj);
 
bool xroad_instr_fmp_name_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_twelve_name(xroad_instr_t* obj, xroad_str_t val);
 
xroad_str_t xroad_instr_get_twelve_name(const xroad_instr_t* obj);
 
void xroad_instr_reset_twelve_name(xroad_instr_t* obj);
 
bool xroad_instr_twelve_name_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_flags(xroad_instr_t* obj, xroad_int8_t val);
 
xroad_int8_t xroad_instr_get_flags(const xroad_instr_t* obj);
 
void xroad_instr_reset_flags(xroad_instr_t* obj);
 
bool xroad_instr_flags_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_quote_cur(xroad_instr_t* obj, void* ref);
 
xroad_errno_t xroad_instr_set_quote_cur_ref(xroad_instr_t* obj, xroad_object_ref_t ref);
 
void* xroad_instr_get_quote_cur(const xroad_instr_t* obj);
 
xroad_object_ref_t xroad_instr_get_quote_cur_ref(const xroad_instr_t* obj);
 
void xroad_instr_reset_quote_cur(xroad_instr_t* obj);
 
bool xroad_instr_quote_cur_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_set_ib_name(xroad_instr_t* obj, xroad_str_t val);
 
xroad_str_t xroad_instr_get_ib_name(const xroad_instr_t* obj);
 
void xroad_instr_reset_ib_name(xroad_instr_t* obj);
 
bool xroad_instr_ib_name_is_set(const xroad_instr_t* obj);
 
xroad_errno_t xroad_instr_send(xroad_instr_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_instr_route(xroad_instr_t* obj, ...);
 
void xroad_instr_reset(xroad_instr_t* obj);
 
xroad_instr_t* xroad_instr_clone(const xroad_instr_t* obj);
 
bool xroad_instr_is_valid(const xroad_instr_t* obj);
 
int32_t xroad_instr_print(const xroad_instr_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_instr_calc_hash(const xroad_instr_t* obj);
 
xroad_str_t xroad_instr_calc_uniq_id(const xroad_instr_t* obj);
 
void xroad_instr_clear(xroad_instr_t* obj);
 
 
/* xroad_tick_info_t */
 
xroad_object_id_t xroad_tick_info_get_id(const xroad_tick_info_t* obj);
 
xroad_object_ref_t xroad_tick_info_get_ref(const xroad_tick_info_t* obj);
 
xroad_errno_t xroad_tick_info_set_deleted(xroad_tick_info_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_tick_info_get_deleted(const xroad_tick_info_t* obj);
 
void xroad_tick_info_reset_deleted(xroad_tick_info_t* obj);
 
bool xroad_tick_info_deleted_is_set(const xroad_tick_info_t* obj);
 
xroad_errno_t xroad_tick_info_set_price_min(xroad_tick_info_t* obj, xroad_price_t val);
 
xroad_price_t xroad_tick_info_get_price_min(const xroad_tick_info_t* obj);
 
void xroad_tick_info_reset_price_min(xroad_tick_info_t* obj);
 
bool xroad_tick_info_price_min_is_set(const xroad_tick_info_t* obj);
 
xroad_errno_t xroad_tick_info_set_price_max(xroad_tick_info_t* obj, xroad_price_t val);
 
xroad_price_t xroad_tick_info_get_price_max(const xroad_tick_info_t* obj);
 
void xroad_tick_info_reset_price_max(xroad_tick_info_t* obj);
 
bool xroad_tick_info_price_max_is_set(const xroad_tick_info_t* obj);
 
xroad_errno_t xroad_tick_info_set_size(xroad_tick_info_t* obj, xroad_double_t val);
 
xroad_double_t xroad_tick_info_get_size(const xroad_tick_info_t* obj);
 
void xroad_tick_info_reset_size(xroad_tick_info_t* obj);
 
bool xroad_tick_info_size_is_set(const xroad_tick_info_t* obj);
 
xroad_errno_t xroad_tick_info_set_value(xroad_tick_info_t* obj, xroad_double_t val);
 
xroad_double_t xroad_tick_info_get_value(const xroad_tick_info_t* obj);
 
void xroad_tick_info_reset_value(xroad_tick_info_t* obj);
 
bool xroad_tick_info_value_is_set(const xroad_tick_info_t* obj);
 
xroad_errno_t xroad_tick_info_set_precision(xroad_tick_info_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_tick_info_get_precision(const xroad_tick_info_t* obj);
 
void xroad_tick_info_reset_precision(xroad_tick_info_t* obj);
 
bool xroad_tick_info_precision_is_set(const xroad_tick_info_t* obj);
 
xroad_errno_t xroad_tick_info_set_next(xroad_tick_info_t* obj, void* ref);
 
xroad_errno_t xroad_tick_info_set_next_ref(xroad_tick_info_t* obj, xroad_object_ref_t ref);
 
void* xroad_tick_info_get_next(const xroad_tick_info_t* obj);
 
xroad_object_ref_t xroad_tick_info_get_next_ref(const xroad_tick_info_t* obj);
 
void xroad_tick_info_reset_next(xroad_tick_info_t* obj);
 
bool xroad_tick_info_next_is_set(const xroad_tick_info_t* obj);
 
xroad_errno_t xroad_tick_info_send(xroad_tick_info_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_tick_info_route(xroad_tick_info_t* obj, ...);
 
void xroad_tick_info_reset(xroad_tick_info_t* obj);
 
xroad_tick_info_t* xroad_tick_info_clone(const xroad_tick_info_t* obj);
 
bool xroad_tick_info_is_valid(const xroad_tick_info_t* obj);
 
int32_t xroad_tick_info_print(const xroad_tick_info_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_tick_info_calc_hash(const xroad_tick_info_t* obj);
 
xroad_str_t xroad_tick_info_calc_uniq_id(const xroad_tick_info_t* obj);
 
 
 
/* xroad_timesheet_t */
 
xroad_object_id_t xroad_timesheet_get_id(const xroad_timesheet_t* obj);
 
xroad_object_ref_t xroad_timesheet_get_ref(const xroad_timesheet_t* obj);
 
xroad_errno_t xroad_timesheet_set_deleted(xroad_timesheet_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_timesheet_get_deleted(const xroad_timesheet_t* obj);
 
void xroad_timesheet_reset_deleted(xroad_timesheet_t* obj);
 
bool xroad_timesheet_deleted_is_set(const xroad_timesheet_t* obj);
 
xroad_errno_t xroad_timesheet_set_start(xroad_timesheet_t* obj, xroad_int64_t val);
 
xroad_int64_t xroad_timesheet_get_start(const xroad_timesheet_t* obj);
 
void xroad_timesheet_reset_start(xroad_timesheet_t* obj);
 
bool xroad_timesheet_start_is_set(const xroad_timesheet_t* obj);
 
xroad_errno_t xroad_timesheet_set_stop(xroad_timesheet_t* obj, xroad_int64_t val);
 
xroad_int64_t xroad_timesheet_get_stop(const xroad_timesheet_t* obj);
 
void xroad_timesheet_reset_stop(xroad_timesheet_t* obj);
 
bool xroad_timesheet_stop_is_set(const xroad_timesheet_t* obj);
 
xroad_errno_t xroad_timesheet_set_type(xroad_timesheet_t* obj, xroad_trading_session_type_t val);
 
xroad_trading_session_type_t xroad_timesheet_get_type(const xroad_timesheet_t* obj);
 
void xroad_timesheet_reset_type(xroad_timesheet_t* obj);
 
bool xroad_timesheet_type_is_set(const xroad_timesheet_t* obj);
 
xroad_errno_t xroad_timesheet_set_next(xroad_timesheet_t* obj, void* ref);
 
xroad_errno_t xroad_timesheet_set_next_ref(xroad_timesheet_t* obj, xroad_object_ref_t ref);
 
void* xroad_timesheet_get_next(const xroad_timesheet_t* obj);
 
xroad_object_ref_t xroad_timesheet_get_next_ref(const xroad_timesheet_t* obj);
 
void xroad_timesheet_reset_next(xroad_timesheet_t* obj);
 
bool xroad_timesheet_next_is_set(const xroad_timesheet_t* obj);
 
xroad_errno_t xroad_timesheet_send(xroad_timesheet_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_timesheet_route(xroad_timesheet_t* obj, ...);
 
void xroad_timesheet_reset(xroad_timesheet_t* obj);
 
xroad_timesheet_t* xroad_timesheet_clone(const xroad_timesheet_t* obj);
 
bool xroad_timesheet_is_valid(const xroad_timesheet_t* obj);
 
int32_t xroad_timesheet_print(const xroad_timesheet_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_timesheet_calc_hash(const xroad_timesheet_t* obj);
 
xroad_str_t xroad_timesheet_calc_uniq_id(const xroad_timesheet_t* obj);
 
 
 
/* xroad_mdstat_t */
 
xroad_object_id_t xroad_mdstat_get_id(const xroad_mdstat_t* obj);
 
xroad_object_ref_t xroad_mdstat_get_ref(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_last_price(xroad_mdstat_t* obj, xroad_price_t val);
 
xroad_price_t xroad_mdstat_get_last_price(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_last_price(xroad_mdstat_t* obj);
 
bool xroad_mdstat_last_price_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_last_qty(xroad_mdstat_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_mdstat_get_last_qty(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_last_qty(xroad_mdstat_t* obj);
 
bool xroad_mdstat_last_qty_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_last_ts(xroad_mdstat_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_mdstat_get_last_ts(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_last_ts(xroad_mdstat_t* obj);
 
bool xroad_mdstat_last_ts_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_bid_price(xroad_mdstat_t* obj, xroad_price_t val);
 
xroad_price_t xroad_mdstat_get_bid_price(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_bid_price(xroad_mdstat_t* obj);
 
bool xroad_mdstat_bid_price_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_bid_qty(xroad_mdstat_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_mdstat_get_bid_qty(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_bid_qty(xroad_mdstat_t* obj);
 
bool xroad_mdstat_bid_qty_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_ask_price(xroad_mdstat_t* obj, xroad_price_t val);
 
xroad_price_t xroad_mdstat_get_ask_price(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_ask_price(xroad_mdstat_t* obj);
 
bool xroad_mdstat_ask_price_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_ask_qty(xroad_mdstat_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_mdstat_get_ask_qty(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_ask_qty(xroad_mdstat_t* obj);
 
bool xroad_mdstat_ask_qty_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_quote_ts(xroad_mdstat_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_mdstat_get_quote_ts(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_quote_ts(xroad_mdstat_t* obj);
 
bool xroad_mdstat_quote_ts_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_open_price(xroad_mdstat_t* obj, xroad_price_t val);
 
xroad_price_t xroad_mdstat_get_open_price(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_open_price(xroad_mdstat_t* obj);
 
bool xroad_mdstat_open_price_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_open_price_ts(xroad_mdstat_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_mdstat_get_open_price_ts(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_open_price_ts(xroad_mdstat_t* obj);
 
bool xroad_mdstat_open_price_ts_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_vwap(xroad_mdstat_t* obj, xroad_price_t val);
 
xroad_price_t xroad_mdstat_get_vwap(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_vwap(xroad_mdstat_t* obj);
 
bool xroad_mdstat_vwap_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_vwap_ts(xroad_mdstat_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_mdstat_get_vwap_ts(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_vwap_ts(xroad_mdstat_t* obj);
 
bool xroad_mdstat_vwap_ts_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_close_price(xroad_mdstat_t* obj, xroad_price_t val);
 
xroad_price_t xroad_mdstat_get_close_price(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_close_price(xroad_mdstat_t* obj);
 
bool xroad_mdstat_close_price_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_close_price_ts(xroad_mdstat_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_mdstat_get_close_price_ts(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_close_price_ts(xroad_mdstat_t* obj);
 
bool xroad_mdstat_close_price_ts_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_prev_day_bid_price(xroad_mdstat_t* obj, xroad_price_t val);
 
xroad_price_t xroad_mdstat_get_prev_day_bid_price(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_prev_day_bid_price(xroad_mdstat_t* obj);
 
bool xroad_mdstat_prev_day_bid_price_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_prev_day_ask_price(xroad_mdstat_t* obj, xroad_price_t val);
 
xroad_price_t xroad_mdstat_get_prev_day_ask_price(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_prev_day_ask_price(xroad_mdstat_t* obj);
 
bool xroad_mdstat_prev_day_ask_price_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_prev_day_quote_ts(xroad_mdstat_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_mdstat_get_prev_day_quote_ts(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_prev_day_quote_ts(xroad_mdstat_t* obj);
 
bool xroad_mdstat_prev_day_quote_ts_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_prev_day_last_price(xroad_mdstat_t* obj, xroad_price_t val);
 
xroad_price_t xroad_mdstat_get_prev_day_last_price(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_prev_day_last_price(xroad_mdstat_t* obj);
 
bool xroad_mdstat_prev_day_last_price_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_prev_day_last_price_ts(xroad_mdstat_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_mdstat_get_prev_day_last_price_ts(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_prev_day_last_price_ts(xroad_mdstat_t* obj);
 
bool xroad_mdstat_prev_day_last_price_ts_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_min_price(xroad_mdstat_t* obj, xroad_price_t val);
 
xroad_price_t xroad_mdstat_get_min_price(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_min_price(xroad_mdstat_t* obj);
 
bool xroad_mdstat_min_price_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_min_price_ts(xroad_mdstat_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_mdstat_get_min_price_ts(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_min_price_ts(xroad_mdstat_t* obj);
 
bool xroad_mdstat_min_price_ts_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_max_price(xroad_mdstat_t* obj, xroad_price_t val);
 
xroad_price_t xroad_mdstat_get_max_price(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_max_price(xroad_mdstat_t* obj);
 
bool xroad_mdstat_max_price_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_max_price_ts(xroad_mdstat_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_mdstat_get_max_price_ts(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_max_price_ts(xroad_mdstat_t* obj);
 
bool xroad_mdstat_max_price_ts_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_low_price(xroad_mdstat_t* obj, xroad_price_t val);
 
xroad_price_t xroad_mdstat_get_low_price(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_low_price(xroad_mdstat_t* obj);
 
bool xroad_mdstat_low_price_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_low_price_ts(xroad_mdstat_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_mdstat_get_low_price_ts(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_low_price_ts(xroad_mdstat_t* obj);
 
bool xroad_mdstat_low_price_ts_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_high_price(xroad_mdstat_t* obj, xroad_price_t val);
 
xroad_price_t xroad_mdstat_get_high_price(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_high_price(xroad_mdstat_t* obj);
 
bool xroad_mdstat_high_price_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_high_price_ts(xroad_mdstat_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_mdstat_get_high_price_ts(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_high_price_ts(xroad_mdstat_t* obj);
 
bool xroad_mdstat_high_price_ts_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_oa_price(xroad_mdstat_t* obj, xroad_price_t val);
 
xroad_price_t xroad_mdstat_get_oa_price(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_oa_price(xroad_mdstat_t* obj);
 
bool xroad_mdstat_oa_price_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_oa_price_ts(xroad_mdstat_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_mdstat_get_oa_price_ts(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_oa_price_ts(xroad_mdstat_t* obj);
 
bool xroad_mdstat_oa_price_ts_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_ca_price(xroad_mdstat_t* obj, xroad_price_t val);
 
xroad_price_t xroad_mdstat_get_ca_price(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_ca_price(xroad_mdstat_t* obj);
 
bool xroad_mdstat_ca_price_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_ca_price_ts(xroad_mdstat_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_mdstat_get_ca_price_ts(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_ca_price_ts(xroad_mdstat_t* obj);
 
bool xroad_mdstat_ca_price_ts_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_best_bid(xroad_mdstat_t* obj, xroad_price_t val);
 
xroad_price_t xroad_mdstat_get_best_bid(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_best_bid(xroad_mdstat_t* obj);
 
bool xroad_mdstat_best_bid_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_best_ask(xroad_mdstat_t* obj, xroad_price_t val);
 
xroad_price_t xroad_mdstat_get_best_ask(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_best_ask(xroad_mdstat_t* obj);
 
bool xroad_mdstat_best_ask_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_best_price_ts(xroad_mdstat_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_mdstat_get_best_price_ts(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_best_price_ts(xroad_mdstat_t* obj);
 
bool xroad_mdstat_best_price_ts_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_book(xroad_mdstat_t* obj, xroad_binary_t val);
 
uint32_t xroad_mdstat_get_book(const xroad_mdstat_t* obj, void* buf, uint32_t buf_size);
 
void xroad_mdstat_reset_book(xroad_mdstat_t* obj);
 
bool xroad_mdstat_book_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_book_ts(xroad_mdstat_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_mdstat_get_book_ts(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_book_ts(xroad_mdstat_t* obj);
 
bool xroad_mdstat_book_ts_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_indicator(xroad_mdstat_t* obj, xroad_binary_t val);
 
xroad_binary_t xroad_mdstat_get_indicator(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_indicator(xroad_mdstat_t* obj);
 
bool xroad_mdstat_indicator_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_mdsource(xroad_mdstat_t* obj, void* ref);
 
xroad_errno_t xroad_mdstat_set_mdsource_ref(xroad_mdstat_t* obj, xroad_object_ref_t ref);
 
void* xroad_mdstat_get_mdsource(const xroad_mdstat_t* obj);
 
xroad_object_ref_t xroad_mdstat_get_mdsource_ref(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_mdsource(xroad_mdstat_t* obj);
 
bool xroad_mdstat_mdsource_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_settle_date(xroad_mdstat_t* obj, xroad_date_t val);
 
xroad_date_t xroad_mdstat_get_settle_date(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_settle_date(xroad_mdstat_t* obj);
 
bool xroad_mdstat_settle_date_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_wa_price(xroad_mdstat_t* obj, xroad_price_t val);
 
xroad_price_t xroad_mdstat_get_wa_price(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_wa_price(xroad_mdstat_t* obj);
 
bool xroad_mdstat_wa_price_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_wa_price_ts(xroad_mdstat_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_mdstat_get_wa_price_ts(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_wa_price_ts(xroad_mdstat_t* obj);
 
bool xroad_mdstat_wa_price_ts_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_oi(xroad_mdstat_t* obj, xroad_price_t val);
 
xroad_price_t xroad_mdstat_get_oi(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_oi(xroad_mdstat_t* obj);
 
bool xroad_mdstat_oi_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_oi_ts(xroad_mdstat_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_mdstat_get_oi_ts(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_oi_ts(xroad_mdstat_t* obj);
 
bool xroad_mdstat_oi_ts_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_volume(xroad_mdstat_t* obj, xroad_price_t val);
 
xroad_price_t xroad_mdstat_get_volume(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_volume(xroad_mdstat_t* obj);
 
bool xroad_mdstat_volume_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_set_volume_ts(xroad_mdstat_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_mdstat_get_volume_ts(const xroad_mdstat_t* obj);
 
void xroad_mdstat_reset_volume_ts(xroad_mdstat_t* obj);
 
bool xroad_mdstat_volume_ts_is_set(const xroad_mdstat_t* obj);
 
xroad_errno_t xroad_mdstat_send(xroad_mdstat_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_mdstat_route(xroad_mdstat_t* obj, ...);
 
void xroad_mdstat_reset(xroad_mdstat_t* obj);
 
xroad_mdstat_t* xroad_mdstat_clone(const xroad_mdstat_t* obj);
 
bool xroad_mdstat_is_valid(const xroad_mdstat_t* obj);
 
int32_t xroad_mdstat_print(const xroad_mdstat_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_mdstat_calc_hash(const xroad_mdstat_t* obj);
 
xroad_str_t xroad_mdstat_calc_uniq_id(const xroad_mdstat_t* obj);
 
void xroad_mdstat_clear(xroad_mdstat_t* obj);
 
 
/* xroad_order_sql_t */
 
xroad_object_id_t xroad_order_sql_get_id(const xroad_order_sql_t* obj);
 
xroad_object_ref_t xroad_order_sql_get_ref(const xroad_order_sql_t* obj);
 
xroad_errno_t xroad_order_sql_set_node_id(xroad_order_sql_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_order_sql_get_node_id(const xroad_order_sql_t* obj);
 
void xroad_order_sql_reset_node_id(xroad_order_sql_t* obj);
 
bool xroad_order_sql_node_id_is_set(const xroad_order_sql_t* obj);
 
xroad_errno_t xroad_order_sql_set_db_id(xroad_order_sql_t* obj, xroad_int64_t val);
 
xroad_int64_t xroad_order_sql_get_db_id(const xroad_order_sql_t* obj);
 
void xroad_order_sql_reset_db_id(xroad_order_sql_t* obj);
 
bool xroad_order_sql_db_id_is_set(const xroad_order_sql_t* obj);
 
xroad_errno_t xroad_order_sql_set_order(xroad_order_sql_t* obj, void* ref);
 
xroad_errno_t xroad_order_sql_set_order_ref(xroad_order_sql_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_sql_get_order(const xroad_order_sql_t* obj);
 
xroad_object_ref_t xroad_order_sql_get_order_ref(const xroad_order_sql_t* obj);
 
void xroad_order_sql_reset_order(xroad_order_sql_t* obj);
 
bool xroad_order_sql_order_is_set(const xroad_order_sql_t* obj);
 
xroad_errno_t xroad_order_sql_set_qty(xroad_order_sql_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_order_sql_get_qty(const xroad_order_sql_t* obj);
 
void xroad_order_sql_reset_qty(xroad_order_sql_t* obj);
 
bool xroad_order_sql_qty_is_set(const xroad_order_sql_t* obj);
 
xroad_errno_t xroad_order_sql_set_price(xroad_order_sql_t* obj, xroad_price_t val);
 
xroad_price_t xroad_order_sql_get_price(const xroad_order_sql_t* obj);
 
void xroad_order_sql_reset_price(xroad_order_sql_t* obj);
 
bool xroad_order_sql_price_is_set(const xroad_order_sql_t* obj);
 
xroad_errno_t xroad_order_sql_send(xroad_order_sql_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_order_sql_route(xroad_order_sql_t* obj, ...);
 
void xroad_order_sql_reset(xroad_order_sql_t* obj);
 
xroad_order_sql_t* xroad_order_sql_clone(const xroad_order_sql_t* obj);
 
bool xroad_order_sql_is_valid(const xroad_order_sql_t* obj);
 
int32_t xroad_order_sql_print(const xroad_order_sql_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_order_sql_calc_hash(const xroad_order_sql_t* obj);
 
xroad_str_t xroad_order_sql_calc_uniq_id(const xroad_order_sql_t* obj);
 
 
 
/* xroad_cancel_sql_t */
 
xroad_object_id_t xroad_cancel_sql_get_id(const xroad_cancel_sql_t* obj);
 
xroad_object_ref_t xroad_cancel_sql_get_ref(const xroad_cancel_sql_t* obj);
 
xroad_errno_t xroad_cancel_sql_set_node_id(xroad_cancel_sql_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_cancel_sql_get_node_id(const xroad_cancel_sql_t* obj);
 
void xroad_cancel_sql_reset_node_id(xroad_cancel_sql_t* obj);
 
bool xroad_cancel_sql_node_id_is_set(const xroad_cancel_sql_t* obj);
 
xroad_errno_t xroad_cancel_sql_set_db_id(xroad_cancel_sql_t* obj, xroad_int64_t val);
 
xroad_int64_t xroad_cancel_sql_get_db_id(const xroad_cancel_sql_t* obj);
 
void xroad_cancel_sql_reset_db_id(xroad_cancel_sql_t* obj);
 
bool xroad_cancel_sql_db_id_is_set(const xroad_cancel_sql_t* obj);
 
xroad_errno_t xroad_cancel_sql_set_order(xroad_cancel_sql_t* obj, void* ref);
 
xroad_errno_t xroad_cancel_sql_set_order_ref(xroad_cancel_sql_t* obj, xroad_object_ref_t ref);
 
void* xroad_cancel_sql_get_order(const xroad_cancel_sql_t* obj);
 
xroad_object_ref_t xroad_cancel_sql_get_order_ref(const xroad_cancel_sql_t* obj);
 
void xroad_cancel_sql_reset_order(xroad_cancel_sql_t* obj);
 
bool xroad_cancel_sql_order_is_set(const xroad_cancel_sql_t* obj);
 
xroad_errno_t xroad_cancel_sql_send(xroad_cancel_sql_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_cancel_sql_route(xroad_cancel_sql_t* obj, ...);
 
void xroad_cancel_sql_reset(xroad_cancel_sql_t* obj);
 
xroad_cancel_sql_t* xroad_cancel_sql_clone(const xroad_cancel_sql_t* obj);
 
bool xroad_cancel_sql_is_valid(const xroad_cancel_sql_t* obj);
 
int32_t xroad_cancel_sql_print(const xroad_cancel_sql_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_cancel_sql_calc_hash(const xroad_cancel_sql_t* obj);
 
xroad_str_t xroad_cancel_sql_calc_uniq_id(const xroad_cancel_sql_t* obj);
 
 
 
/* xroad_replace_sql_t */
 
xroad_object_id_t xroad_replace_sql_get_id(const xroad_replace_sql_t* obj);
 
xroad_object_ref_t xroad_replace_sql_get_ref(const xroad_replace_sql_t* obj);
 
xroad_errno_t xroad_replace_sql_set_node_id(xroad_replace_sql_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_replace_sql_get_node_id(const xroad_replace_sql_t* obj);
 
void xroad_replace_sql_reset_node_id(xroad_replace_sql_t* obj);
 
bool xroad_replace_sql_node_id_is_set(const xroad_replace_sql_t* obj);
 
xroad_errno_t xroad_replace_sql_set_db_id(xroad_replace_sql_t* obj, xroad_int64_t val);
 
xroad_int64_t xroad_replace_sql_get_db_id(const xroad_replace_sql_t* obj);
 
void xroad_replace_sql_reset_db_id(xroad_replace_sql_t* obj);
 
bool xroad_replace_sql_db_id_is_set(const xroad_replace_sql_t* obj);
 
xroad_errno_t xroad_replace_sql_set_order(xroad_replace_sql_t* obj, void* ref);
 
xroad_errno_t xroad_replace_sql_set_order_ref(xroad_replace_sql_t* obj, xroad_object_ref_t ref);
 
void* xroad_replace_sql_get_order(const xroad_replace_sql_t* obj);
 
xroad_object_ref_t xroad_replace_sql_get_order_ref(const xroad_replace_sql_t* obj);
 
void xroad_replace_sql_reset_order(xroad_replace_sql_t* obj);
 
bool xroad_replace_sql_order_is_set(const xroad_replace_sql_t* obj);
 
xroad_errno_t xroad_replace_sql_send(xroad_replace_sql_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_replace_sql_route(xroad_replace_sql_t* obj, ...);
 
void xroad_replace_sql_reset(xroad_replace_sql_t* obj);
 
xroad_replace_sql_t* xroad_replace_sql_clone(const xroad_replace_sql_t* obj);
 
bool xroad_replace_sql_is_valid(const xroad_replace_sql_t* obj);
 
int32_t xroad_replace_sql_print(const xroad_replace_sql_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_replace_sql_calc_hash(const xroad_replace_sql_t* obj);
 
xroad_str_t xroad_replace_sql_calc_uniq_id(const xroad_replace_sql_t* obj);
 
 
 
/* xroad_order_rabbit_t */
 
xroad_object_id_t xroad_order_rabbit_get_id(const xroad_order_rabbit_t* obj);
 
xroad_object_ref_t xroad_order_rabbit_get_ref(const xroad_order_rabbit_t* obj);
 
xroad_errno_t xroad_order_rabbit_set_side(xroad_order_rabbit_t* obj, xroad_side_t val);
 
xroad_side_t xroad_order_rabbit_get_side(const xroad_order_rabbit_t* obj);
 
void xroad_order_rabbit_reset_side(xroad_order_rabbit_t* obj);
 
bool xroad_order_rabbit_side_is_set(const xroad_order_rabbit_t* obj);
 
xroad_errno_t xroad_order_rabbit_set_tif(xroad_order_rabbit_t* obj, xroad_tif_t val);
 
xroad_tif_t xroad_order_rabbit_get_tif(const xroad_order_rabbit_t* obj);
 
void xroad_order_rabbit_reset_tif(xroad_order_rabbit_t* obj);
 
bool xroad_order_rabbit_tif_is_set(const xroad_order_rabbit_t* obj);
 
xroad_errno_t xroad_order_rabbit_set_src_node_id(xroad_order_rabbit_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_order_rabbit_get_src_node_id(const xroad_order_rabbit_t* obj);
 
void xroad_order_rabbit_reset_src_node_id(xroad_order_rabbit_t* obj);
 
bool xroad_order_rabbit_src_node_id_is_set(const xroad_order_rabbit_t* obj);
 
xroad_errno_t xroad_order_rabbit_set_dst_node_id(xroad_order_rabbit_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_order_rabbit_get_dst_node_id(const xroad_order_rabbit_t* obj);
 
void xroad_order_rabbit_reset_dst_node_id(xroad_order_rabbit_t* obj);
 
bool xroad_order_rabbit_dst_node_id_is_set(const xroad_order_rabbit_t* obj);
 
xroad_errno_t xroad_order_rabbit_set_ext_ref(xroad_order_rabbit_t* obj, xroad_str_t val);
 
xroad_str_t xroad_order_rabbit_get_ext_ref(const xroad_order_rabbit_t* obj);
 
void xroad_order_rabbit_reset_ext_ref(xroad_order_rabbit_t* obj);
 
bool xroad_order_rabbit_ext_ref_is_set(const xroad_order_rabbit_t* obj);
 
xroad_errno_t xroad_order_rabbit_set_status(xroad_order_rabbit_t* obj, xroad_order_status_t val);
 
xroad_order_status_t xroad_order_rabbit_get_status(const xroad_order_rabbit_t* obj);
 
void xroad_order_rabbit_reset_status(xroad_order_rabbit_t* obj);
 
bool xroad_order_rabbit_status_is_set(const xroad_order_rabbit_t* obj);
 
xroad_errno_t xroad_order_rabbit_set_sub_status(xroad_order_rabbit_t* obj, xroad_sub_status_t val);
 
xroad_sub_status_t xroad_order_rabbit_get_sub_status(const xroad_order_rabbit_t* obj);
 
void xroad_order_rabbit_reset_sub_status(xroad_order_rabbit_t* obj);
 
bool xroad_order_rabbit_sub_status_is_set(const xroad_order_rabbit_t* obj);
 
xroad_errno_t xroad_order_rabbit_set_clord_id(xroad_order_rabbit_t* obj, xroad_int64_t val);
 
xroad_int64_t xroad_order_rabbit_get_clord_id(const xroad_order_rabbit_t* obj);
 
void xroad_order_rabbit_reset_clord_id(xroad_order_rabbit_t* obj);
 
bool xroad_order_rabbit_clord_id_is_set(const xroad_order_rabbit_t* obj);
 
xroad_errno_t xroad_order_rabbit_set_order(xroad_order_rabbit_t* obj, void* ref);
 
xroad_errno_t xroad_order_rabbit_set_order_ref(xroad_order_rabbit_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_rabbit_get_order(const xroad_order_rabbit_t* obj);
 
xroad_object_ref_t xroad_order_rabbit_get_order_ref(const xroad_order_rabbit_t* obj);
 
void xroad_order_rabbit_reset_order(xroad_order_rabbit_t* obj);
 
bool xroad_order_rabbit_order_is_set(const xroad_order_rabbit_t* obj);
 
xroad_errno_t xroad_order_rabbit_send(xroad_order_rabbit_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_order_rabbit_route(xroad_order_rabbit_t* obj, ...);
 
void xroad_order_rabbit_reset(xroad_order_rabbit_t* obj);
 
xroad_order_rabbit_t* xroad_order_rabbit_clone(const xroad_order_rabbit_t* obj);
 
bool xroad_order_rabbit_is_valid(const xroad_order_rabbit_t* obj);
 
int32_t xroad_order_rabbit_print(const xroad_order_rabbit_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_order_rabbit_calc_hash(const xroad_order_rabbit_t* obj);
 
xroad_str_t xroad_order_rabbit_calc_uniq_id(const xroad_order_rabbit_t* obj);
 
 
 
/* xroad_rake_t */
 
xroad_object_id_t xroad_rake_get_id(const xroad_rake_t* obj);
 
xroad_object_ref_t xroad_rake_get_ref(const xroad_rake_t* obj);
 
xroad_errno_t xroad_rake_set_working_int(xroad_rake_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_rake_get_working_int(const xroad_rake_t* obj);
 
void xroad_rake_reset_working_int(xroad_rake_t* obj);
 
bool xroad_rake_working_int_is_set(const xroad_rake_t* obj);
 
xroad_errno_t xroad_rake_set_book_depth(xroad_rake_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_rake_get_book_depth(const xroad_rake_t* obj);
 
void xroad_rake_reset_book_depth(xroad_rake_t* obj);
 
bool xroad_rake_book_depth_is_set(const xroad_rake_t* obj);
 
xroad_errno_t xroad_rake_set_level_dist(xroad_rake_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_rake_get_level_dist(const xroad_rake_t* obj);
 
void xroad_rake_reset_level_dist(xroad_rake_t* obj);
 
bool xroad_rake_level_dist_is_set(const xroad_rake_t* obj);
 
xroad_errno_t xroad_rake_set_agression_level(xroad_rake_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_rake_get_agression_level(const xroad_rake_t* obj);
 
void xroad_rake_reset_agression_level(xroad_rake_t* obj);
 
bool xroad_rake_agression_level_is_set(const xroad_rake_t* obj);
 
xroad_errno_t xroad_rake_set_mid_time(xroad_rake_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_rake_get_mid_time(const xroad_rake_t* obj);
 
void xroad_rake_reset_mid_time(xroad_rake_t* obj);
 
bool xroad_rake_mid_time_is_set(const xroad_rake_t* obj);
 
xroad_errno_t xroad_rake_set_agression_time(xroad_rake_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_rake_get_agression_time(const xroad_rake_t* obj);
 
void xroad_rake_reset_agression_time(xroad_rake_t* obj);
 
bool xroad_rake_agression_time_is_set(const xroad_rake_t* obj);
 
xroad_errno_t xroad_rake_set_display_qty(xroad_rake_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_rake_get_display_qty(const xroad_rake_t* obj);
 
void xroad_rake_reset_display_qty(xroad_rake_t* obj);
 
bool xroad_rake_display_qty_is_set(const xroad_rake_t* obj);
 
xroad_errno_t xroad_rake_set_sensitivity(xroad_rake_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_rake_get_sensitivity(const xroad_rake_t* obj);
 
void xroad_rake_reset_sensitivity(xroad_rake_t* obj);
 
bool xroad_rake_sensitivity_is_set(const xroad_rake_t* obj);
 
xroad_errno_t xroad_rake_set_deviation(xroad_rake_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_rake_get_deviation(const xroad_rake_t* obj);
 
void xroad_rake_reset_deviation(xroad_rake_t* obj);
 
bool xroad_rake_deviation_is_set(const xroad_rake_t* obj);
 
xroad_errno_t xroad_rake_set_threshold(xroad_rake_t* obj, xroad_double_t val);
 
xroad_double_t xroad_rake_get_threshold(const xroad_rake_t* obj);
 
void xroad_rake_reset_threshold(xroad_rake_t* obj);
 
bool xroad_rake_threshold_is_set(const xroad_rake_t* obj);
 
xroad_errno_t xroad_rake_send(xroad_rake_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_rake_route(xroad_rake_t* obj, ...);
 
void xroad_rake_reset(xroad_rake_t* obj);
 
xroad_rake_t* xroad_rake_clone(const xroad_rake_t* obj);
 
bool xroad_rake_is_valid(const xroad_rake_t* obj);
 
int32_t xroad_rake_print(const xroad_rake_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_rake_calc_hash(const xroad_rake_t* obj);
 
xroad_str_t xroad_rake_calc_uniq_id(const xroad_rake_t* obj);
 
 
 
/* xroad_stealth_t */
 
xroad_object_id_t xroad_stealth_get_id(const xroad_stealth_t* obj);
 
xroad_object_ref_t xroad_stealth_get_ref(const xroad_stealth_t* obj);
 
xroad_errno_t xroad_stealth_set_working_int(xroad_stealth_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_stealth_get_working_int(const xroad_stealth_t* obj);
 
void xroad_stealth_reset_working_int(xroad_stealth_t* obj);
 
bool xroad_stealth_working_int_is_set(const xroad_stealth_t* obj);
 
xroad_errno_t xroad_stealth_set_display_qty(xroad_stealth_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_stealth_get_display_qty(const xroad_stealth_t* obj);
 
void xroad_stealth_reset_display_qty(xroad_stealth_t* obj);
 
bool xroad_stealth_display_qty_is_set(const xroad_stealth_t* obj);
 
xroad_errno_t xroad_stealth_set_qty_shift(xroad_stealth_t* obj, xroad_double_t val);
 
xroad_double_t xroad_stealth_get_qty_shift(const xroad_stealth_t* obj);
 
void xroad_stealth_reset_qty_shift(xroad_stealth_t* obj);
 
bool xroad_stealth_qty_shift_is_set(const xroad_stealth_t* obj);
 
xroad_errno_t xroad_stealth_set_book_depth(xroad_stealth_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_stealth_get_book_depth(const xroad_stealth_t* obj);
 
void xroad_stealth_reset_book_depth(xroad_stealth_t* obj);
 
bool xroad_stealth_book_depth_is_set(const xroad_stealth_t* obj);
 
xroad_errno_t xroad_stealth_set_level_dist(xroad_stealth_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_stealth_get_level_dist(const xroad_stealth_t* obj);
 
void xroad_stealth_reset_level_dist(xroad_stealth_t* obj);
 
bool xroad_stealth_level_dist_is_set(const xroad_stealth_t* obj);
 
xroad_errno_t xroad_stealth_set_liq_price_shift(xroad_stealth_t* obj, xroad_double_t val);
 
xroad_double_t xroad_stealth_get_liq_price_shift(const xroad_stealth_t* obj);
 
void xroad_stealth_reset_liq_price_shift(xroad_stealth_t* obj);
 
bool xroad_stealth_liq_price_shift_is_set(const xroad_stealth_t* obj);
 
xroad_errno_t xroad_stealth_send(xroad_stealth_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_stealth_route(xroad_stealth_t* obj, ...);
 
void xroad_stealth_reset(xroad_stealth_t* obj);
 
xroad_stealth_t* xroad_stealth_clone(const xroad_stealth_t* obj);
 
bool xroad_stealth_is_valid(const xroad_stealth_t* obj);
 
int32_t xroad_stealth_print(const xroad_stealth_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_stealth_calc_hash(const xroad_stealth_t* obj);
 
xroad_str_t xroad_stealth_calc_uniq_id(const xroad_stealth_t* obj);
 
 
 
/* xroad_spread_t */
 
xroad_object_id_t xroad_spread_get_id(const xroad_spread_t* obj);
 
xroad_object_ref_t xroad_spread_get_ref(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_side(xroad_spread_t* obj, xroad_side_t val);
 
xroad_side_t xroad_spread_get_side(const xroad_spread_t* obj);
 
void xroad_spread_reset_side(xroad_spread_t* obj);
 
bool xroad_spread_side_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_tif(xroad_spread_t* obj, xroad_tif_t val);
 
xroad_tif_t xroad_spread_get_tif(const xroad_spread_t* obj);
 
void xroad_spread_reset_tif(xroad_spread_t* obj);
 
bool xroad_spread_tif_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_src_node_id(xroad_spread_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_spread_get_src_node_id(const xroad_spread_t* obj);
 
void xroad_spread_reset_src_node_id(xroad_spread_t* obj);
 
bool xroad_spread_src_node_id_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_dst_node_id(xroad_spread_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_spread_get_dst_node_id(const xroad_spread_t* obj);
 
void xroad_spread_reset_dst_node_id(xroad_spread_t* obj);
 
bool xroad_spread_dst_node_id_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_ext_ref(xroad_spread_t* obj, xroad_str_t val);
 
xroad_str_t xroad_spread_get_ext_ref(const xroad_spread_t* obj);
 
void xroad_spread_reset_ext_ref(xroad_spread_t* obj);
 
bool xroad_spread_ext_ref_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_status(xroad_spread_t* obj, xroad_order_status_t val);
 
xroad_order_status_t xroad_spread_get_status(const xroad_spread_t* obj);
 
void xroad_spread_reset_status(xroad_spread_t* obj);
 
bool xroad_spread_status_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_sub_status(xroad_spread_t* obj, xroad_sub_status_t val);
 
xroad_sub_status_t xroad_spread_get_sub_status(const xroad_spread_t* obj);
 
void xroad_spread_reset_sub_status(xroad_spread_t* obj);
 
bool xroad_spread_sub_status_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_sender(xroad_spread_t* obj, xroad_str_t val);
 
xroad_str_t xroad_spread_get_sender(const xroad_spread_t* obj);
 
void xroad_spread_reset_sender(xroad_spread_t* obj);
 
bool xroad_spread_sender_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_timestamp(xroad_spread_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_spread_get_timestamp(const xroad_spread_t* obj);
 
void xroad_spread_reset_timestamp(xroad_spread_t* obj);
 
bool xroad_spread_timestamp_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_type(xroad_spread_t* obj, xroad_ord_type_t val);
 
xroad_ord_type_t xroad_spread_get_type(const xroad_spread_t* obj);
 
void xroad_spread_reset_type(xroad_spread_t* obj);
 
bool xroad_spread_type_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_qty(xroad_spread_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_spread_get_qty(const xroad_spread_t* obj);
 
void xroad_spread_reset_qty(xroad_spread_t* obj);
 
bool xroad_spread_qty_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_leaves_qty(xroad_spread_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_spread_get_leaves_qty(const xroad_spread_t* obj);
 
void xroad_spread_reset_leaves_qty(xroad_spread_t* obj);
 
bool xroad_spread_leaves_qty_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_cum_qty(xroad_spread_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_spread_get_cum_qty(const xroad_spread_t* obj);
 
void xroad_spread_reset_cum_qty(xroad_spread_t* obj);
 
bool xroad_spread_cum_qty_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_price(xroad_spread_t* obj, xroad_price_t val);
 
xroad_price_t xroad_spread_get_price(const xroad_spread_t* obj);
 
void xroad_spread_reset_price(xroad_spread_t* obj);
 
bool xroad_spread_price_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_flag(xroad_spread_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_spread_get_flag(const xroad_spread_t* obj);
 
void xroad_spread_reset_flag(xroad_spread_t* obj);
 
bool xroad_spread_flag_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_agression_level(xroad_spread_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_spread_get_agression_level(const xroad_spread_t* obj);
 
void xroad_spread_reset_agression_level(xroad_spread_t* obj);
 
bool xroad_spread_agression_level_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_fill_timeout(xroad_spread_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_spread_get_fill_timeout(const xroad_spread_t* obj);
 
void xroad_spread_reset_fill_timeout(xroad_spread_t* obj);
 
bool xroad_spread_fill_timeout_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_is_relative(xroad_spread_t* obj, xroad_int8_t val);
 
xroad_int8_t xroad_spread_get_is_relative(const xroad_spread_t* obj);
 
void xroad_spread_reset_is_relative(xroad_spread_t* obj);
 
bool xroad_spread_is_relative_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_quote_wleg(xroad_spread_t* obj, xroad_int8_t val);
 
xroad_int8_t xroad_spread_get_quote_wleg(const xroad_spread_t* obj);
 
void xroad_spread_reset_quote_wleg(xroad_spread_t* obj);
 
bool xroad_spread_quote_wleg_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_leg(xroad_spread_t* obj, void* ref);
 
xroad_errno_t xroad_spread_set_leg_ref(xroad_spread_t* obj, xroad_object_ref_t ref);
 
void* xroad_spread_get_leg(const xroad_spread_t* obj);
 
xroad_object_ref_t xroad_spread_get_leg_ref(const xroad_spread_t* obj);
 
void xroad_spread_reset_leg(xroad_spread_t* obj);
 
bool xroad_spread_leg_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_text(xroad_spread_t* obj, xroad_str_t val);
 
xroad_str_t xroad_spread_get_text(const xroad_spread_t* obj);
 
void xroad_spread_reset_text(xroad_spread_t* obj);
 
bool xroad_spread_text_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_vwap_price(xroad_spread_t* obj, xroad_price_t val);
 
xroad_price_t xroad_spread_get_vwap_price(const xroad_spread_t* obj);
 
void xroad_spread_reset_vwap_price(xroad_spread_t* obj);
 
bool xroad_spread_vwap_price_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_mdata_price(xroad_spread_t* obj, xroad_price_t val);
 
xroad_price_t xroad_spread_get_mdata_price(const xroad_spread_t* obj);
 
void xroad_spread_reset_mdata_price(xroad_spread_t* obj);
 
bool xroad_spread_mdata_price_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_mdata_qty(xroad_spread_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_spread_get_mdata_qty(const xroad_spread_t* obj);
 
void xroad_spread_reset_mdata_qty(xroad_spread_t* obj);
 
bool xroad_spread_mdata_qty_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_hedge_second_leg(xroad_spread_t* obj, xroad_int8_t val);
 
xroad_int8_t xroad_spread_get_hedge_second_leg(const xroad_spread_t* obj);
 
void xroad_spread_reset_hedge_second_leg(xroad_spread_t* obj);
 
bool xroad_spread_hedge_second_leg_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_currency_hedge(xroad_spread_t* obj, xroad_int8_t val);
 
xroad_int8_t xroad_spread_get_currency_hedge(const xroad_spread_t* obj);
 
void xroad_spread_reset_currency_hedge(xroad_spread_t* obj);
 
bool xroad_spread_currency_hedge_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_currency(xroad_spread_t* obj, void* ref);
 
xroad_errno_t xroad_spread_set_currency_ref(xroad_spread_t* obj, xroad_object_ref_t ref);
 
void* xroad_spread_get_currency(const xroad_spread_t* obj);
 
xroad_object_ref_t xroad_spread_get_currency_ref(const xroad_spread_t* obj);
 
void xroad_spread_reset_currency(xroad_spread_t* obj);
 
bool xroad_spread_currency_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_quote_qty_ratio(xroad_spread_t* obj, xroad_double_t val);
 
xroad_double_t xroad_spread_get_quote_qty_ratio(const xroad_spread_t* obj);
 
void xroad_spread_reset_quote_qty_ratio(xroad_spread_t* obj);
 
bool xroad_spread_quote_qty_ratio_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_max_quote_qty(xroad_spread_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_spread_get_max_quote_qty(const xroad_spread_t* obj);
 
void xroad_spread_reset_max_quote_qty(xroad_spread_t* obj);
 
bool xroad_spread_max_quote_qty_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_set_sensitivity(xroad_spread_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_spread_get_sensitivity(const xroad_spread_t* obj);
 
void xroad_spread_reset_sensitivity(xroad_spread_t* obj);
 
bool xroad_spread_sensitivity_is_set(const xroad_spread_t* obj);
 
xroad_errno_t xroad_spread_send(xroad_spread_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_spread_route(xroad_spread_t* obj, ...);
 
void xroad_spread_reset(xroad_spread_t* obj);
 
xroad_spread_t* xroad_spread_clone(const xroad_spread_t* obj);
 
bool xroad_spread_is_valid(const xroad_spread_t* obj);
 
int32_t xroad_spread_print(const xroad_spread_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_spread_calc_hash(const xroad_spread_t* obj);
 
xroad_str_t xroad_spread_calc_uniq_id(const xroad_spread_t* obj);
 
 
 
/* xroad_leg_t */
 
xroad_object_id_t xroad_leg_get_id(const xroad_leg_t* obj);
 
xroad_object_ref_t xroad_leg_get_ref(const xroad_leg_t* obj);
 
xroad_errno_t xroad_leg_set_uniq_id(xroad_leg_t* obj, xroad_str_t val);
 
xroad_str_t xroad_leg_get_uniq_id(const xroad_leg_t* obj);
 
void xroad_leg_reset_uniq_id(xroad_leg_t* obj);
 
bool xroad_leg_uniq_id_is_set(const xroad_leg_t* obj);
 
xroad_errno_t xroad_leg_set_next(xroad_leg_t* obj, void* ref);
 
xroad_errno_t xroad_leg_set_next_ref(xroad_leg_t* obj, xroad_object_ref_t ref);
 
void* xroad_leg_get_next(const xroad_leg_t* obj);
 
xroad_object_ref_t xroad_leg_get_next_ref(const xroad_leg_t* obj);
 
void xroad_leg_reset_next(xroad_leg_t* obj);
 
bool xroad_leg_next_is_set(const xroad_leg_t* obj);
 
xroad_errno_t xroad_leg_set_order(xroad_leg_t* obj, void* ref);
 
xroad_errno_t xroad_leg_set_order_ref(xroad_leg_t* obj, xroad_object_ref_t ref);
 
void* xroad_leg_get_order(const xroad_leg_t* obj);
 
xroad_object_ref_t xroad_leg_get_order_ref(const xroad_leg_t* obj);
 
void xroad_leg_reset_order(xroad_leg_t* obj);
 
bool xroad_leg_order_is_set(const xroad_leg_t* obj);
 
xroad_errno_t xroad_leg_set_price_ratio(xroad_leg_t* obj, xroad_double_t val);
 
xroad_double_t xroad_leg_get_price_ratio(const xroad_leg_t* obj);
 
void xroad_leg_reset_price_ratio(xroad_leg_t* obj);
 
bool xroad_leg_price_ratio_is_set(const xroad_leg_t* obj);
 
xroad_errno_t xroad_leg_set_qty_ratio(xroad_leg_t* obj, xroad_double_t val);
 
xroad_double_t xroad_leg_get_qty_ratio(const xroad_leg_t* obj);
 
void xroad_leg_reset_qty_ratio(xroad_leg_t* obj);
 
bool xroad_leg_qty_ratio_is_set(const xroad_leg_t* obj);
 
xroad_errno_t xroad_leg_set_is_working(xroad_leg_t* obj, xroad_int8_t val);
 
xroad_int8_t xroad_leg_get_is_working(const xroad_leg_t* obj);
 
void xroad_leg_reset_is_working(xroad_leg_t* obj);
 
bool xroad_leg_is_working_is_set(const xroad_leg_t* obj);
 
xroad_errno_t xroad_leg_set_vwap_price(xroad_leg_t* obj, xroad_price_t val);
 
xroad_price_t xroad_leg_get_vwap_price(const xroad_leg_t* obj);
 
void xroad_leg_reset_vwap_price(xroad_leg_t* obj);
 
bool xroad_leg_vwap_price_is_set(const xroad_leg_t* obj);
 
xroad_errno_t xroad_leg_send(xroad_leg_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_leg_route(xroad_leg_t* obj, ...);
 
void xroad_leg_reset(xroad_leg_t* obj);
 
xroad_leg_t* xroad_leg_clone(const xroad_leg_t* obj);
 
bool xroad_leg_is_valid(const xroad_leg_t* obj);
 
int32_t xroad_leg_print(const xroad_leg_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_leg_calc_hash(const xroad_leg_t* obj);
 
xroad_str_t xroad_leg_calc_uniq_id(const xroad_leg_t* obj);
 
 
 
/* xroad_spread_trade_t */
 
xroad_object_id_t xroad_spread_trade_get_id(const xroad_spread_trade_t* obj);
 
xroad_object_ref_t xroad_spread_trade_get_ref(const xroad_spread_trade_t* obj);
 
xroad_errno_t xroad_spread_trade_set_spread(xroad_spread_trade_t* obj, void* ref);
 
xroad_errno_t xroad_spread_trade_set_spread_ref(xroad_spread_trade_t* obj, xroad_object_ref_t ref);
 
void* xroad_spread_trade_get_spread(const xroad_spread_trade_t* obj);
 
xroad_object_ref_t xroad_spread_trade_get_spread_ref(const xroad_spread_trade_t* obj);
 
void xroad_spread_trade_reset_spread(xroad_spread_trade_t* obj);
 
bool xroad_spread_trade_spread_is_set(const xroad_spread_trade_t* obj);
 
xroad_errno_t xroad_spread_trade_set_tran_time(xroad_spread_trade_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_spread_trade_get_tran_time(const xroad_spread_trade_t* obj);
 
void xroad_spread_trade_reset_tran_time(xroad_spread_trade_t* obj);
 
bool xroad_spread_trade_tran_time_is_set(const xroad_spread_trade_t* obj);
 
xroad_errno_t xroad_spread_trade_set_order_status(xroad_spread_trade_t* obj, xroad_order_status_t val);
 
xroad_order_status_t xroad_spread_trade_get_order_status(const xroad_spread_trade_t* obj);
 
void xroad_spread_trade_reset_order_status(xroad_spread_trade_t* obj);
 
bool xroad_spread_trade_order_status_is_set(const xroad_spread_trade_t* obj);
 
xroad_errno_t xroad_spread_trade_set_qty(xroad_spread_trade_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_spread_trade_get_qty(const xroad_spread_trade_t* obj);
 
void xroad_spread_trade_reset_qty(xroad_spread_trade_t* obj);
 
bool xroad_spread_trade_qty_is_set(const xroad_spread_trade_t* obj);
 
xroad_errno_t xroad_spread_trade_set_leaves_qty(xroad_spread_trade_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_spread_trade_get_leaves_qty(const xroad_spread_trade_t* obj);
 
void xroad_spread_trade_reset_leaves_qty(xroad_spread_trade_t* obj);
 
bool xroad_spread_trade_leaves_qty_is_set(const xroad_spread_trade_t* obj);
 
xroad_errno_t xroad_spread_trade_set_cum_qty(xroad_spread_trade_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_spread_trade_get_cum_qty(const xroad_spread_trade_t* obj);
 
void xroad_spread_trade_reset_cum_qty(xroad_spread_trade_t* obj);
 
bool xroad_spread_trade_cum_qty_is_set(const xroad_spread_trade_t* obj);
 
xroad_errno_t xroad_spread_trade_set_price(xroad_spread_trade_t* obj, xroad_price_t val);
 
xroad_price_t xroad_spread_trade_get_price(const xroad_spread_trade_t* obj);
 
void xroad_spread_trade_reset_price(xroad_spread_trade_t* obj);
 
bool xroad_spread_trade_price_is_set(const xroad_spread_trade_t* obj);
 
xroad_errno_t xroad_spread_trade_set_trade(xroad_spread_trade_t* obj, void* ref);
 
xroad_errno_t xroad_spread_trade_set_trade_ref(xroad_spread_trade_t* obj, xroad_object_ref_t ref);
 
void* xroad_spread_trade_get_trade(const xroad_spread_trade_t* obj);
 
xroad_object_ref_t xroad_spread_trade_get_trade_ref(const xroad_spread_trade_t* obj);
 
void xroad_spread_trade_reset_trade(xroad_spread_trade_t* obj);
 
bool xroad_spread_trade_trade_is_set(const xroad_spread_trade_t* obj);
 
xroad_errno_t xroad_spread_trade_send(xroad_spread_trade_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_spread_trade_route(xroad_spread_trade_t* obj, ...);
 
void xroad_spread_trade_reset(xroad_spread_trade_t* obj);
 
xroad_spread_trade_t* xroad_spread_trade_clone(const xroad_spread_trade_t* obj);
 
bool xroad_spread_trade_is_valid(const xroad_spread_trade_t* obj);
 
int32_t xroad_spread_trade_print(const xroad_spread_trade_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_spread_trade_calc_hash(const xroad_spread_trade_t* obj);
 
xroad_str_t xroad_spread_trade_calc_uniq_id(const xroad_spread_trade_t* obj);
 
 
 
/* xroad_cgate_session_t */
 
xroad_object_id_t xroad_cgate_session_get_id(const xroad_cgate_session_t* obj);
 
xroad_object_ref_t xroad_cgate_session_get_ref(const xroad_cgate_session_t* obj);
 
xroad_errno_t xroad_cgate_session_set_node_id(xroad_cgate_session_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_cgate_session_get_node_id(const xroad_cgate_session_t* obj);
 
void xroad_cgate_session_reset_node_id(xroad_cgate_session_t* obj);
 
bool xroad_cgate_session_node_id_is_set(const xroad_cgate_session_t* obj);
 
xroad_errno_t xroad_cgate_session_set_name(xroad_cgate_session_t* obj, xroad_str_t val);
 
xroad_str_t xroad_cgate_session_get_name(const xroad_cgate_session_t* obj);
 
void xroad_cgate_session_reset_name(xroad_cgate_session_t* obj);
 
bool xroad_cgate_session_name_is_set(const xroad_cgate_session_t* obj);
 
xroad_errno_t xroad_cgate_session_set_lifenum(xroad_cgate_session_t* obj, xroad_int64_t val);
 
xroad_int64_t xroad_cgate_session_get_lifenum(const xroad_cgate_session_t* obj);
 
void xroad_cgate_session_reset_lifenum(xroad_cgate_session_t* obj);
 
bool xroad_cgate_session_lifenum_is_set(const xroad_cgate_session_t* obj);
 
xroad_errno_t xroad_cgate_session_set_cgate_table(xroad_cgate_session_t* obj, void* ref);
 
xroad_errno_t xroad_cgate_session_set_cgate_table_ref(xroad_cgate_session_t* obj, xroad_object_ref_t ref);
 
void* xroad_cgate_session_get_cgate_table(const xroad_cgate_session_t* obj);
 
xroad_object_ref_t xroad_cgate_session_get_cgate_table_ref(const xroad_cgate_session_t* obj);
 
void xroad_cgate_session_reset_cgate_table(xroad_cgate_session_t* obj);
 
bool xroad_cgate_session_cgate_table_is_set(const xroad_cgate_session_t* obj);
 
xroad_errno_t xroad_cgate_session_send(xroad_cgate_session_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_cgate_session_route(xroad_cgate_session_t* obj, ...);
 
void xroad_cgate_session_reset(xroad_cgate_session_t* obj);
 
xroad_cgate_session_t* xroad_cgate_session_clone(const xroad_cgate_session_t* obj);
 
bool xroad_cgate_session_is_valid(const xroad_cgate_session_t* obj);
 
int32_t xroad_cgate_session_print(const xroad_cgate_session_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_cgate_session_calc_hash(const xroad_cgate_session_t* obj);
 
xroad_str_t xroad_cgate_session_calc_uniq_id(const xroad_cgate_session_t* obj);
 
 
 
/* xroad_cgate_table_t */
 
xroad_object_id_t xroad_cgate_table_get_id(const xroad_cgate_table_t* obj);
 
xroad_object_ref_t xroad_cgate_table_get_ref(const xroad_cgate_table_t* obj);
 
xroad_errno_t xroad_cgate_table_set_name(xroad_cgate_table_t* obj, xroad_str_t val);
 
xroad_str_t xroad_cgate_table_get_name(const xroad_cgate_table_t* obj);
 
void xroad_cgate_table_reset_name(xroad_cgate_table_t* obj);
 
bool xroad_cgate_table_name_is_set(const xroad_cgate_table_t* obj);
 
xroad_errno_t xroad_cgate_table_set_rev(xroad_cgate_table_t* obj, xroad_int64_t val);
 
xroad_int64_t xroad_cgate_table_get_rev(const xroad_cgate_table_t* obj);
 
void xroad_cgate_table_reset_rev(xroad_cgate_table_t* obj);
 
bool xroad_cgate_table_rev_is_set(const xroad_cgate_table_t* obj);
 
xroad_errno_t xroad_cgate_table_set_next(xroad_cgate_table_t* obj, void* ref);
 
xroad_errno_t xroad_cgate_table_set_next_ref(xroad_cgate_table_t* obj, xroad_object_ref_t ref);
 
void* xroad_cgate_table_get_next(const xroad_cgate_table_t* obj);
 
xroad_object_ref_t xroad_cgate_table_get_next_ref(const xroad_cgate_table_t* obj);
 
void xroad_cgate_table_reset_next(xroad_cgate_table_t* obj);
 
bool xroad_cgate_table_next_is_set(const xroad_cgate_table_t* obj);
 
xroad_errno_t xroad_cgate_table_send(xroad_cgate_table_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_cgate_table_route(xroad_cgate_table_t* obj, ...);
 
void xroad_cgate_table_reset(xroad_cgate_table_t* obj);
 
xroad_cgate_table_t* xroad_cgate_table_clone(const xroad_cgate_table_t* obj);
 
bool xroad_cgate_table_is_valid(const xroad_cgate_table_t* obj);
 
int32_t xroad_cgate_table_print(const xroad_cgate_table_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_cgate_table_calc_hash(const xroad_cgate_table_t* obj);
 
xroad_str_t xroad_cgate_table_calc_uniq_id(const xroad_cgate_table_t* obj);
 
 
 
/* xroad_cgate_order_t */
 
xroad_object_id_t xroad_cgate_order_get_id(const xroad_cgate_order_t* obj);
 
xroad_object_ref_t xroad_cgate_order_get_ref(const xroad_cgate_order_t* obj);
 
xroad_errno_t xroad_cgate_order_set_node_id(xroad_cgate_order_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_cgate_order_get_node_id(const xroad_cgate_order_t* obj);
 
void xroad_cgate_order_reset_node_id(xroad_cgate_order_t* obj);
 
bool xroad_cgate_order_node_id_is_set(const xroad_cgate_order_t* obj);
 
xroad_errno_t xroad_cgate_order_set_order(xroad_cgate_order_t* obj, void* ref);
 
xroad_errno_t xroad_cgate_order_set_order_ref(xroad_cgate_order_t* obj, xroad_object_ref_t ref);
 
void* xroad_cgate_order_get_order(const xroad_cgate_order_t* obj);
 
xroad_object_ref_t xroad_cgate_order_get_order_ref(const xroad_cgate_order_t* obj);
 
void xroad_cgate_order_reset_order(xroad_cgate_order_t* obj);
 
bool xroad_cgate_order_order_is_set(const xroad_cgate_order_t* obj);
 
xroad_errno_t xroad_cgate_order_set_exch_id(xroad_cgate_order_t* obj, xroad_int64_t val);
 
xroad_int64_t xroad_cgate_order_get_exch_id(const xroad_cgate_order_t* obj);
 
void xroad_cgate_order_reset_exch_id(xroad_cgate_order_t* obj);
 
bool xroad_cgate_order_exch_id_is_set(const xroad_cgate_order_t* obj);
 
xroad_errno_t xroad_cgate_order_set_replace(xroad_cgate_order_t* obj, void* ref);
 
xroad_errno_t xroad_cgate_order_set_replace_ref(xroad_cgate_order_t* obj, xroad_object_ref_t ref);
 
void* xroad_cgate_order_get_replace(const xroad_cgate_order_t* obj);
 
xroad_object_ref_t xroad_cgate_order_get_replace_ref(const xroad_cgate_order_t* obj);
 
void xroad_cgate_order_reset_replace(xroad_cgate_order_t* obj);
 
bool xroad_cgate_order_replace_is_set(const xroad_cgate_order_t* obj);
 
xroad_errno_t xroad_cgate_order_set_qty(xroad_cgate_order_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_cgate_order_get_qty(const xroad_cgate_order_t* obj);
 
void xroad_cgate_order_reset_qty(xroad_cgate_order_t* obj);
 
bool xroad_cgate_order_qty_is_set(const xroad_cgate_order_t* obj);
 
xroad_errno_t xroad_cgate_order_set_leaves_qty(xroad_cgate_order_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_cgate_order_get_leaves_qty(const xroad_cgate_order_t* obj);
 
void xroad_cgate_order_reset_leaves_qty(xroad_cgate_order_t* obj);
 
bool xroad_cgate_order_leaves_qty_is_set(const xroad_cgate_order_t* obj);
 
xroad_errno_t xroad_cgate_order_set_sync_req(xroad_cgate_order_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_cgate_order_get_sync_req(const xroad_cgate_order_t* obj);
 
void xroad_cgate_order_reset_sync_req(xroad_cgate_order_t* obj);
 
bool xroad_cgate_order_sync_req_is_set(const xroad_cgate_order_t* obj);
 
xroad_errno_t xroad_cgate_order_send(xroad_cgate_order_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_cgate_order_route(xroad_cgate_order_t* obj, ...);
 
void xroad_cgate_order_reset(xroad_cgate_order_t* obj);
 
xroad_cgate_order_t* xroad_cgate_order_clone(const xroad_cgate_order_t* obj);
 
bool xroad_cgate_order_is_valid(const xroad_cgate_order_t* obj);
 
int32_t xroad_cgate_order_print(const xroad_cgate_order_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_cgate_order_calc_hash(const xroad_cgate_order_t* obj);
 
xroad_str_t xroad_cgate_order_calc_uniq_id(const xroad_cgate_order_t* obj);
 
 
 
/* xroad_obj_uuid_t */
 
xroad_object_id_t xroad_obj_uuid_get_id(const xroad_obj_uuid_t* obj);
 
xroad_object_ref_t xroad_obj_uuid_get_ref(const xroad_obj_uuid_t* obj);
 
xroad_errno_t xroad_obj_uuid_set_type(xroad_obj_uuid_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_obj_uuid_get_type(const xroad_obj_uuid_t* obj);
 
void xroad_obj_uuid_reset_type(xroad_obj_uuid_t* obj);
 
bool xroad_obj_uuid_type_is_set(const xroad_obj_uuid_t* obj);
 
xroad_errno_t xroad_obj_uuid_set_uuid(xroad_obj_uuid_t* obj, xroad_str_t val);
 
xroad_str_t xroad_obj_uuid_get_uuid(const xroad_obj_uuid_t* obj);
 
void xroad_obj_uuid_reset_uuid(xroad_obj_uuid_t* obj);
 
bool xroad_obj_uuid_uuid_is_set(const xroad_obj_uuid_t* obj);
 
xroad_errno_t xroad_obj_uuid_send(xroad_obj_uuid_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_obj_uuid_route(xroad_obj_uuid_t* obj, ...);
 
void xroad_obj_uuid_reset(xroad_obj_uuid_t* obj);
 
xroad_obj_uuid_t* xroad_obj_uuid_clone(const xroad_obj_uuid_t* obj);
 
bool xroad_obj_uuid_is_valid(const xroad_obj_uuid_t* obj);
 
int32_t xroad_obj_uuid_print(const xroad_obj_uuid_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_obj_uuid_calc_hash(const xroad_obj_uuid_t* obj);
 
xroad_str_t xroad_obj_uuid_calc_uniq_id(const xroad_obj_uuid_t* obj);
 
 
 
/* xroad_free_form_t */
 
xroad_errno_t xroad_free_form_set_value(xroad_free_form_t* obj, xroad_binary_t val);
 
xroad_binary_t xroad_free_form_get_value(const xroad_free_form_t* obj);
 
void xroad_free_form_reset_value(xroad_free_form_t* obj);
 
bool xroad_free_form_value_is_set(const xroad_free_form_t* obj);
 
void xroad_free_form_destroy(xroad_free_form_t* obj);
 
xroad_errno_t xroad_free_form_send(xroad_free_form_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_free_form_route(xroad_free_form_t* obj, ...);
 
void xroad_free_form_reset(xroad_free_form_t* obj);
 
xroad_free_form_t* xroad_free_form_clone(const xroad_free_form_t* obj);
 
bool xroad_free_form_is_valid(const xroad_free_form_t* obj);
 
int32_t xroad_free_form_print(const xroad_free_form_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_free_form_calc_hash(const xroad_free_form_t* obj);
 
xroad_str_t xroad_free_form_calc_uniq_id(const xroad_free_form_t* obj);
 
 
 
/* xroad_order_fix_t */
 
xroad_object_id_t xroad_order_fix_get_id(const xroad_order_fix_t* obj);
 
xroad_object_ref_t xroad_order_fix_get_ref(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_node_id(xroad_order_fix_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_order_fix_get_node_id(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_node_id(xroad_order_fix_t* obj);
 
bool xroad_order_fix_node_id_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_session(xroad_order_fix_t* obj, void* ref);
 
xroad_errno_t xroad_order_fix_set_session_ref(xroad_order_fix_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_fix_get_session(const xroad_order_fix_t* obj);
 
xroad_object_ref_t xroad_order_fix_get_session_ref(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_session(xroad_order_fix_t* obj);
 
bool xroad_order_fix_session_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_sender(xroad_order_fix_t* obj, xroad_str_t val);
 
xroad_str_t xroad_order_fix_get_sender(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_sender(xroad_order_fix_t* obj);
 
bool xroad_order_fix_sender_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_instr(xroad_order_fix_t* obj, void* ref);
 
xroad_errno_t xroad_order_fix_set_instr_ref(xroad_order_fix_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_fix_get_instr(const xroad_order_fix_t* obj);
 
xroad_object_ref_t xroad_order_fix_get_instr_ref(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_instr(xroad_order_fix_t* obj);
 
bool xroad_order_fix_instr_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_sending_time(xroad_order_fix_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_order_fix_get_sending_time(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_sending_time(xroad_order_fix_t* obj);
 
bool xroad_order_fix_sending_time_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_order(xroad_order_fix_t* obj, void* ref);
 
xroad_errno_t xroad_order_fix_set_order_ref(xroad_order_fix_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_fix_get_order(const xroad_order_fix_t* obj);
 
xroad_object_ref_t xroad_order_fix_get_order_ref(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_order(xroad_order_fix_t* obj);
 
bool xroad_order_fix_order_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_order_id(xroad_order_fix_t* obj, xroad_str_t val);
 
xroad_str_t xroad_order_fix_get_order_id(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_order_id(xroad_order_fix_t* obj);
 
bool xroad_order_fix_order_id_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_status(xroad_order_fix_t* obj, xroad_order_fix_status_t val);
 
xroad_order_fix_status_t xroad_order_fix_get_status(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_status(xroad_order_fix_t* obj);
 
bool xroad_order_fix_status_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_clord_id(xroad_order_fix_t* obj, xroad_str_t val);
 
xroad_str_t xroad_order_fix_get_clord_id(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_clord_id(xroad_order_fix_t* obj);
 
bool xroad_order_fix_clord_id_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_orig_clord_id(xroad_order_fix_t* obj, xroad_str_t val);
 
xroad_str_t xroad_order_fix_get_orig_clord_id(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_orig_clord_id(xroad_order_fix_t* obj);
 
bool xroad_order_fix_orig_clord_id_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_security_id_src(xroad_order_fix_t* obj, xroad_str_t val);
 
xroad_str_t xroad_order_fix_get_security_id_src(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_security_id_src(xroad_order_fix_t* obj);
 
bool xroad_order_fix_security_id_src_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_price(xroad_order_fix_t* obj, xroad_price_t val);
 
xroad_price_t xroad_order_fix_get_price(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_price(xroad_order_fix_t* obj);
 
bool xroad_order_fix_price_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_qty(xroad_order_fix_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_order_fix_get_qty(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_qty(xroad_order_fix_t* obj);
 
bool xroad_order_fix_qty_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_leaves_qty(xroad_order_fix_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_order_fix_get_leaves_qty(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_leaves_qty(xroad_order_fix_t* obj);
 
bool xroad_order_fix_leaves_qty_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_cum_qty(xroad_order_fix_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_order_fix_get_cum_qty(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_cum_qty(xroad_order_fix_t* obj);
 
bool xroad_order_fix_cum_qty_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_display_qty(xroad_order_fix_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_order_fix_get_display_qty(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_display_qty(xroad_order_fix_t* obj);
 
bool xroad_order_fix_display_qty_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_volume(xroad_order_fix_t* obj, xroad_price_t val);
 
xroad_price_t xroad_order_fix_get_volume(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_volume(xroad_order_fix_t* obj);
 
bool xroad_order_fix_volume_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_hedge_volume(xroad_order_fix_t* obj, xroad_price_t val);
 
xroad_price_t xroad_order_fix_get_hedge_volume(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_hedge_volume(xroad_order_fix_t* obj);
 
bool xroad_order_fix_hedge_volume_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_hedge_amount(xroad_order_fix_t* obj, xroad_price_t val);
 
xroad_price_t xroad_order_fix_get_hedge_amount(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_hedge_amount(xroad_order_fix_t* obj);
 
bool xroad_order_fix_hedge_amount_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_avg_hedge_px(xroad_order_fix_t* obj, xroad_price_t val);
 
xroad_price_t xroad_order_fix_get_avg_hedge_px(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_avg_hedge_px(xroad_order_fix_t* obj);
 
bool xroad_order_fix_avg_hedge_px_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_avg_hedge_rate(xroad_order_fix_t* obj, xroad_price_t val);
 
xroad_price_t xroad_order_fix_get_avg_hedge_rate(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_avg_hedge_rate(xroad_order_fix_t* obj);
 
bool xroad_order_fix_avg_hedge_rate_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_avg_px(xroad_order_fix_t* obj, xroad_price_t val);
 
xroad_price_t xroad_order_fix_get_avg_px(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_avg_px(xroad_order_fix_t* obj);
 
bool xroad_order_fix_avg_px_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_last_px(xroad_order_fix_t* obj, xroad_price_t val);
 
xroad_price_t xroad_order_fix_get_last_px(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_last_px(xroad_order_fix_t* obj);
 
bool xroad_order_fix_last_px_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_replace(xroad_order_fix_t* obj, void* ref);
 
xroad_errno_t xroad_order_fix_set_replace_ref(xroad_order_fix_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_fix_get_replace(const xroad_order_fix_t* obj);
 
xroad_object_ref_t xroad_order_fix_get_replace_ref(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_replace(xroad_order_fix_t* obj);
 
bool xroad_order_fix_replace_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_set_cont_mult(xroad_order_fix_t* obj, xroad_double_t val);
 
xroad_double_t xroad_order_fix_get_cont_mult(const xroad_order_fix_t* obj);
 
void xroad_order_fix_reset_cont_mult(xroad_order_fix_t* obj);
 
bool xroad_order_fix_cont_mult_is_set(const xroad_order_fix_t* obj);
 
xroad_errno_t xroad_order_fix_send(xroad_order_fix_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_order_fix_route(xroad_order_fix_t* obj, ...);
 
void xroad_order_fix_reset(xroad_order_fix_t* obj);
 
xroad_order_fix_t* xroad_order_fix_clone(const xroad_order_fix_t* obj);
 
bool xroad_order_fix_is_valid(const xroad_order_fix_t* obj);
 
int32_t xroad_order_fix_print(const xroad_order_fix_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_order_fix_calc_hash(const xroad_order_fix_t* obj);
 
xroad_str_t xroad_order_fix_calc_uniq_id(const xroad_order_fix_t* obj);
 
 
 
/* xroad_fix_msg_in_t */
 
xroad_object_id_t xroad_fix_msg_in_get_id(const xroad_fix_msg_in_t* obj);
 
xroad_object_ref_t xroad_fix_msg_in_get_ref(const xroad_fix_msg_in_t* obj);
 
xroad_errno_t xroad_fix_msg_in_set_node_id(xroad_fix_msg_in_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_fix_msg_in_get_node_id(const xroad_fix_msg_in_t* obj);
 
void xroad_fix_msg_in_reset_node_id(xroad_fix_msg_in_t* obj);
 
bool xroad_fix_msg_in_node_id_is_set(const xroad_fix_msg_in_t* obj);
 
xroad_errno_t xroad_fix_msg_in_set_session(xroad_fix_msg_in_t* obj, void* ref);
 
xroad_errno_t xroad_fix_msg_in_set_session_ref(xroad_fix_msg_in_t* obj, xroad_object_ref_t ref);
 
void* xroad_fix_msg_in_get_session(const xroad_fix_msg_in_t* obj);
 
xroad_object_ref_t xroad_fix_msg_in_get_session_ref(const xroad_fix_msg_in_t* obj);
 
void xroad_fix_msg_in_reset_session(xroad_fix_msg_in_t* obj);
 
bool xroad_fix_msg_in_session_is_set(const xroad_fix_msg_in_t* obj);
 
xroad_errno_t xroad_fix_msg_in_set_msg_type(xroad_fix_msg_in_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_fix_msg_in_get_msg_type(const xroad_fix_msg_in_t* obj);
 
void xroad_fix_msg_in_reset_msg_type(xroad_fix_msg_in_t* obj);
 
bool xroad_fix_msg_in_msg_type_is_set(const xroad_fix_msg_in_t* obj);
 
xroad_errno_t xroad_fix_msg_in_set_seq_num(xroad_fix_msg_in_t* obj, xroad_uint32_t val);
 
xroad_uint32_t xroad_fix_msg_in_get_seq_num(const xroad_fix_msg_in_t* obj);
 
void xroad_fix_msg_in_reset_seq_num(xroad_fix_msg_in_t* obj);
 
bool xroad_fix_msg_in_seq_num_is_set(const xroad_fix_msg_in_t* obj);
 
xroad_errno_t xroad_fix_msg_in_set_msg(xroad_fix_msg_in_t* obj, xroad_str_t val);
 
xroad_str_t xroad_fix_msg_in_get_msg(const xroad_fix_msg_in_t* obj);
 
void xroad_fix_msg_in_reset_msg(xroad_fix_msg_in_t* obj);
 
bool xroad_fix_msg_in_msg_is_set(const xroad_fix_msg_in_t* obj);
 
xroad_errno_t xroad_fix_msg_in_send(xroad_fix_msg_in_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_fix_msg_in_route(xroad_fix_msg_in_t* obj, ...);
 
void xroad_fix_msg_in_reset(xroad_fix_msg_in_t* obj);
 
xroad_fix_msg_in_t* xroad_fix_msg_in_clone(const xroad_fix_msg_in_t* obj);
 
bool xroad_fix_msg_in_is_valid(const xroad_fix_msg_in_t* obj);
 
int32_t xroad_fix_msg_in_print(const xroad_fix_msg_in_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_fix_msg_in_calc_hash(const xroad_fix_msg_in_t* obj);
 
xroad_str_t xroad_fix_msg_in_calc_uniq_id(const xroad_fix_msg_in_t* obj);
 
 
 
/* xroad_fix_msg_out_t */
 
xroad_object_id_t xroad_fix_msg_out_get_id(const xroad_fix_msg_out_t* obj);
 
xroad_object_ref_t xroad_fix_msg_out_get_ref(const xroad_fix_msg_out_t* obj);
 
xroad_errno_t xroad_fix_msg_out_set_node_id(xroad_fix_msg_out_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_fix_msg_out_get_node_id(const xroad_fix_msg_out_t* obj);
 
void xroad_fix_msg_out_reset_node_id(xroad_fix_msg_out_t* obj);
 
bool xroad_fix_msg_out_node_id_is_set(const xroad_fix_msg_out_t* obj);
 
xroad_errno_t xroad_fix_msg_out_set_session(xroad_fix_msg_out_t* obj, void* ref);
 
xroad_errno_t xroad_fix_msg_out_set_session_ref(xroad_fix_msg_out_t* obj, xroad_object_ref_t ref);
 
void* xroad_fix_msg_out_get_session(const xroad_fix_msg_out_t* obj);
 
xroad_object_ref_t xroad_fix_msg_out_get_session_ref(const xroad_fix_msg_out_t* obj);
 
void xroad_fix_msg_out_reset_session(xroad_fix_msg_out_t* obj);
 
bool xroad_fix_msg_out_session_is_set(const xroad_fix_msg_out_t* obj);
 
xroad_errno_t xroad_fix_msg_out_set_msg_type(xroad_fix_msg_out_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_fix_msg_out_get_msg_type(const xroad_fix_msg_out_t* obj);
 
void xroad_fix_msg_out_reset_msg_type(xroad_fix_msg_out_t* obj);
 
bool xroad_fix_msg_out_msg_type_is_set(const xroad_fix_msg_out_t* obj);
 
xroad_errno_t xroad_fix_msg_out_set_seq_num(xroad_fix_msg_out_t* obj, xroad_uint32_t val);
 
xroad_uint32_t xroad_fix_msg_out_get_seq_num(const xroad_fix_msg_out_t* obj);
 
void xroad_fix_msg_out_reset_seq_num(xroad_fix_msg_out_t* obj);
 
bool xroad_fix_msg_out_seq_num_is_set(const xroad_fix_msg_out_t* obj);
 
xroad_errno_t xroad_fix_msg_out_set_msg(xroad_fix_msg_out_t* obj, xroad_str_t val);
 
xroad_str_t xroad_fix_msg_out_get_msg(const xroad_fix_msg_out_t* obj);
 
void xroad_fix_msg_out_reset_msg(xroad_fix_msg_out_t* obj);
 
bool xroad_fix_msg_out_msg_is_set(const xroad_fix_msg_out_t* obj);
 
xroad_errno_t xroad_fix_msg_out_send(xroad_fix_msg_out_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_fix_msg_out_route(xroad_fix_msg_out_t* obj, ...);
 
void xroad_fix_msg_out_reset(xroad_fix_msg_out_t* obj);
 
xroad_fix_msg_out_t* xroad_fix_msg_out_clone(const xroad_fix_msg_out_t* obj);
 
bool xroad_fix_msg_out_is_valid(const xroad_fix_msg_out_t* obj);
 
int32_t xroad_fix_msg_out_print(const xroad_fix_msg_out_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_fix_msg_out_calc_hash(const xroad_fix_msg_out_t* obj);
 
xroad_str_t xroad_fix_msg_out_calc_uniq_id(const xroad_fix_msg_out_t* obj);
 
 
 
/* xroad_trade_fix_t */
 
xroad_object_id_t xroad_trade_fix_get_id(const xroad_trade_fix_t* obj);
 
xroad_object_ref_t xroad_trade_fix_get_ref(const xroad_trade_fix_t* obj);
 
xroad_errno_t xroad_trade_fix_set_session(xroad_trade_fix_t* obj, void* ref);
 
xroad_errno_t xroad_trade_fix_set_session_ref(xroad_trade_fix_t* obj, xroad_object_ref_t ref);
 
void* xroad_trade_fix_get_session(const xroad_trade_fix_t* obj);
 
xroad_object_ref_t xroad_trade_fix_get_session_ref(const xroad_trade_fix_t* obj);
 
void xroad_trade_fix_reset_session(xroad_trade_fix_t* obj);
 
bool xroad_trade_fix_session_is_set(const xroad_trade_fix_t* obj);
 
xroad_errno_t xroad_trade_fix_set_behalf_of(xroad_trade_fix_t* obj, xroad_str_t val);
 
xroad_str_t xroad_trade_fix_get_behalf_of(const xroad_trade_fix_t* obj);
 
void xroad_trade_fix_reset_behalf_of(xroad_trade_fix_t* obj);
 
bool xroad_trade_fix_behalf_of_is_set(const xroad_trade_fix_t* obj);
 
xroad_errno_t xroad_trade_fix_send(xroad_trade_fix_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_trade_fix_route(xroad_trade_fix_t* obj, ...);
 
void xroad_trade_fix_reset(xroad_trade_fix_t* obj);
 
xroad_trade_fix_t* xroad_trade_fix_clone(const xroad_trade_fix_t* obj);
 
bool xroad_trade_fix_is_valid(const xroad_trade_fix_t* obj);
 
int32_t xroad_trade_fix_print(const xroad_trade_fix_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_trade_fix_calc_hash(const xroad_trade_fix_t* obj);
 
xroad_str_t xroad_trade_fix_calc_uniq_id(const xroad_trade_fix_t* obj);
 
 
 
/* xroad_lock_by_pid_t */
 
xroad_object_id_t xroad_lock_by_pid_get_id(const xroad_lock_by_pid_t* obj);
 
xroad_object_ref_t xroad_lock_by_pid_get_ref(const xroad_lock_by_pid_t* obj);
 
xroad_errno_t xroad_lock_by_pid_set_pid(xroad_lock_by_pid_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_lock_by_pid_get_pid(const xroad_lock_by_pid_t* obj);
 
void xroad_lock_by_pid_reset_pid(xroad_lock_by_pid_t* obj);
 
bool xroad_lock_by_pid_pid_is_set(const xroad_lock_by_pid_t* obj);
 
xroad_errno_t xroad_lock_by_pid_set_obj(xroad_lock_by_pid_t* obj, void* ref);
 
xroad_errno_t xroad_lock_by_pid_set_obj_ref(xroad_lock_by_pid_t* obj, xroad_object_ref_t ref);
 
void* xroad_lock_by_pid_get_obj(const xroad_lock_by_pid_t* obj);
 
xroad_object_ref_t xroad_lock_by_pid_get_obj_ref(const xroad_lock_by_pid_t* obj);
 
void xroad_lock_by_pid_reset_obj(xroad_lock_by_pid_t* obj);
 
bool xroad_lock_by_pid_obj_is_set(const xroad_lock_by_pid_t* obj);
 
xroad_errno_t xroad_lock_by_pid_send(xroad_lock_by_pid_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_lock_by_pid_route(xroad_lock_by_pid_t* obj, ...);
 
void xroad_lock_by_pid_reset(xroad_lock_by_pid_t* obj);
 
xroad_lock_by_pid_t* xroad_lock_by_pid_clone(const xroad_lock_by_pid_t* obj);
 
bool xroad_lock_by_pid_is_valid(const xroad_lock_by_pid_t* obj);
 
int32_t xroad_lock_by_pid_print(const xroad_lock_by_pid_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_lock_by_pid_calc_hash(const xroad_lock_by_pid_t* obj);
 
xroad_str_t xroad_lock_by_pid_calc_uniq_id(const xroad_lock_by_pid_t* obj);
 
 
 
/* xroad_system_role_changed_t */
 
xroad_errno_t xroad_system_role_changed_set_new_role(xroad_system_role_changed_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_system_role_changed_get_new_role(const xroad_system_role_changed_t* obj);
 
void xroad_system_role_changed_reset_new_role(xroad_system_role_changed_t* obj);
 
bool xroad_system_role_changed_new_role_is_set(const xroad_system_role_changed_t* obj);
 
void xroad_system_role_changed_destroy(xroad_system_role_changed_t* obj);
 
xroad_errno_t xroad_system_role_changed_send(xroad_system_role_changed_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_system_role_changed_route(xroad_system_role_changed_t* obj, ...);
 
void xroad_system_role_changed_reset(xroad_system_role_changed_t* obj);
 
xroad_system_role_changed_t* xroad_system_role_changed_clone(const xroad_system_role_changed_t* obj);
 
bool xroad_system_role_changed_is_valid(const xroad_system_role_changed_t* obj);
 
int32_t xroad_system_role_changed_print(const xroad_system_role_changed_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_system_role_changed_calc_hash(const xroad_system_role_changed_t* obj);
 
xroad_str_t xroad_system_role_changed_calc_uniq_id(const xroad_system_role_changed_t* obj);
 
 
 
/* xroad_cancel_t */
 
xroad_errno_t xroad_cancel_set_order(xroad_cancel_t* obj, void* ref);
 
xroad_errno_t xroad_cancel_set_order_ref(xroad_cancel_t* obj, xroad_object_ref_t ref);
 
void* xroad_cancel_get_order(const xroad_cancel_t* obj);
 
xroad_object_ref_t xroad_cancel_get_order_ref(const xroad_cancel_t* obj);
 
void xroad_cancel_reset_order(xroad_cancel_t* obj);
 
bool xroad_cancel_order_is_set(const xroad_cancel_t* obj);
 
void xroad_cancel_destroy(xroad_cancel_t* obj);
 
xroad_errno_t xroad_cancel_send(xroad_cancel_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_cancel_route(xroad_cancel_t* obj, ...);
 
void xroad_cancel_reset(xroad_cancel_t* obj);
 
xroad_cancel_t* xroad_cancel_clone(const xroad_cancel_t* obj);
 
bool xroad_cancel_is_valid(const xroad_cancel_t* obj);
 
int32_t xroad_cancel_print(const xroad_cancel_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_cancel_calc_hash(const xroad_cancel_t* obj);
 
xroad_str_t xroad_cancel_calc_uniq_id(const xroad_cancel_t* obj);
 
 
 
/* xroad_remove_t */
 
xroad_errno_t xroad_remove_set_order(xroad_remove_t* obj, void* ref);
 
xroad_errno_t xroad_remove_set_order_ref(xroad_remove_t* obj, xroad_object_ref_t ref);
 
void* xroad_remove_get_order(const xroad_remove_t* obj);
 
xroad_object_ref_t xroad_remove_get_order_ref(const xroad_remove_t* obj);
 
void xroad_remove_reset_order(xroad_remove_t* obj);
 
bool xroad_remove_order_is_set(const xroad_remove_t* obj);
 
void xroad_remove_destroy(xroad_remove_t* obj);
 
xroad_errno_t xroad_remove_send(xroad_remove_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_remove_route(xroad_remove_t* obj, ...);
 
void xroad_remove_reset(xroad_remove_t* obj);
 
xroad_remove_t* xroad_remove_clone(const xroad_remove_t* obj);
 
bool xroad_remove_is_valid(const xroad_remove_t* obj);
 
int32_t xroad_remove_print(const xroad_remove_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_remove_calc_hash(const xroad_remove_t* obj);
 
xroad_str_t xroad_remove_calc_uniq_id(const xroad_remove_t* obj);
 
 
 
/* xroad_replace_t */
 
xroad_object_id_t xroad_replace_get_id(const xroad_replace_t* obj);
 
xroad_object_ref_t xroad_replace_get_ref(const xroad_replace_t* obj);
 
xroad_errno_t xroad_replace_set_order(xroad_replace_t* obj, void* ref);
 
xroad_errno_t xroad_replace_set_order_ref(xroad_replace_t* obj, xroad_object_ref_t ref);
 
void* xroad_replace_get_order(const xroad_replace_t* obj);
 
xroad_object_ref_t xroad_replace_get_order_ref(const xroad_replace_t* obj);
 
void xroad_replace_reset_order(xroad_replace_t* obj);
 
bool xroad_replace_order_is_set(const xroad_replace_t* obj);
 
xroad_errno_t xroad_replace_set_price(xroad_replace_t* obj, xroad_price_t val);
 
xroad_price_t xroad_replace_get_price(const xroad_replace_t* obj);
 
void xroad_replace_reset_price(xroad_replace_t* obj);
 
bool xroad_replace_price_is_set(const xroad_replace_t* obj);
 
xroad_errno_t xroad_replace_set_qty(xroad_replace_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_replace_get_qty(const xroad_replace_t* obj);
 
void xroad_replace_reset_qty(xroad_replace_t* obj);
 
bool xroad_replace_qty_is_set(const xroad_replace_t* obj);
 
xroad_errno_t xroad_replace_set_hedge_cur(xroad_replace_t* obj, void* ref);
 
xroad_errno_t xroad_replace_set_hedge_cur_ref(xroad_replace_t* obj, xroad_object_ref_t ref);
 
void* xroad_replace_get_hedge_cur(const xroad_replace_t* obj);
 
xroad_object_ref_t xroad_replace_get_hedge_cur_ref(const xroad_replace_t* obj);
 
void xroad_replace_reset_hedge_cur(xroad_replace_t* obj);
 
bool xroad_replace_hedge_cur_is_set(const xroad_replace_t* obj);
 
xroad_errno_t xroad_replace_set_algo(xroad_replace_t* obj, void* ref);
 
xroad_errno_t xroad_replace_set_algo_ref(xroad_replace_t* obj, xroad_object_ref_t ref);
 
void* xroad_replace_get_algo(const xroad_replace_t* obj);
 
xroad_object_ref_t xroad_replace_get_algo_ref(const xroad_replace_t* obj);
 
void xroad_replace_reset_algo(xroad_replace_t* obj);
 
bool xroad_replace_algo_is_set(const xroad_replace_t* obj);
 
xroad_errno_t xroad_replace_send(xroad_replace_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_replace_route(xroad_replace_t* obj, ...);
 
void xroad_replace_reset(xroad_replace_t* obj);
 
xroad_replace_t* xroad_replace_clone(const xroad_replace_t* obj);
 
bool xroad_replace_is_valid(const xroad_replace_t* obj);
 
int32_t xroad_replace_print(const xroad_replace_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_replace_calc_hash(const xroad_replace_t* obj);
 
xroad_str_t xroad_replace_calc_uniq_id(const xroad_replace_t* obj);
 
 
 
/* xroad_accepted_t */
 
xroad_object_id_t xroad_accepted_get_id(const xroad_accepted_t* obj);
 
xroad_object_ref_t xroad_accepted_get_ref(const xroad_accepted_t* obj);
 
xroad_errno_t xroad_accepted_set_order(xroad_accepted_t* obj, void* ref);
 
xroad_errno_t xroad_accepted_set_order_ref(xroad_accepted_t* obj, xroad_object_ref_t ref);
 
void* xroad_accepted_get_order(const xroad_accepted_t* obj);
 
xroad_object_ref_t xroad_accepted_get_order_ref(const xroad_accepted_t* obj);
 
void xroad_accepted_reset_order(xroad_accepted_t* obj);
 
bool xroad_accepted_order_is_set(const xroad_accepted_t* obj);
 
xroad_errno_t xroad_accepted_set_tran_time(xroad_accepted_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_accepted_get_tran_time(const xroad_accepted_t* obj);
 
void xroad_accepted_reset_tran_time(xroad_accepted_t* obj);
 
bool xroad_accepted_tran_time_is_set(const xroad_accepted_t* obj);
 
xroad_errno_t xroad_accepted_set_exch_id(xroad_accepted_t* obj, xroad_str_t val);
 
xroad_str_t xroad_accepted_get_exch_id(const xroad_accepted_t* obj);
 
void xroad_accepted_reset_exch_id(xroad_accepted_t* obj);
 
bool xroad_accepted_exch_id_is_set(const xroad_accepted_t* obj);
 
xroad_errno_t xroad_accepted_set_order_status(xroad_accepted_t* obj, xroad_order_status_t val);
 
xroad_order_status_t xroad_accepted_get_order_status(const xroad_accepted_t* obj);
 
void xroad_accepted_reset_order_status(xroad_accepted_t* obj);
 
bool xroad_accepted_order_status_is_set(const xroad_accepted_t* obj);
 
xroad_errno_t xroad_accepted_set_price(xroad_accepted_t* obj, xroad_price_t val);
 
xroad_price_t xroad_accepted_get_price(const xroad_accepted_t* obj);
 
void xroad_accepted_reset_price(xroad_accepted_t* obj);
 
bool xroad_accepted_price_is_set(const xroad_accepted_t* obj);
 
xroad_errno_t xroad_accepted_set_qty(xroad_accepted_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_accepted_get_qty(const xroad_accepted_t* obj);
 
void xroad_accepted_reset_qty(xroad_accepted_t* obj);
 
bool xroad_accepted_qty_is_set(const xroad_accepted_t* obj);
 
xroad_errno_t xroad_accepted_set_leaves_qty(xroad_accepted_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_accepted_get_leaves_qty(const xroad_accepted_t* obj);
 
void xroad_accepted_reset_leaves_qty(xroad_accepted_t* obj);
 
bool xroad_accepted_leaves_qty_is_set(const xroad_accepted_t* obj);
 
xroad_errno_t xroad_accepted_set_cum_qty(xroad_accepted_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_accepted_get_cum_qty(const xroad_accepted_t* obj);
 
void xroad_accepted_reset_cum_qty(xroad_accepted_t* obj);
 
bool xroad_accepted_cum_qty_is_set(const xroad_accepted_t* obj);
 
xroad_errno_t xroad_accepted_set_timestamp(xroad_accepted_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_accepted_get_timestamp(const xroad_accepted_t* obj);
 
void xroad_accepted_reset_timestamp(xroad_accepted_t* obj);
 
bool xroad_accepted_timestamp_is_set(const xroad_accepted_t* obj);
 
xroad_errno_t xroad_accepted_send(xroad_accepted_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_accepted_route(xroad_accepted_t* obj, ...);
 
void xroad_accepted_reset(xroad_accepted_t* obj);
 
xroad_accepted_t* xroad_accepted_clone(const xroad_accepted_t* obj);
 
bool xroad_accepted_is_valid(const xroad_accepted_t* obj);
 
int32_t xroad_accepted_print(const xroad_accepted_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_accepted_calc_hash(const xroad_accepted_t* obj);
 
xroad_str_t xroad_accepted_calc_uniq_id(const xroad_accepted_t* obj);
 
 
 
/* xroad_rejected_t */
 
xroad_object_id_t xroad_rejected_get_id(const xroad_rejected_t* obj);
 
xroad_object_ref_t xroad_rejected_get_ref(const xroad_rejected_t* obj);
 
xroad_errno_t xroad_rejected_set_order(xroad_rejected_t* obj, void* ref);
 
xroad_errno_t xroad_rejected_set_order_ref(xroad_rejected_t* obj, xroad_object_ref_t ref);
 
void* xroad_rejected_get_order(const xroad_rejected_t* obj);
 
xroad_object_ref_t xroad_rejected_get_order_ref(const xroad_rejected_t* obj);
 
void xroad_rejected_reset_order(xroad_rejected_t* obj);
 
bool xroad_rejected_order_is_set(const xroad_rejected_t* obj);
 
xroad_errno_t xroad_rejected_set_tran_time(xroad_rejected_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_rejected_get_tran_time(const xroad_rejected_t* obj);
 
void xroad_rejected_reset_tran_time(xroad_rejected_t* obj);
 
bool xroad_rejected_tran_time_is_set(const xroad_rejected_t* obj);
 
xroad_errno_t xroad_rejected_set_reason(xroad_rejected_t* obj, xroad_rej_reason_t val);
 
xroad_rej_reason_t xroad_rejected_get_reason(const xroad_rejected_t* obj);
 
void xroad_rejected_reset_reason(xroad_rejected_t* obj);
 
bool xroad_rejected_reason_is_set(const xroad_rejected_t* obj);
 
xroad_errno_t xroad_rejected_set_text(xroad_rejected_t* obj, xroad_str_t val);
 
xroad_str_t xroad_rejected_get_text(const xroad_rejected_t* obj);
 
void xroad_rejected_reset_text(xroad_rejected_t* obj);
 
bool xroad_rejected_text_is_set(const xroad_rejected_t* obj);
 
xroad_errno_t xroad_rejected_send(xroad_rejected_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_rejected_route(xroad_rejected_t* obj, ...);
 
void xroad_rejected_reset(xroad_rejected_t* obj);
 
xroad_rejected_t* xroad_rejected_clone(const xroad_rejected_t* obj);
 
bool xroad_rejected_is_valid(const xroad_rejected_t* obj);
 
int32_t xroad_rejected_print(const xroad_rejected_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_rejected_calc_hash(const xroad_rejected_t* obj);
 
xroad_str_t xroad_rejected_calc_uniq_id(const xroad_rejected_t* obj);
 
 
 
/* xroad_canceled_t */
 
xroad_object_id_t xroad_canceled_get_id(const xroad_canceled_t* obj);
 
xroad_object_ref_t xroad_canceled_get_ref(const xroad_canceled_t* obj);
 
xroad_errno_t xroad_canceled_set_order(xroad_canceled_t* obj, void* ref);
 
xroad_errno_t xroad_canceled_set_order_ref(xroad_canceled_t* obj, xroad_object_ref_t ref);
 
void* xroad_canceled_get_order(const xroad_canceled_t* obj);
 
xroad_object_ref_t xroad_canceled_get_order_ref(const xroad_canceled_t* obj);
 
void xroad_canceled_reset_order(xroad_canceled_t* obj);
 
bool xroad_canceled_order_is_set(const xroad_canceled_t* obj);
 
xroad_errno_t xroad_canceled_set_tran_time(xroad_canceled_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_canceled_get_tran_time(const xroad_canceled_t* obj);
 
void xroad_canceled_reset_tran_time(xroad_canceled_t* obj);
 
bool xroad_canceled_tran_time_is_set(const xroad_canceled_t* obj);
 
xroad_errno_t xroad_canceled_set_reason(xroad_canceled_t* obj, xroad_rej_reason_t val);
 
xroad_rej_reason_t xroad_canceled_get_reason(const xroad_canceled_t* obj);
 
void xroad_canceled_reset_reason(xroad_canceled_t* obj);
 
bool xroad_canceled_reason_is_set(const xroad_canceled_t* obj);
 
xroad_errno_t xroad_canceled_set_text(xroad_canceled_t* obj, xroad_str_t val);
 
xroad_str_t xroad_canceled_get_text(const xroad_canceled_t* obj);
 
void xroad_canceled_reset_text(xroad_canceled_t* obj);
 
bool xroad_canceled_text_is_set(const xroad_canceled_t* obj);
 
xroad_errno_t xroad_canceled_send(xroad_canceled_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_canceled_route(xroad_canceled_t* obj, ...);
 
void xroad_canceled_reset(xroad_canceled_t* obj);
 
xroad_canceled_t* xroad_canceled_clone(const xroad_canceled_t* obj);
 
bool xroad_canceled_is_valid(const xroad_canceled_t* obj);
 
int32_t xroad_canceled_print(const xroad_canceled_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_canceled_calc_hash(const xroad_canceled_t* obj);
 
xroad_str_t xroad_canceled_calc_uniq_id(const xroad_canceled_t* obj);
 
 
 
/* xroad_trade_t */
 
xroad_object_id_t xroad_trade_get_id(const xroad_trade_t* obj);
 
xroad_object_ref_t xroad_trade_get_ref(const xroad_trade_t* obj);
 
xroad_errno_t xroad_trade_set_order(xroad_trade_t* obj, void* ref);
 
xroad_errno_t xroad_trade_set_order_ref(xroad_trade_t* obj, xroad_object_ref_t ref);
 
void* xroad_trade_get_order(const xroad_trade_t* obj);
 
xroad_object_ref_t xroad_trade_get_order_ref(const xroad_trade_t* obj);
 
void xroad_trade_reset_order(xroad_trade_t* obj);
 
bool xroad_trade_order_is_set(const xroad_trade_t* obj);
 
xroad_errno_t xroad_trade_set_tran_time(xroad_trade_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_trade_get_tran_time(const xroad_trade_t* obj);
 
void xroad_trade_reset_tran_time(xroad_trade_t* obj);
 
bool xroad_trade_tran_time_is_set(const xroad_trade_t* obj);
 
xroad_errno_t xroad_trade_set_exch_id(xroad_trade_t* obj, xroad_str_t val);
 
xroad_str_t xroad_trade_get_exch_id(const xroad_trade_t* obj);
 
void xroad_trade_reset_exch_id(xroad_trade_t* obj);
 
bool xroad_trade_exch_id_is_set(const xroad_trade_t* obj);
 
xroad_errno_t xroad_trade_set_order_exch_id(xroad_trade_t* obj, xroad_str_t val);
 
xroad_str_t xroad_trade_get_order_exch_id(const xroad_trade_t* obj);
 
void xroad_trade_reset_order_exch_id(xroad_trade_t* obj);
 
bool xroad_trade_order_exch_id_is_set(const xroad_trade_t* obj);
 
xroad_errno_t xroad_trade_set_order_status(xroad_trade_t* obj, xroad_order_status_t val);
 
xroad_order_status_t xroad_trade_get_order_status(const xroad_trade_t* obj);
 
void xroad_trade_reset_order_status(xroad_trade_t* obj);
 
bool xroad_trade_order_status_is_set(const xroad_trade_t* obj);
 
xroad_errno_t xroad_trade_set_qty(xroad_trade_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_trade_get_qty(const xroad_trade_t* obj);
 
void xroad_trade_reset_qty(xroad_trade_t* obj);
 
bool xroad_trade_qty_is_set(const xroad_trade_t* obj);
 
xroad_errno_t xroad_trade_set_leaves_qty(xroad_trade_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_trade_get_leaves_qty(const xroad_trade_t* obj);
 
void xroad_trade_reset_leaves_qty(xroad_trade_t* obj);
 
bool xroad_trade_leaves_qty_is_set(const xroad_trade_t* obj);
 
xroad_errno_t xroad_trade_set_cum_qty(xroad_trade_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_trade_get_cum_qty(const xroad_trade_t* obj);
 
void xroad_trade_reset_cum_qty(xroad_trade_t* obj);
 
bool xroad_trade_cum_qty_is_set(const xroad_trade_t* obj);
 
xroad_errno_t xroad_trade_set_price(xroad_trade_t* obj, xroad_price_t val);
 
xroad_price_t xroad_trade_get_price(const xroad_trade_t* obj);
 
void xroad_trade_reset_price(xroad_trade_t* obj);
 
bool xroad_trade_price_is_set(const xroad_trade_t* obj);
 
xroad_errno_t xroad_trade_set_fee(xroad_trade_t* obj, xroad_price_t val);
 
xroad_price_t xroad_trade_get_fee(const xroad_trade_t* obj);
 
void xroad_trade_reset_fee(xroad_trade_t* obj);
 
bool xroad_trade_fee_is_set(const xroad_trade_t* obj);
 
xroad_errno_t xroad_trade_set_fee_asset(xroad_trade_t* obj, xroad_str_t val);
 
xroad_str_t xroad_trade_get_fee_asset(const xroad_trade_t* obj);
 
void xroad_trade_reset_fee_asset(xroad_trade_t* obj);
 
bool xroad_trade_fee_asset_is_set(const xroad_trade_t* obj);
 
xroad_errno_t xroad_trade_set_hedge_rate(xroad_trade_t* obj, xroad_price_t val);
 
xroad_price_t xroad_trade_get_hedge_rate(const xroad_trade_t* obj);
 
void xroad_trade_reset_hedge_rate(xroad_trade_t* obj);
 
bool xroad_trade_hedge_rate_is_set(const xroad_trade_t* obj);
 
xroad_errno_t xroad_trade_set_hedge_qty(xroad_trade_t* obj, xroad_double_t val);
 
xroad_double_t xroad_trade_get_hedge_qty(const xroad_trade_t* obj);
 
void xroad_trade_reset_hedge_qty(xroad_trade_t* obj);
 
bool xroad_trade_hedge_qty_is_set(const xroad_trade_t* obj);
 
xroad_errno_t xroad_trade_set_hedge_reverse(xroad_trade_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_trade_get_hedge_reverse(const xroad_trade_t* obj);
 
void xroad_trade_reset_hedge_reverse(xroad_trade_t* obj);
 
bool xroad_trade_hedge_reverse_is_set(const xroad_trade_t* obj);
 
xroad_errno_t xroad_trade_set_next(xroad_trade_t* obj, void* ref);
 
xroad_errno_t xroad_trade_set_next_ref(xroad_trade_t* obj, xroad_object_ref_t ref);
 
void* xroad_trade_get_next(const xroad_trade_t* obj);
 
xroad_object_ref_t xroad_trade_get_next_ref(const xroad_trade_t* obj);
 
void xroad_trade_reset_next(xroad_trade_t* obj);
 
bool xroad_trade_next_is_set(const xroad_trade_t* obj);
 
xroad_errno_t xroad_trade_set_comment(xroad_trade_t* obj, xroad_str_t val);
 
xroad_str_t xroad_trade_get_comment(const xroad_trade_t* obj);
 
void xroad_trade_reset_comment(xroad_trade_t* obj);
 
bool xroad_trade_comment_is_set(const xroad_trade_t* obj);
 
xroad_errno_t xroad_trade_set_market(xroad_trade_t* obj, void* ref);
 
xroad_errno_t xroad_trade_set_market_ref(xroad_trade_t* obj, xroad_object_ref_t ref);
 
void* xroad_trade_get_market(const xroad_trade_t* obj);
 
xroad_object_ref_t xroad_trade_get_market_ref(const xroad_trade_t* obj);
 
void xroad_trade_reset_market(xroad_trade_t* obj);
 
bool xroad_trade_market_is_set(const xroad_trade_t* obj);
 
xroad_errno_t xroad_trade_set_ext(xroad_trade_t* obj, void* ref);
 
xroad_errno_t xroad_trade_set_ext_ref(xroad_trade_t* obj, xroad_object_ref_t ref);
 
void* xroad_trade_get_ext(const xroad_trade_t* obj);
 
xroad_object_ref_t xroad_trade_get_ext_ref(const xroad_trade_t* obj);
 
void xroad_trade_reset_ext(xroad_trade_t* obj);
 
bool xroad_trade_ext_is_set(const xroad_trade_t* obj);
 
xroad_errno_t xroad_trade_set_opp_order(xroad_trade_t* obj, void* ref);
 
xroad_errno_t xroad_trade_set_opp_order_ref(xroad_trade_t* obj, xroad_object_ref_t ref);
 
void* xroad_trade_get_opp_order(const xroad_trade_t* obj);
 
xroad_object_ref_t xroad_trade_get_opp_order_ref(const xroad_trade_t* obj);
 
void xroad_trade_reset_opp_order(xroad_trade_t* obj);
 
bool xroad_trade_opp_order_is_set(const xroad_trade_t* obj);
 
xroad_errno_t xroad_trade_send(xroad_trade_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_trade_route(xroad_trade_t* obj, ...);
 
void xroad_trade_reset(xroad_trade_t* obj);
 
xroad_trade_t* xroad_trade_clone(const xroad_trade_t* obj);
 
bool xroad_trade_is_valid(const xroad_trade_t* obj);
 
int32_t xroad_trade_print(const xroad_trade_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_trade_calc_hash(const xroad_trade_t* obj);
 
xroad_str_t xroad_trade_calc_uniq_id(const xroad_trade_t* obj);
 
 
 
/* xroad_cancel_rejected_t */
 
xroad_errno_t xroad_cancel_rejected_set_order(xroad_cancel_rejected_t* obj, void* ref);
 
xroad_errno_t xroad_cancel_rejected_set_order_ref(xroad_cancel_rejected_t* obj, xroad_object_ref_t ref);
 
void* xroad_cancel_rejected_get_order(const xroad_cancel_rejected_t* obj);
 
xroad_object_ref_t xroad_cancel_rejected_get_order_ref(const xroad_cancel_rejected_t* obj);
 
void xroad_cancel_rejected_reset_order(xroad_cancel_rejected_t* obj);
 
bool xroad_cancel_rejected_order_is_set(const xroad_cancel_rejected_t* obj);
 
xroad_errno_t xroad_cancel_rejected_set_order_status(xroad_cancel_rejected_t* obj, xroad_order_status_t val);
 
xroad_order_status_t xroad_cancel_rejected_get_order_status(const xroad_cancel_rejected_t* obj);
 
void xroad_cancel_rejected_reset_order_status(xroad_cancel_rejected_t* obj);
 
bool xroad_cancel_rejected_order_status_is_set(const xroad_cancel_rejected_t* obj);
 
xroad_errno_t xroad_cancel_rejected_set_reason(xroad_cancel_rejected_t* obj, xroad_rej_reason_t val);
 
xroad_rej_reason_t xroad_cancel_rejected_get_reason(const xroad_cancel_rejected_t* obj);
 
void xroad_cancel_rejected_reset_reason(xroad_cancel_rejected_t* obj);
 
bool xroad_cancel_rejected_reason_is_set(const xroad_cancel_rejected_t* obj);
 
xroad_errno_t xroad_cancel_rejected_set_text(xroad_cancel_rejected_t* obj, xroad_str_t val);
 
xroad_str_t xroad_cancel_rejected_get_text(const xroad_cancel_rejected_t* obj);
 
void xroad_cancel_rejected_reset_text(xroad_cancel_rejected_t* obj);
 
bool xroad_cancel_rejected_text_is_set(const xroad_cancel_rejected_t* obj);
 
void xroad_cancel_rejected_destroy(xroad_cancel_rejected_t* obj);
 
xroad_errno_t xroad_cancel_rejected_send(xroad_cancel_rejected_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_cancel_rejected_route(xroad_cancel_rejected_t* obj, ...);
 
void xroad_cancel_rejected_reset(xroad_cancel_rejected_t* obj);
 
xroad_cancel_rejected_t* xroad_cancel_rejected_clone(const xroad_cancel_rejected_t* obj);
 
bool xroad_cancel_rejected_is_valid(const xroad_cancel_rejected_t* obj);
 
int32_t xroad_cancel_rejected_print(const xroad_cancel_rejected_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_cancel_rejected_calc_hash(const xroad_cancel_rejected_t* obj);
 
xroad_str_t xroad_cancel_rejected_calc_uniq_id(const xroad_cancel_rejected_t* obj);
 
 
 
/* xroad_replace_rejected_t */
 
xroad_errno_t xroad_replace_rejected_set_order(xroad_replace_rejected_t* obj, void* ref);
 
xroad_errno_t xroad_replace_rejected_set_order_ref(xroad_replace_rejected_t* obj, xroad_object_ref_t ref);
 
void* xroad_replace_rejected_get_order(const xroad_replace_rejected_t* obj);
 
xroad_object_ref_t xroad_replace_rejected_get_order_ref(const xroad_replace_rejected_t* obj);
 
void xroad_replace_rejected_reset_order(xroad_replace_rejected_t* obj);
 
bool xroad_replace_rejected_order_is_set(const xroad_replace_rejected_t* obj);
 
xroad_errno_t xroad_replace_rejected_set_order_status(xroad_replace_rejected_t* obj, xroad_order_status_t val);
 
xroad_order_status_t xroad_replace_rejected_get_order_status(const xroad_replace_rejected_t* obj);
 
void xroad_replace_rejected_reset_order_status(xroad_replace_rejected_t* obj);
 
bool xroad_replace_rejected_order_status_is_set(const xroad_replace_rejected_t* obj);
 
xroad_errno_t xroad_replace_rejected_set_price(xroad_replace_rejected_t* obj, xroad_price_t val);
 
xroad_price_t xroad_replace_rejected_get_price(const xroad_replace_rejected_t* obj);
 
void xroad_replace_rejected_reset_price(xroad_replace_rejected_t* obj);
 
bool xroad_replace_rejected_price_is_set(const xroad_replace_rejected_t* obj);
 
xroad_errno_t xroad_replace_rejected_set_qty(xroad_replace_rejected_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_replace_rejected_get_qty(const xroad_replace_rejected_t* obj);
 
void xroad_replace_rejected_reset_qty(xroad_replace_rejected_t* obj);
 
bool xroad_replace_rejected_qty_is_set(const xroad_replace_rejected_t* obj);
 
xroad_errno_t xroad_replace_rejected_set_leaves_qty(xroad_replace_rejected_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_replace_rejected_get_leaves_qty(const xroad_replace_rejected_t* obj);
 
void xroad_replace_rejected_reset_leaves_qty(xroad_replace_rejected_t* obj);
 
bool xroad_replace_rejected_leaves_qty_is_set(const xroad_replace_rejected_t* obj);
 
xroad_errno_t xroad_replace_rejected_set_cum_qty(xroad_replace_rejected_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_replace_rejected_get_cum_qty(const xroad_replace_rejected_t* obj);
 
void xroad_replace_rejected_reset_cum_qty(xroad_replace_rejected_t* obj);
 
bool xroad_replace_rejected_cum_qty_is_set(const xroad_replace_rejected_t* obj);
 
xroad_errno_t xroad_replace_rejected_set_reason(xroad_replace_rejected_t* obj, xroad_rej_reason_t val);
 
xroad_rej_reason_t xroad_replace_rejected_get_reason(const xroad_replace_rejected_t* obj);
 
void xroad_replace_rejected_reset_reason(xroad_replace_rejected_t* obj);
 
bool xroad_replace_rejected_reason_is_set(const xroad_replace_rejected_t* obj);
 
xroad_errno_t xroad_replace_rejected_set_text(xroad_replace_rejected_t* obj, xroad_str_t val);
 
xroad_str_t xroad_replace_rejected_get_text(const xroad_replace_rejected_t* obj);
 
void xroad_replace_rejected_reset_text(xroad_replace_rejected_t* obj);
 
bool xroad_replace_rejected_text_is_set(const xroad_replace_rejected_t* obj);
 
void xroad_replace_rejected_destroy(xroad_replace_rejected_t* obj);
 
xroad_errno_t xroad_replace_rejected_send(xroad_replace_rejected_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_replace_rejected_route(xroad_replace_rejected_t* obj, ...);
 
void xroad_replace_rejected_reset(xroad_replace_rejected_t* obj);
 
xroad_replace_rejected_t* xroad_replace_rejected_clone(const xroad_replace_rejected_t* obj);
 
bool xroad_replace_rejected_is_valid(const xroad_replace_rejected_t* obj);
 
int32_t xroad_replace_rejected_print(const xroad_replace_rejected_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_replace_rejected_calc_hash(const xroad_replace_rejected_t* obj);
 
xroad_str_t xroad_replace_rejected_calc_uniq_id(const xroad_replace_rejected_t* obj);
 
 
 
/* xroad_replaced_t */
 
xroad_object_id_t xroad_replaced_get_id(const xroad_replaced_t* obj);
 
xroad_object_ref_t xroad_replaced_get_ref(const xroad_replaced_t* obj);
 
xroad_errno_t xroad_replaced_set_order(xroad_replaced_t* obj, void* ref);
 
xroad_errno_t xroad_replaced_set_order_ref(xroad_replaced_t* obj, xroad_object_ref_t ref);
 
void* xroad_replaced_get_order(const xroad_replaced_t* obj);
 
xroad_object_ref_t xroad_replaced_get_order_ref(const xroad_replaced_t* obj);
 
void xroad_replaced_reset_order(xroad_replaced_t* obj);
 
bool xroad_replaced_order_is_set(const xroad_replaced_t* obj);
 
xroad_errno_t xroad_replaced_set_tran_time(xroad_replaced_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_replaced_get_tran_time(const xroad_replaced_t* obj);
 
void xroad_replaced_reset_tran_time(xroad_replaced_t* obj);
 
bool xroad_replaced_tran_time_is_set(const xroad_replaced_t* obj);
 
xroad_errno_t xroad_replaced_set_exch_id(xroad_replaced_t* obj, xroad_str_t val);
 
xroad_str_t xroad_replaced_get_exch_id(const xroad_replaced_t* obj);
 
void xroad_replaced_reset_exch_id(xroad_replaced_t* obj);
 
bool xroad_replaced_exch_id_is_set(const xroad_replaced_t* obj);
 
xroad_errno_t xroad_replaced_set_order_status(xroad_replaced_t* obj, xroad_order_status_t val);
 
xroad_order_status_t xroad_replaced_get_order_status(const xroad_replaced_t* obj);
 
void xroad_replaced_reset_order_status(xroad_replaced_t* obj);
 
bool xroad_replaced_order_status_is_set(const xroad_replaced_t* obj);
 
xroad_errno_t xroad_replaced_set_price(xroad_replaced_t* obj, xroad_price_t val);
 
xroad_price_t xroad_replaced_get_price(const xroad_replaced_t* obj);
 
void xroad_replaced_reset_price(xroad_replaced_t* obj);
 
bool xroad_replaced_price_is_set(const xroad_replaced_t* obj);
 
xroad_errno_t xroad_replaced_set_qty(xroad_replaced_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_replaced_get_qty(const xroad_replaced_t* obj);
 
void xroad_replaced_reset_qty(xroad_replaced_t* obj);
 
bool xroad_replaced_qty_is_set(const xroad_replaced_t* obj);
 
xroad_errno_t xroad_replaced_set_leaves_qty(xroad_replaced_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_replaced_get_leaves_qty(const xroad_replaced_t* obj);
 
void xroad_replaced_reset_leaves_qty(xroad_replaced_t* obj);
 
bool xroad_replaced_leaves_qty_is_set(const xroad_replaced_t* obj);
 
xroad_errno_t xroad_replaced_set_cum_qty(xroad_replaced_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_replaced_get_cum_qty(const xroad_replaced_t* obj);
 
void xroad_replaced_reset_cum_qty(xroad_replaced_t* obj);
 
bool xroad_replaced_cum_qty_is_set(const xroad_replaced_t* obj);
 
xroad_errno_t xroad_replaced_send(xroad_replaced_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_replaced_route(xroad_replaced_t* obj, ...);
 
void xroad_replaced_reset(xroad_replaced_t* obj);
 
xroad_replaced_t* xroad_replaced_clone(const xroad_replaced_t* obj);
 
bool xroad_replaced_is_valid(const xroad_replaced_t* obj);
 
int32_t xroad_replaced_print(const xroad_replaced_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_replaced_calc_hash(const xroad_replaced_t* obj);
 
xroad_str_t xroad_replaced_calc_uniq_id(const xroad_replaced_t* obj);
 
 
 
/* xroad_subscribe_t */
 
xroad_errno_t xroad_subscribe_set_src_node_id(xroad_subscribe_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_subscribe_get_src_node_id(const xroad_subscribe_t* obj);
 
void xroad_subscribe_reset_src_node_id(xroad_subscribe_t* obj);
 
bool xroad_subscribe_src_node_id_is_set(const xroad_subscribe_t* obj);
 
xroad_errno_t xroad_subscribe_set_instr(xroad_subscribe_t* obj, void* ref);
 
xroad_errno_t xroad_subscribe_set_instr_ref(xroad_subscribe_t* obj, xroad_object_ref_t ref);
 
void* xroad_subscribe_get_instr(const xroad_subscribe_t* obj);
 
xroad_object_ref_t xroad_subscribe_get_instr_ref(const xroad_subscribe_t* obj);
 
void xroad_subscribe_reset_instr(xroad_subscribe_t* obj);
 
bool xroad_subscribe_instr_is_set(const xroad_subscribe_t* obj);
 
xroad_errno_t xroad_subscribe_set_forced(xroad_subscribe_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_subscribe_get_forced(const xroad_subscribe_t* obj);
 
void xroad_subscribe_reset_forced(xroad_subscribe_t* obj);
 
bool xroad_subscribe_forced_is_set(const xroad_subscribe_t* obj);
 
void xroad_subscribe_destroy(xroad_subscribe_t* obj);
 
xroad_errno_t xroad_subscribe_send(xroad_subscribe_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_subscribe_route(xroad_subscribe_t* obj, ...);
 
void xroad_subscribe_reset(xroad_subscribe_t* obj);
 
xroad_subscribe_t* xroad_subscribe_clone(const xroad_subscribe_t* obj);
 
bool xroad_subscribe_is_valid(const xroad_subscribe_t* obj);
 
int32_t xroad_subscribe_print(const xroad_subscribe_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_subscribe_calc_hash(const xroad_subscribe_t* obj);
 
xroad_str_t xroad_subscribe_calc_uniq_id(const xroad_subscribe_t* obj);
 
 
 
/* xroad_unsubscribe_t */
 
xroad_errno_t xroad_unsubscribe_set_src_node_id(xroad_unsubscribe_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_unsubscribe_get_src_node_id(const xroad_unsubscribe_t* obj);
 
void xroad_unsubscribe_reset_src_node_id(xroad_unsubscribe_t* obj);
 
bool xroad_unsubscribe_src_node_id_is_set(const xroad_unsubscribe_t* obj);
 
xroad_errno_t xroad_unsubscribe_set_instr(xroad_unsubscribe_t* obj, void* ref);
 
xroad_errno_t xroad_unsubscribe_set_instr_ref(xroad_unsubscribe_t* obj, xroad_object_ref_t ref);
 
void* xroad_unsubscribe_get_instr(const xroad_unsubscribe_t* obj);
 
xroad_object_ref_t xroad_unsubscribe_get_instr_ref(const xroad_unsubscribe_t* obj);
 
void xroad_unsubscribe_reset_instr(xroad_unsubscribe_t* obj);
 
bool xroad_unsubscribe_instr_is_set(const xroad_unsubscribe_t* obj);
 
xroad_errno_t xroad_unsubscribe_set_forced(xroad_unsubscribe_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_unsubscribe_get_forced(const xroad_unsubscribe_t* obj);
 
void xroad_unsubscribe_reset_forced(xroad_unsubscribe_t* obj);
 
bool xroad_unsubscribe_forced_is_set(const xroad_unsubscribe_t* obj);
 
void xroad_unsubscribe_destroy(xroad_unsubscribe_t* obj);
 
xroad_errno_t xroad_unsubscribe_send(xroad_unsubscribe_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_unsubscribe_route(xroad_unsubscribe_t* obj, ...);
 
void xroad_unsubscribe_reset(xroad_unsubscribe_t* obj);
 
xroad_unsubscribe_t* xroad_unsubscribe_clone(const xroad_unsubscribe_t* obj);
 
bool xroad_unsubscribe_is_valid(const xroad_unsubscribe_t* obj);
 
int32_t xroad_unsubscribe_print(const xroad_unsubscribe_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_unsubscribe_calc_hash(const xroad_unsubscribe_t* obj);
 
xroad_str_t xroad_unsubscribe_calc_uniq_id(const xroad_unsubscribe_t* obj);
 
 
 
/* xroad_update_t */
 
xroad_errno_t xroad_update_set_node_id(xroad_update_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_update_get_node_id(const xroad_update_t* obj);
 
void xroad_update_reset_node_id(xroad_update_t* obj);
 
bool xroad_update_node_id_is_set(const xroad_update_t* obj);
 
xroad_errno_t xroad_update_set_instr(xroad_update_t* obj, void* ref);
 
xroad_errno_t xroad_update_set_instr_ref(xroad_update_t* obj, xroad_object_ref_t ref);
 
void* xroad_update_get_instr(const xroad_update_t* obj);
 
xroad_object_ref_t xroad_update_get_instr_ref(const xroad_update_t* obj);
 
void xroad_update_reset_instr(xroad_update_t* obj);
 
bool xroad_update_instr_is_set(const xroad_update_t* obj);
 
xroad_errno_t xroad_update_set_user_id(xroad_update_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_update_get_user_id(const xroad_update_t* obj);
 
void xroad_update_reset_user_id(xroad_update_t* obj);
 
bool xroad_update_user_id_is_set(const xroad_update_t* obj);
 
void xroad_update_destroy(xroad_update_t* obj);
 
xroad_errno_t xroad_update_send(xroad_update_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_update_route(xroad_update_t* obj, ...);
 
void xroad_update_reset(xroad_update_t* obj);
 
xroad_update_t* xroad_update_clone(const xroad_update_t* obj);
 
bool xroad_update_is_valid(const xroad_update_t* obj);
 
int32_t xroad_update_print(const xroad_update_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_update_calc_hash(const xroad_update_t* obj);
 
xroad_str_t xroad_update_calc_uniq_id(const xroad_update_t* obj);
 
 
 
/* xroad_money_limit_t */
 
xroad_object_id_t xroad_money_limit_get_id(const xroad_money_limit_t* obj);
 
xroad_object_ref_t xroad_money_limit_get_ref(const xroad_money_limit_t* obj);
 
xroad_errno_t xroad_money_limit_set_deleted(xroad_money_limit_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_money_limit_get_deleted(const xroad_money_limit_t* obj);
 
void xroad_money_limit_reset_deleted(xroad_money_limit_t* obj);
 
bool xroad_money_limit_deleted_is_set(const xroad_money_limit_t* obj);
 
xroad_errno_t xroad_money_limit_set_node_id(xroad_money_limit_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_money_limit_get_node_id(const xroad_money_limit_t* obj);
 
void xroad_money_limit_reset_node_id(xroad_money_limit_t* obj);
 
bool xroad_money_limit_node_id_is_set(const xroad_money_limit_t* obj);
 
xroad_errno_t xroad_money_limit_set_db_id(xroad_money_limit_t* obj, xroad_int64_t val);
 
xroad_int64_t xroad_money_limit_get_db_id(const xroad_money_limit_t* obj);
 
void xroad_money_limit_reset_db_id(xroad_money_limit_t* obj);
 
bool xroad_money_limit_db_id_is_set(const xroad_money_limit_t* obj);
 
xroad_errno_t xroad_money_limit_set_client_id(xroad_money_limit_t* obj, xroad_int64_t val);
 
xroad_int64_t xroad_money_limit_get_client_id(const xroad_money_limit_t* obj);
 
void xroad_money_limit_reset_client_id(xroad_money_limit_t* obj);
 
bool xroad_money_limit_client_id_is_set(const xroad_money_limit_t* obj);
 
xroad_errno_t xroad_money_limit_set_account_id(xroad_money_limit_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_money_limit_get_account_id(const xroad_money_limit_t* obj);
 
void xroad_money_limit_reset_account_id(xroad_money_limit_t* obj);
 
bool xroad_money_limit_account_id_is_set(const xroad_money_limit_t* obj);
 
xroad_errno_t xroad_money_limit_set_client_name(xroad_money_limit_t* obj, xroad_str_t val);
 
xroad_str_t xroad_money_limit_get_client_name(const xroad_money_limit_t* obj);
 
void xroad_money_limit_reset_client_name(xroad_money_limit_t* obj);
 
bool xroad_money_limit_client_name_is_set(const xroad_money_limit_t* obj);
 
xroad_errno_t xroad_money_limit_set_initial(xroad_money_limit_t* obj, xroad_double_t val);
 
xroad_double_t xroad_money_limit_get_initial(const xroad_money_limit_t* obj);
 
void xroad_money_limit_reset_initial(xroad_money_limit_t* obj);
 
bool xroad_money_limit_initial_is_set(const xroad_money_limit_t* obj);
 
xroad_errno_t xroad_money_limit_set_reserved(xroad_money_limit_t* obj, xroad_double_t val);
 
xroad_double_t xroad_money_limit_get_reserved(const xroad_money_limit_t* obj);
 
void xroad_money_limit_reset_reserved(xroad_money_limit_t* obj);
 
bool xroad_money_limit_reserved_is_set(const xroad_money_limit_t* obj);
 
xroad_errno_t xroad_money_limit_set_leverage(xroad_money_limit_t* obj, xroad_double_t val);
 
xroad_double_t xroad_money_limit_get_leverage(const xroad_money_limit_t* obj);
 
void xroad_money_limit_reset_leverage(xroad_money_limit_t* obj);
 
bool xroad_money_limit_leverage_is_set(const xroad_money_limit_t* obj);
 
xroad_errno_t xroad_money_limit_set_currency(xroad_money_limit_t* obj, void* ref);
 
xroad_errno_t xroad_money_limit_set_currency_ref(xroad_money_limit_t* obj, xroad_object_ref_t ref);
 
void* xroad_money_limit_get_currency(const xroad_money_limit_t* obj);
 
xroad_object_ref_t xroad_money_limit_get_currency_ref(const xroad_money_limit_t* obj);
 
void xroad_money_limit_reset_currency(xroad_money_limit_t* obj);
 
bool xroad_money_limit_currency_is_set(const xroad_money_limit_t* obj);
 
xroad_errno_t xroad_money_limit_set_level1(xroad_money_limit_t* obj, xroad_double_t val);
 
xroad_double_t xroad_money_limit_get_level1(const xroad_money_limit_t* obj);
 
void xroad_money_limit_reset_level1(xroad_money_limit_t* obj);
 
bool xroad_money_limit_level1_is_set(const xroad_money_limit_t* obj);
 
xroad_errno_t xroad_money_limit_set_level2(xroad_money_limit_t* obj, xroad_double_t val);
 
xroad_double_t xroad_money_limit_get_level2(const xroad_money_limit_t* obj);
 
void xroad_money_limit_reset_level2(xroad_money_limit_t* obj);
 
bool xroad_money_limit_level2_is_set(const xroad_money_limit_t* obj);
 
xroad_errno_t xroad_money_limit_set_account(xroad_money_limit_t* obj, xroad_str_t val);
 
xroad_str_t xroad_money_limit_get_account(const xroad_money_limit_t* obj);
 
void xroad_money_limit_reset_account(xroad_money_limit_t* obj);
 
bool xroad_money_limit_account_is_set(const xroad_money_limit_t* obj);
 
xroad_errno_t xroad_money_limit_set_client_code(xroad_money_limit_t* obj, xroad_str_t val);
 
xroad_str_t xroad_money_limit_get_client_code(const xroad_money_limit_t* obj);
 
void xroad_money_limit_reset_client_code(xroad_money_limit_t* obj);
 
bool xroad_money_limit_client_code_is_set(const xroad_money_limit_t* obj);
 
xroad_errno_t xroad_money_limit_send(xroad_money_limit_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_money_limit_route(xroad_money_limit_t* obj, ...);
 
void xroad_money_limit_reset(xroad_money_limit_t* obj);
 
xroad_money_limit_t* xroad_money_limit_clone(const xroad_money_limit_t* obj);
 
bool xroad_money_limit_is_valid(const xroad_money_limit_t* obj);
 
int32_t xroad_money_limit_print(const xroad_money_limit_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_money_limit_calc_hash(const xroad_money_limit_t* obj);
 
xroad_str_t xroad_money_limit_calc_uniq_id(const xroad_money_limit_t* obj);
 
 
 
/* xroad_order_limit_t */
 
xroad_object_id_t xroad_order_limit_get_id(const xroad_order_limit_t* obj);
 
xroad_object_ref_t xroad_order_limit_get_ref(const xroad_order_limit_t* obj);
 
xroad_errno_t xroad_order_limit_set_order(xroad_order_limit_t* obj, void* ref);
 
xroad_errno_t xroad_order_limit_set_order_ref(xroad_order_limit_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_limit_get_order(const xroad_order_limit_t* obj);
 
xroad_object_ref_t xroad_order_limit_get_order_ref(const xroad_order_limit_t* obj);
 
void xroad_order_limit_reset_order(xroad_order_limit_t* obj);
 
bool xroad_order_limit_order_is_set(const xroad_order_limit_t* obj);
 
xroad_errno_t xroad_order_limit_set_money_limit(xroad_order_limit_t* obj, void* ref);
 
xroad_errno_t xroad_order_limit_set_money_limit_ref(xroad_order_limit_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_limit_get_money_limit(const xroad_order_limit_t* obj);
 
xroad_object_ref_t xroad_order_limit_get_money_limit_ref(const xroad_order_limit_t* obj);
 
void xroad_order_limit_reset_money_limit(xroad_order_limit_t* obj);
 
bool xroad_order_limit_money_limit_is_set(const xroad_order_limit_t* obj);
 
xroad_errno_t xroad_order_limit_set_price(xroad_order_limit_t* obj, xroad_price_t val);
 
xroad_price_t xroad_order_limit_get_price(const xroad_order_limit_t* obj);
 
void xroad_order_limit_reset_price(xroad_order_limit_t* obj);
 
bool xroad_order_limit_price_is_set(const xroad_order_limit_t* obj);
 
xroad_errno_t xroad_order_limit_set_qty(xroad_order_limit_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_order_limit_get_qty(const xroad_order_limit_t* obj);
 
void xroad_order_limit_reset_qty(xroad_order_limit_t* obj);
 
bool xroad_order_limit_qty_is_set(const xroad_order_limit_t* obj);
 
xroad_errno_t xroad_order_limit_set_cur(xroad_order_limit_t* obj, void* ref);
 
xroad_errno_t xroad_order_limit_set_cur_ref(xroad_order_limit_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_limit_get_cur(const xroad_order_limit_t* obj);
 
xroad_object_ref_t xroad_order_limit_get_cur_ref(const xroad_order_limit_t* obj);
 
void xroad_order_limit_reset_cur(xroad_order_limit_t* obj);
 
bool xroad_order_limit_cur_is_set(const xroad_order_limit_t* obj);
 
xroad_errno_t xroad_order_limit_set_cur_divide(xroad_order_limit_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_order_limit_get_cur_divide(const xroad_order_limit_t* obj);
 
void xroad_order_limit_reset_cur_divide(xroad_order_limit_t* obj);
 
bool xroad_order_limit_cur_divide_is_set(const xroad_order_limit_t* obj);
 
xroad_errno_t xroad_order_limit_set_cur_rate(xroad_order_limit_t* obj, xroad_double_t val);
 
xroad_double_t xroad_order_limit_get_cur_rate(const xroad_order_limit_t* obj);
 
void xroad_order_limit_reset_cur_rate(xroad_order_limit_t* obj);
 
bool xroad_order_limit_cur_rate_is_set(const xroad_order_limit_t* obj);
 
xroad_errno_t xroad_order_limit_set_reserved(xroad_order_limit_t* obj, xroad_double_t val);
 
xroad_double_t xroad_order_limit_get_reserved(const xroad_order_limit_t* obj);
 
void xroad_order_limit_reset_reserved(xroad_order_limit_t* obj);
 
bool xroad_order_limit_reserved_is_set(const xroad_order_limit_t* obj);
 
xroad_errno_t xroad_order_limit_set_discount(xroad_order_limit_t* obj, xroad_double_t val);
 
xroad_double_t xroad_order_limit_get_discount(const xroad_order_limit_t* obj);
 
void xroad_order_limit_reset_discount(xroad_order_limit_t* obj);
 
bool xroad_order_limit_discount_is_set(const xroad_order_limit_t* obj);
 
xroad_errno_t xroad_order_limit_set_delta(xroad_order_limit_t* obj, xroad_double_t val);
 
xroad_double_t xroad_order_limit_get_delta(const xroad_order_limit_t* obj);
 
void xroad_order_limit_reset_delta(xroad_order_limit_t* obj);
 
bool xroad_order_limit_delta_is_set(const xroad_order_limit_t* obj);
 
xroad_errno_t xroad_order_limit_set_replace(xroad_order_limit_t* obj, void* ref);
 
xroad_errno_t xroad_order_limit_set_replace_ref(xroad_order_limit_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_limit_get_replace(const xroad_order_limit_t* obj);
 
xroad_object_ref_t xroad_order_limit_get_replace_ref(const xroad_order_limit_t* obj);
 
void xroad_order_limit_reset_replace(xroad_order_limit_t* obj);
 
bool xroad_order_limit_replace_is_set(const xroad_order_limit_t* obj);
 
xroad_errno_t xroad_order_limit_send(xroad_order_limit_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_order_limit_route(xroad_order_limit_t* obj, ...);
 
void xroad_order_limit_reset(xroad_order_limit_t* obj);
 
xroad_order_limit_t* xroad_order_limit_clone(const xroad_order_limit_t* obj);
 
bool xroad_order_limit_is_valid(const xroad_order_limit_t* obj);
 
int32_t xroad_order_limit_print(const xroad_order_limit_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_order_limit_calc_hash(const xroad_order_limit_t* obj);
 
xroad_str_t xroad_order_limit_calc_uniq_id(const xroad_order_limit_t* obj);
 
 
 
/* xroad_security_short_t */
 
xroad_object_id_t xroad_security_short_get_id(const xroad_security_short_t* obj);
 
xroad_object_ref_t xroad_security_short_get_ref(const xroad_security_short_t* obj);
 
xroad_errno_t xroad_security_short_set_deleted(xroad_security_short_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_security_short_get_deleted(const xroad_security_short_t* obj);
 
void xroad_security_short_reset_deleted(xroad_security_short_t* obj);
 
bool xroad_security_short_deleted_is_set(const xroad_security_short_t* obj);
 
xroad_errno_t xroad_security_short_set_node_id(xroad_security_short_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_security_short_get_node_id(const xroad_security_short_t* obj);
 
void xroad_security_short_reset_node_id(xroad_security_short_t* obj);
 
bool xroad_security_short_node_id_is_set(const xroad_security_short_t* obj);
 
xroad_errno_t xroad_security_short_set_limit_id(xroad_security_short_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_security_short_get_limit_id(const xroad_security_short_t* obj);
 
void xroad_security_short_reset_limit_id(xroad_security_short_t* obj);
 
bool xroad_security_short_limit_id_is_set(const xroad_security_short_t* obj);
 
xroad_errno_t xroad_security_short_set_instr(xroad_security_short_t* obj, void* ref);
 
xroad_errno_t xroad_security_short_set_instr_ref(xroad_security_short_t* obj, xroad_object_ref_t ref);
 
void* xroad_security_short_get_instr(const xroad_security_short_t* obj);
 
xroad_object_ref_t xroad_security_short_get_instr_ref(const xroad_security_short_t* obj);
 
void xroad_security_short_reset_instr(xroad_security_short_t* obj);
 
bool xroad_security_short_instr_is_set(const xroad_security_short_t* obj);
 
xroad_errno_t xroad_security_short_set_initial(xroad_security_short_t* obj, xroad_double_t val);
 
xroad_double_t xroad_security_short_get_initial(const xroad_security_short_t* obj);
 
void xroad_security_short_reset_initial(xroad_security_short_t* obj);
 
bool xroad_security_short_initial_is_set(const xroad_security_short_t* obj);
 
xroad_errno_t xroad_security_short_set_leverage(xroad_security_short_t* obj, xroad_double_t val);
 
xroad_double_t xroad_security_short_get_leverage(const xroad_security_short_t* obj);
 
void xroad_security_short_reset_leverage(xroad_security_short_t* obj);
 
bool xroad_security_short_leverage_is_set(const xroad_security_short_t* obj);
 
xroad_errno_t xroad_security_short_set_current(xroad_security_short_t* obj, xroad_double_t val);
 
xroad_double_t xroad_security_short_get_current(const xroad_security_short_t* obj);
 
void xroad_security_short_reset_current(xroad_security_short_t* obj);
 
bool xroad_security_short_current_is_set(const xroad_security_short_t* obj);
 
xroad_errno_t xroad_security_short_set_level1(xroad_security_short_t* obj, xroad_double_t val);
 
xroad_double_t xroad_security_short_get_level1(const xroad_security_short_t* obj);
 
void xroad_security_short_reset_level1(xroad_security_short_t* obj);
 
bool xroad_security_short_level1_is_set(const xroad_security_short_t* obj);
 
xroad_errno_t xroad_security_short_set_level2(xroad_security_short_t* obj, xroad_double_t val);
 
xroad_double_t xroad_security_short_get_level2(const xroad_security_short_t* obj);
 
void xroad_security_short_reset_level2(xroad_security_short_t* obj);
 
bool xroad_security_short_level2_is_set(const xroad_security_short_t* obj);
 
xroad_errno_t xroad_security_short_set_last_trade(xroad_security_short_t* obj, void* ref);
 
xroad_errno_t xroad_security_short_set_last_trade_ref(xroad_security_short_t* obj, xroad_object_ref_t ref);
 
void* xroad_security_short_get_last_trade(const xroad_security_short_t* obj);
 
xroad_object_ref_t xroad_security_short_get_last_trade_ref(const xroad_security_short_t* obj);
 
void xroad_security_short_reset_last_trade(xroad_security_short_t* obj);
 
bool xroad_security_short_last_trade_is_set(const xroad_security_short_t* obj);
 
xroad_errno_t xroad_security_short_send(xroad_security_short_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_security_short_route(xroad_security_short_t* obj, ...);
 
void xroad_security_short_reset(xroad_security_short_t* obj);
 
xroad_security_short_t* xroad_security_short_clone(const xroad_security_short_t* obj);
 
bool xroad_security_short_is_valid(const xroad_security_short_t* obj);
 
int32_t xroad_security_short_print(const xroad_security_short_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_security_short_calc_hash(const xroad_security_short_t* obj);
 
xroad_str_t xroad_security_short_calc_uniq_id(const xroad_security_short_t* obj);
 
 
 
/* xroad_client_short_t */
 
xroad_object_id_t xroad_client_short_get_id(const xroad_client_short_t* obj);
 
xroad_object_ref_t xroad_client_short_get_ref(const xroad_client_short_t* obj);
 
xroad_errno_t xroad_client_short_set_deleted(xroad_client_short_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_client_short_get_deleted(const xroad_client_short_t* obj);
 
void xroad_client_short_reset_deleted(xroad_client_short_t* obj);
 
bool xroad_client_short_deleted_is_set(const xroad_client_short_t* obj);
 
xroad_errno_t xroad_client_short_set_node_id(xroad_client_short_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_client_short_get_node_id(const xroad_client_short_t* obj);
 
void xroad_client_short_reset_node_id(xroad_client_short_t* obj);
 
bool xroad_client_short_node_id_is_set(const xroad_client_short_t* obj);
 
xroad_errno_t xroad_client_short_set_limit_id(xroad_client_short_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_client_short_get_limit_id(const xroad_client_short_t* obj);
 
void xroad_client_short_reset_limit_id(xroad_client_short_t* obj);
 
bool xroad_client_short_limit_id_is_set(const xroad_client_short_t* obj);
 
xroad_errno_t xroad_client_short_set_instr(xroad_client_short_t* obj, void* ref);
 
xroad_errno_t xroad_client_short_set_instr_ref(xroad_client_short_t* obj, xroad_object_ref_t ref);
 
void* xroad_client_short_get_instr(const xroad_client_short_t* obj);
 
xroad_object_ref_t xroad_client_short_get_instr_ref(const xroad_client_short_t* obj);
 
void xroad_client_short_reset_instr(xroad_client_short_t* obj);
 
bool xroad_client_short_instr_is_set(const xroad_client_short_t* obj);
 
xroad_errno_t xroad_client_short_set_client_name(xroad_client_short_t* obj, xroad_str_t val);
 
xroad_str_t xroad_client_short_get_client_name(const xroad_client_short_t* obj);
 
void xroad_client_short_reset_client_name(xroad_client_short_t* obj);
 
bool xroad_client_short_client_name_is_set(const xroad_client_short_t* obj);
 
xroad_errno_t xroad_client_short_set_initial(xroad_client_short_t* obj, xroad_double_t val);
 
xroad_double_t xroad_client_short_get_initial(const xroad_client_short_t* obj);
 
void xroad_client_short_reset_initial(xroad_client_short_t* obj);
 
bool xroad_client_short_initial_is_set(const xroad_client_short_t* obj);
 
xroad_errno_t xroad_client_short_set_leverage(xroad_client_short_t* obj, xroad_double_t val);
 
xroad_double_t xroad_client_short_get_leverage(const xroad_client_short_t* obj);
 
void xroad_client_short_reset_leverage(xroad_client_short_t* obj);
 
bool xroad_client_short_leverage_is_set(const xroad_client_short_t* obj);
 
xroad_errno_t xroad_client_short_set_current(xroad_client_short_t* obj, xroad_double_t val);
 
xroad_double_t xroad_client_short_get_current(const xroad_client_short_t* obj);
 
void xroad_client_short_reset_current(xroad_client_short_t* obj);
 
bool xroad_client_short_current_is_set(const xroad_client_short_t* obj);
 
xroad_errno_t xroad_client_short_set_level1(xroad_client_short_t* obj, xroad_double_t val);
 
xroad_double_t xroad_client_short_get_level1(const xroad_client_short_t* obj);
 
void xroad_client_short_reset_level1(xroad_client_short_t* obj);
 
bool xroad_client_short_level1_is_set(const xroad_client_short_t* obj);
 
xroad_errno_t xroad_client_short_set_level2(xroad_client_short_t* obj, xroad_double_t val);
 
xroad_double_t xroad_client_short_get_level2(const xroad_client_short_t* obj);
 
void xroad_client_short_reset_level2(xroad_client_short_t* obj);
 
bool xroad_client_short_level2_is_set(const xroad_client_short_t* obj);
 
xroad_errno_t xroad_client_short_set_last_trade(xroad_client_short_t* obj, void* ref);
 
xroad_errno_t xroad_client_short_set_last_trade_ref(xroad_client_short_t* obj, xroad_object_ref_t ref);
 
void* xroad_client_short_get_last_trade(const xroad_client_short_t* obj);
 
xroad_object_ref_t xroad_client_short_get_last_trade_ref(const xroad_client_short_t* obj);
 
void xroad_client_short_reset_last_trade(xroad_client_short_t* obj);
 
bool xroad_client_short_last_trade_is_set(const xroad_client_short_t* obj);
 
xroad_errno_t xroad_client_short_send(xroad_client_short_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_client_short_route(xroad_client_short_t* obj, ...);
 
void xroad_client_short_reset(xroad_client_short_t* obj);
 
xroad_client_short_t* xroad_client_short_clone(const xroad_client_short_t* obj);
 
bool xroad_client_short_is_valid(const xroad_client_short_t* obj);
 
int32_t xroad_client_short_print(const xroad_client_short_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_client_short_calc_hash(const xroad_client_short_t* obj);
 
xroad_str_t xroad_client_short_calc_uniq_id(const xroad_client_short_t* obj);
 
 
 
/* xroad_opt_mm_t */
 
xroad_object_id_t xroad_opt_mm_get_id(const xroad_opt_mm_t* obj);
 
xroad_object_ref_t xroad_opt_mm_get_ref(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_deleted(xroad_opt_mm_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_opt_mm_get_deleted(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_deleted(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_deleted_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_node_id(xroad_opt_mm_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_opt_mm_get_node_id(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_node_id(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_node_id_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_instr(xroad_opt_mm_t* obj, void* ref);
 
xroad_errno_t xroad_opt_mm_set_instr_ref(xroad_opt_mm_t* obj, xroad_object_ref_t ref);
 
void* xroad_opt_mm_get_instr(const xroad_opt_mm_t* obj);
 
xroad_object_ref_t xroad_opt_mm_get_instr_ref(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_instr(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_instr_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_enabled(xroad_opt_mm_t* obj, xroad_int8_t val);
 
xroad_int8_t xroad_opt_mm_get_enabled(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_enabled(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_enabled_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_bid_enabled(xroad_opt_mm_t* obj, xroad_int8_t val);
 
xroad_int8_t xroad_opt_mm_get_bid_enabled(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_bid_enabled(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_bid_enabled_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_bid_state(xroad_opt_mm_t* obj, xroad_opt_mm_state_t val);
 
xroad_opt_mm_state_t xroad_opt_mm_get_bid_state(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_bid_state(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_bid_state_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_ask_enabled(xroad_opt_mm_t* obj, xroad_int8_t val);
 
xroad_int8_t xroad_opt_mm_get_ask_enabled(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_ask_enabled(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_ask_enabled_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_ask_state(xroad_opt_mm_t* obj, xroad_opt_mm_state_t val);
 
xroad_opt_mm_state_t xroad_opt_mm_get_ask_state(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_ask_state(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_ask_state_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_premium(xroad_opt_mm_t* obj, xroad_price_t val);
 
xroad_price_t xroad_opt_mm_get_premium(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_premium(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_premium_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_delta(xroad_opt_mm_t* obj, xroad_double_t val);
 
xroad_double_t xroad_opt_mm_get_delta(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_delta(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_delta_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_volatility(xroad_opt_mm_t* obj, xroad_double_t val);
 
xroad_double_t xroad_opt_mm_get_volatility(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_volatility(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_volatility_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_rate(xroad_opt_mm_t* obj, xroad_double_t val);
 
xroad_double_t xroad_opt_mm_get_rate(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_rate(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_rate_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_time_rate(xroad_opt_mm_t* obj, xroad_double_t val);
 
xroad_double_t xroad_opt_mm_get_time_rate(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_time_rate(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_time_rate_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_fut_mid_price(xroad_opt_mm_t* obj, xroad_price_t val);
 
xroad_price_t xroad_opt_mm_get_fut_mid_price(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_fut_mid_price(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_fut_mid_price_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_mid_price(xroad_opt_mm_t* obj, xroad_price_t val);
 
xroad_price_t xroad_opt_mm_get_mid_price(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_mid_price(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_mid_price_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_bid_size(xroad_opt_mm_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_opt_mm_get_bid_size(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_bid_size(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_bid_size_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_ask_size(xroad_opt_mm_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_opt_mm_get_ask_size(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_ask_size(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_ask_size_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_lower(xroad_opt_mm_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_opt_mm_get_lower(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_lower(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_lower_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_higher(xroad_opt_mm_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_opt_mm_get_higher(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_higher(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_higher_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_position(xroad_opt_mm_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_opt_mm_get_position(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_position(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_position_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_pos_keep(xroad_opt_mm_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_opt_mm_get_pos_keep(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_pos_keep(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_pos_keep_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_bid_spread(xroad_opt_mm_t* obj, xroad_price_t val);
 
xroad_price_t xroad_opt_mm_get_bid_spread(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_bid_spread(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_bid_spread_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_ask_spread(xroad_opt_mm_t* obj, xroad_price_t val);
 
xroad_price_t xroad_opt_mm_get_ask_spread(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_ask_spread(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_ask_spread_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_sensitivity(xroad_opt_mm_t* obj, xroad_price_t val);
 
xroad_price_t xroad_opt_mm_get_sensitivity(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_sensitivity(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_sensitivity_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_shift(xroad_opt_mm_t* obj, xroad_double_t val);
 
xroad_double_t xroad_opt_mm_get_shift(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_shift(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_shift_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_shift_vol(xroad_opt_mm_t* obj, xroad_double_t val);
 
xroad_double_t xroad_opt_mm_get_shift_vol(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_shift_vol(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_shift_vol_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_calc_mid(xroad_opt_mm_t* obj, xroad_calc_mid_t val);
 
xroad_calc_mid_t xroad_opt_mm_get_calc_mid(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_calc_mid(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_calc_mid_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_bid_text(xroad_opt_mm_t* obj, xroad_str_t val);
 
xroad_str_t xroad_opt_mm_get_bid_text(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_bid_text(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_bid_text_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_set_ask_text(xroad_opt_mm_t* obj, xroad_str_t val);
 
xroad_str_t xroad_opt_mm_get_ask_text(const xroad_opt_mm_t* obj);
 
void xroad_opt_mm_reset_ask_text(xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_ask_text_is_set(const xroad_opt_mm_t* obj);
 
xroad_errno_t xroad_opt_mm_send(xroad_opt_mm_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_opt_mm_route(xroad_opt_mm_t* obj, ...);
 
void xroad_opt_mm_reset(xroad_opt_mm_t* obj);
 
xroad_opt_mm_t* xroad_opt_mm_clone(const xroad_opt_mm_t* obj);
 
bool xroad_opt_mm_is_valid(const xroad_opt_mm_t* obj);
 
int32_t xroad_opt_mm_print(const xroad_opt_mm_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_opt_mm_calc_hash(const xroad_opt_mm_t* obj);
 
xroad_str_t xroad_opt_mm_calc_uniq_id(const xroad_opt_mm_t* obj);
 
 
 
/* xroad_field_t */
 
xroad_object_id_t xroad_field_get_id(const xroad_field_t* obj);
 
xroad_object_ref_t xroad_field_get_ref(const xroad_field_t* obj);
 
xroad_errno_t xroad_field_set_deleted(xroad_field_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_field_get_deleted(const xroad_field_t* obj);
 
void xroad_field_reset_deleted(xroad_field_t* obj);
 
bool xroad_field_deleted_is_set(const xroad_field_t* obj);
 
xroad_errno_t xroad_field_set_node_id(xroad_field_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_field_get_node_id(const xroad_field_t* obj);
 
void xroad_field_reset_node_id(xroad_field_t* obj);
 
bool xroad_field_node_id_is_set(const xroad_field_t* obj);
 
xroad_errno_t xroad_field_set_name(xroad_field_t* obj, xroad_str_t val);
 
xroad_str_t xroad_field_get_name(const xroad_field_t* obj);
 
void xroad_field_reset_name(xroad_field_t* obj);
 
bool xroad_field_name_is_set(const xroad_field_t* obj);
 
xroad_errno_t xroad_field_set_type(xroad_field_t* obj, xroad_field_type_t val);
 
xroad_field_type_t xroad_field_get_type(const xroad_field_t* obj);
 
void xroad_field_reset_type(xroad_field_t* obj);
 
bool xroad_field_type_is_set(const xroad_field_t* obj);
 
xroad_errno_t xroad_field_set_value(xroad_field_t* obj, xroad_binary_t val);
 
xroad_binary_t xroad_field_get_value(const xroad_field_t* obj);
 
void xroad_field_reset_value(xroad_field_t* obj);
 
bool xroad_field_value_is_set(const xroad_field_t* obj);
 
xroad_errno_t xroad_field_send(xroad_field_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_field_route(xroad_field_t* obj, ...);
 
void xroad_field_reset(xroad_field_t* obj);
 
xroad_field_t* xroad_field_clone(const xroad_field_t* obj);
 
bool xroad_field_is_valid(const xroad_field_t* obj);
 
int32_t xroad_field_print(const xroad_field_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_field_calc_hash(const xroad_field_t* obj);
 
xroad_str_t xroad_field_calc_uniq_id(const xroad_field_t* obj);
 
 
 
/* xroad_prop_t */
 
xroad_object_id_t xroad_prop_get_id(const xroad_prop_t* obj);
 
xroad_object_ref_t xroad_prop_get_ref(const xroad_prop_t* obj);
 
xroad_errno_t xroad_prop_set_node_id(xroad_prop_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_prop_get_node_id(const xroad_prop_t* obj);
 
void xroad_prop_reset_node_id(xroad_prop_t* obj);
 
bool xroad_prop_node_id_is_set(const xroad_prop_t* obj);
 
xroad_errno_t xroad_prop_set_parent(xroad_prop_t* obj, void* ref);
 
xroad_errno_t xroad_prop_set_parent_ref(xroad_prop_t* obj, xroad_object_ref_t ref);
 
void* xroad_prop_get_parent(const xroad_prop_t* obj);
 
xroad_object_ref_t xroad_prop_get_parent_ref(const xroad_prop_t* obj);
 
void xroad_prop_reset_parent(xroad_prop_t* obj);
 
bool xroad_prop_parent_is_set(const xroad_prop_t* obj);
 
xroad_errno_t xroad_prop_set_name(xroad_prop_t* obj, xroad_str_t val);
 
xroad_str_t xroad_prop_get_name(const xroad_prop_t* obj);
 
void xroad_prop_reset_name(xroad_prop_t* obj);
 
bool xroad_prop_name_is_set(const xroad_prop_t* obj);
 
xroad_errno_t xroad_prop_set_type(xroad_prop_t* obj, xroad_prop_type_t val);
 
xroad_prop_type_t xroad_prop_get_type(const xroad_prop_t* obj);
 
void xroad_prop_reset_type(xroad_prop_t* obj);
 
bool xroad_prop_type_is_set(const xroad_prop_t* obj);
 
xroad_errno_t xroad_prop_set_value(xroad_prop_t* obj, xroad_binary_t val);
 
xroad_binary_t xroad_prop_get_value(const xroad_prop_t* obj);
 
void xroad_prop_reset_value(xroad_prop_t* obj);
 
bool xroad_prop_value_is_set(const xroad_prop_t* obj);
 
xroad_errno_t xroad_prop_set_linked(xroad_prop_t* obj, xroad_binary_t val);
 
xroad_binary_t xroad_prop_get_linked(const xroad_prop_t* obj);
 
void xroad_prop_reset_linked(xroad_prop_t* obj);
 
bool xroad_prop_linked_is_set(const xroad_prop_t* obj);
 
xroad_errno_t xroad_prop_set_link(xroad_prop_t* obj, void* ref);
 
xroad_errno_t xroad_prop_set_link_ref(xroad_prop_t* obj, xroad_object_ref_t ref);
 
void* xroad_prop_get_link(const xroad_prop_t* obj);
 
xroad_object_ref_t xroad_prop_get_link_ref(const xroad_prop_t* obj);
 
void xroad_prop_reset_link(xroad_prop_t* obj);
 
bool xroad_prop_link_is_set(const xroad_prop_t* obj);
 
xroad_errno_t xroad_prop_set_flags(xroad_prop_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_prop_get_flags(const xroad_prop_t* obj);
 
void xroad_prop_reset_flags(xroad_prop_t* obj);
 
bool xroad_prop_flags_is_set(const xroad_prop_t* obj);
 
xroad_errno_t xroad_prop_send(xroad_prop_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_prop_route(xroad_prop_t* obj, ...);
 
void xroad_prop_reset(xroad_prop_t* obj);
 
xroad_prop_t* xroad_prop_clone(const xroad_prop_t* obj);
 
bool xroad_prop_is_valid(const xroad_prop_t* obj);
 
int32_t xroad_prop_print(const xroad_prop_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_prop_calc_hash(const xroad_prop_t* obj);
 
xroad_str_t xroad_prop_calc_uniq_id(const xroad_prop_t* obj);
 
 
 
/* xroad_prop_row_t */
 
xroad_object_id_t xroad_prop_row_get_id(const xroad_prop_row_t* obj);
 
xroad_object_ref_t xroad_prop_row_get_ref(const xroad_prop_row_t* obj);
 
xroad_errno_t xroad_prop_row_set_node_id(xroad_prop_row_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_prop_row_get_node_id(const xroad_prop_row_t* obj);
 
void xroad_prop_row_reset_node_id(xroad_prop_row_t* obj);
 
bool xroad_prop_row_node_id_is_set(const xroad_prop_row_t* obj);
 
xroad_errno_t xroad_prop_row_set_deleted(xroad_prop_row_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_prop_row_get_deleted(const xroad_prop_row_t* obj);
 
void xroad_prop_row_reset_deleted(xroad_prop_row_t* obj);
 
bool xroad_prop_row_deleted_is_set(const xroad_prop_row_t* obj);
 
xroad_errno_t xroad_prop_row_set_parent(xroad_prop_row_t* obj, void* ref);
 
xroad_errno_t xroad_prop_row_set_parent_ref(xroad_prop_row_t* obj, xroad_object_ref_t ref);
 
void* xroad_prop_row_get_parent(const xroad_prop_row_t* obj);
 
xroad_object_ref_t xroad_prop_row_get_parent_ref(const xroad_prop_row_t* obj);
 
void xroad_prop_row_reset_parent(xroad_prop_row_t* obj);
 
bool xroad_prop_row_parent_is_set(const xroad_prop_row_t* obj);
 
xroad_errno_t xroad_prop_row_set_children(xroad_prop_row_t* obj, xroad_binary_t val);
 
xroad_binary_t xroad_prop_row_get_children(const xroad_prop_row_t* obj);
 
void xroad_prop_row_reset_children(xroad_prop_row_t* obj);
 
bool xroad_prop_row_children_is_set(const xroad_prop_row_t* obj);
 
xroad_errno_t xroad_prop_row_send(xroad_prop_row_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_prop_row_route(xroad_prop_row_t* obj, ...);
 
void xroad_prop_row_reset(xroad_prop_row_t* obj);
 
xroad_prop_row_t* xroad_prop_row_clone(const xroad_prop_row_t* obj);
 
bool xroad_prop_row_is_valid(const xroad_prop_row_t* obj);
 
int32_t xroad_prop_row_print(const xroad_prop_row_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_prop_row_calc_hash(const xroad_prop_row_t* obj);
 
xroad_str_t xroad_prop_row_calc_uniq_id(const xroad_prop_row_t* obj);
 
 
 
/* xroad_mmaker_t */
 
xroad_object_id_t xroad_mmaker_get_id(const xroad_mmaker_t* obj);
 
xroad_object_ref_t xroad_mmaker_get_ref(const xroad_mmaker_t* obj);
 
xroad_errno_t xroad_mmaker_set_node_id(xroad_mmaker_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_mmaker_get_node_id(const xroad_mmaker_t* obj);
 
void xroad_mmaker_reset_node_id(xroad_mmaker_t* obj);
 
bool xroad_mmaker_node_id_is_set(const xroad_mmaker_t* obj);
 
xroad_errno_t xroad_mmaker_set_start_ts(xroad_mmaker_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_mmaker_get_start_ts(const xroad_mmaker_t* obj);
 
void xroad_mmaker_reset_start_ts(xroad_mmaker_t* obj);
 
bool xroad_mmaker_start_ts_is_set(const xroad_mmaker_t* obj);
 
xroad_errno_t xroad_mmaker_set_instr(xroad_mmaker_t* obj, void* ref);
 
xroad_errno_t xroad_mmaker_set_instr_ref(xroad_mmaker_t* obj, xroad_object_ref_t ref);
 
void* xroad_mmaker_get_instr(const xroad_mmaker_t* obj);
 
xroad_object_ref_t xroad_mmaker_get_instr_ref(const xroad_mmaker_t* obj);
 
void xroad_mmaker_reset_instr(xroad_mmaker_t* obj);
 
bool xroad_mmaker_instr_is_set(const xroad_mmaker_t* obj);
 
xroad_errno_t xroad_mmaker_set_autostart(xroad_mmaker_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_mmaker_get_autostart(const xroad_mmaker_t* obj);
 
void xroad_mmaker_reset_autostart(xroad_mmaker_t* obj);
 
bool xroad_mmaker_autostart_is_set(const xroad_mmaker_t* obj);
 
xroad_errno_t xroad_mmaker_set_active_side(xroad_mmaker_t* obj, xroad_side_t val);
 
xroad_side_t xroad_mmaker_get_active_side(const xroad_mmaker_t* obj);
 
void xroad_mmaker_reset_active_side(xroad_mmaker_t* obj);
 
bool xroad_mmaker_active_side_is_set(const xroad_mmaker_t* obj);
 
xroad_errno_t xroad_mmaker_set_best_bid(xroad_mmaker_t* obj, xroad_price_t val);
 
xroad_price_t xroad_mmaker_get_best_bid(const xroad_mmaker_t* obj);
 
void xroad_mmaker_reset_best_bid(xroad_mmaker_t* obj);
 
bool xroad_mmaker_best_bid_is_set(const xroad_mmaker_t* obj);
 
xroad_errno_t xroad_mmaker_set_last_trade(xroad_mmaker_t* obj, xroad_side_t val);
 
xroad_side_t xroad_mmaker_get_last_trade(const xroad_mmaker_t* obj);
 
void xroad_mmaker_reset_last_trade(xroad_mmaker_t* obj);
 
bool xroad_mmaker_last_trade_is_set(const xroad_mmaker_t* obj);
 
xroad_errno_t xroad_mmaker_set_total_buy(xroad_mmaker_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_mmaker_get_total_buy(const xroad_mmaker_t* obj);
 
void xroad_mmaker_reset_total_buy(xroad_mmaker_t* obj);
 
bool xroad_mmaker_total_buy_is_set(const xroad_mmaker_t* obj);
 
xroad_errno_t xroad_mmaker_set_total_sell(xroad_mmaker_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_mmaker_get_total_sell(const xroad_mmaker_t* obj);
 
void xroad_mmaker_reset_total_sell(xroad_mmaker_t* obj);
 
bool xroad_mmaker_total_sell_is_set(const xroad_mmaker_t* obj);
 
xroad_errno_t xroad_mmaker_set_bids(xroad_mmaker_t* obj, xroad_binary_t val);
 
xroad_binary_t xroad_mmaker_get_bids(const xroad_mmaker_t* obj);
 
void xroad_mmaker_reset_bids(xroad_mmaker_t* obj);
 
bool xroad_mmaker_bids_is_set(const xroad_mmaker_t* obj);
 
xroad_errno_t xroad_mmaker_set_asks(xroad_mmaker_t* obj, xroad_binary_t val);
 
xroad_binary_t xroad_mmaker_get_asks(const xroad_mmaker_t* obj);
 
void xroad_mmaker_reset_asks(xroad_mmaker_t* obj);
 
bool xroad_mmaker_asks_is_set(const xroad_mmaker_t* obj);
 
xroad_errno_t xroad_mmaker_send(xroad_mmaker_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_mmaker_route(xroad_mmaker_t* obj, ...);
 
void xroad_mmaker_reset(xroad_mmaker_t* obj);
 
xroad_mmaker_t* xroad_mmaker_clone(const xroad_mmaker_t* obj);
 
bool xroad_mmaker_is_valid(const xroad_mmaker_t* obj);
 
int32_t xroad_mmaker_print(const xroad_mmaker_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_mmaker_calc_hash(const xroad_mmaker_t* obj);
 
xroad_str_t xroad_mmaker_calc_uniq_id(const xroad_mmaker_t* obj);
 
 
 
/* xroad_sniper_t */
 
xroad_object_id_t xroad_sniper_get_id(const xroad_sniper_t* obj);
 
xroad_object_ref_t xroad_sniper_get_ref(const xroad_sniper_t* obj);
 
xroad_errno_t xroad_sniper_send(xroad_sniper_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_sniper_route(xroad_sniper_t* obj, ...);
 
void xroad_sniper_reset(xroad_sniper_t* obj);
 
xroad_sniper_t* xroad_sniper_clone(const xroad_sniper_t* obj);
 
bool xroad_sniper_is_valid(const xroad_sniper_t* obj);
 
int32_t xroad_sniper_print(const xroad_sniper_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_sniper_calc_hash(const xroad_sniper_t* obj);
 
xroad_str_t xroad_sniper_calc_uniq_id(const xroad_sniper_t* obj);
 
 
 
/* xroad_pmaker_t */
 
xroad_object_id_t xroad_pmaker_get_id(const xroad_pmaker_t* obj);
 
xroad_object_ref_t xroad_pmaker_get_ref(const xroad_pmaker_t* obj);
 
xroad_errno_t xroad_pmaker_set_node_id(xroad_pmaker_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_pmaker_get_node_id(const xroad_pmaker_t* obj);
 
void xroad_pmaker_reset_node_id(xroad_pmaker_t* obj);
 
bool xroad_pmaker_node_id_is_set(const xroad_pmaker_t* obj);
 
xroad_errno_t xroad_pmaker_set_start_ts(xroad_pmaker_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_pmaker_get_start_ts(const xroad_pmaker_t* obj);
 
void xroad_pmaker_reset_start_ts(xroad_pmaker_t* obj);
 
bool xroad_pmaker_start_ts_is_set(const xroad_pmaker_t* obj);
 
xroad_errno_t xroad_pmaker_set_instr(xroad_pmaker_t* obj, void* ref);
 
xroad_errno_t xroad_pmaker_set_instr_ref(xroad_pmaker_t* obj, xroad_object_ref_t ref);
 
void* xroad_pmaker_get_instr(const xroad_pmaker_t* obj);
 
xroad_object_ref_t xroad_pmaker_get_instr_ref(const xroad_pmaker_t* obj);
 
void xroad_pmaker_reset_instr(xroad_pmaker_t* obj);
 
bool xroad_pmaker_instr_is_set(const xroad_pmaker_t* obj);
 
xroad_errno_t xroad_pmaker_set_autostart(xroad_pmaker_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_pmaker_get_autostart(const xroad_pmaker_t* obj);
 
void xroad_pmaker_reset_autostart(xroad_pmaker_t* obj);
 
bool xroad_pmaker_autostart_is_set(const xroad_pmaker_t* obj);
 
xroad_errno_t xroad_pmaker_set_active_side(xroad_pmaker_t* obj, xroad_side_t val);
 
xroad_side_t xroad_pmaker_get_active_side(const xroad_pmaker_t* obj);
 
void xroad_pmaker_reset_active_side(xroad_pmaker_t* obj);
 
bool xroad_pmaker_active_side_is_set(const xroad_pmaker_t* obj);
 
xroad_errno_t xroad_pmaker_set_inav(xroad_pmaker_t* obj, xroad_price_t val);
 
xroad_price_t xroad_pmaker_get_inav(const xroad_pmaker_t* obj);
 
void xroad_pmaker_reset_inav(xroad_pmaker_t* obj);
 
bool xroad_pmaker_inav_is_set(const xroad_pmaker_t* obj);
 
xroad_errno_t xroad_pmaker_set_last_trade(xroad_pmaker_t* obj, xroad_side_t val);
 
xroad_side_t xroad_pmaker_get_last_trade(const xroad_pmaker_t* obj);
 
void xroad_pmaker_reset_last_trade(xroad_pmaker_t* obj);
 
bool xroad_pmaker_last_trade_is_set(const xroad_pmaker_t* obj);
 
xroad_errno_t xroad_pmaker_set_total_buy(xroad_pmaker_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_pmaker_get_total_buy(const xroad_pmaker_t* obj);
 
void xroad_pmaker_reset_total_buy(xroad_pmaker_t* obj);
 
bool xroad_pmaker_total_buy_is_set(const xroad_pmaker_t* obj);
 
xroad_errno_t xroad_pmaker_set_total_sell(xroad_pmaker_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_pmaker_get_total_sell(const xroad_pmaker_t* obj);
 
void xroad_pmaker_reset_total_sell(xroad_pmaker_t* obj);
 
bool xroad_pmaker_total_sell_is_set(const xroad_pmaker_t* obj);
 
xroad_errno_t xroad_pmaker_set_total(xroad_pmaker_t* obj, xroad_double_t val);
 
xroad_double_t xroad_pmaker_get_total(const xroad_pmaker_t* obj);
 
void xroad_pmaker_reset_total(xroad_pmaker_t* obj);
 
bool xroad_pmaker_total_is_set(const xroad_pmaker_t* obj);
 
xroad_errno_t xroad_pmaker_set_pos_adjust(xroad_pmaker_t* obj, xroad_int64_t val);
 
xroad_int64_t xroad_pmaker_get_pos_adjust(const xroad_pmaker_t* obj);
 
void xroad_pmaker_reset_pos_adjust(xroad_pmaker_t* obj);
 
bool xroad_pmaker_pos_adjust_is_set(const xroad_pmaker_t* obj);
 
xroad_errno_t xroad_pmaker_set_bids(xroad_pmaker_t* obj, xroad_binary_t val);
 
xroad_binary_t xroad_pmaker_get_bids(const xroad_pmaker_t* obj);
 
void xroad_pmaker_reset_bids(xroad_pmaker_t* obj);
 
bool xroad_pmaker_bids_is_set(const xroad_pmaker_t* obj);
 
xroad_errno_t xroad_pmaker_set_asks(xroad_pmaker_t* obj, xroad_binary_t val);
 
xroad_binary_t xroad_pmaker_get_asks(const xroad_pmaker_t* obj);
 
void xroad_pmaker_reset_asks(xroad_pmaker_t* obj);
 
bool xroad_pmaker_asks_is_set(const xroad_pmaker_t* obj);
 
xroad_errno_t xroad_pmaker_set_prev_mid(xroad_pmaker_t* obj, xroad_price_t val);
 
xroad_price_t xroad_pmaker_get_prev_mid(const xroad_pmaker_t* obj);
 
void xroad_pmaker_reset_prev_mid(xroad_pmaker_t* obj);
 
bool xroad_pmaker_prev_mid_is_set(const xroad_pmaker_t* obj);
 
xroad_errno_t xroad_pmaker_set_mid(xroad_pmaker_t* obj, xroad_price_t val);
 
xroad_price_t xroad_pmaker_get_mid(const xroad_pmaker_t* obj);
 
void xroad_pmaker_reset_mid(xroad_pmaker_t* obj);
 
bool xroad_pmaker_mid_is_set(const xroad_pmaker_t* obj);
 
xroad_errno_t xroad_pmaker_set_spread(xroad_pmaker_t* obj, xroad_double_t val);
 
xroad_double_t xroad_pmaker_get_spread(const xroad_pmaker_t* obj);
 
void xroad_pmaker_reset_spread(xroad_pmaker_t* obj);
 
bool xroad_pmaker_spread_is_set(const xroad_pmaker_t* obj);
 
xroad_errno_t xroad_pmaker_set_stop(xroad_pmaker_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_pmaker_get_stop(const xroad_pmaker_t* obj);
 
void xroad_pmaker_reset_stop(xroad_pmaker_t* obj);
 
bool xroad_pmaker_stop_is_set(const xroad_pmaker_t* obj);
 
xroad_errno_t xroad_pmaker_set_pos_hedge_coef(xroad_pmaker_t* obj, xroad_double_t val);
 
xroad_double_t xroad_pmaker_get_pos_hedge_coef(const xroad_pmaker_t* obj);
 
void xroad_pmaker_reset_pos_hedge_coef(xroad_pmaker_t* obj);
 
bool xroad_pmaker_pos_hedge_coef_is_set(const xroad_pmaker_t* obj);
 
xroad_errno_t xroad_pmaker_send(xroad_pmaker_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_pmaker_route(xroad_pmaker_t* obj, ...);
 
void xroad_pmaker_reset(xroad_pmaker_t* obj);
 
xroad_pmaker_t* xroad_pmaker_clone(const xroad_pmaker_t* obj);
 
bool xroad_pmaker_is_valid(const xroad_pmaker_t* obj);
 
int32_t xroad_pmaker_print(const xroad_pmaker_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_pmaker_calc_hash(const xroad_pmaker_t* obj);
 
xroad_str_t xroad_pmaker_calc_uniq_id(const xroad_pmaker_t* obj);
 
 
 
/* xroad_trd_capt_t */
 
xroad_object_id_t xroad_trd_capt_get_id(const xroad_trd_capt_t* obj);
 
xroad_object_ref_t xroad_trd_capt_get_ref(const xroad_trd_capt_t* obj);
 
xroad_errno_t xroad_trd_capt_set_deleted(xroad_trd_capt_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_trd_capt_get_deleted(const xroad_trd_capt_t* obj);
 
void xroad_trd_capt_reset_deleted(xroad_trd_capt_t* obj);
 
bool xroad_trd_capt_deleted_is_set(const xroad_trd_capt_t* obj);
 
xroad_errno_t xroad_trd_capt_set_node_id(xroad_trd_capt_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_trd_capt_get_node_id(const xroad_trd_capt_t* obj);
 
void xroad_trd_capt_reset_node_id(xroad_trd_capt_t* obj);
 
bool xroad_trd_capt_node_id_is_set(const xroad_trd_capt_t* obj);
 
xroad_errno_t xroad_trd_capt_set_tradeno(xroad_trd_capt_t* obj, xroad_str_t val);
 
xroad_str_t xroad_trd_capt_get_tradeno(const xroad_trd_capt_t* obj);
 
void xroad_trd_capt_reset_tradeno(xroad_trd_capt_t* obj);
 
bool xroad_trd_capt_tradeno_is_set(const xroad_trd_capt_t* obj);
 
xroad_errno_t xroad_trd_capt_set_orderno(xroad_trd_capt_t* obj, xroad_str_t val);
 
xroad_str_t xroad_trd_capt_get_orderno(const xroad_trd_capt_t* obj);
 
void xroad_trd_capt_reset_orderno(xroad_trd_capt_t* obj);
 
bool xroad_trd_capt_orderno_is_set(const xroad_trd_capt_t* obj);
 
xroad_errno_t xroad_trd_capt_set_trade(xroad_trd_capt_t* obj, void* ref);
 
xroad_errno_t xroad_trd_capt_set_trade_ref(xroad_trd_capt_t* obj, xroad_object_ref_t ref);
 
void* xroad_trd_capt_get_trade(const xroad_trd_capt_t* obj);
 
xroad_object_ref_t xroad_trd_capt_get_trade_ref(const xroad_trd_capt_t* obj);
 
void xroad_trd_capt_reset_trade(xroad_trd_capt_t* obj);
 
bool xroad_trd_capt_trade_is_set(const xroad_trd_capt_t* obj);
 
xroad_errno_t xroad_trd_capt_set_instr(xroad_trd_capt_t* obj, void* ref);
 
xroad_errno_t xroad_trd_capt_set_instr_ref(xroad_trd_capt_t* obj, xroad_object_ref_t ref);
 
void* xroad_trd_capt_get_instr(const xroad_trd_capt_t* obj);
 
xroad_object_ref_t xroad_trd_capt_get_instr_ref(const xroad_trd_capt_t* obj);
 
void xroad_trd_capt_reset_instr(xroad_trd_capt_t* obj);
 
bool xroad_trd_capt_instr_is_set(const xroad_trd_capt_t* obj);
 
xroad_errno_t xroad_trd_capt_set_tran_time(xroad_trd_capt_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_trd_capt_get_tran_time(const xroad_trd_capt_t* obj);
 
void xroad_trd_capt_reset_tran_time(xroad_trd_capt_t* obj);
 
bool xroad_trd_capt_tran_time_is_set(const xroad_trd_capt_t* obj);
 
xroad_errno_t xroad_trd_capt_set_side(xroad_trd_capt_t* obj, xroad_side_t val);
 
xroad_side_t xroad_trd_capt_get_side(const xroad_trd_capt_t* obj);
 
void xroad_trd_capt_reset_side(xroad_trd_capt_t* obj);
 
bool xroad_trd_capt_side_is_set(const xroad_trd_capt_t* obj);
 
xroad_errno_t xroad_trd_capt_set_qty(xroad_trd_capt_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_trd_capt_get_qty(const xroad_trd_capt_t* obj);
 
void xroad_trd_capt_reset_qty(xroad_trd_capt_t* obj);
 
bool xroad_trd_capt_qty_is_set(const xroad_trd_capt_t* obj);
 
xroad_errno_t xroad_trd_capt_set_qty_units(xroad_trd_capt_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_trd_capt_get_qty_units(const xroad_trd_capt_t* obj);
 
void xroad_trd_capt_reset_qty_units(xroad_trd_capt_t* obj);
 
bool xroad_trd_capt_qty_units_is_set(const xroad_trd_capt_t* obj);
 
xroad_errno_t xroad_trd_capt_set_price(xroad_trd_capt_t* obj, xroad_price_t val);
 
xroad_price_t xroad_trd_capt_get_price(const xroad_trd_capt_t* obj);
 
void xroad_trd_capt_reset_price(xroad_trd_capt_t* obj);
 
bool xroad_trd_capt_price_is_set(const xroad_trd_capt_t* obj);
 
xroad_errno_t xroad_trd_capt_set_account(xroad_trd_capt_t* obj, xroad_str_t val);
 
xroad_str_t xroad_trd_capt_get_account(const xroad_trd_capt_t* obj);
 
void xroad_trd_capt_reset_account(xroad_trd_capt_t* obj);
 
bool xroad_trd_capt_account_is_set(const xroad_trd_capt_t* obj);
 
xroad_errno_t xroad_trd_capt_set_client_code(xroad_trd_capt_t* obj, xroad_str_t val);
 
xroad_str_t xroad_trd_capt_get_client_code(const xroad_trd_capt_t* obj);
 
void xroad_trd_capt_reset_client_code(xroad_trd_capt_t* obj);
 
bool xroad_trd_capt_client_code_is_set(const xroad_trd_capt_t* obj);
 
xroad_errno_t xroad_trd_capt_set_exch_fee(xroad_trd_capt_t* obj, xroad_double_t val);
 
xroad_double_t xroad_trd_capt_get_exch_fee(const xroad_trd_capt_t* obj);
 
void xroad_trd_capt_reset_exch_fee(xroad_trd_capt_t* obj);
 
bool xroad_trd_capt_exch_fee_is_set(const xroad_trd_capt_t* obj);
 
xroad_errno_t xroad_trd_capt_set_book(xroad_trd_capt_t* obj, xroad_str_t val);
 
xroad_str_t xroad_trd_capt_get_book(const xroad_trd_capt_t* obj);
 
void xroad_trd_capt_reset_book(xroad_trd_capt_t* obj);
 
bool xroad_trd_capt_book_is_set(const xroad_trd_capt_t* obj);
 
xroad_errno_t xroad_trd_capt_set_otc_id(xroad_trd_capt_t* obj, xroad_int64_t val);
 
xroad_int64_t xroad_trd_capt_get_otc_id(const xroad_trd_capt_t* obj);
 
void xroad_trd_capt_reset_otc_id(xroad_trd_capt_t* obj);
 
bool xroad_trd_capt_otc_id_is_set(const xroad_trd_capt_t* obj);
 
xroad_errno_t xroad_trd_capt_set_counterparty(xroad_trd_capt_t* obj, xroad_str_t val);
 
xroad_str_t xroad_trd_capt_get_counterparty(const xroad_trd_capt_t* obj);
 
void xroad_trd_capt_reset_counterparty(xroad_trd_capt_t* obj);
 
bool xroad_trd_capt_counterparty_is_set(const xroad_trd_capt_t* obj);
 
xroad_errno_t xroad_trd_capt_set_face_value(xroad_trd_capt_t* obj, xroad_price_t val);
 
xroad_price_t xroad_trd_capt_get_face_value(const xroad_trd_capt_t* obj);
 
void xroad_trd_capt_reset_face_value(xroad_trd_capt_t* obj);
 
bool xroad_trd_capt_face_value_is_set(const xroad_trd_capt_t* obj);
 
xroad_errno_t xroad_trd_capt_set_accrued_int(xroad_trd_capt_t* obj, xroad_double_t val);
 
xroad_double_t xroad_trd_capt_get_accrued_int(const xroad_trd_capt_t* obj);
 
void xroad_trd_capt_reset_accrued_int(xroad_trd_capt_t* obj);
 
bool xroad_trd_capt_accrued_int_is_set(const xroad_trd_capt_t* obj);
 
xroad_errno_t xroad_trd_capt_set_cur(xroad_trd_capt_t* obj, void* ref);
 
xroad_errno_t xroad_trd_capt_set_cur_ref(xroad_trd_capt_t* obj, xroad_object_ref_t ref);
 
void* xroad_trd_capt_get_cur(const xroad_trd_capt_t* obj);
 
xroad_object_ref_t xroad_trd_capt_get_cur_ref(const xroad_trd_capt_t* obj);
 
void xroad_trd_capt_reset_cur(xroad_trd_capt_t* obj);
 
bool xroad_trd_capt_cur_is_set(const xroad_trd_capt_t* obj);
 
xroad_errno_t xroad_trd_capt_send(xroad_trd_capt_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_trd_capt_route(xroad_trd_capt_t* obj, ...);
 
void xroad_trd_capt_reset(xroad_trd_capt_t* obj);
 
xroad_trd_capt_t* xroad_trd_capt_clone(const xroad_trd_capt_t* obj);
 
bool xroad_trd_capt_is_valid(const xroad_trd_capt_t* obj);
 
int32_t xroad_trd_capt_print(const xroad_trd_capt_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_trd_capt_calc_hash(const xroad_trd_capt_t* obj);
 
xroad_str_t xroad_trd_capt_calc_uniq_id(const xroad_trd_capt_t* obj);
 
 
 
/* xroad_props_t */
 
xroad_object_id_t xroad_props_get_id(const xroad_props_t* obj);
 
xroad_object_ref_t xroad_props_get_ref(const xroad_props_t* obj);
 
xroad_errno_t xroad_props_set_node_id(xroad_props_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_props_get_node_id(const xroad_props_t* obj);
 
void xroad_props_reset_node_id(xroad_props_t* obj);
 
bool xroad_props_node_id_is_set(const xroad_props_t* obj);
 
xroad_errno_t xroad_props_set_children(xroad_props_t* obj, xroad_binary_t val);
 
xroad_binary_t xroad_props_get_children(const xroad_props_t* obj);
 
void xroad_props_reset_children(xroad_props_t* obj);
 
bool xroad_props_children_is_set(const xroad_props_t* obj);
 
xroad_errno_t xroad_props_set_descr(xroad_props_t* obj, xroad_str_t val);
 
xroad_str_t xroad_props_get_descr(const xroad_props_t* obj);
 
void xroad_props_reset_descr(xroad_props_t* obj);
 
bool xroad_props_descr_is_set(const xroad_props_t* obj);
 
xroad_errno_t xroad_props_send(xroad_props_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_props_route(xroad_props_t* obj, ...);
 
void xroad_props_reset(xroad_props_t* obj);
 
xroad_props_t* xroad_props_clone(const xroad_props_t* obj);
 
bool xroad_props_is_valid(const xroad_props_t* obj);
 
int32_t xroad_props_print(const xroad_props_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_props_calc_hash(const xroad_props_t* obj);
 
xroad_str_t xroad_props_calc_uniq_id(const xroad_props_t* obj);
 
 
 
/* xroad_resolve_t */
 
xroad_object_id_t xroad_resolve_get_id(const xroad_resolve_t* obj);
 
xroad_object_ref_t xroad_resolve_get_ref(const xroad_resolve_t* obj);
 
xroad_errno_t xroad_resolve_set_req_id(xroad_resolve_t* obj, xroad_str_t val);
 
xroad_str_t xroad_resolve_get_req_id(const xroad_resolve_t* obj);
 
void xroad_resolve_reset_req_id(xroad_resolve_t* obj);
 
bool xroad_resolve_req_id_is_set(const xroad_resolve_t* obj);
 
xroad_errno_t xroad_resolve_set_alias(xroad_resolve_t* obj, xroad_str_t val);
 
xroad_str_t xroad_resolve_get_alias(const xroad_resolve_t* obj);
 
void xroad_resolve_reset_alias(xroad_resolve_t* obj);
 
bool xroad_resolve_alias_is_set(const xroad_resolve_t* obj);
 
xroad_errno_t xroad_resolve_set_from_node(xroad_resolve_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_resolve_get_from_node(const xroad_resolve_t* obj);
 
void xroad_resolve_reset_from_node(xroad_resolve_t* obj);
 
bool xroad_resolve_from_node_is_set(const xroad_resolve_t* obj);
 
xroad_errno_t xroad_resolve_set_isin(xroad_resolve_t* obj, xroad_str_t val);
 
xroad_str_t xroad_resolve_get_isin(const xroad_resolve_t* obj);
 
void xroad_resolve_reset_isin(xroad_resolve_t* obj);
 
bool xroad_resolve_isin_is_set(const xroad_resolve_t* obj);
 
xroad_errno_t xroad_resolve_set_bb_source(xroad_resolve_t* obj, xroad_str_t val);
 
xroad_str_t xroad_resolve_get_bb_source(const xroad_resolve_t* obj);
 
void xroad_resolve_reset_bb_source(xroad_resolve_t* obj);
 
bool xroad_resolve_bb_source_is_set(const xroad_resolve_t* obj);
 
xroad_errno_t xroad_resolve_set_bb_code(xroad_resolve_t* obj, xroad_str_t val);
 
xroad_str_t xroad_resolve_get_bb_code(const xroad_resolve_t* obj);
 
void xroad_resolve_reset_bb_code(xroad_resolve_t* obj);
 
bool xroad_resolve_bb_code_is_set(const xroad_resolve_t* obj);
 
xroad_errno_t xroad_resolve_set_default_alias(xroad_resolve_t* obj, xroad_str_t val);
 
xroad_str_t xroad_resolve_get_default_alias(const xroad_resolve_t* obj);
 
void xroad_resolve_reset_default_alias(xroad_resolve_t* obj);
 
bool xroad_resolve_default_alias_is_set(const xroad_resolve_t* obj);
 
xroad_errno_t xroad_resolve_set_default_name(xroad_resolve_t* obj, xroad_str_t val);
 
xroad_str_t xroad_resolve_get_default_name(const xroad_resolve_t* obj);
 
void xroad_resolve_reset_default_name(xroad_resolve_t* obj);
 
bool xroad_resolve_default_name_is_set(const xroad_resolve_t* obj);
 
xroad_errno_t xroad_resolve_set_default_facevalue(xroad_resolve_t* obj, xroad_price_t val);
 
xroad_price_t xroad_resolve_get_default_facevalue(const xroad_resolve_t* obj);
 
void xroad_resolve_reset_default_facevalue(xroad_resolve_t* obj);
 
bool xroad_resolve_default_facevalue_is_set(const xroad_resolve_t* obj);
 
xroad_errno_t xroad_resolve_set_default_cfi(xroad_resolve_t* obj, xroad_str_t val);
 
xroad_str_t xroad_resolve_get_default_cfi(const xroad_resolve_t* obj);
 
void xroad_resolve_reset_default_cfi(xroad_resolve_t* obj);
 
bool xroad_resolve_default_cfi_is_set(const xroad_resolve_t* obj);
 
xroad_errno_t xroad_resolve_set_default_currency(xroad_resolve_t* obj, void* ref);
 
xroad_errno_t xroad_resolve_set_default_currency_ref(xroad_resolve_t* obj, xroad_object_ref_t ref);
 
void* xroad_resolve_get_default_currency(const xroad_resolve_t* obj);
 
xroad_object_ref_t xroad_resolve_get_default_currency_ref(const xroad_resolve_t* obj);
 
void xroad_resolve_reset_default_currency(xroad_resolve_t* obj);
 
bool xroad_resolve_default_currency_is_set(const xroad_resolve_t* obj);
 
xroad_errno_t xroad_resolve_send(xroad_resolve_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_resolve_route(xroad_resolve_t* obj, ...);
 
void xroad_resolve_reset(xroad_resolve_t* obj);
 
xroad_resolve_t* xroad_resolve_clone(const xroad_resolve_t* obj);
 
bool xroad_resolve_is_valid(const xroad_resolve_t* obj);
 
int32_t xroad_resolve_print(const xroad_resolve_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_resolve_calc_hash(const xroad_resolve_t* obj);
 
xroad_str_t xroad_resolve_calc_uniq_id(const xroad_resolve_t* obj);
 
 
 
/* xroad_resolve_ack_t */
 
xroad_errno_t xroad_resolve_ack_set_req(xroad_resolve_ack_t* obj, void* ref);
 
xroad_errno_t xroad_resolve_ack_set_req_ref(xroad_resolve_ack_t* obj, xroad_object_ref_t ref);
 
void* xroad_resolve_ack_get_req(const xroad_resolve_ack_t* obj);
 
xroad_object_ref_t xroad_resolve_ack_get_req_ref(const xroad_resolve_ack_t* obj);
 
void xroad_resolve_ack_reset_req(xroad_resolve_ack_t* obj);
 
bool xroad_resolve_ack_req_is_set(const xroad_resolve_ack_t* obj);
 
xroad_errno_t xroad_resolve_ack_set_instr(xroad_resolve_ack_t* obj, void* ref);
 
xroad_errno_t xroad_resolve_ack_set_instr_ref(xroad_resolve_ack_t* obj, xroad_object_ref_t ref);
 
void* xroad_resolve_ack_get_instr(const xroad_resolve_ack_t* obj);
 
xroad_object_ref_t xroad_resolve_ack_get_instr_ref(const xroad_resolve_ack_t* obj);
 
void xroad_resolve_ack_reset_instr(xroad_resolve_ack_t* obj);
 
bool xroad_resolve_ack_instr_is_set(const xroad_resolve_ack_t* obj);
 
void xroad_resolve_ack_destroy(xroad_resolve_ack_t* obj);
 
xroad_errno_t xroad_resolve_ack_send(xroad_resolve_ack_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_resolve_ack_route(xroad_resolve_ack_t* obj, ...);
 
void xroad_resolve_ack_reset(xroad_resolve_ack_t* obj);
 
xroad_resolve_ack_t* xroad_resolve_ack_clone(const xroad_resolve_ack_t* obj);
 
bool xroad_resolve_ack_is_valid(const xroad_resolve_ack_t* obj);
 
int32_t xroad_resolve_ack_print(const xroad_resolve_ack_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_resolve_ack_calc_hash(const xroad_resolve_ack_t* obj);
 
xroad_str_t xroad_resolve_ack_calc_uniq_id(const xroad_resolve_ack_t* obj);
 
 
 
/* xroad_mdata_subs_t */
 
xroad_object_id_t xroad_mdata_subs_get_id(const xroad_mdata_subs_t* obj);
 
xroad_object_ref_t xroad_mdata_subs_get_ref(const xroad_mdata_subs_t* obj);
 
xroad_errno_t xroad_mdata_subs_set_node_id(xroad_mdata_subs_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_mdata_subs_get_node_id(const xroad_mdata_subs_t* obj);
 
void xroad_mdata_subs_reset_node_id(xroad_mdata_subs_t* obj);
 
bool xroad_mdata_subs_node_id_is_set(const xroad_mdata_subs_t* obj);
 
xroad_errno_t xroad_mdata_subs_set_req_id(xroad_mdata_subs_t* obj, xroad_str_t val);
 
xroad_str_t xroad_mdata_subs_get_req_id(const xroad_mdata_subs_t* obj);
 
void xroad_mdata_subs_reset_req_id(xroad_mdata_subs_t* obj);
 
bool xroad_mdata_subs_req_id_is_set(const xroad_mdata_subs_t* obj);
 
xroad_errno_t xroad_mdata_subs_set_instr(xroad_mdata_subs_t* obj, void* ref);
 
xroad_errno_t xroad_mdata_subs_set_instr_ref(xroad_mdata_subs_t* obj, xroad_object_ref_t ref);
 
void* xroad_mdata_subs_get_instr(const xroad_mdata_subs_t* obj);
 
xroad_object_ref_t xroad_mdata_subs_get_instr_ref(const xroad_mdata_subs_t* obj);
 
void xroad_mdata_subs_reset_instr(xroad_mdata_subs_t* obj);
 
bool xroad_mdata_subs_instr_is_set(const xroad_mdata_subs_t* obj);
 
xroad_errno_t xroad_mdata_subs_set_state(xroad_mdata_subs_t* obj, xroad_mdata_subs_state_t val);
 
xroad_mdata_subs_state_t xroad_mdata_subs_get_state(const xroad_mdata_subs_t* obj);
 
void xroad_mdata_subs_reset_state(xroad_mdata_subs_t* obj);
 
bool xroad_mdata_subs_state_is_set(const xroad_mdata_subs_t* obj);
 
xroad_errno_t xroad_mdata_subs_set_ref_cnt(xroad_mdata_subs_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_mdata_subs_get_ref_cnt(const xroad_mdata_subs_t* obj);
 
void xroad_mdata_subs_reset_ref_cnt(xroad_mdata_subs_t* obj);
 
bool xroad_mdata_subs_ref_cnt_is_set(const xroad_mdata_subs_t* obj);
 
xroad_errno_t xroad_mdata_subs_send(xroad_mdata_subs_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_mdata_subs_route(xroad_mdata_subs_t* obj, ...);
 
void xroad_mdata_subs_reset(xroad_mdata_subs_t* obj);
 
xroad_mdata_subs_t* xroad_mdata_subs_clone(const xroad_mdata_subs_t* obj);
 
bool xroad_mdata_subs_is_valid(const xroad_mdata_subs_t* obj);
 
int32_t xroad_mdata_subs_print(const xroad_mdata_subs_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_mdata_subs_calc_hash(const xroad_mdata_subs_t* obj);
 
xroad_str_t xroad_mdata_subs_calc_uniq_id(const xroad_mdata_subs_t* obj);
 
 
 
/* xroad_reload_t */
 
xroad_errno_t xroad_reload_set_instr(xroad_reload_t* obj, void* ref);
 
xroad_errno_t xroad_reload_set_instr_ref(xroad_reload_t* obj, xroad_object_ref_t ref);
 
void* xroad_reload_get_instr(const xroad_reload_t* obj);
 
xroad_object_ref_t xroad_reload_get_instr_ref(const xroad_reload_t* obj);
 
void xroad_reload_reset_instr(xroad_reload_t* obj);
 
bool xroad_reload_instr_is_set(const xroad_reload_t* obj);
 
xroad_errno_t xroad_reload_set_start_date(xroad_reload_t* obj, xroad_date_t val);
 
xroad_date_t xroad_reload_get_start_date(const xroad_reload_t* obj);
 
void xroad_reload_reset_start_date(xroad_reload_t* obj);
 
bool xroad_reload_start_date_is_set(const xroad_reload_t* obj);
 
xroad_errno_t xroad_reload_set_end_date(xroad_reload_t* obj, xroad_date_t val);
 
xroad_date_t xroad_reload_get_end_date(const xroad_reload_t* obj);
 
void xroad_reload_reset_end_date(xroad_reload_t* obj);
 
bool xroad_reload_end_date_is_set(const xroad_reload_t* obj);
 
xroad_errno_t xroad_reload_set_from_node(xroad_reload_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_reload_get_from_node(const xroad_reload_t* obj);
 
void xroad_reload_reset_from_node(xroad_reload_t* obj);
 
bool xroad_reload_from_node_is_set(const xroad_reload_t* obj);
 
void xroad_reload_destroy(xroad_reload_t* obj);
 
xroad_errno_t xroad_reload_send(xroad_reload_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_reload_route(xroad_reload_t* obj, ...);
 
void xroad_reload_reset(xroad_reload_t* obj);
 
xroad_reload_t* xroad_reload_clone(const xroad_reload_t* obj);
 
bool xroad_reload_is_valid(const xroad_reload_t* obj);
 
int32_t xroad_reload_print(const xroad_reload_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_reload_calc_hash(const xroad_reload_t* obj);
 
xroad_str_t xroad_reload_calc_uniq_id(const xroad_reload_t* obj);
 
 
 
/* xroad_sbe_session_t */
 
xroad_object_id_t xroad_sbe_session_get_id(const xroad_sbe_session_t* obj);
 
xroad_object_ref_t xroad_sbe_session_get_ref(const xroad_sbe_session_t* obj);
 
xroad_errno_t xroad_sbe_session_set_node_id(xroad_sbe_session_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_sbe_session_get_node_id(const xroad_sbe_session_t* obj);
 
void xroad_sbe_session_reset_node_id(xroad_sbe_session_t* obj);
 
bool xroad_sbe_session_node_id_is_set(const xroad_sbe_session_t* obj);
 
xroad_errno_t xroad_sbe_session_set_deleted(xroad_sbe_session_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_sbe_session_get_deleted(const xroad_sbe_session_t* obj);
 
void xroad_sbe_session_reset_deleted(xroad_sbe_session_t* obj);
 
bool xroad_sbe_session_deleted_is_set(const xroad_sbe_session_t* obj);
 
xroad_errno_t xroad_sbe_session_set_name(xroad_sbe_session_t* obj, xroad_str_t val);
 
xroad_str_t xroad_sbe_session_get_name(const xroad_sbe_session_t* obj);
 
void xroad_sbe_session_reset_name(xroad_sbe_session_t* obj);
 
bool xroad_sbe_session_name_is_set(const xroad_sbe_session_t* obj);
 
xroad_errno_t xroad_sbe_session_set_tran_cnt(xroad_sbe_session_t* obj, xroad_uint64_t val);
 
xroad_uint64_t xroad_sbe_session_get_tran_cnt(const xroad_sbe_session_t* obj);
 
void xroad_sbe_session_reset_tran_cnt(xroad_sbe_session_t* obj);
 
bool xroad_sbe_session_tran_cnt_is_set(const xroad_sbe_session_t* obj);
 
xroad_errno_t xroad_sbe_session_set_next_seq_num_in(xroad_sbe_session_t* obj, xroad_uint64_t val);
 
xroad_uint64_t xroad_sbe_session_get_next_seq_num_in(const xroad_sbe_session_t* obj);
 
void xroad_sbe_session_reset_next_seq_num_in(xroad_sbe_session_t* obj);
 
bool xroad_sbe_session_next_seq_num_in_is_set(const xroad_sbe_session_t* obj);
 
xroad_errno_t xroad_sbe_session_set_next_seq_num_out(xroad_sbe_session_t* obj, xroad_uint64_t val);
 
xroad_uint64_t xroad_sbe_session_get_next_seq_num_out(const xroad_sbe_session_t* obj);
 
void xroad_sbe_session_reset_next_seq_num_out(xroad_sbe_session_t* obj);
 
bool xroad_sbe_session_next_seq_num_out_is_set(const xroad_sbe_session_t* obj);
 
xroad_errno_t xroad_sbe_session_set_uuid(xroad_sbe_session_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_sbe_session_get_uuid(const xroad_sbe_session_t* obj);
 
void xroad_sbe_session_reset_uuid(xroad_sbe_session_t* obj);
 
bool xroad_sbe_session_uuid_is_set(const xroad_sbe_session_t* obj);
 
xroad_errno_t xroad_sbe_session_set_state(xroad_sbe_session_t* obj, xroad_session_state_t val);
 
xroad_session_state_t xroad_sbe_session_get_state(const xroad_sbe_session_t* obj);
 
void xroad_sbe_session_reset_state(xroad_sbe_session_t* obj);
 
bool xroad_sbe_session_state_is_set(const xroad_sbe_session_t* obj);
 
xroad_errno_t xroad_sbe_session_set_disabled(xroad_sbe_session_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_sbe_session_get_disabled(const xroad_sbe_session_t* obj);
 
void xroad_sbe_session_reset_disabled(xroad_sbe_session_t* obj);
 
bool xroad_sbe_session_disabled_is_set(const xroad_sbe_session_t* obj);
 
xroad_errno_t xroad_sbe_session_set_msg_in(xroad_sbe_session_t* obj, xroad_uint64_t val);
 
xroad_uint64_t xroad_sbe_session_get_msg_in(const xroad_sbe_session_t* obj);
 
void xroad_sbe_session_reset_msg_in(xroad_sbe_session_t* obj);
 
bool xroad_sbe_session_msg_in_is_set(const xroad_sbe_session_t* obj);
 
xroad_errno_t xroad_sbe_session_set_msg_out(xroad_sbe_session_t* obj, xroad_uint64_t val);
 
xroad_uint64_t xroad_sbe_session_get_msg_out(const xroad_sbe_session_t* obj);
 
void xroad_sbe_session_reset_msg_out(xroad_sbe_session_t* obj);
 
bool xroad_sbe_session_msg_out_is_set(const xroad_sbe_session_t* obj);
 
xroad_errno_t xroad_sbe_session_send(xroad_sbe_session_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_sbe_session_route(xroad_sbe_session_t* obj, ...);
 
void xroad_sbe_session_reset(xroad_sbe_session_t* obj);
 
xroad_sbe_session_t* xroad_sbe_session_clone(const xroad_sbe_session_t* obj);
 
bool xroad_sbe_session_is_valid(const xroad_sbe_session_t* obj);
 
int32_t xroad_sbe_session_print(const xroad_sbe_session_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_sbe_session_calc_hash(const xroad_sbe_session_t* obj);
 
xroad_str_t xroad_sbe_session_calc_uniq_id(const xroad_sbe_session_t* obj);
 
 
 
/* xroad_order_crypto_t */
 
xroad_object_id_t xroad_order_crypto_get_id(const xroad_order_crypto_t* obj);
 
xroad_object_ref_t xroad_order_crypto_get_ref(const xroad_order_crypto_t* obj);
 
xroad_errno_t xroad_order_crypto_set_node_id(xroad_order_crypto_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_order_crypto_get_node_id(const xroad_order_crypto_t* obj);
 
void xroad_order_crypto_reset_node_id(xroad_order_crypto_t* obj);
 
bool xroad_order_crypto_node_id_is_set(const xroad_order_crypto_t* obj);
 
xroad_errno_t xroad_order_crypto_set_order(xroad_order_crypto_t* obj, void* ref);
 
xroad_errno_t xroad_order_crypto_set_order_ref(xroad_order_crypto_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_crypto_get_order(const xroad_order_crypto_t* obj);
 
xroad_object_ref_t xroad_order_crypto_get_order_ref(const xroad_order_crypto_t* obj);
 
void xroad_order_crypto_reset_order(xroad_order_crypto_t* obj);
 
bool xroad_order_crypto_order_is_set(const xroad_order_crypto_t* obj);
 
xroad_errno_t xroad_order_crypto_set_tran_cnt(xroad_order_crypto_t* obj, xroad_uint32_t val);
 
xroad_uint32_t xroad_order_crypto_get_tran_cnt(const xroad_order_crypto_t* obj);
 
void xroad_order_crypto_reset_tran_cnt(xroad_order_crypto_t* obj);
 
bool xroad_order_crypto_tran_cnt_is_set(const xroad_order_crypto_t* obj);
 
xroad_errno_t xroad_order_crypto_set_exch_id(xroad_order_crypto_t* obj, xroad_str_t val);
 
xroad_str_t xroad_order_crypto_get_exch_id(const xroad_order_crypto_t* obj);
 
void xroad_order_crypto_reset_exch_id(xroad_order_crypto_t* obj);
 
bool xroad_order_crypto_exch_id_is_set(const xroad_order_crypto_t* obj);
 
xroad_errno_t xroad_order_crypto_set_clord_id(xroad_order_crypto_t* obj, xroad_str_t val);
 
xroad_str_t xroad_order_crypto_get_clord_id(const xroad_order_crypto_t* obj);
 
void xroad_order_crypto_reset_clord_id(xroad_order_crypto_t* obj);
 
bool xroad_order_crypto_clord_id_is_set(const xroad_order_crypto_t* obj);
 
xroad_errno_t xroad_order_crypto_set_price(xroad_order_crypto_t* obj, xroad_price_t val);
 
xroad_price_t xroad_order_crypto_get_price(const xroad_order_crypto_t* obj);
 
void xroad_order_crypto_reset_price(xroad_order_crypto_t* obj);
 
bool xroad_order_crypto_price_is_set(const xroad_order_crypto_t* obj);
 
xroad_errno_t xroad_order_crypto_set_qty(xroad_order_crypto_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_order_crypto_get_qty(const xroad_order_crypto_t* obj);
 
void xroad_order_crypto_reset_qty(xroad_order_crypto_t* obj);
 
bool xroad_order_crypto_qty_is_set(const xroad_order_crypto_t* obj);
 
xroad_errno_t xroad_order_crypto_set_r_price(xroad_order_crypto_t* obj, xroad_price_t val);
 
xroad_price_t xroad_order_crypto_get_r_price(const xroad_order_crypto_t* obj);
 
void xroad_order_crypto_reset_r_price(xroad_order_crypto_t* obj);
 
bool xroad_order_crypto_r_price_is_set(const xroad_order_crypto_t* obj);
 
xroad_errno_t xroad_order_crypto_set_r_qty(xroad_order_crypto_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_order_crypto_get_r_qty(const xroad_order_crypto_t* obj);
 
void xroad_order_crypto_reset_r_qty(xroad_order_crypto_t* obj);
 
bool xroad_order_crypto_r_qty_is_set(const xroad_order_crypto_t* obj);
 
xroad_errno_t xroad_order_crypto_set_flags(xroad_order_crypto_t* obj, xroad_uint32_t val);
 
xroad_uint32_t xroad_order_crypto_get_flags(const xroad_order_crypto_t* obj);
 
void xroad_order_crypto_reset_flags(xroad_order_crypto_t* obj);
 
bool xroad_order_crypto_flags_is_set(const xroad_order_crypto_t* obj);
 
xroad_errno_t xroad_order_crypto_set_fee(xroad_order_crypto_t* obj, xroad_price_t val);
 
xroad_price_t xroad_order_crypto_get_fee(const xroad_order_crypto_t* obj);
 
void xroad_order_crypto_reset_fee(xroad_order_crypto_t* obj);
 
bool xroad_order_crypto_fee_is_set(const xroad_order_crypto_t* obj);
 
xroad_errno_t xroad_order_crypto_send(xroad_order_crypto_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_order_crypto_route(xroad_order_crypto_t* obj, ...);
 
void xroad_order_crypto_reset(xroad_order_crypto_t* obj);
 
xroad_order_crypto_t* xroad_order_crypto_clone(const xroad_order_crypto_t* obj);
 
bool xroad_order_crypto_is_valid(const xroad_order_crypto_t* obj);
 
int32_t xroad_order_crypto_print(const xroad_order_crypto_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_order_crypto_calc_hash(const xroad_order_crypto_t* obj);
 
xroad_str_t xroad_order_crypto_calc_uniq_id(const xroad_order_crypto_t* obj);
 
 
 
/* xroad_crypto_session_t */
 
xroad_object_id_t xroad_crypto_session_get_id(const xroad_crypto_session_t* obj);
 
xroad_object_ref_t xroad_crypto_session_get_ref(const xroad_crypto_session_t* obj);
 
xroad_errno_t xroad_crypto_session_set_node_id(xroad_crypto_session_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_crypto_session_get_node_id(const xroad_crypto_session_t* obj);
 
void xroad_crypto_session_reset_node_id(xroad_crypto_session_t* obj);
 
bool xroad_crypto_session_node_id_is_set(const xroad_crypto_session_t* obj);
 
xroad_errno_t xroad_crypto_session_set_tran_cnt(xroad_crypto_session_t* obj, xroad_int64_t val);
 
xroad_int64_t xroad_crypto_session_get_tran_cnt(const xroad_crypto_session_t* obj);
 
void xroad_crypto_session_reset_tran_cnt(xroad_crypto_session_t* obj);
 
bool xroad_crypto_session_tran_cnt_is_set(const xroad_crypto_session_t* obj);
 
xroad_errno_t xroad_crypto_session_send(xroad_crypto_session_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_crypto_session_route(xroad_crypto_session_t* obj, ...);
 
void xroad_crypto_session_reset(xroad_crypto_session_t* obj);
 
xroad_crypto_session_t* xroad_crypto_session_clone(const xroad_crypto_session_t* obj);
 
bool xroad_crypto_session_is_valid(const xroad_crypto_session_t* obj);
 
int32_t xroad_crypto_session_print(const xroad_crypto_session_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_crypto_session_calc_hash(const xroad_crypto_session_t* obj);
 
xroad_str_t xroad_crypto_session_calc_uniq_id(const xroad_crypto_session_t* obj);
 
 
 
/* xroad_acc_pos_t */
 
xroad_object_id_t xroad_acc_pos_get_id(const xroad_acc_pos_t* obj);
 
xroad_object_ref_t xroad_acc_pos_get_ref(const xroad_acc_pos_t* obj);
 
xroad_errno_t xroad_acc_pos_set_deleted(xroad_acc_pos_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_acc_pos_get_deleted(const xroad_acc_pos_t* obj);
 
void xroad_acc_pos_reset_deleted(xroad_acc_pos_t* obj);
 
bool xroad_acc_pos_deleted_is_set(const xroad_acc_pos_t* obj);
 
xroad_errno_t xroad_acc_pos_set_node_id(xroad_acc_pos_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_acc_pos_get_node_id(const xroad_acc_pos_t* obj);
 
void xroad_acc_pos_reset_node_id(xroad_acc_pos_t* obj);
 
bool xroad_acc_pos_node_id_is_set(const xroad_acc_pos_t* obj);
 
xroad_errno_t xroad_acc_pos_set_account(xroad_acc_pos_t* obj, xroad_str_t val);
 
xroad_str_t xroad_acc_pos_get_account(const xroad_acc_pos_t* obj);
 
void xroad_acc_pos_reset_account(xroad_acc_pos_t* obj);
 
bool xroad_acc_pos_account_is_set(const xroad_acc_pos_t* obj);
 
xroad_errno_t xroad_acc_pos_set_exch_account(xroad_acc_pos_t* obj, xroad_str_t val);
 
xroad_str_t xroad_acc_pos_get_exch_account(const xroad_acc_pos_t* obj);
 
void xroad_acc_pos_reset_exch_account(xroad_acc_pos_t* obj);
 
bool xroad_acc_pos_exch_account_is_set(const xroad_acc_pos_t* obj);
 
xroad_errno_t xroad_acc_pos_set_instr(xroad_acc_pos_t* obj, void* ref);
 
xroad_errno_t xroad_acc_pos_set_instr_ref(xroad_acc_pos_t* obj, xroad_object_ref_t ref);
 
void* xroad_acc_pos_get_instr(const xroad_acc_pos_t* obj);
 
xroad_object_ref_t xroad_acc_pos_get_instr_ref(const xroad_acc_pos_t* obj);
 
void xroad_acc_pos_reset_instr(xroad_acc_pos_t* obj);
 
bool xroad_acc_pos_instr_is_set(const xroad_acc_pos_t* obj);
 
xroad_errno_t xroad_acc_pos_set_realized_pnl(xroad_acc_pos_t* obj, xroad_price_t val);
 
xroad_price_t xroad_acc_pos_get_realized_pnl(const xroad_acc_pos_t* obj);
 
void xroad_acc_pos_reset_realized_pnl(xroad_acc_pos_t* obj);
 
bool xroad_acc_pos_realized_pnl_is_set(const xroad_acc_pos_t* obj);
 
xroad_errno_t xroad_acc_pos_set_change_pnl(xroad_acc_pos_t* obj, xroad_price_t val);
 
xroad_price_t xroad_acc_pos_get_change_pnl(const xroad_acc_pos_t* obj);
 
void xroad_acc_pos_reset_change_pnl(xroad_acc_pos_t* obj);
 
bool xroad_acc_pos_change_pnl_is_set(const xroad_acc_pos_t* obj);
 
xroad_errno_t xroad_acc_pos_set_unrealized_pnl(xroad_acc_pos_t* obj, xroad_price_t val);
 
xroad_price_t xroad_acc_pos_get_unrealized_pnl(const xroad_acc_pos_t* obj);
 
void xroad_acc_pos_reset_unrealized_pnl(xroad_acc_pos_t* obj);
 
bool xroad_acc_pos_unrealized_pnl_is_set(const xroad_acc_pos_t* obj);
 
xroad_errno_t xroad_acc_pos_set_total_buy(xroad_acc_pos_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_acc_pos_get_total_buy(const xroad_acc_pos_t* obj);
 
void xroad_acc_pos_reset_total_buy(xroad_acc_pos_t* obj);
 
bool xroad_acc_pos_total_buy_is_set(const xroad_acc_pos_t* obj);
 
xroad_errno_t xroad_acc_pos_set_total_sell(xroad_acc_pos_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_acc_pos_get_total_sell(const xroad_acc_pos_t* obj);
 
void xroad_acc_pos_reset_total_sell(xroad_acc_pos_t* obj);
 
bool xroad_acc_pos_total_sell_is_set(const xroad_acc_pos_t* obj);
 
xroad_errno_t xroad_acc_pos_set_avg_price(xroad_acc_pos_t* obj, xroad_price_t val);
 
xroad_price_t xroad_acc_pos_get_avg_price(const xroad_acc_pos_t* obj);
 
void xroad_acc_pos_reset_avg_price(xroad_acc_pos_t* obj);
 
bool xroad_acc_pos_avg_price_is_set(const xroad_acc_pos_t* obj);
 
xroad_errno_t xroad_acc_pos_set_update_ts(xroad_acc_pos_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_acc_pos_get_update_ts(const xroad_acc_pos_t* obj);
 
void xroad_acc_pos_reset_update_ts(xroad_acc_pos_t* obj);
 
bool xroad_acc_pos_update_ts_is_set(const xroad_acc_pos_t* obj);
 
xroad_errno_t xroad_acc_pos_send(xroad_acc_pos_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_acc_pos_route(xroad_acc_pos_t* obj, ...);
 
void xroad_acc_pos_reset(xroad_acc_pos_t* obj);
 
xroad_acc_pos_t* xroad_acc_pos_clone(const xroad_acc_pos_t* obj);
 
bool xroad_acc_pos_is_valid(const xroad_acc_pos_t* obj);
 
int32_t xroad_acc_pos_print(const xroad_acc_pos_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_acc_pos_calc_hash(const xroad_acc_pos_t* obj);
 
xroad_str_t xroad_acc_pos_calc_uniq_id(const xroad_acc_pos_t* obj);
 
 
 
/* xroad_acc_balance_t */
 
xroad_object_id_t xroad_acc_balance_get_id(const xroad_acc_balance_t* obj);
 
xroad_object_ref_t xroad_acc_balance_get_ref(const xroad_acc_balance_t* obj);
 
xroad_errno_t xroad_acc_balance_set_deleted(xroad_acc_balance_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_acc_balance_get_deleted(const xroad_acc_balance_t* obj);
 
void xroad_acc_balance_reset_deleted(xroad_acc_balance_t* obj);
 
bool xroad_acc_balance_deleted_is_set(const xroad_acc_balance_t* obj);
 
xroad_errno_t xroad_acc_balance_set_node_id(xroad_acc_balance_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_acc_balance_get_node_id(const xroad_acc_balance_t* obj);
 
void xroad_acc_balance_reset_node_id(xroad_acc_balance_t* obj);
 
bool xroad_acc_balance_node_id_is_set(const xroad_acc_balance_t* obj);
 
xroad_errno_t xroad_acc_balance_set_exch(xroad_acc_balance_t* obj, void* ref);
 
xroad_errno_t xroad_acc_balance_set_exch_ref(xroad_acc_balance_t* obj, xroad_object_ref_t ref);
 
void* xroad_acc_balance_get_exch(const xroad_acc_balance_t* obj);
 
xroad_object_ref_t xroad_acc_balance_get_exch_ref(const xroad_acc_balance_t* obj);
 
void xroad_acc_balance_reset_exch(xroad_acc_balance_t* obj);
 
bool xroad_acc_balance_exch_is_set(const xroad_acc_balance_t* obj);
 
xroad_errno_t xroad_acc_balance_set_exch_account(xroad_acc_balance_t* obj, xroad_str_t val);
 
xroad_str_t xroad_acc_balance_get_exch_account(const xroad_acc_balance_t* obj);
 
void xroad_acc_balance_reset_exch_account(xroad_acc_balance_t* obj);
 
bool xroad_acc_balance_exch_account_is_set(const xroad_acc_balance_t* obj);
 
xroad_errno_t xroad_acc_balance_set_account(xroad_acc_balance_t* obj, xroad_str_t val);
 
xroad_str_t xroad_acc_balance_get_account(const xroad_acc_balance_t* obj);
 
void xroad_acc_balance_reset_account(xroad_acc_balance_t* obj);
 
bool xroad_acc_balance_account_is_set(const xroad_acc_balance_t* obj);
 
xroad_errno_t xroad_acc_balance_set_asset(xroad_acc_balance_t* obj, xroad_str_t val);
 
xroad_str_t xroad_acc_balance_get_asset(const xroad_acc_balance_t* obj);
 
void xroad_acc_balance_reset_asset(xroad_acc_balance_t* obj);
 
bool xroad_acc_balance_asset_is_set(const xroad_acc_balance_t* obj);
 
xroad_errno_t xroad_acc_balance_set_total(xroad_acc_balance_t* obj, xroad_double_t val);
 
xroad_double_t xroad_acc_balance_get_total(const xroad_acc_balance_t* obj);
 
void xroad_acc_balance_reset_total(xroad_acc_balance_t* obj);
 
bool xroad_acc_balance_total_is_set(const xroad_acc_balance_t* obj);
 
xroad_errno_t xroad_acc_balance_set_available(xroad_acc_balance_t* obj, xroad_double_t val);
 
xroad_double_t xroad_acc_balance_get_available(const xroad_acc_balance_t* obj);
 
void xroad_acc_balance_reset_available(xroad_acc_balance_t* obj);
 
bool xroad_acc_balance_available_is_set(const xroad_acc_balance_t* obj);
 
xroad_errno_t xroad_acc_balance_set_update_ts(xroad_acc_balance_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_acc_balance_get_update_ts(const xroad_acc_balance_t* obj);
 
void xroad_acc_balance_reset_update_ts(xroad_acc_balance_t* obj);
 
bool xroad_acc_balance_update_ts_is_set(const xroad_acc_balance_t* obj);
 
xroad_errno_t xroad_acc_balance_send(xroad_acc_balance_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_acc_balance_route(xroad_acc_balance_t* obj, ...);
 
void xroad_acc_balance_reset(xroad_acc_balance_t* obj);
 
xroad_acc_balance_t* xroad_acc_balance_clone(const xroad_acc_balance_t* obj);
 
bool xroad_acc_balance_is_valid(const xroad_acc_balance_t* obj);
 
int32_t xroad_acc_balance_print(const xroad_acc_balance_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_acc_balance_calc_hash(const xroad_acc_balance_t* obj);
 
xroad_str_t xroad_acc_balance_calc_uniq_id(const xroad_acc_balance_t* obj);
 
 
 
/* xroad_order_ws_t */
 
xroad_object_id_t xroad_order_ws_get_id(const xroad_order_ws_t* obj);
 
xroad_object_ref_t xroad_order_ws_get_ref(const xroad_order_ws_t* obj);
 
xroad_errno_t xroad_order_ws_set_node_id(xroad_order_ws_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_order_ws_get_node_id(const xroad_order_ws_t* obj);
 
void xroad_order_ws_reset_node_id(xroad_order_ws_t* obj);
 
bool xroad_order_ws_node_id_is_set(const xroad_order_ws_t* obj);
 
xroad_errno_t xroad_order_ws_set_order(xroad_order_ws_t* obj, void* ref);
 
xroad_errno_t xroad_order_ws_set_order_ref(xroad_order_ws_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_ws_get_order(const xroad_order_ws_t* obj);
 
xroad_object_ref_t xroad_order_ws_get_order_ref(const xroad_order_ws_t* obj);
 
void xroad_order_ws_reset_order(xroad_order_ws_t* obj);
 
bool xroad_order_ws_order_is_set(const xroad_order_ws_t* obj);
 
xroad_errno_t xroad_order_ws_set_status(xroad_order_ws_t* obj, xroad_order_status_t val);
 
xroad_order_status_t xroad_order_ws_get_status(const xroad_order_ws_t* obj);
 
void xroad_order_ws_reset_status(xroad_order_ws_t* obj);
 
bool xroad_order_ws_status_is_set(const xroad_order_ws_t* obj);
 
xroad_errno_t xroad_order_ws_set_qty(xroad_order_ws_t* obj, xroad_double_t val);
 
xroad_double_t xroad_order_ws_get_qty(const xroad_order_ws_t* obj);
 
void xroad_order_ws_reset_qty(xroad_order_ws_t* obj);
 
bool xroad_order_ws_qty_is_set(const xroad_order_ws_t* obj);
 
xroad_errno_t xroad_order_ws_set_reason(xroad_order_ws_t* obj, xroad_str_t val);
 
xroad_str_t xroad_order_ws_get_reason(const xroad_order_ws_t* obj);
 
void xroad_order_ws_reset_reason(xroad_order_ws_t* obj);
 
bool xroad_order_ws_reason_is_set(const xroad_order_ws_t* obj);
 
xroad_errno_t xroad_order_ws_set_text(xroad_order_ws_t* obj, xroad_str_t val);
 
xroad_str_t xroad_order_ws_get_text(const xroad_order_ws_t* obj);
 
void xroad_order_ws_reset_text(xroad_order_ws_t* obj);
 
bool xroad_order_ws_text_is_set(const xroad_order_ws_t* obj);
 
xroad_errno_t xroad_order_ws_send(xroad_order_ws_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_order_ws_route(xroad_order_ws_t* obj, ...);
 
void xroad_order_ws_reset(xroad_order_ws_t* obj);
 
xroad_order_ws_t* xroad_order_ws_clone(const xroad_order_ws_t* obj);
 
bool xroad_order_ws_is_valid(const xroad_order_ws_t* obj);
 
int32_t xroad_order_ws_print(const xroad_order_ws_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_order_ws_calc_hash(const xroad_order_ws_t* obj);
 
xroad_str_t xroad_order_ws_calc_uniq_id(const xroad_order_ws_t* obj);
 
 
 
/* xroad_order_sbe_t */
 
xroad_object_id_t xroad_order_sbe_get_id(const xroad_order_sbe_t* obj);
 
xroad_object_ref_t xroad_order_sbe_get_ref(const xroad_order_sbe_t* obj);
 
xroad_errno_t xroad_order_sbe_set_node_id(xroad_order_sbe_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_order_sbe_get_node_id(const xroad_order_sbe_t* obj);
 
void xroad_order_sbe_reset_node_id(xroad_order_sbe_t* obj);
 
bool xroad_order_sbe_node_id_is_set(const xroad_order_sbe_t* obj);
 
xroad_errno_t xroad_order_sbe_set_order(xroad_order_sbe_t* obj, void* ref);
 
xroad_errno_t xroad_order_sbe_set_order_ref(xroad_order_sbe_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_sbe_get_order(const xroad_order_sbe_t* obj);
 
xroad_object_ref_t xroad_order_sbe_get_order_ref(const xroad_order_sbe_t* obj);
 
void xroad_order_sbe_reset_order(xroad_order_sbe_t* obj);
 
bool xroad_order_sbe_order_is_set(const xroad_order_sbe_t* obj);
 
xroad_errno_t xroad_order_sbe_set_tran_cnt(xroad_order_sbe_t* obj, xroad_uint32_t val);
 
xroad_uint32_t xroad_order_sbe_get_tran_cnt(const xroad_order_sbe_t* obj);
 
void xroad_order_sbe_reset_tran_cnt(xroad_order_sbe_t* obj);
 
bool xroad_order_sbe_tran_cnt_is_set(const xroad_order_sbe_t* obj);
 
xroad_errno_t xroad_order_sbe_set_order_id(xroad_order_sbe_t* obj, xroad_int64_t val);
 
xroad_int64_t xroad_order_sbe_get_order_id(const xroad_order_sbe_t* obj);
 
void xroad_order_sbe_reset_order_id(xroad_order_sbe_t* obj);
 
bool xroad_order_sbe_order_id_is_set(const xroad_order_sbe_t* obj);
 
xroad_errno_t xroad_order_sbe_set_price(xroad_order_sbe_t* obj, xroad_price_t val);
 
xroad_price_t xroad_order_sbe_get_price(const xroad_order_sbe_t* obj);
 
void xroad_order_sbe_reset_price(xroad_order_sbe_t* obj);
 
bool xroad_order_sbe_price_is_set(const xroad_order_sbe_t* obj);
 
xroad_errno_t xroad_order_sbe_set_qty(xroad_order_sbe_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_order_sbe_get_qty(const xroad_order_sbe_t* obj);
 
void xroad_order_sbe_reset_qty(xroad_order_sbe_t* obj);
 
bool xroad_order_sbe_qty_is_set(const xroad_order_sbe_t* obj);
 
xroad_errno_t xroad_order_sbe_set_cum_qty(xroad_order_sbe_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_order_sbe_get_cum_qty(const xroad_order_sbe_t* obj);
 
void xroad_order_sbe_reset_cum_qty(xroad_order_sbe_t* obj);
 
bool xroad_order_sbe_cum_qty_is_set(const xroad_order_sbe_t* obj);
 
xroad_errno_t xroad_order_sbe_set_replace(xroad_order_sbe_t* obj, void* ref);
 
xroad_errno_t xroad_order_sbe_set_replace_ref(xroad_order_sbe_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_sbe_get_replace(const xroad_order_sbe_t* obj);
 
xroad_object_ref_t xroad_order_sbe_get_replace_ref(const xroad_order_sbe_t* obj);
 
void xroad_order_sbe_reset_replace(xroad_order_sbe_t* obj);
 
bool xroad_order_sbe_replace_is_set(const xroad_order_sbe_t* obj);
 
xroad_errno_t xroad_order_sbe_set_leaves_qty(xroad_order_sbe_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_order_sbe_get_leaves_qty(const xroad_order_sbe_t* obj);
 
void xroad_order_sbe_reset_leaves_qty(xroad_order_sbe_t* obj);
 
bool xroad_order_sbe_leaves_qty_is_set(const xroad_order_sbe_t* obj);
 
xroad_errno_t xroad_order_sbe_set_display_qty(xroad_order_sbe_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_order_sbe_get_display_qty(const xroad_order_sbe_t* obj);
 
void xroad_order_sbe_reset_display_qty(xroad_order_sbe_t* obj);
 
bool xroad_order_sbe_display_qty_is_set(const xroad_order_sbe_t* obj);
 
xroad_errno_t xroad_order_sbe_set_clord_id(xroad_order_sbe_t* obj, xroad_uint64_t val);
 
xroad_uint64_t xroad_order_sbe_get_clord_id(const xroad_order_sbe_t* obj);
 
void xroad_order_sbe_reset_clord_id(xroad_order_sbe_t* obj);
 
bool xroad_order_sbe_clord_id_is_set(const xroad_order_sbe_t* obj);
 
xroad_errno_t xroad_order_sbe_send(xroad_order_sbe_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_order_sbe_route(xroad_order_sbe_t* obj, ...);
 
void xroad_order_sbe_reset(xroad_order_sbe_t* obj);
 
xroad_order_sbe_t* xroad_order_sbe_clone(const xroad_order_sbe_t* obj);
 
bool xroad_order_sbe_is_valid(const xroad_order_sbe_t* obj);
 
int32_t xroad_order_sbe_print(const xroad_order_sbe_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_order_sbe_calc_hash(const xroad_order_sbe_t* obj);
 
xroad_str_t xroad_order_sbe_calc_uniq_id(const xroad_order_sbe_t* obj);
 
 
 
/* xroad_pmaker_total_t */
 
xroad_object_id_t xroad_pmaker_total_get_id(const xroad_pmaker_total_t* obj);
 
xroad_object_ref_t xroad_pmaker_total_get_ref(const xroad_pmaker_total_t* obj);
 
xroad_errno_t xroad_pmaker_total_set_node_id(xroad_pmaker_total_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_pmaker_total_get_node_id(const xroad_pmaker_total_t* obj);
 
void xroad_pmaker_total_reset_node_id(xroad_pmaker_total_t* obj);
 
bool xroad_pmaker_total_node_id_is_set(const xroad_pmaker_total_t* obj);
 
xroad_errno_t xroad_pmaker_total_set_deleted(xroad_pmaker_total_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_pmaker_total_get_deleted(const xroad_pmaker_total_t* obj);
 
void xroad_pmaker_total_reset_deleted(xroad_pmaker_total_t* obj);
 
bool xroad_pmaker_total_deleted_is_set(const xroad_pmaker_total_t* obj);
 
xroad_errno_t xroad_pmaker_total_set_pmaker_id(xroad_pmaker_total_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_pmaker_total_get_pmaker_id(const xroad_pmaker_total_t* obj);
 
void xroad_pmaker_total_reset_pmaker_id(xroad_pmaker_total_t* obj);
 
bool xroad_pmaker_total_pmaker_id_is_set(const xroad_pmaker_total_t* obj);
 
xroad_errno_t xroad_pmaker_total_set_buy_coef(xroad_pmaker_total_t* obj, xroad_double_t val);
 
xroad_double_t xroad_pmaker_total_get_buy_coef(const xroad_pmaker_total_t* obj);
 
void xroad_pmaker_total_reset_buy_coef(xroad_pmaker_total_t* obj);
 
bool xroad_pmaker_total_buy_coef_is_set(const xroad_pmaker_total_t* obj);
 
xroad_errno_t xroad_pmaker_total_set_sell_coef(xroad_pmaker_total_t* obj, xroad_double_t val);
 
xroad_double_t xroad_pmaker_total_get_sell_coef(const xroad_pmaker_total_t* obj);
 
void xroad_pmaker_total_reset_sell_coef(xroad_pmaker_total_t* obj);
 
bool xroad_pmaker_total_sell_coef_is_set(const xroad_pmaker_total_t* obj);
 
xroad_errno_t xroad_pmaker_total_set_pos_adjust_coef(xroad_pmaker_total_t* obj, xroad_double_t val);
 
xroad_double_t xroad_pmaker_total_get_pos_adjust_coef(const xroad_pmaker_total_t* obj);
 
void xroad_pmaker_total_reset_pos_adjust_coef(xroad_pmaker_total_t* obj);
 
bool xroad_pmaker_total_pos_adjust_coef_is_set(const xroad_pmaker_total_t* obj);
 
xroad_errno_t xroad_pmaker_total_set_use_total(xroad_pmaker_total_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_pmaker_total_get_use_total(const xroad_pmaker_total_t* obj);
 
void xroad_pmaker_total_reset_use_total(xroad_pmaker_total_t* obj);
 
bool xroad_pmaker_total_use_total_is_set(const xroad_pmaker_total_t* obj);
 
xroad_errno_t xroad_pmaker_total_set_total_coef(xroad_pmaker_total_t* obj, xroad_double_t val);
 
xroad_double_t xroad_pmaker_total_get_total_coef(const xroad_pmaker_total_t* obj);
 
void xroad_pmaker_total_reset_total_coef(xroad_pmaker_total_t* obj);
 
bool xroad_pmaker_total_total_coef_is_set(const xroad_pmaker_total_t* obj);
 
xroad_errno_t xroad_pmaker_total_send(xroad_pmaker_total_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_pmaker_total_route(xroad_pmaker_total_t* obj, ...);
 
void xroad_pmaker_total_reset(xroad_pmaker_total_t* obj);
 
xroad_pmaker_total_t* xroad_pmaker_total_clone(const xroad_pmaker_total_t* obj);
 
bool xroad_pmaker_total_is_valid(const xroad_pmaker_total_t* obj);
 
int32_t xroad_pmaker_total_print(const xroad_pmaker_total_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_pmaker_total_calc_hash(const xroad_pmaker_total_t* obj);
 
xroad_str_t xroad_pmaker_total_calc_uniq_id(const xroad_pmaker_total_t* obj);
 
 
 
/* xroad_cancel_all_t */
 
xroad_errno_t xroad_cancel_all_set_exch(xroad_cancel_all_t* obj, void* ref);
 
xroad_errno_t xroad_cancel_all_set_exch_ref(xroad_cancel_all_t* obj, xroad_object_ref_t ref);
 
void* xroad_cancel_all_get_exch(const xroad_cancel_all_t* obj);
 
xroad_object_ref_t xroad_cancel_all_get_exch_ref(const xroad_cancel_all_t* obj);
 
void xroad_cancel_all_reset_exch(xroad_cancel_all_t* obj);
 
bool xroad_cancel_all_exch_is_set(const xroad_cancel_all_t* obj);
 
xroad_errno_t xroad_cancel_all_set_instr(xroad_cancel_all_t* obj, void* ref);
 
xroad_errno_t xroad_cancel_all_set_instr_ref(xroad_cancel_all_t* obj, xroad_object_ref_t ref);
 
void* xroad_cancel_all_get_instr(const xroad_cancel_all_t* obj);
 
xroad_object_ref_t xroad_cancel_all_get_instr_ref(const xroad_cancel_all_t* obj);
 
void xroad_cancel_all_reset_instr(xroad_cancel_all_t* obj);
 
bool xroad_cancel_all_instr_is_set(const xroad_cancel_all_t* obj);
 
xroad_errno_t xroad_cancel_all_set_account(xroad_cancel_all_t* obj, xroad_str_t val);
 
xroad_str_t xroad_cancel_all_get_account(const xroad_cancel_all_t* obj);
 
void xroad_cancel_all_reset_account(xroad_cancel_all_t* obj);
 
bool xroad_cancel_all_account_is_set(const xroad_cancel_all_t* obj);
 
xroad_errno_t xroad_cancel_all_set_side(xroad_cancel_all_t* obj, xroad_side_t val);
 
xroad_side_t xroad_cancel_all_get_side(const xroad_cancel_all_t* obj);
 
void xroad_cancel_all_reset_side(xroad_cancel_all_t* obj);
 
bool xroad_cancel_all_side_is_set(const xroad_cancel_all_t* obj);
 
void xroad_cancel_all_destroy(xroad_cancel_all_t* obj);
 
xroad_errno_t xroad_cancel_all_send(xroad_cancel_all_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_cancel_all_route(xroad_cancel_all_t* obj, ...);
 
void xroad_cancel_all_reset(xroad_cancel_all_t* obj);
 
xroad_cancel_all_t* xroad_cancel_all_clone(const xroad_cancel_all_t* obj);
 
bool xroad_cancel_all_is_valid(const xroad_cancel_all_t* obj);
 
int32_t xroad_cancel_all_print(const xroad_cancel_all_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_cancel_all_calc_hash(const xroad_cancel_all_t* obj);
 
xroad_str_t xroad_cancel_all_calc_uniq_id(const xroad_cancel_all_t* obj);
 
 
 
/* xroad_pos_reset_t */
 
xroad_object_id_t xroad_pos_reset_get_id(const xroad_pos_reset_t* obj);
 
xroad_object_ref_t xroad_pos_reset_get_ref(const xroad_pos_reset_t* obj);
 
xroad_errno_t xroad_pos_reset_set_deleted(xroad_pos_reset_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_pos_reset_get_deleted(const xroad_pos_reset_t* obj);
 
void xroad_pos_reset_reset_deleted(xroad_pos_reset_t* obj);
 
bool xroad_pos_reset_deleted_is_set(const xroad_pos_reset_t* obj);
 
xroad_errno_t xroad_pos_reset_set_sender(xroad_pos_reset_t* obj, xroad_str_t val);
 
xroad_str_t xroad_pos_reset_get_sender(const xroad_pos_reset_t* obj);
 
void xroad_pos_reset_reset_sender(xroad_pos_reset_t* obj);
 
bool xroad_pos_reset_sender_is_set(const xroad_pos_reset_t* obj);
 
xroad_errno_t xroad_pos_reset_set_instr(xroad_pos_reset_t* obj, void* ref);
 
xroad_errno_t xroad_pos_reset_set_instr_ref(xroad_pos_reset_t* obj, xroad_object_ref_t ref);
 
void* xroad_pos_reset_get_instr(const xroad_pos_reset_t* obj);
 
xroad_object_ref_t xroad_pos_reset_get_instr_ref(const xroad_pos_reset_t* obj);
 
void xroad_pos_reset_reset_instr(xroad_pos_reset_t* obj);
 
bool xroad_pos_reset_instr_is_set(const xroad_pos_reset_t* obj);
 
xroad_errno_t xroad_pos_reset_set_realized_pnl(xroad_pos_reset_t* obj, xroad_price_t val);
 
xroad_price_t xroad_pos_reset_get_realized_pnl(const xroad_pos_reset_t* obj);
 
void xroad_pos_reset_reset_realized_pnl(xroad_pos_reset_t* obj);
 
bool xroad_pos_reset_realized_pnl_is_set(const xroad_pos_reset_t* obj);
 
xroad_errno_t xroad_pos_reset_set_total_buy(xroad_pos_reset_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_pos_reset_get_total_buy(const xroad_pos_reset_t* obj);
 
void xroad_pos_reset_reset_total_buy(xroad_pos_reset_t* obj);
 
bool xroad_pos_reset_total_buy_is_set(const xroad_pos_reset_t* obj);
 
xroad_errno_t xroad_pos_reset_set_total_sell(xroad_pos_reset_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_pos_reset_get_total_sell(const xroad_pos_reset_t* obj);
 
void xroad_pos_reset_reset_total_sell(xroad_pos_reset_t* obj);
 
bool xroad_pos_reset_total_sell_is_set(const xroad_pos_reset_t* obj);
 
xroad_errno_t xroad_pos_reset_set_avg_price(xroad_pos_reset_t* obj, xroad_price_t val);
 
xroad_price_t xroad_pos_reset_get_avg_price(const xroad_pos_reset_t* obj);
 
void xroad_pos_reset_reset_avg_price(xroad_pos_reset_t* obj);
 
bool xroad_pos_reset_avg_price_is_set(const xroad_pos_reset_t* obj);
 
xroad_errno_t xroad_pos_reset_set_last_trd(xroad_pos_reset_t* obj, void* ref);
 
xroad_errno_t xroad_pos_reset_set_last_trd_ref(xroad_pos_reset_t* obj, xroad_object_ref_t ref);
 
void* xroad_pos_reset_get_last_trd(const xroad_pos_reset_t* obj);
 
xroad_object_ref_t xroad_pos_reset_get_last_trd_ref(const xroad_pos_reset_t* obj);
 
void xroad_pos_reset_reset_last_trd(xroad_pos_reset_t* obj);
 
bool xroad_pos_reset_last_trd_is_set(const xroad_pos_reset_t* obj);
 
xroad_errno_t xroad_pos_reset_send(xroad_pos_reset_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_pos_reset_route(xroad_pos_reset_t* obj, ...);
 
void xroad_pos_reset_reset(xroad_pos_reset_t* obj);
 
xroad_pos_reset_t* xroad_pos_reset_clone(const xroad_pos_reset_t* obj);
 
bool xroad_pos_reset_is_valid(const xroad_pos_reset_t* obj);
 
int32_t xroad_pos_reset_print(const xroad_pos_reset_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_pos_reset_calc_hash(const xroad_pos_reset_t* obj);
 
xroad_str_t xroad_pos_reset_calc_uniq_id(const xroad_pos_reset_t* obj);
 
 
 
/* xroad_acc_int_request_t */
 
xroad_errno_t xroad_acc_int_request_set_node_id(xroad_acc_int_request_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_acc_int_request_get_node_id(const xroad_acc_int_request_t* obj);
 
void xroad_acc_int_request_reset_node_id(xroad_acc_int_request_t* obj);
 
bool xroad_acc_int_request_node_id_is_set(const xroad_acc_int_request_t* obj);
 
xroad_errno_t xroad_acc_int_request_set_req_id(xroad_acc_int_request_t* obj, xroad_str_t val);
 
xroad_str_t xroad_acc_int_request_get_req_id(const xroad_acc_int_request_t* obj);
 
void xroad_acc_int_request_reset_req_id(xroad_acc_int_request_t* obj);
 
bool xroad_acc_int_request_req_id_is_set(const xroad_acc_int_request_t* obj);
 
xroad_errno_t xroad_acc_int_request_set_user_id(xroad_acc_int_request_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_acc_int_request_get_user_id(const xroad_acc_int_request_t* obj);
 
void xroad_acc_int_request_reset_user_id(xroad_acc_int_request_t* obj);
 
bool xroad_acc_int_request_user_id_is_set(const xroad_acc_int_request_t* obj);
 
xroad_errno_t xroad_acc_int_request_set_instr(xroad_acc_int_request_t* obj, void* ref);
 
xroad_errno_t xroad_acc_int_request_set_instr_ref(xroad_acc_int_request_t* obj, xroad_object_ref_t ref);
 
void* xroad_acc_int_request_get_instr(const xroad_acc_int_request_t* obj);
 
xroad_object_ref_t xroad_acc_int_request_get_instr_ref(const xroad_acc_int_request_t* obj);
 
void xroad_acc_int_request_reset_instr(xroad_acc_int_request_t* obj);
 
bool xroad_acc_int_request_instr_is_set(const xroad_acc_int_request_t* obj);
 
xroad_errno_t xroad_acc_int_request_set_date(xroad_acc_int_request_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_acc_int_request_get_date(const xroad_acc_int_request_t* obj);
 
void xroad_acc_int_request_reset_date(xroad_acc_int_request_t* obj);
 
bool xroad_acc_int_request_date_is_set(const xroad_acc_int_request_t* obj);
 
void xroad_acc_int_request_destroy(xroad_acc_int_request_t* obj);
 
xroad_errno_t xroad_acc_int_request_send(xroad_acc_int_request_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_acc_int_request_route(xroad_acc_int_request_t* obj, ...);
 
void xroad_acc_int_request_reset(xroad_acc_int_request_t* obj);
 
xroad_acc_int_request_t* xroad_acc_int_request_clone(const xroad_acc_int_request_t* obj);
 
bool xroad_acc_int_request_is_valid(const xroad_acc_int_request_t* obj);
 
int32_t xroad_acc_int_request_print(const xroad_acc_int_request_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_acc_int_request_calc_hash(const xroad_acc_int_request_t* obj);
 
xroad_str_t xroad_acc_int_request_calc_uniq_id(const xroad_acc_int_request_t* obj);
 
 
 
/* xroad_acc_int_response_t */
 
xroad_errno_t xroad_acc_int_response_set_req_id(xroad_acc_int_response_t* obj, xroad_str_t val);
 
xroad_str_t xroad_acc_int_response_get_req_id(const xroad_acc_int_response_t* obj);
 
void xroad_acc_int_response_reset_req_id(xroad_acc_int_response_t* obj);
 
bool xroad_acc_int_response_req_id_is_set(const xroad_acc_int_response_t* obj);
 
xroad_errno_t xroad_acc_int_response_set_value(xroad_acc_int_response_t* obj, xroad_price_t val);
 
xroad_price_t xroad_acc_int_response_get_value(const xroad_acc_int_response_t* obj);
 
void xroad_acc_int_response_reset_value(xroad_acc_int_response_t* obj);
 
bool xroad_acc_int_response_value_is_set(const xroad_acc_int_response_t* obj);
 
xroad_errno_t xroad_acc_int_response_set_text(xroad_acc_int_response_t* obj, xroad_str_t val);
 
xroad_str_t xroad_acc_int_response_get_text(const xroad_acc_int_response_t* obj);
 
void xroad_acc_int_response_reset_text(xroad_acc_int_response_t* obj);
 
bool xroad_acc_int_response_text_is_set(const xroad_acc_int_response_t* obj);
 
void xroad_acc_int_response_destroy(xroad_acc_int_response_t* obj);
 
xroad_errno_t xroad_acc_int_response_send(xroad_acc_int_response_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_acc_int_response_route(xroad_acc_int_response_t* obj, ...);
 
void xroad_acc_int_response_reset(xroad_acc_int_response_t* obj);
 
xroad_acc_int_response_t* xroad_acc_int_response_clone(const xroad_acc_int_response_t* obj);
 
bool xroad_acc_int_response_is_valid(const xroad_acc_int_response_t* obj);
 
int32_t xroad_acc_int_response_print(const xroad_acc_int_response_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_acc_int_response_calc_hash(const xroad_acc_int_response_t* obj);
 
xroad_str_t xroad_acc_int_response_calc_uniq_id(const xroad_acc_int_response_t* obj);
 
 
 
/* xroad_fund_asset_t */
 
xroad_object_id_t xroad_fund_asset_get_id(const xroad_fund_asset_t* obj);
 
xroad_object_ref_t xroad_fund_asset_get_ref(const xroad_fund_asset_t* obj);
 
xroad_errno_t xroad_fund_asset_set_deleted(xroad_fund_asset_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_fund_asset_get_deleted(const xroad_fund_asset_t* obj);
 
void xroad_fund_asset_reset_deleted(xroad_fund_asset_t* obj);
 
bool xroad_fund_asset_deleted_is_set(const xroad_fund_asset_t* obj);
 
xroad_errno_t xroad_fund_asset_set_pmaker(xroad_fund_asset_t* obj, void* ref);
 
xroad_errno_t xroad_fund_asset_set_pmaker_ref(xroad_fund_asset_t* obj, xroad_object_ref_t ref);
 
void* xroad_fund_asset_get_pmaker(const xroad_fund_asset_t* obj);
 
xroad_object_ref_t xroad_fund_asset_get_pmaker_ref(const xroad_fund_asset_t* obj);
 
void xroad_fund_asset_reset_pmaker(xroad_fund_asset_t* obj);
 
bool xroad_fund_asset_pmaker_is_set(const xroad_fund_asset_t* obj);
 
xroad_errno_t xroad_fund_asset_set_isin(xroad_fund_asset_t* obj, xroad_str_t val);
 
xroad_str_t xroad_fund_asset_get_isin(const xroad_fund_asset_t* obj);
 
void xroad_fund_asset_reset_isin(xroad_fund_asset_t* obj);
 
bool xroad_fund_asset_isin_is_set(const xroad_fund_asset_t* obj);
 
xroad_errno_t xroad_fund_asset_set_bb_code(xroad_fund_asset_t* obj, xroad_str_t val);
 
xroad_str_t xroad_fund_asset_get_bb_code(const xroad_fund_asset_t* obj);
 
void xroad_fund_asset_reset_bb_code(xroad_fund_asset_t* obj);
 
bool xroad_fund_asset_bb_code_is_set(const xroad_fund_asset_t* obj);
 
xroad_errno_t xroad_fund_asset_set_price(xroad_fund_asset_t* obj, xroad_double_t val);
 
xroad_double_t xroad_fund_asset_get_price(const xroad_fund_asset_t* obj);
 
void xroad_fund_asset_reset_price(xroad_fund_asset_t* obj);
 
bool xroad_fund_asset_price_is_set(const xroad_fund_asset_t* obj);
 
xroad_errno_t xroad_fund_asset_set_qty(xroad_fund_asset_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_fund_asset_get_qty(const xroad_fund_asset_t* obj);
 
void xroad_fund_asset_reset_qty(xroad_fund_asset_t* obj);
 
bool xroad_fund_asset_qty_is_set(const xroad_fund_asset_t* obj);
 
xroad_errno_t xroad_fund_asset_set_acc_int(xroad_fund_asset_t* obj, xroad_double_t val);
 
xroad_double_t xroad_fund_asset_get_acc_int(const xroad_fund_asset_t* obj);
 
void xroad_fund_asset_reset_acc_int(xroad_fund_asset_t* obj);
 
bool xroad_fund_asset_acc_int_is_set(const xroad_fund_asset_t* obj);
 
xroad_errno_t xroad_fund_asset_set_market_price(xroad_fund_asset_t* obj, xroad_price_t val);
 
xroad_price_t xroad_fund_asset_get_market_price(const xroad_fund_asset_t* obj);
 
void xroad_fund_asset_reset_market_price(xroad_fund_asset_t* obj);
 
bool xroad_fund_asset_market_price_is_set(const xroad_fund_asset_t* obj);
 
xroad_errno_t xroad_fund_asset_set_market_value(xroad_fund_asset_t* obj, xroad_double_t val);
 
xroad_double_t xroad_fund_asset_get_market_value(const xroad_fund_asset_t* obj);
 
void xroad_fund_asset_reset_market_value(xroad_fund_asset_t* obj);
 
bool xroad_fund_asset_market_value_is_set(const xroad_fund_asset_t* obj);
 
xroad_errno_t xroad_fund_asset_set_cur_rate(xroad_fund_asset_t* obj, xroad_price_t val);
 
xroad_price_t xroad_fund_asset_get_cur_rate(const xroad_fund_asset_t* obj);
 
void xroad_fund_asset_reset_cur_rate(xroad_fund_asset_t* obj);
 
bool xroad_fund_asset_cur_rate_is_set(const xroad_fund_asset_t* obj);
 
xroad_errno_t xroad_fund_asset_set_weight(xroad_fund_asset_t* obj, xroad_double_t val);
 
xroad_double_t xroad_fund_asset_get_weight(const xroad_fund_asset_t* obj);
 
void xroad_fund_asset_reset_weight(xroad_fund_asset_t* obj);
 
bool xroad_fund_asset_weight_is_set(const xroad_fund_asset_t* obj);
 
xroad_errno_t xroad_fund_asset_set_hedge_instr(xroad_fund_asset_t* obj, void* ref);
 
xroad_errno_t xroad_fund_asset_set_hedge_instr_ref(xroad_fund_asset_t* obj, xroad_object_ref_t ref);
 
void* xroad_fund_asset_get_hedge_instr(const xroad_fund_asset_t* obj);
 
xroad_object_ref_t xroad_fund_asset_get_hedge_instr_ref(const xroad_fund_asset_t* obj);
 
void xroad_fund_asset_reset_hedge_instr(xroad_fund_asset_t* obj);
 
bool xroad_fund_asset_hedge_instr_is_set(const xroad_fund_asset_t* obj);
 
xroad_errno_t xroad_fund_asset_set_hedge_total(xroad_fund_asset_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_fund_asset_get_hedge_total(const xroad_fund_asset_t* obj);
 
void xroad_fund_asset_reset_hedge_total(xroad_fund_asset_t* obj);
 
bool xroad_fund_asset_hedge_total_is_set(const xroad_fund_asset_t* obj);
 
xroad_errno_t xroad_fund_asset_send(xroad_fund_asset_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_fund_asset_route(xroad_fund_asset_t* obj, ...);
 
void xroad_fund_asset_reset(xroad_fund_asset_t* obj);
 
xroad_fund_asset_t* xroad_fund_asset_clone(const xroad_fund_asset_t* obj);
 
bool xroad_fund_asset_is_valid(const xroad_fund_asset_t* obj);
 
int32_t xroad_fund_asset_print(const xroad_fund_asset_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_fund_asset_calc_hash(const xroad_fund_asset_t* obj);
 
xroad_str_t xroad_fund_asset_calc_uniq_id(const xroad_fund_asset_t* obj);
 
 
 
/* xroad_rps_robot_t */
 
xroad_object_id_t xroad_rps_robot_get_id(const xroad_rps_robot_t* obj);
 
xroad_object_ref_t xroad_rps_robot_get_ref(const xroad_rps_robot_t* obj);
 
xroad_errno_t xroad_rps_robot_set_node_id(xroad_rps_robot_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_rps_robot_get_node_id(const xroad_rps_robot_t* obj);
 
void xroad_rps_robot_reset_node_id(xroad_rps_robot_t* obj);
 
bool xroad_rps_robot_node_id_is_set(const xroad_rps_robot_t* obj);
 
xroad_errno_t xroad_rps_robot_set_disabled(xroad_rps_robot_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_rps_robot_get_disabled(const xroad_rps_robot_t* obj);
 
void xroad_rps_robot_reset_disabled(xroad_rps_robot_t* obj);
 
bool xroad_rps_robot_disabled_is_set(const xroad_rps_robot_t* obj);
 
xroad_errno_t xroad_rps_robot_set_start_ts(xroad_rps_robot_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_rps_robot_get_start_ts(const xroad_rps_robot_t* obj);
 
void xroad_rps_robot_reset_start_ts(xroad_rps_robot_t* obj);
 
bool xroad_rps_robot_start_ts_is_set(const xroad_rps_robot_t* obj);
 
xroad_errno_t xroad_rps_robot_set_total_buy(xroad_rps_robot_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_rps_robot_get_total_buy(const xroad_rps_robot_t* obj);
 
void xroad_rps_robot_reset_total_buy(xroad_rps_robot_t* obj);
 
bool xroad_rps_robot_total_buy_is_set(const xroad_rps_robot_t* obj);
 
xroad_errno_t xroad_rps_robot_set_total_sell(xroad_rps_robot_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_rps_robot_get_total_sell(const xroad_rps_robot_t* obj);
 
void xroad_rps_robot_reset_total_sell(xroad_rps_robot_t* obj);
 
bool xroad_rps_robot_total_sell_is_set(const xroad_rps_robot_t* obj);
 
xroad_errno_t xroad_rps_robot_send(xroad_rps_robot_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_rps_robot_route(xroad_rps_robot_t* obj, ...);
 
void xroad_rps_robot_reset(xroad_rps_robot_t* obj);
 
xroad_rps_robot_t* xroad_rps_robot_clone(const xroad_rps_robot_t* obj);
 
bool xroad_rps_robot_is_valid(const xroad_rps_robot_t* obj);
 
int32_t xroad_rps_robot_print(const xroad_rps_robot_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_rps_robot_calc_hash(const xroad_rps_robot_t* obj);
 
xroad_str_t xroad_rps_robot_calc_uniq_id(const xroad_rps_robot_t* obj);
 
 
 
/* xroad_rps_filter_t */
 
xroad_object_id_t xroad_rps_filter_get_id(const xroad_rps_filter_t* obj);
 
xroad_object_ref_t xroad_rps_filter_get_ref(const xroad_rps_filter_t* obj);
 
xroad_errno_t xroad_rps_filter_set_deleted(xroad_rps_filter_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_rps_filter_get_deleted(const xroad_rps_filter_t* obj);
 
void xroad_rps_filter_reset_deleted(xroad_rps_filter_t* obj);
 
bool xroad_rps_filter_deleted_is_set(const xroad_rps_filter_t* obj);
 
xroad_errno_t xroad_rps_filter_set_rps_robot(xroad_rps_filter_t* obj, void* ref);
 
xroad_errno_t xroad_rps_filter_set_rps_robot_ref(xroad_rps_filter_t* obj, xroad_object_ref_t ref);
 
void* xroad_rps_filter_get_rps_robot(const xroad_rps_filter_t* obj);
 
xroad_object_ref_t xroad_rps_filter_get_rps_robot_ref(const xroad_rps_filter_t* obj);
 
void xroad_rps_filter_reset_rps_robot(xroad_rps_filter_t* obj);
 
bool xroad_rps_filter_rps_robot_is_set(const xroad_rps_filter_t* obj);
 
xroad_errno_t xroad_rps_filter_set_asset(xroad_rps_filter_t* obj, xroad_str_t val);
 
xroad_str_t xroad_rps_filter_get_asset(const xroad_rps_filter_t* obj);
 
void xroad_rps_filter_reset_asset(xroad_rps_filter_t* obj);
 
bool xroad_rps_filter_asset_is_set(const xroad_rps_filter_t* obj);
 
xroad_errno_t xroad_rps_filter_set_board(xroad_rps_filter_t* obj, xroad_str_t val);
 
xroad_str_t xroad_rps_filter_get_board(const xroad_rps_filter_t* obj);
 
void xroad_rps_filter_reset_board(xroad_rps_filter_t* obj);
 
bool xroad_rps_filter_board_is_set(const xroad_rps_filter_t* obj);
 
xroad_errno_t xroad_rps_filter_set_max_qty(xroad_rps_filter_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_rps_filter_get_max_qty(const xroad_rps_filter_t* obj);
 
void xroad_rps_filter_reset_max_qty(xroad_rps_filter_t* obj);
 
bool xroad_rps_filter_max_qty_is_set(const xroad_rps_filter_t* obj);
 
xroad_errno_t xroad_rps_filter_set_pmaker(xroad_rps_filter_t* obj, xroad_str_t val);
 
xroad_str_t xroad_rps_filter_get_pmaker(const xroad_rps_filter_t* obj);
 
void xroad_rps_filter_reset_pmaker(xroad_rps_filter_t* obj);
 
bool xroad_rps_filter_pmaker_is_set(const xroad_rps_filter_t* obj);
 
xroad_errno_t xroad_rps_filter_set_side(xroad_rps_filter_t* obj, xroad_side_t val);
 
xroad_side_t xroad_rps_filter_get_side(const xroad_rps_filter_t* obj);
 
void xroad_rps_filter_reset_side(xroad_rps_filter_t* obj);
 
bool xroad_rps_filter_side_is_set(const xroad_rps_filter_t* obj);
 
xroad_errno_t xroad_rps_filter_set_loss_dev(xroad_rps_filter_t* obj, xroad_double_t val);
 
xroad_double_t xroad_rps_filter_get_loss_dev(const xroad_rps_filter_t* obj);
 
void xroad_rps_filter_reset_loss_dev(xroad_rps_filter_t* obj);
 
bool xroad_rps_filter_loss_dev_is_set(const xroad_rps_filter_t* obj);
 
xroad_errno_t xroad_rps_filter_set_profit_dev(xroad_rps_filter_t* obj, xroad_double_t val);
 
xroad_double_t xroad_rps_filter_get_profit_dev(const xroad_rps_filter_t* obj);
 
void xroad_rps_filter_reset_profit_dev(xroad_rps_filter_t* obj);
 
bool xroad_rps_filter_profit_dev_is_set(const xroad_rps_filter_t* obj);
 
xroad_errno_t xroad_rps_filter_set_settl_code(xroad_rps_filter_t* obj, xroad_str_t val);
 
xroad_str_t xroad_rps_filter_get_settl_code(const xroad_rps_filter_t* obj);
 
void xroad_rps_filter_reset_settl_code(xroad_rps_filter_t* obj);
 
bool xroad_rps_filter_settl_code_is_set(const xroad_rps_filter_t* obj);
 
xroad_errno_t xroad_rps_filter_set_contragent(xroad_rps_filter_t* obj, xroad_str_t val);
 
xroad_str_t xroad_rps_filter_get_contragent(const xroad_rps_filter_t* obj);
 
void xroad_rps_filter_reset_contragent(xroad_rps_filter_t* obj);
 
bool xroad_rps_filter_contragent_is_set(const xroad_rps_filter_t* obj);
 
xroad_errno_t xroad_rps_filter_set_hedge_cur(xroad_rps_filter_t* obj, void* ref);
 
xroad_errno_t xroad_rps_filter_set_hedge_cur_ref(xroad_rps_filter_t* obj, xroad_object_ref_t ref);
 
void* xroad_rps_filter_get_hedge_cur(const xroad_rps_filter_t* obj);
 
xroad_object_ref_t xroad_rps_filter_get_hedge_cur_ref(const xroad_rps_filter_t* obj);
 
void xroad_rps_filter_reset_hedge_cur(xroad_rps_filter_t* obj);
 
bool xroad_rps_filter_hedge_cur_is_set(const xroad_rps_filter_t* obj);
 
xroad_errno_t xroad_rps_filter_set_enabled(xroad_rps_filter_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_rps_filter_get_enabled(const xroad_rps_filter_t* obj);
 
void xroad_rps_filter_reset_enabled(xroad_rps_filter_t* obj);
 
bool xroad_rps_filter_enabled_is_set(const xroad_rps_filter_t* obj);
 
xroad_errno_t xroad_rps_filter_set_spread(xroad_rps_filter_t* obj, xroad_double_t val);
 
xroad_double_t xroad_rps_filter_get_spread(const xroad_rps_filter_t* obj);
 
void xroad_rps_filter_reset_spread(xroad_rps_filter_t* obj);
 
bool xroad_rps_filter_spread_is_set(const xroad_rps_filter_t* obj);
 
xroad_errno_t xroad_rps_filter_set_inav(xroad_rps_filter_t* obj, xroad_str_t val);
 
xroad_str_t xroad_rps_filter_get_inav(const xroad_rps_filter_t* obj);
 
void xroad_rps_filter_reset_inav(xroad_rps_filter_t* obj);
 
bool xroad_rps_filter_inav_is_set(const xroad_rps_filter_t* obj);
 
xroad_errno_t xroad_rps_filter_set_mode(xroad_rps_filter_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_rps_filter_get_mode(const xroad_rps_filter_t* obj);
 
void xroad_rps_filter_reset_mode(xroad_rps_filter_t* obj);
 
bool xroad_rps_filter_mode_is_set(const xroad_rps_filter_t* obj);
 
xroad_errno_t xroad_rps_filter_set_stop_fill_qty(xroad_rps_filter_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_rps_filter_get_stop_fill_qty(const xroad_rps_filter_t* obj);
 
void xroad_rps_filter_reset_stop_fill_qty(xroad_rps_filter_t* obj);
 
bool xroad_rps_filter_stop_fill_qty_is_set(const xroad_rps_filter_t* obj);
 
xroad_errno_t xroad_rps_filter_set_total_buy(xroad_rps_filter_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_rps_filter_get_total_buy(const xroad_rps_filter_t* obj);
 
void xroad_rps_filter_reset_total_buy(xroad_rps_filter_t* obj);
 
bool xroad_rps_filter_total_buy_is_set(const xroad_rps_filter_t* obj);
 
xroad_errno_t xroad_rps_filter_set_total_sell(xroad_rps_filter_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_rps_filter_get_total_sell(const xroad_rps_filter_t* obj);
 
void xroad_rps_filter_reset_total_sell(xroad_rps_filter_t* obj);
 
bool xroad_rps_filter_total_sell_is_set(const xroad_rps_filter_t* obj);
 
xroad_errno_t xroad_rps_filter_send(xroad_rps_filter_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_rps_filter_route(xroad_rps_filter_t* obj, ...);
 
void xroad_rps_filter_reset(xroad_rps_filter_t* obj);
 
xroad_rps_filter_t* xroad_rps_filter_clone(const xroad_rps_filter_t* obj);
 
bool xroad_rps_filter_is_valid(const xroad_rps_filter_t* obj);
 
int32_t xroad_rps_filter_print(const xroad_rps_filter_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_rps_filter_calc_hash(const xroad_rps_filter_t* obj);
 
xroad_str_t xroad_rps_filter_calc_uniq_id(const xroad_rps_filter_t* obj);
 
void xroad_rps_filter_clear(xroad_rps_filter_t* obj);
 
 
/* xroad_fi_bot_t */
 
xroad_object_id_t xroad_fi_bot_get_id(const xroad_fi_bot_t* obj);
 
xroad_object_ref_t xroad_fi_bot_get_ref(const xroad_fi_bot_t* obj);
 
xroad_errno_t xroad_fi_bot_set_deleted(xroad_fi_bot_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_fi_bot_get_deleted(const xroad_fi_bot_t* obj);
 
void xroad_fi_bot_reset_deleted(xroad_fi_bot_t* obj);
 
bool xroad_fi_bot_deleted_is_set(const xroad_fi_bot_t* obj);
 
xroad_errno_t xroad_fi_bot_set_node_id(xroad_fi_bot_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_fi_bot_get_node_id(const xroad_fi_bot_t* obj);
 
void xroad_fi_bot_reset_node_id(xroad_fi_bot_t* obj);
 
bool xroad_fi_bot_node_id_is_set(const xroad_fi_bot_t* obj);
 
xroad_errno_t xroad_fi_bot_set_bid_enabled(xroad_fi_bot_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_fi_bot_get_bid_enabled(const xroad_fi_bot_t* obj);
 
void xroad_fi_bot_reset_bid_enabled(xroad_fi_bot_t* obj);
 
bool xroad_fi_bot_bid_enabled_is_set(const xroad_fi_bot_t* obj);
 
xroad_errno_t xroad_fi_bot_set_ask_enabled(xroad_fi_bot_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_fi_bot_get_ask_enabled(const xroad_fi_bot_t* obj);
 
void xroad_fi_bot_reset_ask_enabled(xroad_fi_bot_t* obj);
 
bool xroad_fi_bot_ask_enabled_is_set(const xroad_fi_bot_t* obj);
 
xroad_errno_t xroad_fi_bot_set_instr(xroad_fi_bot_t* obj, void* ref);
 
xroad_errno_t xroad_fi_bot_set_instr_ref(xroad_fi_bot_t* obj, xroad_object_ref_t ref);
 
void* xroad_fi_bot_get_instr(const xroad_fi_bot_t* obj);
 
xroad_object_ref_t xroad_fi_bot_get_instr_ref(const xroad_fi_bot_t* obj);
 
void xroad_fi_bot_reset_instr(xroad_fi_bot_t* obj);
 
bool xroad_fi_bot_instr_is_set(const xroad_fi_bot_t* obj);
 
xroad_errno_t xroad_fi_bot_set_bid_start(xroad_fi_bot_t* obj, xroad_price_t val);
 
xroad_price_t xroad_fi_bot_get_bid_start(const xroad_fi_bot_t* obj);
 
void xroad_fi_bot_reset_bid_start(xroad_fi_bot_t* obj);
 
bool xroad_fi_bot_bid_start_is_set(const xroad_fi_bot_t* obj);
 
xroad_errno_t xroad_fi_bot_set_bid_max(xroad_fi_bot_t* obj, xroad_price_t val);
 
xroad_price_t xroad_fi_bot_get_bid_max(const xroad_fi_bot_t* obj);
 
void xroad_fi_bot_reset_bid_max(xroad_fi_bot_t* obj);
 
bool xroad_fi_bot_bid_max_is_set(const xroad_fi_bot_t* obj);
 
xroad_errno_t xroad_fi_bot_set_bid_step(xroad_fi_bot_t* obj, xroad_price_t val);
 
xroad_price_t xroad_fi_bot_get_bid_step(const xroad_fi_bot_t* obj);
 
void xroad_fi_bot_reset_bid_step(xroad_fi_bot_t* obj);
 
bool xroad_fi_bot_bid_step_is_set(const xroad_fi_bot_t* obj);
 
xroad_errno_t xroad_fi_bot_set_ask_start(xroad_fi_bot_t* obj, xroad_price_t val);
 
xroad_price_t xroad_fi_bot_get_ask_start(const xroad_fi_bot_t* obj);
 
void xroad_fi_bot_reset_ask_start(xroad_fi_bot_t* obj);
 
bool xroad_fi_bot_ask_start_is_set(const xroad_fi_bot_t* obj);
 
xroad_errno_t xroad_fi_bot_set_ask_min(xroad_fi_bot_t* obj, xroad_price_t val);
 
xroad_price_t xroad_fi_bot_get_ask_min(const xroad_fi_bot_t* obj);
 
void xroad_fi_bot_reset_ask_min(xroad_fi_bot_t* obj);
 
bool xroad_fi_bot_ask_min_is_set(const xroad_fi_bot_t* obj);
 
xroad_errno_t xroad_fi_bot_set_ask_step(xroad_fi_bot_t* obj, xroad_price_t val);
 
xroad_price_t xroad_fi_bot_get_ask_step(const xroad_fi_bot_t* obj);
 
void xroad_fi_bot_reset_ask_step(xroad_fi_bot_t* obj);
 
bool xroad_fi_bot_ask_step_is_set(const xroad_fi_bot_t* obj);
 
xroad_errno_t xroad_fi_bot_set_qty(xroad_fi_bot_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_fi_bot_get_qty(const xroad_fi_bot_t* obj);
 
void xroad_fi_bot_reset_qty(xroad_fi_bot_t* obj);
 
bool xroad_fi_bot_qty_is_set(const xroad_fi_bot_t* obj);
 
xroad_errno_t xroad_fi_bot_set_max_qty(xroad_fi_bot_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_fi_bot_get_max_qty(const xroad_fi_bot_t* obj);
 
void xroad_fi_bot_reset_max_qty(xroad_fi_bot_t* obj);
 
bool xroad_fi_bot_max_qty_is_set(const xroad_fi_bot_t* obj);
 
xroad_errno_t xroad_fi_bot_set_bid_price(xroad_fi_bot_t* obj, xroad_price_t val);
 
xroad_price_t xroad_fi_bot_get_bid_price(const xroad_fi_bot_t* obj);
 
void xroad_fi_bot_reset_bid_price(xroad_fi_bot_t* obj);
 
bool xroad_fi_bot_bid_price_is_set(const xroad_fi_bot_t* obj);
 
xroad_errno_t xroad_fi_bot_set_ask_price(xroad_fi_bot_t* obj, xroad_price_t val);
 
xroad_price_t xroad_fi_bot_get_ask_price(const xroad_fi_bot_t* obj);
 
void xroad_fi_bot_reset_ask_price(xroad_fi_bot_t* obj);
 
bool xroad_fi_bot_ask_price_is_set(const xroad_fi_bot_t* obj);
 
xroad_errno_t xroad_fi_bot_set_total_buy(xroad_fi_bot_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_fi_bot_get_total_buy(const xroad_fi_bot_t* obj);
 
void xroad_fi_bot_reset_total_buy(xroad_fi_bot_t* obj);
 
bool xroad_fi_bot_total_buy_is_set(const xroad_fi_bot_t* obj);
 
xroad_errno_t xroad_fi_bot_set_total_sell(xroad_fi_bot_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_fi_bot_get_total_sell(const xroad_fi_bot_t* obj);
 
void xroad_fi_bot_reset_total_sell(xroad_fi_bot_t* obj);
 
bool xroad_fi_bot_total_sell_is_set(const xroad_fi_bot_t* obj);
 
xroad_errno_t xroad_fi_bot_set_bid_state(xroad_fi_bot_t* obj, xroad_opt_mm_state_t val);
 
xroad_opt_mm_state_t xroad_fi_bot_get_bid_state(const xroad_fi_bot_t* obj);
 
void xroad_fi_bot_reset_bid_state(xroad_fi_bot_t* obj);
 
bool xroad_fi_bot_bid_state_is_set(const xroad_fi_bot_t* obj);
 
xroad_errno_t xroad_fi_bot_set_ask_state(xroad_fi_bot_t* obj, xroad_opt_mm_state_t val);
 
xroad_opt_mm_state_t xroad_fi_bot_get_ask_state(const xroad_fi_bot_t* obj);
 
void xroad_fi_bot_reset_ask_state(xroad_fi_bot_t* obj);
 
bool xroad_fi_bot_ask_state_is_set(const xroad_fi_bot_t* obj);
 
xroad_errno_t xroad_fi_bot_send(xroad_fi_bot_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_fi_bot_route(xroad_fi_bot_t* obj, ...);
 
void xroad_fi_bot_reset(xroad_fi_bot_t* obj);
 
xroad_fi_bot_t* xroad_fi_bot_clone(const xroad_fi_bot_t* obj);
 
bool xroad_fi_bot_is_valid(const xroad_fi_bot_t* obj);
 
int32_t xroad_fi_bot_print(const xroad_fi_bot_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_fi_bot_calc_hash(const xroad_fi_bot_t* obj);
 
xroad_str_t xroad_fi_bot_calc_uniq_id(const xroad_fi_bot_t* obj);
 
 
 
/* xroad_mdsource_t */
 
xroad_object_id_t xroad_mdsource_get_id(const xroad_mdsource_t* obj);
 
xroad_object_ref_t xroad_mdsource_get_ref(const xroad_mdsource_t* obj);
 
xroad_errno_t xroad_mdsource_set_node_id(xroad_mdsource_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_mdsource_get_node_id(const xroad_mdsource_t* obj);
 
void xroad_mdsource_reset_node_id(xroad_mdsource_t* obj);
 
bool xroad_mdsource_node_id_is_set(const xroad_mdsource_t* obj);
 
xroad_errno_t xroad_mdsource_set_name(xroad_mdsource_t* obj, xroad_str_t val);
 
xroad_str_t xroad_mdsource_get_name(const xroad_mdsource_t* obj);
 
void xroad_mdsource_reset_name(xroad_mdsource_t* obj);
 
bool xroad_mdsource_name_is_set(const xroad_mdsource_t* obj);
 
xroad_errno_t xroad_mdsource_set_uri(xroad_mdsource_t* obj, xroad_str_t val);
 
xroad_str_t xroad_mdsource_get_uri(const xroad_mdsource_t* obj);
 
void xroad_mdsource_reset_uri(xroad_mdsource_t* obj);
 
bool xroad_mdsource_uri_is_set(const xroad_mdsource_t* obj);
 
xroad_errno_t xroad_mdsource_set_state(xroad_mdsource_t* obj, xroad_mdsource_state_t val);
 
xroad_mdsource_state_t xroad_mdsource_get_state(const xroad_mdsource_t* obj);
 
void xroad_mdsource_reset_state(xroad_mdsource_t* obj);
 
bool xroad_mdsource_state_is_set(const xroad_mdsource_t* obj);
 
xroad_errno_t xroad_mdsource_set_weight(xroad_mdsource_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_mdsource_get_weight(const xroad_mdsource_t* obj);
 
void xroad_mdsource_reset_weight(xroad_mdsource_t* obj);
 
bool xroad_mdsource_weight_is_set(const xroad_mdsource_t* obj);
 
xroad_errno_t xroad_mdsource_set_heartbeat(xroad_mdsource_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_mdsource_get_heartbeat(const xroad_mdsource_t* obj);
 
void xroad_mdsource_reset_heartbeat(xroad_mdsource_t* obj);
 
bool xroad_mdsource_heartbeat_is_set(const xroad_mdsource_t* obj);
 
xroad_errno_t xroad_mdsource_set_flags(xroad_mdsource_t* obj, xroad_int8_t val);
 
xroad_int8_t xroad_mdsource_get_flags(const xroad_mdsource_t* obj);
 
void xroad_mdsource_reset_flags(xroad_mdsource_t* obj);
 
bool xroad_mdsource_flags_is_set(const xroad_mdsource_t* obj);
 
xroad_errno_t xroad_mdsource_send(xroad_mdsource_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_mdsource_route(xroad_mdsource_t* obj, ...);
 
void xroad_mdsource_reset(xroad_mdsource_t* obj);
 
xroad_mdsource_t* xroad_mdsource_clone(const xroad_mdsource_t* obj);
 
bool xroad_mdsource_is_valid(const xroad_mdsource_t* obj);
 
int32_t xroad_mdsource_print(const xroad_mdsource_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_mdsource_calc_hash(const xroad_mdsource_t* obj);
 
xroad_str_t xroad_mdsource_calc_uniq_id(const xroad_mdsource_t* obj);
 
 
 
/* xroad_instr_mdsource_t */
 
xroad_object_id_t xroad_instr_mdsource_get_id(const xroad_instr_mdsource_t* obj);
 
xroad_object_ref_t xroad_instr_mdsource_get_ref(const xroad_instr_mdsource_t* obj);
 
xroad_errno_t xroad_instr_mdsource_set_instr(xroad_instr_mdsource_t* obj, void* ref);
 
xroad_errno_t xroad_instr_mdsource_set_instr_ref(xroad_instr_mdsource_t* obj, xroad_object_ref_t ref);
 
void* xroad_instr_mdsource_get_instr(const xroad_instr_mdsource_t* obj);
 
xroad_object_ref_t xroad_instr_mdsource_get_instr_ref(const xroad_instr_mdsource_t* obj);
 
void xroad_instr_mdsource_reset_instr(xroad_instr_mdsource_t* obj);
 
bool xroad_instr_mdsource_instr_is_set(const xroad_instr_mdsource_t* obj);
 
xroad_errno_t xroad_instr_mdsource_set_mdsource(xroad_instr_mdsource_t* obj, void* ref);
 
xroad_errno_t xroad_instr_mdsource_set_mdsource_ref(xroad_instr_mdsource_t* obj, xroad_object_ref_t ref);
 
void* xroad_instr_mdsource_get_mdsource(const xroad_instr_mdsource_t* obj);
 
xroad_object_ref_t xroad_instr_mdsource_get_mdsource_ref(const xroad_instr_mdsource_t* obj);
 
void xroad_instr_mdsource_reset_mdsource(xroad_instr_mdsource_t* obj);
 
bool xroad_instr_mdsource_mdsource_is_set(const xroad_instr_mdsource_t* obj);
 
xroad_errno_t xroad_instr_mdsource_set_next(xroad_instr_mdsource_t* obj, void* ref);
 
xroad_errno_t xroad_instr_mdsource_set_next_ref(xroad_instr_mdsource_t* obj, xroad_object_ref_t ref);
 
void* xroad_instr_mdsource_get_next(const xroad_instr_mdsource_t* obj);
 
xroad_object_ref_t xroad_instr_mdsource_get_next_ref(const xroad_instr_mdsource_t* obj);
 
void xroad_instr_mdsource_reset_next(xroad_instr_mdsource_t* obj);
 
bool xroad_instr_mdsource_next_is_set(const xroad_instr_mdsource_t* obj);
 
xroad_errno_t xroad_instr_mdsource_send(xroad_instr_mdsource_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_instr_mdsource_route(xroad_instr_mdsource_t* obj, ...);
 
void xroad_instr_mdsource_reset(xroad_instr_mdsource_t* obj);
 
xroad_instr_mdsource_t* xroad_instr_mdsource_clone(const xroad_instr_mdsource_t* obj);
 
bool xroad_instr_mdsource_is_valid(const xroad_instr_mdsource_t* obj);
 
int32_t xroad_instr_mdsource_print(const xroad_instr_mdsource_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_instr_mdsource_calc_hash(const xroad_instr_mdsource_t* obj);
 
xroad_str_t xroad_instr_mdsource_calc_uniq_id(const xroad_instr_mdsource_t* obj);
 
 
 
/* xroad_instr_basket_t */
 
xroad_object_id_t xroad_instr_basket_get_id(const xroad_instr_basket_t* obj);
 
xroad_object_ref_t xroad_instr_basket_get_ref(const xroad_instr_basket_t* obj);
 
xroad_errno_t xroad_instr_basket_set_deleted(xroad_instr_basket_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_instr_basket_get_deleted(const xroad_instr_basket_t* obj);
 
void xroad_instr_basket_reset_deleted(xroad_instr_basket_t* obj);
 
bool xroad_instr_basket_deleted_is_set(const xroad_instr_basket_t* obj);
 
xroad_errno_t xroad_instr_basket_set_instr(xroad_instr_basket_t* obj, void* ref);
 
xroad_errno_t xroad_instr_basket_set_instr_ref(xroad_instr_basket_t* obj, xroad_object_ref_t ref);
 
void* xroad_instr_basket_get_instr(const xroad_instr_basket_t* obj);
 
xroad_object_ref_t xroad_instr_basket_get_instr_ref(const xroad_instr_basket_t* obj);
 
void xroad_instr_basket_reset_instr(xroad_instr_basket_t* obj);
 
bool xroad_instr_basket_instr_is_set(const xroad_instr_basket_t* obj);
 
xroad_errno_t xroad_instr_basket_set_next(xroad_instr_basket_t* obj, void* ref);
 
xroad_errno_t xroad_instr_basket_set_next_ref(xroad_instr_basket_t* obj, xroad_object_ref_t ref);
 
void* xroad_instr_basket_get_next(const xroad_instr_basket_t* obj);
 
xroad_object_ref_t xroad_instr_basket_get_next_ref(const xroad_instr_basket_t* obj);
 
void xroad_instr_basket_reset_next(xroad_instr_basket_t* obj);
 
bool xroad_instr_basket_next_is_set(const xroad_instr_basket_t* obj);
 
xroad_errno_t xroad_instr_basket_set_shares(xroad_instr_basket_t* obj, xroad_double_t val);
 
xroad_double_t xroad_instr_basket_get_shares(const xroad_instr_basket_t* obj);
 
void xroad_instr_basket_reset_shares(xroad_instr_basket_t* obj);
 
bool xroad_instr_basket_shares_is_set(const xroad_instr_basket_t* obj);
 
xroad_errno_t xroad_instr_basket_set_ask(xroad_instr_basket_t* obj, xroad_double_t val);
 
xroad_double_t xroad_instr_basket_get_ask(const xroad_instr_basket_t* obj);
 
void xroad_instr_basket_reset_ask(xroad_instr_basket_t* obj);
 
bool xroad_instr_basket_ask_is_set(const xroad_instr_basket_t* obj);
 
xroad_errno_t xroad_instr_basket_set_bid(xroad_instr_basket_t* obj, xroad_double_t val);
 
xroad_double_t xroad_instr_basket_get_bid(const xroad_instr_basket_t* obj);
 
void xroad_instr_basket_reset_bid(xroad_instr_basket_t* obj);
 
bool xroad_instr_basket_bid_is_set(const xroad_instr_basket_t* obj);
 
xroad_errno_t xroad_instr_basket_set_trade(xroad_instr_basket_t* obj, xroad_double_t val);
 
xroad_double_t xroad_instr_basket_get_trade(const xroad_instr_basket_t* obj);
 
void xroad_instr_basket_reset_trade(xroad_instr_basket_t* obj);
 
bool xroad_instr_basket_trade_is_set(const xroad_instr_basket_t* obj);
 
xroad_errno_t xroad_instr_basket_set_use_indval(xroad_instr_basket_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_instr_basket_get_use_indval(const xroad_instr_basket_t* obj);
 
void xroad_instr_basket_reset_use_indval(xroad_instr_basket_t* obj);
 
bool xroad_instr_basket_use_indval_is_set(const xroad_instr_basket_t* obj);
 
xroad_errno_t xroad_instr_basket_set_multiplier(xroad_instr_basket_t* obj, xroad_double_t val);
 
xroad_double_t xroad_instr_basket_get_multiplier(const xroad_instr_basket_t* obj);
 
void xroad_instr_basket_reset_multiplier(xroad_instr_basket_t* obj);
 
bool xroad_instr_basket_multiplier_is_set(const xroad_instr_basket_t* obj);
 
xroad_errno_t xroad_instr_basket_send(xroad_instr_basket_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_instr_basket_route(xroad_instr_basket_t* obj, ...);
 
void xroad_instr_basket_reset(xroad_instr_basket_t* obj);
 
xroad_instr_basket_t* xroad_instr_basket_clone(const xroad_instr_basket_t* obj);
 
bool xroad_instr_basket_is_valid(const xroad_instr_basket_t* obj);
 
int32_t xroad_instr_basket_print(const xroad_instr_basket_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_instr_basket_calc_hash(const xroad_instr_basket_t* obj);
 
xroad_str_t xroad_instr_basket_calc_uniq_id(const xroad_instr_basket_t* obj);
 
 
 
/* xroad_broker_t */
 
xroad_object_id_t xroad_broker_get_id(const xroad_broker_t* obj);
 
xroad_object_ref_t xroad_broker_get_ref(const xroad_broker_t* obj);
 
xroad_errno_t xroad_broker_set_name(xroad_broker_t* obj, xroad_str_t val);
 
xroad_str_t xroad_broker_get_name(const xroad_broker_t* obj);
 
void xroad_broker_reset_name(xroad_broker_t* obj);
 
bool xroad_broker_name_is_set(const xroad_broker_t* obj);
 
xroad_errno_t xroad_broker_send(xroad_broker_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_broker_route(xroad_broker_t* obj, ...);
 
void xroad_broker_reset(xroad_broker_t* obj);
 
xroad_broker_t* xroad_broker_clone(const xroad_broker_t* obj);
 
bool xroad_broker_is_valid(const xroad_broker_t* obj);
 
int32_t xroad_broker_print(const xroad_broker_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_broker_calc_hash(const xroad_broker_t* obj);
 
xroad_str_t xroad_broker_calc_uniq_id(const xroad_broker_t* obj);
 
 
 
/* xroad_spbex_bin_session_t */
 
xroad_object_id_t xroad_spbex_bin_session_get_id(const xroad_spbex_bin_session_t* obj);
 
xroad_object_ref_t xroad_spbex_bin_session_get_ref(const xroad_spbex_bin_session_t* obj);
 
xroad_errno_t xroad_spbex_bin_session_set_node_id(xroad_spbex_bin_session_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_spbex_bin_session_get_node_id(const xroad_spbex_bin_session_t* obj);
 
void xroad_spbex_bin_session_reset_node_id(xroad_spbex_bin_session_t* obj);
 
bool xroad_spbex_bin_session_node_id_is_set(const xroad_spbex_bin_session_t* obj);
 
xroad_errno_t xroad_spbex_bin_session_set_cur_seq_num_in(xroad_spbex_bin_session_t* obj, xroad_int64_t val);
 
xroad_int64_t xroad_spbex_bin_session_get_cur_seq_num_in(const xroad_spbex_bin_session_t* obj);
 
void xroad_spbex_bin_session_reset_cur_seq_num_in(xroad_spbex_bin_session_t* obj);
 
bool xroad_spbex_bin_session_cur_seq_num_in_is_set(const xroad_spbex_bin_session_t* obj);
 
xroad_errno_t xroad_spbex_bin_session_set_next_seq_num_out(xroad_spbex_bin_session_t* obj, xroad_int64_t val);
 
xroad_int64_t xroad_spbex_bin_session_get_next_seq_num_out(const xroad_spbex_bin_session_t* obj);
 
void xroad_spbex_bin_session_reset_next_seq_num_out(xroad_spbex_bin_session_t* obj);
 
bool xroad_spbex_bin_session_next_seq_num_out_is_set(const xroad_spbex_bin_session_t* obj);
 
xroad_errno_t xroad_spbex_bin_session_send(xroad_spbex_bin_session_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_spbex_bin_session_route(xroad_spbex_bin_session_t* obj, ...);
 
void xroad_spbex_bin_session_reset(xroad_spbex_bin_session_t* obj);
 
xroad_spbex_bin_session_t* xroad_spbex_bin_session_clone(const xroad_spbex_bin_session_t* obj);
 
bool xroad_spbex_bin_session_is_valid(const xroad_spbex_bin_session_t* obj);
 
int32_t xroad_spbex_bin_session_print(const xroad_spbex_bin_session_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_spbex_bin_session_calc_hash(const xroad_spbex_bin_session_t* obj);
 
xroad_str_t xroad_spbex_bin_session_calc_uniq_id(const xroad_spbex_bin_session_t* obj);
 
 
 
/* xroad_order_spbex_t */
 
xroad_object_id_t xroad_order_spbex_get_id(const xroad_order_spbex_t* obj);
 
xroad_object_ref_t xroad_order_spbex_get_ref(const xroad_order_spbex_t* obj);
 
xroad_errno_t xroad_order_spbex_set_node_id(xroad_order_spbex_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_order_spbex_get_node_id(const xroad_order_spbex_t* obj);
 
void xroad_order_spbex_reset_node_id(xroad_order_spbex_t* obj);
 
bool xroad_order_spbex_node_id_is_set(const xroad_order_spbex_t* obj);
 
xroad_errno_t xroad_order_spbex_set_order(xroad_order_spbex_t* obj, void* ref);
 
xroad_errno_t xroad_order_spbex_set_order_ref(xroad_order_spbex_t* obj, xroad_object_ref_t ref);
 
void* xroad_order_spbex_get_order(const xroad_order_spbex_t* obj);
 
xroad_object_ref_t xroad_order_spbex_get_order_ref(const xroad_order_spbex_t* obj);
 
void xroad_order_spbex_reset_order(xroad_order_spbex_t* obj);
 
bool xroad_order_spbex_order_is_set(const xroad_order_spbex_t* obj);
 
xroad_errno_t xroad_order_spbex_set_last_timestamp(xroad_order_spbex_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_order_spbex_get_last_timestamp(const xroad_order_spbex_t* obj);
 
void xroad_order_spbex_reset_last_timestamp(xroad_order_spbex_t* obj);
 
bool xroad_order_spbex_last_timestamp_is_set(const xroad_order_spbex_t* obj);
 
xroad_errno_t xroad_order_spbex_set_last_seq_num(xroad_order_spbex_t* obj, xroad_int64_t val);
 
xroad_int64_t xroad_order_spbex_get_last_seq_num(const xroad_order_spbex_t* obj);
 
void xroad_order_spbex_reset_last_seq_num(xroad_order_spbex_t* obj);
 
bool xroad_order_spbex_last_seq_num_is_set(const xroad_order_spbex_t* obj);
 
xroad_errno_t xroad_order_spbex_set_price(xroad_order_spbex_t* obj, xroad_price_t val);
 
xroad_price_t xroad_order_spbex_get_price(const xroad_order_spbex_t* obj);
 
void xroad_order_spbex_reset_price(xroad_order_spbex_t* obj);
 
bool xroad_order_spbex_price_is_set(const xroad_order_spbex_t* obj);
 
xroad_errno_t xroad_order_spbex_set_qty(xroad_order_spbex_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_order_spbex_get_qty(const xroad_order_spbex_t* obj);
 
void xroad_order_spbex_reset_qty(xroad_order_spbex_t* obj);
 
bool xroad_order_spbex_qty_is_set(const xroad_order_spbex_t* obj);
 
xroad_errno_t xroad_order_spbex_send(xroad_order_spbex_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_order_spbex_route(xroad_order_spbex_t* obj, ...);
 
void xroad_order_spbex_reset(xroad_order_spbex_t* obj);
 
xroad_order_spbex_t* xroad_order_spbex_clone(const xroad_order_spbex_t* obj);
 
bool xroad_order_spbex_is_valid(const xroad_order_spbex_t* obj);
 
int32_t xroad_order_spbex_print(const xroad_order_spbex_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_order_spbex_calc_hash(const xroad_order_spbex_t* obj);
 
xroad_str_t xroad_order_spbex_calc_uniq_id(const xroad_order_spbex_t* obj);
 
 
 
/* xroad_scheduled_t */
 
xroad_object_id_t xroad_scheduled_get_id(const xroad_scheduled_t* obj);
 
xroad_object_ref_t xroad_scheduled_get_ref(const xroad_scheduled_t* obj);
 
xroad_errno_t xroad_scheduled_set_start(xroad_scheduled_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_scheduled_get_start(const xroad_scheduled_t* obj);
 
void xroad_scheduled_reset_start(xroad_scheduled_t* obj);
 
bool xroad_scheduled_start_is_set(const xroad_scheduled_t* obj);
 
xroad_errno_t xroad_scheduled_send(xroad_scheduled_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_scheduled_route(xroad_scheduled_t* obj, ...);
 
void xroad_scheduled_reset(xroad_scheduled_t* obj);
 
xroad_scheduled_t* xroad_scheduled_clone(const xroad_scheduled_t* obj);
 
bool xroad_scheduled_is_valid(const xroad_scheduled_t* obj);
 
int32_t xroad_scheduled_print(const xroad_scheduled_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_scheduled_calc_hash(const xroad_scheduled_t* obj);
 
xroad_str_t xroad_scheduled_calc_uniq_id(const xroad_scheduled_t* obj);
 
 
 
/* xroad_mdconsumer_t */
 
xroad_object_id_t xroad_mdconsumer_get_id(const xroad_mdconsumer_t* obj);
 
xroad_object_ref_t xroad_mdconsumer_get_ref(const xroad_mdconsumer_t* obj);
 
xroad_errno_t xroad_mdconsumer_set_instr(xroad_mdconsumer_t* obj, void* ref);
 
xroad_errno_t xroad_mdconsumer_set_instr_ref(xroad_mdconsumer_t* obj, xroad_object_ref_t ref);
 
void* xroad_mdconsumer_get_instr(const xroad_mdconsumer_t* obj);
 
xroad_object_ref_t xroad_mdconsumer_get_instr_ref(const xroad_mdconsumer_t* obj);
 
void xroad_mdconsumer_reset_instr(xroad_mdconsumer_t* obj);
 
bool xroad_mdconsumer_instr_is_set(const xroad_mdconsumer_t* obj);
 
xroad_errno_t xroad_mdconsumer_set_src_node_id(xroad_mdconsumer_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_mdconsumer_get_src_node_id(const xroad_mdconsumer_t* obj);
 
void xroad_mdconsumer_reset_src_node_id(xroad_mdconsumer_t* obj);
 
bool xroad_mdconsumer_src_node_id_is_set(const xroad_mdconsumer_t* obj);
 
xroad_errno_t xroad_mdconsumer_set_next(xroad_mdconsumer_t* obj, void* ref);
 
xroad_errno_t xroad_mdconsumer_set_next_ref(xroad_mdconsumer_t* obj, xroad_object_ref_t ref);
 
void* xroad_mdconsumer_get_next(const xroad_mdconsumer_t* obj);
 
xroad_object_ref_t xroad_mdconsumer_get_next_ref(const xroad_mdconsumer_t* obj);
 
void xroad_mdconsumer_reset_next(xroad_mdconsumer_t* obj);
 
bool xroad_mdconsumer_next_is_set(const xroad_mdconsumer_t* obj);
 
xroad_errno_t xroad_mdconsumer_send(xroad_mdconsumer_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_mdconsumer_route(xroad_mdconsumer_t* obj, ...);
 
void xroad_mdconsumer_reset(xroad_mdconsumer_t* obj);
 
xroad_mdconsumer_t* xroad_mdconsumer_clone(const xroad_mdconsumer_t* obj);
 
bool xroad_mdconsumer_is_valid(const xroad_mdconsumer_t* obj);
 
int32_t xroad_mdconsumer_print(const xroad_mdconsumer_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_mdconsumer_calc_hash(const xroad_mdconsumer_t* obj);
 
xroad_str_t xroad_mdconsumer_calc_uniq_id(const xroad_mdconsumer_t* obj);
 
 
 
/* xroad_pre_trade_t */
 
xroad_object_id_t xroad_pre_trade_get_id(const xroad_pre_trade_t* obj);
 
xroad_object_ref_t xroad_pre_trade_get_ref(const xroad_pre_trade_t* obj);
 
xroad_errno_t xroad_pre_trade_set_order(xroad_pre_trade_t* obj, void* ref);
 
xroad_errno_t xroad_pre_trade_set_order_ref(xroad_pre_trade_t* obj, xroad_object_ref_t ref);
 
void* xroad_pre_trade_get_order(const xroad_pre_trade_t* obj);
 
xroad_object_ref_t xroad_pre_trade_get_order_ref(const xroad_pre_trade_t* obj);
 
void xroad_pre_trade_reset_order(xroad_pre_trade_t* obj);
 
bool xroad_pre_trade_order_is_set(const xroad_pre_trade_t* obj);
 
xroad_errno_t xroad_pre_trade_set_exch_id(xroad_pre_trade_t* obj, xroad_str_t val);
 
xroad_str_t xroad_pre_trade_get_exch_id(const xroad_pre_trade_t* obj);
 
void xroad_pre_trade_reset_exch_id(xroad_pre_trade_t* obj);
 
bool xroad_pre_trade_exch_id_is_set(const xroad_pre_trade_t* obj);
 
xroad_errno_t xroad_pre_trade_set_price(xroad_pre_trade_t* obj, xroad_price_t val);
 
xroad_price_t xroad_pre_trade_get_price(const xroad_pre_trade_t* obj);
 
void xroad_pre_trade_reset_price(xroad_pre_trade_t* obj);
 
bool xroad_pre_trade_price_is_set(const xroad_pre_trade_t* obj);
 
xroad_errno_t xroad_pre_trade_set_qty(xroad_pre_trade_t* obj, xroad_qty_t val);
 
xroad_qty_t xroad_pre_trade_get_qty(const xroad_pre_trade_t* obj);
 
void xroad_pre_trade_reset_qty(xroad_pre_trade_t* obj);
 
bool xroad_pre_trade_qty_is_set(const xroad_pre_trade_t* obj);
 
xroad_errno_t xroad_pre_trade_set_ts(xroad_pre_trade_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_pre_trade_get_ts(const xroad_pre_trade_t* obj);
 
void xroad_pre_trade_reset_ts(xroad_pre_trade_t* obj);
 
bool xroad_pre_trade_ts_is_set(const xroad_pre_trade_t* obj);
 
xroad_errno_t xroad_pre_trade_send(xroad_pre_trade_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_pre_trade_route(xroad_pre_trade_t* obj, ...);
 
void xroad_pre_trade_reset(xroad_pre_trade_t* obj);
 
xroad_pre_trade_t* xroad_pre_trade_clone(const xroad_pre_trade_t* obj);
 
bool xroad_pre_trade_is_valid(const xroad_pre_trade_t* obj);
 
int32_t xroad_pre_trade_print(const xroad_pre_trade_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_pre_trade_calc_hash(const xroad_pre_trade_t* obj);
 
xroad_str_t xroad_pre_trade_calc_uniq_id(const xroad_pre_trade_t* obj);
 
 
 
/* xroad_pre_trade_ack_t */
 
xroad_object_id_t xroad_pre_trade_ack_get_id(const xroad_pre_trade_ack_t* obj);
 
xroad_object_ref_t xroad_pre_trade_ack_get_ref(const xroad_pre_trade_ack_t* obj);
 
xroad_errno_t xroad_pre_trade_ack_set_pre_trade(xroad_pre_trade_ack_t* obj, void* ref);
 
xroad_errno_t xroad_pre_trade_ack_set_pre_trade_ref(xroad_pre_trade_ack_t* obj, xroad_object_ref_t ref);
 
void* xroad_pre_trade_ack_get_pre_trade(const xroad_pre_trade_ack_t* obj);
 
xroad_object_ref_t xroad_pre_trade_ack_get_pre_trade_ref(const xroad_pre_trade_ack_t* obj);
 
void xroad_pre_trade_ack_reset_pre_trade(xroad_pre_trade_ack_t* obj);
 
bool xroad_pre_trade_ack_pre_trade_is_set(const xroad_pre_trade_ack_t* obj);
 
xroad_errno_t xroad_pre_trade_ack_set_status(xroad_pre_trade_ack_t* obj, xroad_pre_trade_status_t val);
 
xroad_pre_trade_status_t xroad_pre_trade_ack_get_status(const xroad_pre_trade_ack_t* obj);
 
void xroad_pre_trade_ack_reset_status(xroad_pre_trade_ack_t* obj);
 
bool xroad_pre_trade_ack_status_is_set(const xroad_pre_trade_ack_t* obj);
 
xroad_errno_t xroad_pre_trade_ack_set_ts(xroad_pre_trade_ack_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_pre_trade_ack_get_ts(const xroad_pre_trade_ack_t* obj);
 
void xroad_pre_trade_ack_reset_ts(xroad_pre_trade_ack_t* obj);
 
bool xroad_pre_trade_ack_ts_is_set(const xroad_pre_trade_ack_t* obj);
 
xroad_errno_t xroad_pre_trade_ack_send(xroad_pre_trade_ack_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_pre_trade_ack_route(xroad_pre_trade_ack_t* obj, ...);
 
void xroad_pre_trade_ack_reset(xroad_pre_trade_ack_t* obj);
 
xroad_pre_trade_ack_t* xroad_pre_trade_ack_clone(const xroad_pre_trade_ack_t* obj);
 
bool xroad_pre_trade_ack_is_valid(const xroad_pre_trade_ack_t* obj);
 
int32_t xroad_pre_trade_ack_print(const xroad_pre_trade_ack_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_pre_trade_ack_calc_hash(const xroad_pre_trade_ack_t* obj);
 
xroad_str_t xroad_pre_trade_ack_calc_uniq_id(const xroad_pre_trade_ack_t* obj);
 
 
 
/* xroad_speedway_t */
 
xroad_object_id_t xroad_speedway_get_id(const xroad_speedway_t* obj);
 
xroad_object_ref_t xroad_speedway_get_ref(const xroad_speedway_t* obj);
 
xroad_errno_t xroad_speedway_set_src_node_id(xroad_speedway_t* obj, xroad_node_id_t val);
 
xroad_node_id_t xroad_speedway_get_src_node_id(const xroad_speedway_t* obj);
 
void xroad_speedway_reset_src_node_id(xroad_speedway_t* obj);
 
bool xroad_speedway_src_node_id_is_set(const xroad_speedway_t* obj);
 
xroad_errno_t xroad_speedway_set_key(xroad_speedway_t* obj, xroad_str_t val);
 
xroad_str_t xroad_speedway_get_key(const xroad_speedway_t* obj);
 
void xroad_speedway_reset_key(xroad_speedway_t* obj);
 
bool xroad_speedway_key_is_set(const xroad_speedway_t* obj);
 
xroad_errno_t xroad_speedway_set_type(xroad_speedway_t* obj, xroad_field_type_t val);
 
xroad_field_type_t xroad_speedway_get_type(const xroad_speedway_t* obj);
 
void xroad_speedway_reset_type(xroad_speedway_t* obj);
 
bool xroad_speedway_type_is_set(const xroad_speedway_t* obj);
 
xroad_errno_t xroad_speedway_set_value(xroad_speedway_t* obj, xroad_binary_t val);
 
xroad_binary_t xroad_speedway_get_value(const xroad_speedway_t* obj);
 
void xroad_speedway_reset_value(xroad_speedway_t* obj);
 
bool xroad_speedway_value_is_set(const xroad_speedway_t* obj);
 
xroad_errno_t xroad_speedway_set_ts(xroad_speedway_t* obj, xroad_timestamp_t val);
 
xroad_timestamp_t xroad_speedway_get_ts(const xroad_speedway_t* obj);
 
void xroad_speedway_reset_ts(xroad_speedway_t* obj);
 
bool xroad_speedway_ts_is_set(const xroad_speedway_t* obj);
 
xroad_errno_t xroad_speedway_send(xroad_speedway_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_speedway_route(xroad_speedway_t* obj, ...);
 
void xroad_speedway_reset(xroad_speedway_t* obj);
 
xroad_speedway_t* xroad_speedway_clone(const xroad_speedway_t* obj);
 
bool xroad_speedway_is_valid(const xroad_speedway_t* obj);
 
int32_t xroad_speedway_print(const xroad_speedway_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_speedway_calc_hash(const xroad_speedway_t* obj);
 
xroad_str_t xroad_speedway_calc_uniq_id(const xroad_speedway_t* obj);
 
 
 
/* xroad_top_book_t */
 
xroad_object_id_t xroad_top_book_get_id(const xroad_top_book_t* obj);
 
xroad_object_ref_t xroad_top_book_get_ref(const xroad_top_book_t* obj);
 
xroad_errno_t xroad_top_book_set_sniper_mode(xroad_top_book_t* obj, xroad_bool_t val);
 
xroad_bool_t xroad_top_book_get_sniper_mode(const xroad_top_book_t* obj);
 
void xroad_top_book_reset_sniper_mode(xroad_top_book_t* obj);
 
bool xroad_top_book_sniper_mode_is_set(const xroad_top_book_t* obj);
 
xroad_errno_t xroad_top_book_set_step_size(xroad_top_book_t* obj, xroad_int32_t val);
 
xroad_int32_t xroad_top_book_get_step_size(const xroad_top_book_t* obj);
 
void xroad_top_book_reset_step_size(xroad_top_book_t* obj);
 
bool xroad_top_book_step_size_is_set(const xroad_top_book_t* obj);
 
xroad_errno_t xroad_top_book_send(xroad_top_book_t* obj, const xroad_node_id_t id);
 
xroad_errno_t xroad_top_book_route(xroad_top_book_t* obj, ...);
 
void xroad_top_book_reset(xroad_top_book_t* obj);
 
xroad_top_book_t* xroad_top_book_clone(const xroad_top_book_t* obj);
 
bool xroad_top_book_is_valid(const xroad_top_book_t* obj);
 
int32_t xroad_top_book_print(const xroad_top_book_t* obj, char* buf, size_t buf_len);
 
uint64_t xroad_top_book_calc_hash(const xroad_top_book_t* obj);
 
xroad_str_t xroad_top_book_calc_uniq_id(const xroad_top_book_t* obj);
 
 
 
#ifdef __cplusplus
}
#endif