cdqcsim

Go to the documentation of this file.

// <cdqcsim> -*- C++ -*-
 
#ifndef _CDQCSIM_INCLUDED_
#define _CDQCSIM_INCLUDED_
 
#include <cstdio>
#include <cstdarg>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <new>
 
#ifndef _DQCSIM_HDR_CPP_
#define _DQCSIM_HDR_CPP_
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
// For Doxygen:
namespace dqcsim {
namespace raw {
} // namespace raw
} // namespace dqcsim
 
 
namespace dqcsim {
namespace raw {
 
enum class dqcs_basis_t {
  DQCS_BASIS_INVALID = 0,
  DQCS_BASIS_X = 1,
  DQCS_BASIS_Y = 2,
  DQCS_BASIS_Z = 3,
};
 
enum class dqcs_bool_return_t {
  DQCS_BOOL_FAILURE = -1,
  DQCS_FALSE = 0,
  DQCS_TRUE = 1,
};
 
enum class dqcs_gate_type_t {
  DQCS_GATE_TYPE_INVALID = 0,
  DQCS_GATE_TYPE_UNITARY,
  DQCS_GATE_TYPE_MEASUREMENT,
  DQCS_GATE_TYPE_PREP,
  DQCS_GATE_TYPE_CUSTOM,
};
 
enum class dqcs_handle_type_t {
  DQCS_HTYPE_INVALID = 0,
  DQCS_HTYPE_ARB_DATA = 100,
  DQCS_HTYPE_ARB_CMD = 101,
  DQCS_HTYPE_ARB_CMD_QUEUE = 102,
  DQCS_HTYPE_QUBIT_SET = 103,
  DQCS_HTYPE_GATE = 104,
  DQCS_HTYPE_MEAS = 105,
  DQCS_HTYPE_MEAS_SET = 106,
  DQCS_HTYPE_MATRIX = 107,
  DQCS_HTYPE_GATE_MAP = 108,
  DQCS_HTYPE_FRONT_PROCESS_CONFIG = 200,
  DQCS_HTYPE_OPER_PROCESS_CONFIG = 201,
  DQCS_HTYPE_BACK_PROCESS_CONFIG = 203,
  DQCS_HTYPE_FRONT_THREAD_CONFIG = 204,
  DQCS_HTYPE_OPER_THREAD_CONFIG = 205,
  DQCS_HTYPE_BACK_THREAD_CONFIG = 206,
  DQCS_HTYPE_SIM_CONFIG = 207,
  DQCS_HTYPE_SIM = 208,
  DQCS_HTYPE_FRONT_DEF = 300,
  DQCS_HTYPE_OPER_DEF = 301,
  DQCS_HTYPE_BACK_DEF = 302,
  DQCS_HTYPE_PLUGIN_JOIN = 303,
};
 
enum class dqcs_loglevel_t {
  DQCS_LOG_INVALID = -1,
  DQCS_LOG_OFF = 0,
  DQCS_LOG_FATAL = 1,
  DQCS_LOG_ERROR = 2,
  DQCS_LOG_WARN = 3,
  DQCS_LOG_NOTE = 4,
  DQCS_LOG_INFO = 5,
  DQCS_LOG_DEBUG = 6,
  DQCS_LOG_TRACE = 7,
  DQCS_LOG_PASS = 8,
};
 
enum class dqcs_measurement_t {
  DQCS_MEAS_INVALID = -1,
  DQCS_MEAS_ZERO = 0,
  DQCS_MEAS_ONE = 1,
  DQCS_MEAS_UNDEFINED = 2,
};
 
enum class dqcs_path_style_t {
  DQCS_PATH_STYLE_INVALID = -1,
  DQCS_PATH_STYLE_KEEP = 0,
  DQCS_PATH_STYLE_RELATIVE = 1,
  DQCS_PATH_STYLE_ABSOLUTE = 2,
};
 
enum class dqcs_plugin_type_t {
  DQCS_PTYPE_INVALID = -1,
  DQCS_PTYPE_FRONT = 0,
  DQCS_PTYPE_OPER = 1,
  DQCS_PTYPE_BACK = 2,
};
 
enum class dqcs_predefined_gate_t {
  DQCS_GATE_INVALID = 0,
  DQCS_GATE_PAULI_I = 100,
  DQCS_GATE_PAULI_X = 101,
  DQCS_GATE_PAULI_Y = 102,
  DQCS_GATE_PAULI_Z = 103,
  DQCS_GATE_H = 104,
  DQCS_GATE_S = 105,
  DQCS_GATE_S_DAG = 106,
  DQCS_GATE_T = 107,
  DQCS_GATE_T_DAG = 108,
  DQCS_GATE_RX_90 = 109,
  DQCS_GATE_RX_M90 = 110,
  DQCS_GATE_RX_180 = 111,
  DQCS_GATE_RY_90 = 112,
  DQCS_GATE_RY_M90 = 113,
  DQCS_GATE_RY_180 = 114,
  DQCS_GATE_RZ_90 = 115,
  DQCS_GATE_RZ_M90 = 116,
  DQCS_GATE_RZ_180 = 117,
  DQCS_GATE_RX = 150,
  DQCS_GATE_RY = 151,
  DQCS_GATE_RZ = 152,
  DQCS_GATE_PHASE_K = 153,
  DQCS_GATE_PHASE = 154,
  DQCS_GATE_U1 = 190,
  DQCS_GATE_R = 191,
  DQCS_GATE_SWAP = 200,
  DQCS_GATE_SQRT_SWAP = 201,
  DQCS_GATE_U2 = 290,
  DQCS_GATE_U3 = 390,
};
 
enum class dqcs_return_t {
  DQCS_FAILURE = -1,
  DQCS_SUCCESS = 0,
};
 
using dqcs_handle_t = unsigned long long;
 
using dqcs_qubit_t = unsigned long long;
 
using dqcs_plugin_state_t = void*;
 
using dqcs_cycle_t = long long;
 
extern "C" {
 
dqcs_return_t dqcs_arb_assign(dqcs_handle_t dest, dqcs_handle_t src);
 
ssize_t dqcs_arb_cbor_get(dqcs_handle_t arb, void *obj, size_t obj_size);
 
dqcs_return_t dqcs_arb_cbor_set(dqcs_handle_t arb, const void *obj, size_t obj_size);
 
dqcs_return_t dqcs_arb_clear(dqcs_handle_t arb);
 
ssize_t dqcs_arb_get_raw(dqcs_handle_t arb, ssize_t index, void *obj, size_t obj_size);
 
ssize_t dqcs_arb_get_size(dqcs_handle_t arb, ssize_t index);
 
char *dqcs_arb_get_str(dqcs_handle_t arb, ssize_t index);
 
dqcs_return_t dqcs_arb_insert_raw(dqcs_handle_t arb,
                                  ssize_t index,
                                  const void *obj,
                                  size_t obj_size);
 
dqcs_return_t dqcs_arb_insert_str(dqcs_handle_t arb, ssize_t index, const char *s);
 
char *dqcs_arb_json_get(dqcs_handle_t arb);
 
dqcs_return_t dqcs_arb_json_set(dqcs_handle_t arb, const char *json);
 
ssize_t dqcs_arb_len(dqcs_handle_t arb);
 
dqcs_handle_t dqcs_arb_new();
 
dqcs_return_t dqcs_arb_pop(dqcs_handle_t arb);
 
ssize_t dqcs_arb_pop_raw(dqcs_handle_t arb, void *obj, size_t obj_size);
 
char *dqcs_arb_pop_str(dqcs_handle_t arb);
 
dqcs_return_t dqcs_arb_push_raw(dqcs_handle_t arb, const void *obj, size_t obj_size);
 
dqcs_return_t dqcs_arb_push_str(dqcs_handle_t arb, const char *s);
 
dqcs_return_t dqcs_arb_remove(dqcs_handle_t arb, ssize_t index);
 
dqcs_return_t dqcs_arb_set_raw(dqcs_handle_t arb, ssize_t index, const void *obj, size_t obj_size);
 
dqcs_return_t dqcs_arb_set_str(dqcs_handle_t arb, ssize_t index, const char *s);
 
dqcs_bool_return_t dqcs_cmd_iface_cmp(dqcs_handle_t cmd, const char *iface);
 
char *dqcs_cmd_iface_get(dqcs_handle_t cmd);
 
dqcs_handle_t dqcs_cmd_new(const char *iface, const char *oper);
 
dqcs_bool_return_t dqcs_cmd_oper_cmp(dqcs_handle_t cmd, const char *oper);
 
char *dqcs_cmd_oper_get(dqcs_handle_t cmd);
 
ssize_t dqcs_cq_len(dqcs_handle_t cq);
 
dqcs_handle_t dqcs_cq_new();
 
dqcs_return_t dqcs_cq_next(dqcs_handle_t cq);
 
dqcs_return_t dqcs_cq_push(dqcs_handle_t cq, dqcs_handle_t cmd);
 
const char *dqcs_error_get();
 
void dqcs_error_set(const char *msg);
 
dqcs_handle_t dqcs_gate_controls(dqcs_handle_t gate);
 
dqcs_handle_t dqcs_gate_expand_control(dqcs_handle_t gate);
 
dqcs_bool_return_t dqcs_gate_has_controls(dqcs_handle_t gate);
 
dqcs_bool_return_t dqcs_gate_has_matrix(dqcs_handle_t gate);
 
dqcs_bool_return_t dqcs_gate_has_measures(dqcs_handle_t gate);
 
dqcs_bool_return_t dqcs_gate_has_name(dqcs_handle_t gate);
 
dqcs_bool_return_t dqcs_gate_has_targets(dqcs_handle_t gate);
 
dqcs_handle_t dqcs_gate_matrix(dqcs_handle_t gate);
 
dqcs_handle_t dqcs_gate_measures(dqcs_handle_t gate);
 
char *dqcs_gate_name(dqcs_handle_t gate);
 
dqcs_handle_t dqcs_gate_new_custom(const char *name,
                                   dqcs_handle_t targets,
                                   dqcs_handle_t controls,
                                   dqcs_handle_t measures,
                                   dqcs_handle_t matrix);
 
dqcs_handle_t dqcs_gate_new_measurement(dqcs_handle_t measures, dqcs_handle_t matrix);
 
dqcs_handle_t dqcs_gate_new_predef(dqcs_predefined_gate_t gate_type,
                                   dqcs_handle_t qubits,
                                   dqcs_handle_t param_data);
 
dqcs_handle_t dqcs_gate_new_predef_one(dqcs_predefined_gate_t gate_type,
                                       dqcs_qubit_t qa,
                                       dqcs_handle_t param_data);
 
dqcs_handle_t dqcs_gate_new_predef_three(dqcs_predefined_gate_t gate_type,
                                         dqcs_qubit_t qa,
                                         dqcs_qubit_t qb,
                                         dqcs_qubit_t qc,
                                         dqcs_handle_t param_data);
 
dqcs_handle_t dqcs_gate_new_predef_two(dqcs_predefined_gate_t gate_type,
                                       dqcs_qubit_t qa,
                                       dqcs_qubit_t qb,
                                       dqcs_handle_t param_data);
 
dqcs_handle_t dqcs_gate_new_prep(dqcs_handle_t targets, dqcs_handle_t matrix);
 
dqcs_handle_t dqcs_gate_new_unitary(dqcs_handle_t targets,
                                    dqcs_handle_t controls,
                                    dqcs_handle_t matrix);
 
dqcs_handle_t dqcs_gate_reduce_control(dqcs_handle_t gate, double epsilon, bool ignore_gphase);
 
dqcs_handle_t dqcs_gate_targets(dqcs_handle_t gate);
 
dqcs_gate_type_t dqcs_gate_type(dqcs_handle_t gate);
 
dqcs_return_t dqcs_gm_add_custom(dqcs_handle_t gm,
                                 void (*key_free)(void *key_data),
                                 void *key_data,
                                 dqcs_bool_return_t (*detector)(const void *user_data, dqcs_handle_t gate, dqcs_handle_t *qubits, dqcs_handle_t *param_data),
                                 void (*detector_user_free)(void *user_data),
                                 void *detector_user_data,
                                 dqcs_handle_t (*constructor)(const void *user_data, dqcs_handle_t qubits, dqcs_handle_t param_data),
                                 void (*constructor_user_free)(void *user_data),
                                 void *constructor_user_data);
 
dqcs_return_t dqcs_gm_add_custom_unitary(dqcs_handle_t gm,
                                         void (*key_free)(void *key_data),
                                         void *key_data,
                                         dqcs_bool_return_t (*detector)(const void *user_data, dqcs_handle_t matrix, size_t num_controls, dqcs_handle_t *param_data),
                                         void (*detector_user_free)(void *user_data),
                                         void *detector_user_data,
                                         dqcs_handle_t (*constructor)(const void *user_data, dqcs_handle_t *param_data, intptr_t *num_controls),
                                         void (*constructor_user_free)(void *user_data),
                                         void *constructor_user_data);
 
dqcs_return_t dqcs_gm_add_fixed_unitary(dqcs_handle_t gm,
                                        void (*key_free)(void *key_data),
                                        void *key_data,
                                        dqcs_handle_t matrix,
                                        intptr_t num_controls,
                                        double epsilon,
                                        bool ignore_gphase);
 
dqcs_return_t dqcs_gm_add_measure(dqcs_handle_t gm,
                                  void (*key_free)(void *user_data),
                                  void *key_data,
                                  intptr_t num_measures,
                                  dqcs_handle_t basis,
                                  double epsilon);
 
dqcs_return_t dqcs_gm_add_predef_unitary(dqcs_handle_t gm,
                                         void (*key_free)(void *user_data),
                                         void *key_data,
                                         dqcs_predefined_gate_t gate,
                                         intptr_t num_controls,
                                         double epsilon,
                                         bool ignore_gphase);
 
dqcs_return_t dqcs_gm_add_prep(dqcs_handle_t gm,
                               void (*key_free)(void *user_data),
                               void *key_data,
                               intptr_t num_targets,
                               dqcs_handle_t basis,
                               double epsilon);
 
dqcs_handle_t dqcs_gm_construct(dqcs_handle_t gm,
                                const void *key_data,
                                dqcs_handle_t qubits,
                                dqcs_handle_t param_data);
 
dqcs_handle_t dqcs_gm_construct_one(dqcs_handle_t gm,
                                    const void *key_data,
                                    dqcs_qubit_t qa,
                                    dqcs_handle_t param_data);
 
dqcs_handle_t dqcs_gm_construct_three(dqcs_handle_t gm,
                                      const void *key_data,
                                      dqcs_qubit_t qa,
                                      dqcs_qubit_t qb,
                                      dqcs_qubit_t qc,
                                      dqcs_handle_t param_data);
 
dqcs_handle_t dqcs_gm_construct_two(dqcs_handle_t gm,
                                    const void *key_data,
                                    dqcs_qubit_t qa,
                                    dqcs_qubit_t qb,
                                    dqcs_handle_t param_data);
 
dqcs_bool_return_t dqcs_gm_detect(dqcs_handle_t gm,
                                  dqcs_handle_t gate,
                                  const void **key_data,
                                  dqcs_handle_t *qubits,
                                  dqcs_handle_t *param_data);
 
dqcs_handle_t dqcs_gm_new(bool strip_qubit_refs,
                          bool strip_data,
                          bool (*key_cmp)(const void*, const void*),
                          uint64_t (*key_hash)(const void*));
 
dqcs_return_t dqcs_handle_delete(dqcs_handle_t handle);
 
dqcs_return_t dqcs_handle_delete_all();
 
char *dqcs_handle_dump(dqcs_handle_t handle);
 
dqcs_return_t dqcs_handle_leak_check();
 
dqcs_handle_type_t dqcs_handle_type(dqcs_handle_t handle);
 
dqcs_return_t dqcs_log_raw(dqcs_loglevel_t level,
                           const char *module,
                           const char *file,
                           uint32_t line_nr,
                           const char *message);
 
dqcs_handle_t dqcs_mat_add_controls(dqcs_handle_t mat, size_t number_of_controls);
 
dqcs_bool_return_t dqcs_mat_approx_eq(dqcs_handle_t a,
                                      dqcs_handle_t b,
                                      double epsilon,
                                      bool ignore_gphase);
 
dqcs_bool_return_t dqcs_mat_approx_unitary(dqcs_handle_t matrix, double epsilon);
 
dqcs_handle_t dqcs_mat_basis(dqcs_basis_t basis);
 
dqcs_bool_return_t dqcs_mat_basis_approx_eq(dqcs_handle_t a, dqcs_handle_t b, double epsilon);
 
ssize_t dqcs_mat_dimension(dqcs_handle_t mat);
 
double *dqcs_mat_get(dqcs_handle_t mat);
 
dqcs_bool_return_t dqcs_mat_is_predef(dqcs_handle_t mat,
                                      dqcs_predefined_gate_t gate_type,
                                      dqcs_handle_t *param_data,
                                      double epsilon,
                                      bool ignore_gphase);
 
ssize_t dqcs_mat_len(dqcs_handle_t mat);
 
dqcs_handle_t dqcs_mat_new(size_t num_qubits, const double *matrix);
 
ssize_t dqcs_mat_num_qubits(dqcs_handle_t mat);
 
dqcs_handle_t dqcs_mat_predef(dqcs_predefined_gate_t gate_type, dqcs_handle_t param_data);
 
dqcs_handle_t dqcs_mat_strip_control(dqcs_handle_t mat,
                                     double epsilon,
                                     bool ignore_global_phase,
                                     ssize_t **control_indices);
 
dqcs_handle_t dqcs_meas_new(dqcs_qubit_t qubit, dqcs_measurement_t value);
 
dqcs_qubit_t dqcs_meas_qubit_get(dqcs_handle_t meas);
 
dqcs_return_t dqcs_meas_qubit_set(dqcs_handle_t meas, dqcs_qubit_t qubit);
 
dqcs_measurement_t dqcs_meas_value_get(dqcs_handle_t meas);
 
dqcs_return_t dqcs_meas_value_set(dqcs_handle_t meas, dqcs_measurement_t value);
 
dqcs_bool_return_t dqcs_mset_contains(dqcs_handle_t mset, dqcs_qubit_t qubit);
 
dqcs_handle_t dqcs_mset_get(dqcs_handle_t mset, dqcs_qubit_t qubit);
 
ssize_t dqcs_mset_len(dqcs_handle_t mset);
 
dqcs_handle_t dqcs_mset_new();
 
dqcs_return_t dqcs_mset_remove(dqcs_handle_t mset, dqcs_qubit_t qubit);
 
dqcs_return_t dqcs_mset_set(dqcs_handle_t mset, dqcs_handle_t meas);
 
dqcs_handle_t dqcs_mset_take(dqcs_handle_t mset, dqcs_qubit_t qubit);
 
dqcs_handle_t dqcs_mset_take_any(dqcs_handle_t mset);
 
double dqcs_pcfg_accept_timeout_get(dqcs_handle_t pcfg);
 
dqcs_return_t dqcs_pcfg_accept_timeout_set(dqcs_handle_t pcfg, double timeout);
 
dqcs_return_t dqcs_pcfg_env_set(dqcs_handle_t pcfg, const char *key, const char *value);
 
dqcs_return_t dqcs_pcfg_env_unset(dqcs_handle_t pcfg, const char *key);
 
char *dqcs_pcfg_executable(dqcs_handle_t pcfg);
 
dqcs_return_t dqcs_pcfg_init_cmd(dqcs_handle_t pcfg, dqcs_handle_t cmd);
 
char *dqcs_pcfg_name(dqcs_handle_t pcfg);
 
dqcs_handle_t dqcs_pcfg_new(dqcs_plugin_type_t typ, const char *name, const char *spec);
 
dqcs_handle_t dqcs_pcfg_new_raw(dqcs_plugin_type_t typ,
                                const char *name,
                                const char *executable,
                                const char *script);
 
char *dqcs_pcfg_script(dqcs_handle_t pcfg);
 
double dqcs_pcfg_shutdown_timeout_get(dqcs_handle_t pcfg);
 
dqcs_return_t dqcs_pcfg_shutdown_timeout_set(dqcs_handle_t pcfg, double timeout);
 
dqcs_loglevel_t dqcs_pcfg_stderr_mode_get(dqcs_handle_t pcfg);
 
dqcs_return_t dqcs_pcfg_stderr_mode_set(dqcs_handle_t pcfg, dqcs_loglevel_t level);
 
dqcs_loglevel_t dqcs_pcfg_stdout_mode_get(dqcs_handle_t pcfg);
 
dqcs_return_t dqcs_pcfg_stdout_mode_set(dqcs_handle_t pcfg, dqcs_loglevel_t level);
 
dqcs_return_t dqcs_pcfg_tee(dqcs_handle_t pcfg, dqcs_loglevel_t verbosity, const char *filename);
 
dqcs_plugin_type_t dqcs_pcfg_type(dqcs_handle_t pcfg);
 
dqcs_loglevel_t dqcs_pcfg_verbosity_get(dqcs_handle_t pcfg);
 
dqcs_return_t dqcs_pcfg_verbosity_set(dqcs_handle_t pcfg, dqcs_loglevel_t level);
 
char *dqcs_pcfg_work_get(dqcs_handle_t pcfg);
 
dqcs_return_t dqcs_pcfg_work_set(dqcs_handle_t pcfg, const char *work);
 
char *dqcs_pdef_author(dqcs_handle_t pdef);
 
char *dqcs_pdef_name(dqcs_handle_t pdef);
 
dqcs_handle_t dqcs_pdef_new(dqcs_plugin_type_t typ,
                            const char *name,
                            const char *author,
                            const char *version);
 
dqcs_return_t dqcs_pdef_set_advance_cb(dqcs_handle_t pdef,
                                       dqcs_return_t (*callback)(void *user_data, dqcs_plugin_state_t state, dqcs_cycle_t cycles),
                                       void (*user_free)(void *user_data),
                                       void *user_data);
 
dqcs_return_t dqcs_pdef_set_allocate_cb(dqcs_handle_t pdef,
                                        dqcs_return_t (*callback)(void *user_data, dqcs_plugin_state_t state, dqcs_handle_t qubits, dqcs_handle_t alloc_cmds),
                                        void (*user_free)(void *user_data),
                                        void *user_data);
 
dqcs_return_t dqcs_pdef_set_drop_cb(dqcs_handle_t pdef,
                                    dqcs_return_t (*callback)(void *user_data, dqcs_plugin_state_t state),
                                    void (*user_free)(void *user_data),
                                    void *user_data);
 
dqcs_return_t dqcs_pdef_set_free_cb(dqcs_handle_t pdef,
                                    dqcs_return_t (*callback)(void *user_data, dqcs_plugin_state_t state, dqcs_handle_t qubits),
                                    void (*user_free)(void *user_data),
                                    void *user_data);
 
dqcs_return_t dqcs_pdef_set_gate_cb(dqcs_handle_t pdef,
                                    dqcs_handle_t (*callback)(void *user_data, dqcs_plugin_state_t state, dqcs_handle_t gate),
                                    void (*user_free)(void *user_data),
                                    void *user_data);
 
dqcs_return_t dqcs_pdef_set_host_arb_cb(dqcs_handle_t pdef,
                                        dqcs_handle_t (*callback)(void *user_data, dqcs_plugin_state_t state, dqcs_handle_t cmd),
                                        void (*user_free)(void *user_data),
                                        void *user_data);
 
dqcs_return_t dqcs_pdef_set_initialize_cb(dqcs_handle_t pdef,
                                          dqcs_return_t (*callback)(void *user_data, dqcs_plugin_state_t state, dqcs_handle_t init_cmds),
                                          void (*user_free)(void *user_data),
                                          void *user_data);
 
dqcs_return_t dqcs_pdef_set_modify_measurement_cb(dqcs_handle_t pdef,
                                                  dqcs_handle_t (*callback)(void *user_data, dqcs_plugin_state_t state, dqcs_handle_t meas),
                                                  void (*user_free)(void *user_data),
                                                  void *user_data);
 
dqcs_return_t dqcs_pdef_set_run_cb(dqcs_handle_t pdef,
                                   dqcs_handle_t (*callback)(void *user_data, dqcs_plugin_state_t state, dqcs_handle_t args),
                                   void (*user_free)(void *user_data),
                                   void *user_data);
 
dqcs_return_t dqcs_pdef_set_upstream_arb_cb(dqcs_handle_t pdef,
                                            dqcs_handle_t (*callback)(void *user_data, dqcs_plugin_state_t state, dqcs_handle_t cmd),
                                            void (*user_free)(void *user_data),
                                            void *user_data);
 
dqcs_plugin_type_t dqcs_pdef_type(dqcs_handle_t pdef);
 
char *dqcs_pdef_version(dqcs_handle_t pdef);
 
dqcs_cycle_t dqcs_plugin_advance(dqcs_plugin_state_t plugin, dqcs_cycle_t cycles);
 
dqcs_handle_t dqcs_plugin_allocate(dqcs_plugin_state_t plugin,
                                   uintptr_t num_qubits,
                                   dqcs_handle_t cq);
 
dqcs_handle_t dqcs_plugin_arb(dqcs_plugin_state_t plugin, dqcs_handle_t cmd);
 
dqcs_return_t dqcs_plugin_free(dqcs_plugin_state_t plugin, dqcs_handle_t qbset);
 
dqcs_return_t dqcs_plugin_gate(dqcs_plugin_state_t plugin, dqcs_handle_t gate);
 
dqcs_cycle_t dqcs_plugin_get_cycle(dqcs_plugin_state_t plugin);
 
dqcs_cycle_t dqcs_plugin_get_cycles_between_measures(dqcs_plugin_state_t plugin,
                                                     dqcs_qubit_t qubit);
 
dqcs_cycle_t dqcs_plugin_get_cycles_since_measure(dqcs_plugin_state_t plugin, dqcs_qubit_t qubit);
 
dqcs_handle_t dqcs_plugin_get_measurement(dqcs_plugin_state_t plugin, dqcs_qubit_t qubit);
 
double dqcs_plugin_random_f64(dqcs_plugin_state_t plugin);
 
dqcs_handle_t dqcs_plugin_random_u64(dqcs_plugin_state_t plugin);
 
dqcs_handle_t dqcs_plugin_recv(dqcs_plugin_state_t plugin);
 
dqcs_return_t dqcs_plugin_run(dqcs_handle_t pdef, const char *simulator);
 
dqcs_return_t dqcs_plugin_send(dqcs_plugin_state_t plugin, dqcs_handle_t arb);
 
dqcs_handle_t dqcs_plugin_start(dqcs_handle_t pdef, const char *simulator);
 
dqcs_return_t dqcs_plugin_wait(dqcs_handle_t pjoin);
 
dqcs_bool_return_t dqcs_qbset_contains(dqcs_handle_t qbset, dqcs_qubit_t qubit);
 
dqcs_handle_t dqcs_qbset_copy(dqcs_handle_t qbset);
 
ssize_t dqcs_qbset_len(dqcs_handle_t qbset);
 
dqcs_handle_t dqcs_qbset_new();
 
dqcs_qubit_t dqcs_qbset_pop(dqcs_handle_t qbset);
 
dqcs_return_t dqcs_qbset_push(dqcs_handle_t qbset, dqcs_qubit_t qubit);
 
dqcs_loglevel_t dqcs_scfg_dqcsim_verbosity_get(dqcs_handle_t scfg);
 
dqcs_return_t dqcs_scfg_dqcsim_verbosity_set(dqcs_handle_t scfg, dqcs_loglevel_t level);
 
dqcs_return_t dqcs_scfg_log_callback(dqcs_handle_t scfg,
                                     dqcs_loglevel_t verbosity,
                                     void (*callback)(void *user_data, const char *message, const char *logger, dqcs_loglevel_t level, const char *module, const char *file, uint32_t line, uint64_t time_s, uint32_t time_ns, uint32_t pid, uint64_t tid),
                                     void (*user_free)(void *user_data),
                                     void *user_data);
 
dqcs_handle_t dqcs_scfg_new();
 
dqcs_return_t dqcs_scfg_push_plugin(dqcs_handle_t scfg, dqcs_handle_t xcfg);
 
dqcs_return_t dqcs_scfg_repro_disable(dqcs_handle_t scfg);
 
dqcs_path_style_t dqcs_scfg_repro_path_style_get(dqcs_handle_t scfg);
 
dqcs_return_t dqcs_scfg_repro_path_style_set(dqcs_handle_t scfg, dqcs_path_style_t path_style);
 
uint64_t dqcs_scfg_seed_get(dqcs_handle_t scfg);
 
dqcs_return_t dqcs_scfg_seed_set(dqcs_handle_t scfg, uint64_t seed);
 
dqcs_loglevel_t dqcs_scfg_stderr_verbosity_get(dqcs_handle_t scfg);
 
dqcs_return_t dqcs_scfg_stderr_verbosity_set(dqcs_handle_t scfg, dqcs_loglevel_t level);
 
dqcs_return_t dqcs_scfg_tee(dqcs_handle_t scfg, dqcs_loglevel_t verbosity, const char *filename);
 
dqcs_handle_t dqcs_sim_arb(dqcs_handle_t sim, const char *name, dqcs_handle_t cmd);
 
dqcs_handle_t dqcs_sim_arb_idx(dqcs_handle_t sim, ssize_t index, dqcs_handle_t cmd);
 
char *dqcs_sim_get_author(dqcs_handle_t sim, const char *name);
 
char *dqcs_sim_get_author_idx(dqcs_handle_t sim, ssize_t index);
 
char *dqcs_sim_get_name(dqcs_handle_t sim, const char *name);
 
char *dqcs_sim_get_name_idx(dqcs_handle_t sim, ssize_t index);
 
char *dqcs_sim_get_version(dqcs_handle_t sim, const char *name);
 
char *dqcs_sim_get_version_idx(dqcs_handle_t sim, ssize_t index);
 
dqcs_handle_t dqcs_sim_new(dqcs_handle_t scfg);
 
dqcs_handle_t dqcs_sim_recv(dqcs_handle_t sim);
 
dqcs_return_t dqcs_sim_send(dqcs_handle_t sim, dqcs_handle_t data);
 
dqcs_return_t dqcs_sim_start(dqcs_handle_t sim, dqcs_handle_t data);
 
dqcs_handle_t dqcs_sim_wait(dqcs_handle_t sim);
 
dqcs_return_t dqcs_sim_write_reproduction_file(dqcs_handle_t sim, const char *filename);
 
dqcs_return_t dqcs_sim_yield(dqcs_handle_t sim);
 
dqcs_return_t dqcs_tcfg_init_cmd(dqcs_handle_t tcfg, dqcs_handle_t cmd);
 
char *dqcs_tcfg_name(dqcs_handle_t tcfg);
 
dqcs_handle_t dqcs_tcfg_new(dqcs_handle_t pdef, const char *name);
 
dqcs_handle_t dqcs_tcfg_new_raw(dqcs_plugin_type_t plugin_type,
                                const char *name,
                                void (*callback)(void *user_data, const char *simulator),
                                void (*user_free)(void *user_data),
                                void *user_data);
 
dqcs_return_t dqcs_tcfg_tee(dqcs_handle_t tcfg, dqcs_loglevel_t verbosity, const char *filename);
 
dqcs_plugin_type_t dqcs_tcfg_type(dqcs_handle_t tcfg);
 
dqcs_loglevel_t dqcs_tcfg_verbosity_get(dqcs_handle_t tcfg);
 
dqcs_return_t dqcs_tcfg_verbosity_set(dqcs_handle_t tcfg, dqcs_loglevel_t level);
 
} // extern "C"
 
} // namespace raw
} // namespace dqcsim
 
//*****************************************************************************
// Functions that cannot be implemented in Rust
//*****************************************************************************
 
// Place log function in namespace if this is the C++ header.
#ifdef _DQCSIM_HDR_CPP_
namespace dqcsim {
namespace raw {
#endif
 
// Use namespaced C stdlib functions if this is the C++ header.
#ifdef _DQCSIM_HDR_CPP_
#define _DQCSIM_STD_PREFIX_ ::std::
#else
#define _DQCSIM_STD_PREFIX_
#endif
 
static void dqcs_log_format(
  dqcs_loglevel_t level,
  const char *module,
  const char *file,
  uint32_t line,
  const char *fmt,
  ...
)
#if defined(__GNUC__)
__attribute__((format(printf,5,6)))
#endif
;
static void dqcs_log_format(
  dqcs_loglevel_t level,
  const char *module,
  const char *file,
  uint32_t line,
  const char *fmt,
  ...
)
{
  // Figure out the buffer size we need.
  _DQCSIM_STD_PREFIX_ va_list ap;
  va_start(ap, fmt);
  int size = _DQCSIM_STD_PREFIX_ vsnprintf(NULL, 0, fmt, ap) + 1;
  va_end(ap);
 
  // Allocate the buffer.
  char *buffer = (char*)_DQCSIM_STD_PREFIX_ malloc(size);
  if (buffer == NULL) {
    _DQCSIM_STD_PREFIX_ fprintf(stderr, "Error: failed to allocate buffer for log message!\n");
    return;
  }
 
  // Perform the actual formatting operation.
  _DQCSIM_STD_PREFIX_ va_list ap2;
   va_start(ap2, fmt);
  _DQCSIM_STD_PREFIX_ vsnprintf(buffer, size, fmt, ap2);
  va_end(ap2);
 
  // Send to DQCsim.
  if (((int)dqcs_log_raw(level, module, file, line, buffer)) < 0) {
    _DQCSIM_STD_PREFIX_ fprintf(stderr, "Error while trying to log: %s\n", dqcs_error_get());
    _DQCSIM_STD_PREFIX_ fprintf(stderr, "The message was: %s\n", buffer);
    _DQCSIM_STD_PREFIX_ fprintf(stderr, "In %s, %s:%u\n", module, file, line);
  }
 
  // Don't leak!
  _DQCSIM_STD_PREFIX_ free(buffer);
}
 
#undef _DQCSIM_STD_PREFIX_
 
#ifdef _DQCSIM_HDR_CPP_
} // namespace raw
} // namespace dqcsim
#endif
 
//*****************************************************************************
// Macros
//*****************************************************************************
 
#ifndef _DQCSIM_LANGUAGE_
#ifdef _DQCSIM_HDR_CPP_
#define _DQCSIM_LANGUAGE_ "CPP"
#else
#define _DQCSIM_LANGUAGE_ "C"
#endif
#endif
 
#ifndef _DQCSIM_LOGLEVEL_PREFIX_
#ifdef _DQCSIM_HDR_CPP_
#define _DQCSIM_LOGLEVEL_PREFIX_ ::dqcsim::raw::dqcs_loglevel_t::
#else
#define _DQCSIM_LOGLEVEL_PREFIX_
#endif
#endif
 
#ifndef dqcs_log_trace
 
#define dqcs_log_trace(fmt, ...)                \
  dqcs_log_format(                              \
    _DQCSIM_LOGLEVEL_PREFIX_ DQCS_LOG_TRACE,    \
    _DQCSIM_LANGUAGE_,                          \
    __FILE__,                                   \
    __LINE__,                                   \
    fmt,                                        \
    ##__VA_ARGS__                               \
  )
#endif
 
#ifndef dqcs_log_debug
 
#define dqcs_log_debug(fmt, ...)                \
  dqcs_log_format(                              \
    _DQCSIM_LOGLEVEL_PREFIX_ DQCS_LOG_DEBUG,    \
    _DQCSIM_LANGUAGE_,                          \
    __FILE__,                                   \
    __LINE__,                                   \
    fmt,                                        \
    ##__VA_ARGS__                               \
  )
#endif
 
#ifndef dqcs_log_info
 
#define dqcs_log_info(fmt, ...)                 \
  dqcs_log_format(                              \
    _DQCSIM_LOGLEVEL_PREFIX_ DQCS_LOG_INFO,     \
    _DQCSIM_LANGUAGE_,                          \
    __FILE__,                                   \
    __LINE__,                                   \
    fmt,                                        \
    ##__VA_ARGS__                               \
  )
#endif
 
#ifndef dqcs_log_note
 
#define dqcs_log_note(fmt, ...)                 \
  dqcs_log_format(                              \
    _DQCSIM_LOGLEVEL_PREFIX_ DQCS_LOG_NOTE,     \
    _DQCSIM_LANGUAGE_,                          \
    __FILE__,                                   \
    __LINE__,                                   \
    fmt,                                        \
    ##__VA_ARGS__                               \
  )
#endif
 
#ifndef dqcs_log_warn
 
#define dqcs_log_warn(fmt, ...)                 \
  dqcs_log_format(                              \
    _DQCSIM_LOGLEVEL_PREFIX_ DQCS_LOG_WARN,     \
    _DQCSIM_LANGUAGE_,                          \
    __FILE__,                                   \
    __LINE__,                                   \
    fmt,                                        \
    ##__VA_ARGS__                               \
  )
#endif
 
#ifndef dqcs_log_error
 
#define dqcs_log_error(fmt, ...)                \
  dqcs_log_format(                              \
    _DQCSIM_LOGLEVEL_PREFIX_ DQCS_LOG_ERROR,    \
    _DQCSIM_LANGUAGE_,                          \
    __FILE__,                                   \
    __LINE__,                                   \
    fmt,                                        \
    ##__VA_ARGS__                               \
  )
#endif
 
#ifndef dqcs_log_fatal
 
#define dqcs_log_fatal(fmt, ...)                \
  dqcs_log_format(                              \
    _DQCSIM_LOGLEVEL_PREFIX_ DQCS_LOG_FATAL,    \
    _DQCSIM_LANGUAGE_,                          \
    __FILE__,                                   \
    __LINE__,                                   \
    fmt,                                        \
    ##__VA_ARGS__                               \
  )
#endif
 
#ifdef __cplusplus
} // extern "C"
#endif
 
#ifdef _DQCSIM_HDR_CPP_
#undef _DQCSIM_HDR_CPP_
#endif
 
#endif