dqcsim

Go to the documentation of this file.

// <dqcsim> -*- C++ -*-
 
#ifndef _DQCSIM_INCLUDED_
#define _DQCSIM_INCLUDED_
 
#include <stdexcept>
#include <string>
#include <vector>
#include <cstring>
#include <iostream>
#include <complex>
#include <functional>
#include <memory>
#include <cmath>
#include <limits>
#include <chrono>
#include <cdqcsim>
 
namespace dqcsim {
 
namespace wrap {
 
  using HandleIndex = raw::dqcs_handle_t;
 
  using QubitIndex = raw::dqcs_qubit_t;
 
  using Cycle = raw::dqcs_cycle_t;
 
  inline void check(raw::dqcs_return_t code) {
    if (code == raw::dqcs_return_t::DQCS_FAILURE) {
      throw std::runtime_error(raw::dqcs_error_get());
    }
  }
 
  inline bool check(raw::dqcs_bool_return_t code) {
    if (code == raw::dqcs_bool_return_t::DQCS_BOOL_FAILURE) {
      throw std::runtime_error(raw::dqcs_error_get());
    } else if (code == raw::dqcs_bool_return_t::DQCS_TRUE) {
      return true;
    } else {
      return false;
    }
  }
 
  inline unsigned long long check(unsigned long long handle) {
    if (handle == 0) {
      throw std::runtime_error(raw::dqcs_error_get());
    }
    return handle;
  }
 
  inline Cycle check(Cycle cycle) {
    if (cycle == -1) {
      throw std::runtime_error(raw::dqcs_error_get());
    }
    return cycle;
  }
 
  inline size_t check(ssize_t size) {
    if (size < 0) {
      throw std::runtime_error(raw::dqcs_error_get());
    }
    return static_cast<size_t>(size);
  }
 
  inline double check(double value) {
    if (value < 0.0) {
      throw std::runtime_error(raw::dqcs_error_get());
    }
    return value;
  }
 
  enum class HandleType {
 
    ArbData = 100,
 
    ArbCmd = 101,
 
    ArbCmdQueue = 102,
 
    QubitSet = 103,
 
    Gate = 104,
 
    Measurement = 105,
 
    MeasurementSet = 106,
 
    Matrix = 107,
 
    GateMap = 108,
 
    FrontendProcessConfig = 200,
 
    OperatorProcessConfig = 201,
 
    BackendProcessConfig = 203,
 
    FrontendThreadConfig = 204,
 
    OperatorThreadConfig = 205,
 
    BackendThreadConfig = 206,
 
    SimulationConfig = 207,
 
    Simulation = 208,
 
    FrontendDefinition = 300,
 
    OperatorDefinition = 301,
 
    BackendDefinition = 302,
 
    PluginJoinHandle = 303
  };
 
  inline raw::dqcs_handle_type_t to_raw(HandleType type) noexcept {
    switch (type) {
      case HandleType::ArbData:               return raw::dqcs_handle_type_t::DQCS_HTYPE_ARB_DATA;
      case HandleType::ArbCmd:                return raw::dqcs_handle_type_t::DQCS_HTYPE_ARB_CMD;
      case HandleType::ArbCmdQueue:           return raw::dqcs_handle_type_t::DQCS_HTYPE_ARB_CMD_QUEUE;
      case HandleType::QubitSet:              return raw::dqcs_handle_type_t::DQCS_HTYPE_QUBIT_SET;
      case HandleType::Gate:                  return raw::dqcs_handle_type_t::DQCS_HTYPE_GATE;
      case HandleType::Measurement:           return raw::dqcs_handle_type_t::DQCS_HTYPE_MEAS;
      case HandleType::MeasurementSet:        return raw::dqcs_handle_type_t::DQCS_HTYPE_MEAS_SET;
      case HandleType::Matrix:                return raw::dqcs_handle_type_t::DQCS_HTYPE_MATRIX;
      case HandleType::GateMap:               return raw::dqcs_handle_type_t::DQCS_HTYPE_GATE_MAP;
      case HandleType::FrontendProcessConfig: return raw::dqcs_handle_type_t::DQCS_HTYPE_FRONT_PROCESS_CONFIG;
      case HandleType::OperatorProcessConfig: return raw::dqcs_handle_type_t::DQCS_HTYPE_OPER_PROCESS_CONFIG;
      case HandleType::BackendProcessConfig:  return raw::dqcs_handle_type_t::DQCS_HTYPE_BACK_PROCESS_CONFIG;
      case HandleType::FrontendThreadConfig:  return raw::dqcs_handle_type_t::DQCS_HTYPE_FRONT_THREAD_CONFIG;
      case HandleType::OperatorThreadConfig:  return raw::dqcs_handle_type_t::DQCS_HTYPE_OPER_THREAD_CONFIG;
      case HandleType::BackendThreadConfig:   return raw::dqcs_handle_type_t::DQCS_HTYPE_BACK_THREAD_CONFIG;
      case HandleType::SimulationConfig:      return raw::dqcs_handle_type_t::DQCS_HTYPE_SIM_CONFIG;
      case HandleType::Simulation:            return raw::dqcs_handle_type_t::DQCS_HTYPE_SIM;
      case HandleType::FrontendDefinition:    return raw::dqcs_handle_type_t::DQCS_HTYPE_FRONT_DEF;
      case HandleType::OperatorDefinition:    return raw::dqcs_handle_type_t::DQCS_HTYPE_OPER_DEF;
      case HandleType::BackendDefinition:     return raw::dqcs_handle_type_t::DQCS_HTYPE_BACK_DEF;
      case HandleType::PluginJoinHandle:      return raw::dqcs_handle_type_t::DQCS_HTYPE_PLUGIN_JOIN;
    }
    std::cerr << "unknown handle type" << std::endl;
    std::terminate();
  }
 
  inline HandleType check(raw::dqcs_handle_type_t type) {
    switch (type) {
      case raw::dqcs_handle_type_t::DQCS_HTYPE_ARB_DATA:             return HandleType::ArbData;
      case raw::dqcs_handle_type_t::DQCS_HTYPE_ARB_CMD:              return HandleType::ArbCmd;
      case raw::dqcs_handle_type_t::DQCS_HTYPE_ARB_CMD_QUEUE:        return HandleType::ArbCmdQueue;
      case raw::dqcs_handle_type_t::DQCS_HTYPE_QUBIT_SET:            return HandleType::QubitSet;
      case raw::dqcs_handle_type_t::DQCS_HTYPE_GATE:                 return HandleType::Gate;
      case raw::dqcs_handle_type_t::DQCS_HTYPE_MEAS:                 return HandleType::Measurement;
      case raw::dqcs_handle_type_t::DQCS_HTYPE_MEAS_SET:             return HandleType::MeasurementSet;
      case raw::dqcs_handle_type_t::DQCS_HTYPE_MATRIX:               return HandleType::Matrix;
      case raw::dqcs_handle_type_t::DQCS_HTYPE_GATE_MAP:             return HandleType::GateMap;
      case raw::dqcs_handle_type_t::DQCS_HTYPE_FRONT_PROCESS_CONFIG: return HandleType::FrontendProcessConfig;
      case raw::dqcs_handle_type_t::DQCS_HTYPE_OPER_PROCESS_CONFIG:  return HandleType::OperatorProcessConfig;
      case raw::dqcs_handle_type_t::DQCS_HTYPE_BACK_PROCESS_CONFIG:  return HandleType::BackendProcessConfig;
      case raw::dqcs_handle_type_t::DQCS_HTYPE_FRONT_THREAD_CONFIG:  return HandleType::FrontendThreadConfig;
      case raw::dqcs_handle_type_t::DQCS_HTYPE_OPER_THREAD_CONFIG:   return HandleType::OperatorThreadConfig;
      case raw::dqcs_handle_type_t::DQCS_HTYPE_BACK_THREAD_CONFIG:   return HandleType::BackendThreadConfig;
      case raw::dqcs_handle_type_t::DQCS_HTYPE_SIM_CONFIG:           return HandleType::SimulationConfig;
      case raw::dqcs_handle_type_t::DQCS_HTYPE_SIM:                  return HandleType::Simulation;
      case raw::dqcs_handle_type_t::DQCS_HTYPE_FRONT_DEF:            return HandleType::FrontendDefinition;
      case raw::dqcs_handle_type_t::DQCS_HTYPE_OPER_DEF:             return HandleType::OperatorDefinition;
      case raw::dqcs_handle_type_t::DQCS_HTYPE_BACK_DEF:             return HandleType::BackendDefinition;
      case raw::dqcs_handle_type_t::DQCS_HTYPE_PLUGIN_JOIN:          return HandleType::PluginJoinHandle;
      case raw::dqcs_handle_type_t::DQCS_HTYPE_INVALID:              throw std::runtime_error(raw::dqcs_error_get());
    }
    throw std::invalid_argument("unknown handle type");
  }
 
  enum class Loglevel {
 
    Off = 0,
 
    Fatal = 1,
 
    Error = 2,
 
    Warn = 3,
 
    Note = 4,
 
    Info = 5,
 
    Debug = 6,
 
    Trace = 7,
 
    Pass = 8
 
  };
 
  inline raw::dqcs_loglevel_t to_raw(Loglevel loglevel) noexcept {
    switch (loglevel) {
      case Loglevel::Off:   return raw::dqcs_loglevel_t::DQCS_LOG_OFF;
      case Loglevel::Fatal: return raw::dqcs_loglevel_t::DQCS_LOG_FATAL;
      case Loglevel::Error: return raw::dqcs_loglevel_t::DQCS_LOG_ERROR;
      case Loglevel::Warn:  return raw::dqcs_loglevel_t::DQCS_LOG_WARN;
      case Loglevel::Note:  return raw::dqcs_loglevel_t::DQCS_LOG_NOTE;
      case Loglevel::Info:  return raw::dqcs_loglevel_t::DQCS_LOG_INFO;
      case Loglevel::Debug: return raw::dqcs_loglevel_t::DQCS_LOG_DEBUG;
      case Loglevel::Trace: return raw::dqcs_loglevel_t::DQCS_LOG_TRACE;
      case Loglevel::Pass:  return raw::dqcs_loglevel_t::DQCS_LOG_PASS;
    }
    std::cerr << "unknown loglevel" << std::endl;
    std::terminate();
  }
 
  inline Loglevel check(raw::dqcs_loglevel_t loglevel) {
    switch (loglevel) {
      case raw::dqcs_loglevel_t::DQCS_LOG_OFF:      return Loglevel::Off;
      case raw::dqcs_loglevel_t::DQCS_LOG_FATAL:    return Loglevel::Fatal;
      case raw::dqcs_loglevel_t::DQCS_LOG_ERROR:    return Loglevel::Error;
      case raw::dqcs_loglevel_t::DQCS_LOG_WARN:     return Loglevel::Warn;
      case raw::dqcs_loglevel_t::DQCS_LOG_NOTE:     return Loglevel::Note;
      case raw::dqcs_loglevel_t::DQCS_LOG_INFO:     return Loglevel::Info;
      case raw::dqcs_loglevel_t::DQCS_LOG_DEBUG:    return Loglevel::Debug;
      case raw::dqcs_loglevel_t::DQCS_LOG_TRACE:    return Loglevel::Trace;
      case raw::dqcs_loglevel_t::DQCS_LOG_PASS:     return Loglevel::Pass;
      case raw::dqcs_loglevel_t::DQCS_LOG_INVALID:  throw std::runtime_error(raw::dqcs_error_get());
    }
    throw std::invalid_argument("unknown loglevel");
  }
 
  enum class MeasurementValue {
 
    Zero = 0,
 
    One = 1,
 
    Undefined = 2
 
  };
 
  inline raw::dqcs_measurement_t to_raw(MeasurementValue measurement) noexcept {
    switch (measurement) {
      case MeasurementValue::Zero:      return raw::dqcs_measurement_t::DQCS_MEAS_ZERO;
      case MeasurementValue::One:       return raw::dqcs_measurement_t::DQCS_MEAS_ONE;
      case MeasurementValue::Undefined: return raw::dqcs_measurement_t::DQCS_MEAS_UNDEFINED;
    }
    std::cerr << "unknown measurement value" << std::endl;
    std::terminate();
  }
 
  inline MeasurementValue check(raw::dqcs_measurement_t measurement) {
    switch (measurement) {
      case raw::dqcs_measurement_t::DQCS_MEAS_ZERO:      return MeasurementValue::Zero;
      case raw::dqcs_measurement_t::DQCS_MEAS_ONE:       return MeasurementValue::One;
      case raw::dqcs_measurement_t::DQCS_MEAS_UNDEFINED: return MeasurementValue::Undefined;
      case raw::dqcs_measurement_t::DQCS_MEAS_INVALID:   throw std::runtime_error(raw::dqcs_error_get());
    }
    throw std::invalid_argument("unknown measurement value");
  }
 
  enum class PathStyle {
 
    Keep = 0,
 
    Relative = 1,
 
    Absolute = 2
 
  };
 
  inline raw::dqcs_path_style_t to_raw(PathStyle style) noexcept {
    switch (style) {
      case PathStyle::Keep:     return raw::dqcs_path_style_t::DQCS_PATH_STYLE_KEEP;
      case PathStyle::Relative: return raw::dqcs_path_style_t::DQCS_PATH_STYLE_RELATIVE;
      case PathStyle::Absolute: return raw::dqcs_path_style_t::DQCS_PATH_STYLE_ABSOLUTE;
    }
    std::cerr << "unknown path style" << std::endl;
    std::terminate();
  }
 
  inline PathStyle check(raw::dqcs_path_style_t style) {
    switch (style) {
      case raw::dqcs_path_style_t::DQCS_PATH_STYLE_KEEP:      return PathStyle::Keep;
      case raw::dqcs_path_style_t::DQCS_PATH_STYLE_RELATIVE:  return PathStyle::Relative;
      case raw::dqcs_path_style_t::DQCS_PATH_STYLE_ABSOLUTE:  return PathStyle::Absolute;
      case raw::dqcs_path_style_t::DQCS_PATH_STYLE_INVALID:   throw std::runtime_error(raw::dqcs_error_get());
    }
    throw std::invalid_argument("unknown path style");
  }
 
  enum class PluginType {
 
    Frontend = 0,
 
    Operator = 1,
 
    Backend = 2
 
  };
 
  inline raw::dqcs_plugin_type_t to_raw(PluginType type) noexcept {
    switch (type) {
      case PluginType::Frontend:  return raw::dqcs_plugin_type_t::DQCS_PTYPE_FRONT;
      case PluginType::Operator:  return raw::dqcs_plugin_type_t::DQCS_PTYPE_OPER;
      case PluginType::Backend:   return raw::dqcs_plugin_type_t::DQCS_PTYPE_BACK;
    }
    std::cerr << "unknown plugin type" << std::endl;
    std::terminate();
  }
 
  inline PluginType check(raw::dqcs_plugin_type_t type) {
    switch (type) {
      case raw::dqcs_plugin_type_t::DQCS_PTYPE_FRONT:   return PluginType::Frontend;
      case raw::dqcs_plugin_type_t::DQCS_PTYPE_OPER:    return PluginType::Operator;
      case raw::dqcs_plugin_type_t::DQCS_PTYPE_BACK:    return PluginType::Backend;
      case raw::dqcs_plugin_type_t::DQCS_PTYPE_INVALID: throw std::runtime_error(raw::dqcs_error_get());
    }
    throw std::invalid_argument("unknown plugin type");
  }
 
  enum class GateType {
 
    Unitary = 1,
 
    Measurement = 2,
 
    Prep = 3,
 
    Custom = 4
 
  };
 
  inline raw::dqcs_gate_type_t to_raw(GateType type) noexcept {
    switch (type) {
      case GateType::Unitary:     return raw::dqcs_gate_type_t::DQCS_GATE_TYPE_UNITARY;
      case GateType::Measurement: return raw::dqcs_gate_type_t::DQCS_GATE_TYPE_MEASUREMENT;
      case GateType::Prep:        return raw::dqcs_gate_type_t::DQCS_GATE_TYPE_PREP;
      case GateType::Custom:      return raw::dqcs_gate_type_t::DQCS_GATE_TYPE_CUSTOM;
    }
    std::cerr << "unknown gate type" << std::endl;
    std::terminate();
  }
 
  inline GateType check(raw::dqcs_gate_type_t type) {
    switch (type) {
      case raw::dqcs_gate_type_t::DQCS_GATE_TYPE_UNITARY:     return GateType::Unitary;
      case raw::dqcs_gate_type_t::DQCS_GATE_TYPE_MEASUREMENT: return GateType::Measurement;
      case raw::dqcs_gate_type_t::DQCS_GATE_TYPE_PREP:        return GateType::Prep;
      case raw::dqcs_gate_type_t::DQCS_GATE_TYPE_CUSTOM:      return GateType::Custom;
      case raw::dqcs_gate_type_t::DQCS_GATE_TYPE_INVALID:     throw std::runtime_error(raw::dqcs_error_get());
    }
    throw std::invalid_argument("unknown gate type");
  }
 
  enum class PauliBasis {
 
    X = 1,
 
    Y = 2,
 
    Z = 3
 
  };
 
  inline raw::dqcs_basis_t to_raw(PauliBasis type) noexcept {
    switch (type) {
      case PauliBasis::X: return raw::dqcs_basis_t::DQCS_BASIS_X;
      case PauliBasis::Y: return raw::dqcs_basis_t::DQCS_BASIS_Y;
      case PauliBasis::Z: return raw::dqcs_basis_t::DQCS_BASIS_Z;
    }
    std::cerr << "unknown basis" << std::endl;
    std::terminate();
  }
 
  inline PauliBasis check(raw::dqcs_basis_t type) {
    switch (type) {
      case raw::dqcs_basis_t::DQCS_BASIS_X: return PauliBasis::X;
      case raw::dqcs_basis_t::DQCS_BASIS_Y: return PauliBasis::Y;
      case raw::dqcs_basis_t::DQCS_BASIS_Z: return PauliBasis::Z;
      case raw::dqcs_basis_t::DQCS_BASIS_INVALID: throw std::runtime_error(raw::dqcs_error_get());
    }
    throw std::invalid_argument("unknown basis");
  }
 
  enum class PredefinedGate {
 
    I = 100,
 
    X = 101,
 
    Y = 102,
 
    Z = 103,
 
    H = 104,
 
    S = 105,
 
    S_DAG = 106,
 
    T = 107,
 
    T_DAG = 108,
 
    RX_90 = 109,
 
    RX_M90 = 110,
 
    RX_180 = 111,
 
    RY_90 = 112,
 
    RY_M90 = 113,
 
    RY_180 = 114,
 
    RZ_90 = 115,
 
    RZ_M90 = 116,
 
    RZ_180 = 117,
 
    RX = 150,
 
    RY = 151,
 
    RZ = 152,
 
    PhaseK = 153,
 
    Phase = 154,
 
    U1 = 190,
 
    R = 191,
 
    Swap = 200,
 
    SqSwap = 201,
 
    U2 = 290,
 
    U3 = 390,
 
  };
 
  inline raw::dqcs_predefined_gate_t to_raw(PredefinedGate type) noexcept {
    switch (type) {
      case PredefinedGate::I:       return raw::dqcs_predefined_gate_t::DQCS_GATE_PAULI_I;
      case PredefinedGate::X:       return raw::dqcs_predefined_gate_t::DQCS_GATE_PAULI_X;
      case PredefinedGate::Y:       return raw::dqcs_predefined_gate_t::DQCS_GATE_PAULI_Y;
      case PredefinedGate::Z:       return raw::dqcs_predefined_gate_t::DQCS_GATE_PAULI_Z;
      case PredefinedGate::H:       return raw::dqcs_predefined_gate_t::DQCS_GATE_H;
      case PredefinedGate::S:       return raw::dqcs_predefined_gate_t::DQCS_GATE_S;
      case PredefinedGate::S_DAG:   return raw::dqcs_predefined_gate_t::DQCS_GATE_S_DAG;
      case PredefinedGate::T:       return raw::dqcs_predefined_gate_t::DQCS_GATE_T;
      case PredefinedGate::T_DAG:   return raw::dqcs_predefined_gate_t::DQCS_GATE_T_DAG;
      case PredefinedGate::RX_90:   return raw::dqcs_predefined_gate_t::DQCS_GATE_RX_90;
      case PredefinedGate::RX_M90:  return raw::dqcs_predefined_gate_t::DQCS_GATE_RX_M90;
      case PredefinedGate::RX_180:  return raw::dqcs_predefined_gate_t::DQCS_GATE_RX_180;
      case PredefinedGate::RY_90:   return raw::dqcs_predefined_gate_t::DQCS_GATE_RY_90;
      case PredefinedGate::RY_M90:  return raw::dqcs_predefined_gate_t::DQCS_GATE_RY_M90;
      case PredefinedGate::RY_180:  return raw::dqcs_predefined_gate_t::DQCS_GATE_RY_180;
      case PredefinedGate::RZ_90:   return raw::dqcs_predefined_gate_t::DQCS_GATE_RZ_90;
      case PredefinedGate::RZ_M90:  return raw::dqcs_predefined_gate_t::DQCS_GATE_RZ_M90;
      case PredefinedGate::RZ_180:  return raw::dqcs_predefined_gate_t::DQCS_GATE_RZ_180;
      case PredefinedGate::RX:      return raw::dqcs_predefined_gate_t::DQCS_GATE_RX;
      case PredefinedGate::RY:      return raw::dqcs_predefined_gate_t::DQCS_GATE_RY;
      case PredefinedGate::RZ:      return raw::dqcs_predefined_gate_t::DQCS_GATE_RZ;
      case PredefinedGate::PhaseK:  return raw::dqcs_predefined_gate_t::DQCS_GATE_PHASE_K;
      case PredefinedGate::Phase:   return raw::dqcs_predefined_gate_t::DQCS_GATE_PHASE;
      case PredefinedGate::U1:      return raw::dqcs_predefined_gate_t::DQCS_GATE_U1;
      case PredefinedGate::R:       return raw::dqcs_predefined_gate_t::DQCS_GATE_R;
      case PredefinedGate::Swap:    return raw::dqcs_predefined_gate_t::DQCS_GATE_SWAP;
      case PredefinedGate::SqSwap:  return raw::dqcs_predefined_gate_t::DQCS_GATE_SQRT_SWAP;
      case PredefinedGate::U2:      return raw::dqcs_predefined_gate_t::DQCS_GATE_U2;
      case PredefinedGate::U3:      return raw::dqcs_predefined_gate_t::DQCS_GATE_U3;
    }
    std::cerr << "unknown plugin type" << std::endl;
    std::terminate();
  }
 
  inline PredefinedGate check(raw::dqcs_predefined_gate_t type) {
    switch (type) {
      case raw::dqcs_predefined_gate_t::DQCS_GATE_PAULI_I:    return PredefinedGate::I;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_PAULI_X:    return PredefinedGate::X;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_PAULI_Y:    return PredefinedGate::Y;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_PAULI_Z:    return PredefinedGate::Z;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_H:          return PredefinedGate::H;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_S:          return PredefinedGate::S;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_S_DAG:      return PredefinedGate::S_DAG;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_T:          return PredefinedGate::T;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_T_DAG:      return PredefinedGate::T_DAG;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_RX_90:      return PredefinedGate::RX_90;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_RX_M90:     return PredefinedGate::RX_M90;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_RX_180:     return PredefinedGate::RX_180;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_RY_90:      return PredefinedGate::RY_90;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_RY_M90:     return PredefinedGate::RY_M90;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_RY_180:     return PredefinedGate::RY_180;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_RZ_90:      return PredefinedGate::RZ_90;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_RZ_M90:     return PredefinedGate::RZ_M90;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_RZ_180:     return PredefinedGate::RZ_180;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_RX:         return PredefinedGate::RX;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_RY:         return PredefinedGate::RY;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_RZ:         return PredefinedGate::RZ;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_PHASE_K:    return PredefinedGate::PhaseK;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_PHASE:      return PredefinedGate::Phase;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_U1:         return PredefinedGate::U1;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_R:          return PredefinedGate::R;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_SWAP:       return PredefinedGate::Swap;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_SQRT_SWAP:  return PredefinedGate::SqSwap;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_U2:         return PredefinedGate::U2;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_U3:         return PredefinedGate::U3;
      case raw::dqcs_predefined_gate_t::DQCS_GATE_INVALID:    throw std::runtime_error(raw::dqcs_error_get());
    }
    throw std::invalid_argument("unknown plugin type");
  }
 
  template <typename T>
  inline T *check(T *pointer) {
    if (pointer == nullptr) {
      throw std::runtime_error(raw::dqcs_error_get());
    }
    return pointer;
  }
 
  template<typename... Args>
  inline void log(
    wrap::Loglevel level,
    const std::string &module,
    const std::string &file,
    unsigned int line_nr,
    const std::string &format,
    Args... args
  ) noexcept {
    raw::dqcs_log_format(
      to_raw(level),
      module.c_str(),
      file.c_str(),
      line_nr,
      format.c_str(),
      args...
    );
  }
 
  inline bool log_raw(
    wrap::Loglevel level,
    const std::string &module,
    const std::string &file,
    unsigned int line_nr,
    const std::string &message
  ) noexcept {
    return raw::dqcs_log_raw(
      to_raw(level),
      module.c_str(),
      file.c_str(),
      line_nr,
      message.c_str()
    ) == raw::dqcs_return_t::DQCS_SUCCESS;
  }
 
  #define DQCSIM_LOG(level, fmt, ...)             \
    ::dqcsim::wrap::log(                          \
      level, "C++", __FILE__, __LINE__,           \
      fmt, ##__VA_ARGS__)
 
  #define DQCSIM_TRACE(fmt, ...) DQCSIM_LOG(::dqcsim::wrap::Loglevel::Trace, fmt, ##__VA_ARGS__)
 
  #define DQCSIM_DEBUG(fmt, ...) DQCSIM_LOG(::dqcsim::wrap::Loglevel::Debug, fmt, ##__VA_ARGS__)
 
  #define DQCSIM_INFO(fmt, ...) DQCSIM_LOG(::dqcsim::wrap::Loglevel::Info, fmt, ##__VA_ARGS__)
 
  #define DQCSIM_NOTE(fmt, ...) DQCSIM_LOG(::dqcsim::wrap::Loglevel::Note, fmt, ##__VA_ARGS__)
 
  #define DQCSIM_WARN(fmt, ...) DQCSIM_LOG(::dqcsim::wrap::Loglevel::Warn, fmt, ##__VA_ARGS__)
 
  #define DQCSIM_WARNING(fmt, ...) DQCSIM_LOG(::dqcsim::wrap::Loglevel::Warn, fmt, ##__VA_ARGS__)
 
  #define DQCSIM_ERROR(fmt, ...) DQCSIM_LOG(::dqcsim::wrap::Loglevel::Error, fmt, ##__VA_ARGS__)
 
  #define DQCSIM_FATAL(fmt, ...) DQCSIM_LOG(::dqcsim::wrap::Loglevel::Fatal, fmt, ##__VA_ARGS__)
 
  class Handle {
  protected:
 
    HandleIndex handle;
 
  public:
 
    Handle() noexcept : handle(0) {
    }
 
    Handle(HandleIndex handle) noexcept : handle(handle) {
    }
 
    virtual ~Handle() noexcept {
      if (handle) {
        // NOTE: no check; ignore errors (because destructors should be
        // noexcept).
        raw::dqcs_handle_delete(handle);
      }
    }
 
    void free() {
      check(raw::dqcs_handle_delete(handle));
      handle = 0;
    }
 
    bool is_valid() const noexcept {
      try {
        return raw::dqcs_handle_type(handle) != raw::dqcs_handle_type_t::DQCS_HTYPE_INVALID;
      } catch (std::runtime_error) {
        return false;
      }
    }
 
    HandleIndex get_handle() const noexcept {
      return handle;
    }
 
    HandleIndex take_handle() noexcept {
      HandleIndex h = handle;
      handle = 0;
      return h;
    }
 
    // Handles cannot usually be copied, so delete the copy constructor and
    // copy assignment operator.
    Handle(const Handle&) = delete;
    void operator=(const Handle&) = delete;
 
    Handle(Handle &&src) : handle(src.handle) {
      src.handle = 0;
    }
 
    Handle &operator=(Handle &&src) {
      if (handle) {
        free();
      }
      handle = src.handle;
      src.handle = 0;
      return *this;
    }
 
    std::string dump() const {
      char *dump_c = check(raw::dqcs_handle_dump(handle));
      std::string dump(dump_c);
      std::free(dump_c);
      return dump;
    }
 
    friend std::ostream& operator<<(std::ostream &out, const Handle &handle) {
      out << handle.dump();
      return out;
    }
 
    HandleType type() const {
      return check(raw::dqcs_handle_type(handle));
    }
 
  };
 
  class Arb : public Handle {
  public:
 
    Arb(HandleIndex handle) noexcept : Handle(handle) {
    }
 
    std::string get_arb_json_string() const {
      char *json_c = check(raw::dqcs_arb_json_get(handle));
      std::string json(json_c);
      std::free(json_c);
      return json;
    }
 
    void set_arb_json_string(const std::string &json) {
      check(raw::dqcs_arb_json_set(handle, json.c_str()));
    }
 
    std::string get_arb_cbor_string() const {
      size_t size = check(raw::dqcs_arb_cbor_get(handle, nullptr, 0));
      std::string cbor;
      cbor.resize(size);
      check(raw::dqcs_arb_cbor_get(handle, &cbor.front(), size));
      return cbor;
    }
 
    void set_arb_cbor_string(const std::string &cbor) {
      check(raw::dqcs_arb_cbor_set(handle, cbor.data(), cbor.size()));
    }
 
    template <class JSON>
    JSON get_arb_json() const {
      size_t size = check(raw::dqcs_arb_cbor_get(handle, nullptr, 0));
      std::vector<uint8_t> cbor;
      cbor.resize(size);
      check(raw::dqcs_arb_cbor_get(handle, &cbor.front(), size));
      return JSON::from_cbor(cbor);
    }
 
    template <class JSON>
    void set_arb_json(const JSON &json) {
      std::vector<uint8_t> cbor = JSON::to_cbor(json);
      check(raw::dqcs_arb_cbor_set(handle, cbor.data(), cbor.size()));
    }
 
    std::string get_arb_arg_string(ssize_t index) const {
      size_t size = check(raw::dqcs_arb_get_size(handle, index));
      std::string data;
      data.resize(size);
      check(raw::dqcs_arb_get_raw(handle, index, &data.front(), size));
      return data;
    }
 
    template <typename T>
    T get_arb_arg_as(ssize_t index) const {
      size_t size = check(raw::dqcs_arb_get_size(handle, index));
      if (size != sizeof(T)) {
        throw std::runtime_error(
          "Arbitrary argument has incorrect size: "
          "found " + std::to_string(size) + " bytes, "
          "expected " + std::to_string(sizeof(T)) + " bytes");
      }
      T data;
      check(raw::dqcs_arb_get_raw(handle, index, &data, sizeof(data)));
      return data;
    }
 
    template <typename T>
    void set_arb_arg_strings(const T &strings) {
      clear_arb_args();
      for (const std::string &string : strings) {
        push_arb_arg_string(string);
      }
    }
 
    void set_arb_arg_string(ssize_t index, const std::string &data) {
      check(raw::dqcs_arb_set_raw(handle, index, data.data(), data.size()));
    }
 
    template <typename T>
    void set_arb_arg(ssize_t index, const T &data) {
      check(raw::dqcs_arb_set_raw(handle, index, &data, sizeof(data)));
    }
 
    void push_arb_arg_string(const std::string &data) {
      check(raw::dqcs_arb_push_raw(handle, data.data(), data.size()));
    }
 
    template <typename T>
    void push_arb_arg(const T &data) {
      check(raw::dqcs_arb_push_raw(handle, &data, sizeof(data)));
    }
 
    std::string pop_arb_arg_string() {
      size_t size = check(raw::dqcs_arb_get_size(handle, -1));
      std::string data;
      data.resize(size);
      check(raw::dqcs_arb_pop_raw(handle, &data.front(), size));
      return data;
    }
 
    template <typename T>
    T pop_arb_arg_as() const {
      size_t size = check(raw::dqcs_arb_get_size(handle, -1));
      if (size != sizeof(T)) {
        throw std::runtime_error(
          "Arbitrary argument has incorrect size: "
          "found " + std::to_string(size) + " bytes, "
          "expected " + std::to_string(sizeof(T)) + " bytes");
      }
      T data;
      check(raw::dqcs_arb_pop_raw(handle, &data, sizeof(data)));
      return data;
    }
 
    void insert_arb_arg_string(ssize_t index, const std::string &data) {
      check(raw::dqcs_arb_insert_raw(handle, index, data.data(), data.size()));
    }
 
    template <typename T>
    void insert_arb_arg(ssize_t index, const T &data) {
      check(raw::dqcs_arb_insert_raw(handle, index, &data, sizeof(data)));
    }
 
    void remove_arb_arg(ssize_t index) {
      check(raw::dqcs_arb_remove(handle, index));
    }
 
    size_t get_arb_arg_count() const {
      return check(raw::dqcs_arb_len(handle));
    }
 
    void clear_arb_args() {
      check(raw::dqcs_arb_clear(handle));
    }
 
    void set_arb(const Arb &src) {
      check(raw::dqcs_arb_assign(handle, src.get_handle()));
    }
 
  };
 
  class ArbData : public Arb {
  public:
 
    ArbData(HandleIndex handle) noexcept : Arb(handle) {
    }
 
    ArbData() : Arb(check(raw::dqcs_arb_new())) {
    }
 
    ArbData(const Arb &src) : Arb(check(raw::dqcs_arb_new())) {
      set_arb(src);
    }
 
    ArbData(const ArbData &src) : Arb(check(raw::dqcs_arb_new())) {
      set_arb(src);
    }
 
    void operator=(const ArbData &src) {
      set_arb(src);
    }
 
    ArbData(ArbData&&) = default;
 
    ArbData &operator=(ArbData&&) = default;
 
    // Include builder pattern functions.
    #define ARB_BUILDER_SUBCLASS ArbData
 
    ARB_BUILDER_SUBCLASS &with_json_string(const std::string &json) {
      set_arb_json_string(json);
      return *this;
    }
 
    ARB_BUILDER_SUBCLASS &with_cbor_string(const std::string &cbor) {
      set_arb_cbor_string(cbor);
      return *this;
    }
 
    template <class JSON>
    ARB_BUILDER_SUBCLASS &with_json(const JSON &json) {
      set_arb_json(json);
      return *this;
    }
 
    ARB_BUILDER_SUBCLASS &with_arg_string(const std::string &data) {
      push_arb_arg_string(data);
      return *this;
    }
 
    template <typename T>
    ARB_BUILDER_SUBCLASS &with_arg(const T &data) {
      push_arb_arg(data);
      return *this;
    }
 
    #undef ARB_BUILDER_SUBCLASS
 
  };
 
  class Cmd : public Arb {
  public:
 
    Cmd(HandleIndex handle) noexcept : Arb(handle) {
    }
 
    std::string get_iface() const {
      char *iface_c = check(raw::dqcs_cmd_iface_get(handle));
      std::string iface(iface_c);
      std::free(iface_c);
      return iface;
    }
 
    bool is_iface(const std::string &iface) const {
      return check(raw::dqcs_cmd_iface_cmp(handle, iface.c_str()));
    }
 
    std::string get_oper() const {
      char *oper_c = check(raw::dqcs_cmd_oper_get(handle));
      std::string oper(oper_c);
      std::free(oper_c);
      return oper;
    }
 
    bool is_oper(const std::string &oper) const {
      return check(raw::dqcs_cmd_oper_cmp(handle, oper.c_str()));
    }
 
  };
 
  class ArbCmd : public Cmd {
  public:
 
    ArbCmd(HandleIndex handle) noexcept : Cmd(handle) {
    }
 
    ArbCmd(const std::string &iface, const std::string &oper) : Cmd(check(raw::dqcs_cmd_new(
      iface.c_str(), oper.c_str()
    ))) {
    }
 
    ArbCmd(const Cmd &src) : Cmd(check(raw::dqcs_cmd_new(
      src.get_iface().c_str(), src.get_oper().c_str()
    ))) {
      set_arb(src);
    }
 
    ArbCmd(const ArbCmd &src) : Cmd(check(raw::dqcs_cmd_new(
      src.get_iface().c_str(), src.get_oper().c_str()
    ))) {
      set_arb(src);
    }
 
    void operator=(const ArbCmd &src) {
      // The C API doesn't allow `ArbCmd`s to be copied natively, so we need to
      // make a new one and drop the old handle. We make the copy before
      // exchanging the handles to avoid changing our state if the copy
      // operation throws an error for some reason.
      ArbCmd copy(src);
      free();
      handle = copy.take_handle();
    }
 
    ArbCmd(ArbCmd&&) = default;
 
    ArbCmd &operator=(ArbCmd&&) = default;
 
    // Include builder pattern functions.
    #define ARB_BUILDER_SUBCLASS ArbCmd
 
    ARB_BUILDER_SUBCLASS &with_json_string(const std::string &json) {
      set_arb_json_string(json);
      return *this;
    }
 
    ARB_BUILDER_SUBCLASS &with_cbor_string(const std::string &cbor) {
      set_arb_cbor_string(cbor);
      return *this;
    }
 
    template <class JSON>
    ARB_BUILDER_SUBCLASS &with_json(const JSON &json) {
      set_arb_json(json);
      return *this;
    }
 
    ARB_BUILDER_SUBCLASS &with_arg_string(const std::string &data) {
      push_arb_arg_string(data);
      return *this;
    }
 
    template <typename T>
    ARB_BUILDER_SUBCLASS &with_arg(const T &data) {
      push_arb_arg(data);
      return *this;
    }
 
    #undef ARB_BUILDER_SUBCLASS
 
  };
 
  class ArbCmdQueue : public Cmd {
  public:
 
    ArbCmdQueue(HandleIndex handle) noexcept : Cmd(handle) {
    }
 
    ArbCmdQueue() : Cmd(check(raw::dqcs_cq_new())) {
    }
 
    void push(ArbCmd &&cmd) {
      check(raw::dqcs_cq_push(handle, cmd.get_handle()));
    }
 
    void push(const Cmd &cmd) {
      push(ArbCmd(cmd));
    }
 
    template <class T>
    static ArbCmdQueue from_iter(T &&cmds) {
      ArbCmdQueue result;
      for (Cmd &cmd : cmds) {
        result.push(std::move(cmd));
      }
      return result;
    }
 
    template <class T>
    static ArbCmdQueue from_iter(const T &cmds) {
      ArbCmdQueue result;
      for (const Cmd &cmd : cmds) {
        result.push(cmd);
      }
      return result;
    }
 
    ArbCmdQueue &&with(ArbCmd &&cmd) {
      push(std::move(cmd));
      return std::move(*this);
    }
 
    ArbCmdQueue &&with(const Cmd &cmd) {
      push(cmd);
      return std::move(*this);
    }
 
    void next() {
      check(raw::dqcs_cq_next(handle));
    }
 
    size_t size() const {
      return check(raw::dqcs_cq_len(handle));
    }
 
    std::vector<ArbCmd> drain_into_vector() {
      std::vector<ArbCmd> cmds;
      for (; size() > 0; next()) {
        cmds.emplace_back(*this);
      }
      return cmds;
    }
 
    std::vector<ArbCmd> copy_into_vector() {
      std::vector<ArbCmd> cmds = drain_into_vector();
      free();
      handle = ArbCmdQueue::from_iter(cmds).take_handle();
      return cmds;
    }
 
    ArbCmdQueue(ArbCmdQueue &src) : Cmd(0) {
      handle = ArbCmdQueue::from_iter(src.copy_into_vector()).take_handle();
    }
 
    ArbCmdQueue &operator=(ArbCmdQueue &src) {
      free();
      handle = ArbCmdQueue::from_iter(src.copy_into_vector()).take_handle();
      return *this;
    }
 
    ArbCmdQueue(ArbCmdQueue&&) = default;
 
    ArbCmdQueue &operator=(ArbCmdQueue&&) = default;
 
  };
 
  class QubitRef {
  private:
 
    QubitIndex index;
 
  public:
 
    QubitRef(QubitIndex index) : index(index) {
      if (index == 0) {
        throw std::runtime_error("Qubit indices cannot be zero in DQCsim");
      }
    }
 
    QubitRef(const QubitRef&) = default;
 
    QubitRef &operator=(const QubitRef&) = default;
 
    QubitRef(QubitRef&&) = default;
 
    QubitRef &operator=(QubitRef&&) = default;
 
    bool operator==(const QubitRef &other) const noexcept {
      return index == other.index;
    }
 
    bool operator!=(const QubitRef &other) const noexcept {
      return index != other.index;
    }
 
    friend std::ostream& operator<<(std::ostream &out, const QubitRef &qubit) {
      out << 'q' << qubit.index;
      return out;
    }
 
    QubitIndex get_index() const noexcept {
      return index;
    }
 
  };
 
  inline QubitRef operator "" _q(unsigned long long int qubit) {
    return QubitRef(qubit);
  }
 
  class QubitSet : public Handle {
  public:
 
    QubitSet(HandleIndex handle) noexcept : Handle(handle) {
    }
 
    QubitSet() : Handle(check(raw::dqcs_qbset_new())) {
    }
 
    template <class T>
    static QubitSet from_iter(const T &qubits) {
      QubitSet result;
      for (const QubitRef &qubit : qubits) {
        result.push(qubit);
      }
      return result;
    }
 
    QubitSet(const QubitSet &src) : Handle(check(raw::dqcs_qbset_copy(src.handle))) {
    }
 
    void operator=(const QubitSet &src) {
      QubitSet copy(src);
      free();
      handle = copy.take_handle();
    }
 
    QubitSet(QubitSet&&) = default;
 
    QubitSet &operator=(QubitSet&&) = default;
 
    void push(const QubitRef &qubit) {
      check(raw::dqcs_qbset_push(handle, qubit.get_index()));
    }
 
    QubitSet &&with(const QubitRef &qubit) {
      push(qubit);
      return std::move(*this);
    }
 
    QubitRef pop() {
      return QubitRef(check(raw::dqcs_qbset_pop(handle)));
    }
 
    size_t size() const {
      return check(raw::dqcs_qbset_len(handle));
    }
 
    bool contains(const QubitRef &qubit) const {
      return check(raw::dqcs_qbset_contains(handle, qubit.get_index()));
    }
 
    std::vector<QubitRef> drain_into_vector() {
      std::vector<QubitRef> qubits;
      while (size()) {
        qubits.emplace_back(pop());
      }
      return qubits;
    }
 
    std::vector<QubitRef> copy_into_vector() const {
      QubitSet copy(*this);
      return copy.drain_into_vector();
    }
 
  };
 
  using complex = std::complex<double>;
 
  class Matrix : public Handle {
  public:
 
    Matrix(HandleIndex handle) noexcept : Handle(handle) {
    }
 
    Matrix(size_t num_qubits, const complex *matrix)
      : Handle(check(raw::dqcs_mat_new(num_qubits, (const double *)matrix))) {
    }
 
    Matrix(size_t num_qubits, const double *matrix)
      : Handle(check(raw::dqcs_mat_new(num_qubits, matrix))) {
    }
 
    Matrix(PredefinedGate gate)
      : Handle(check(raw::dqcs_mat_predef(to_raw(gate), 0))) {
    }
 
    Matrix(PredefinedGate gate, ArbData &&parameters)
      : Handle(check(raw::dqcs_mat_predef(to_raw(gate), parameters.get_handle()))) {
    }
 
    Matrix(PredefinedGate gate, const ArbData &parameters)
      : Handle(check(raw::dqcs_mat_predef(to_raw(gate), ArbData(parameters).get_handle()))) {
    }
 
    Matrix(PauliBasis basis)
      : Handle(check(raw::dqcs_mat_basis(to_raw(basis)))) {
    }
 
    Matrix(const Matrix &src)
      : Handle(check(raw::dqcs_mat_add_controls(src.get_handle(), 0))) {
    }
 
    void operator=(const Matrix &src) {
      Matrix copy(src);
      free();
      handle = copy.take_handle();
    }
 
    Matrix(Matrix&&) = default;
 
    Matrix &operator=(Matrix&&) = default;
 
    size_t size() const {
        return check(raw::dqcs_mat_len(handle));
    }
 
    size_t dimension() const {
        return check(raw::dqcs_mat_dimension(handle));
    }
 
    size_t num_qubits() const {
        return check(raw::dqcs_mat_num_qubits(handle));
    }
 
    std::vector<complex> get() const {
      size_t s = size();
      std::vector<complex> vec(s);
      double *data = check(raw::dqcs_mat_get(handle));
      std::memcpy(vec.data(), data, s * sizeof(complex));
      return vec;
    }
 
    std::vector<double> get_as_doubles() const {
      size_t s = size();
      std::vector<double> vec(s * 2);
      double *data = check(raw::dqcs_mat_get(handle));
      std::memcpy(vec.data(), data, 2 * s * sizeof(double));
      return vec;
    }
 
    bool approx_eq(
      const Matrix &other,
      double epsilon = 0.000001,
      bool ignore_global_phase = true
    ) const {
      return check(raw::dqcs_mat_approx_eq(handle, other.get_handle(), epsilon, ignore_global_phase));
    }
 
    bool basis_approx_eq(
      const Matrix &other,
      double epsilon = 0.000001
    ) const {
      return check(raw::dqcs_mat_basis_approx_eq(handle, other.get_handle(), epsilon));
    }
 
    bool approx_unitary(double epsilon = 0.000001) const {
      return check(raw::dqcs_mat_approx_unitary(handle, epsilon));
    }
 
    bool is_predefined(
      PredefinedGate gate,
      double epsilon = 0.000001,
      bool ignore_global_phase = true,
      ArbData *parameters = nullptr
    ) const {
      if (parameters) {
        raw::dqcs_handle_t param_data = 0;
        bool match = check(raw::dqcs_mat_is_predef(handle, to_raw(gate), &param_data, epsilon, ignore_global_phase));
        if (!match) return false;
        *parameters = ArbData(param_data);
        return true;
      }
      return check(raw::dqcs_mat_is_predef(handle, to_raw(gate), nullptr, epsilon, ignore_global_phase));
    }
 
    Matrix add_controls(size_t number_of_controls) const {
      return Matrix(check(raw::dqcs_mat_add_controls(handle, number_of_controls)));
    }
 
    std::pair<std::vector<size_t>, Matrix> strip_control(double epsilon, bool ignore_global_phase) const {
      ssize_t *indices = nullptr;
      std::pair<std::vector<size_t>, Matrix> result(
        std::vector<size_t>(),
        check(raw::dqcs_mat_strip_control(handle, epsilon, ignore_global_phase, &indices))
      );
      while (*indices != -1) {
        result.first.push_back(*indices++);
      }
      return result;
    }
 
  };
 
  class Gate : public Arb {
  public:
 
    Gate(HandleIndex handle) noexcept : Arb(handle) {
    }
 
    // Delete copy construct/assign.
    Gate(const Gate&) = delete;
    void operator=(const Gate&) = delete;
 
    Gate(Gate&&) = default;
 
    Gate &operator=(Gate&&) = default;
 
    static Gate predefined(PredefinedGate gate, QubitSet &&qubits, ArbData &&parameters) {
      return Gate(check(raw::dqcs_gate_new_predef(
        to_raw(gate),
        qubits.get_handle(),
        parameters.get_handle()
      )));
    }
 
    static Gate predefined(PredefinedGate gate, const QubitSet &qubits, const ArbData &parameters) {
      return predefined(gate, QubitSet(qubits), ArbData(parameters));
    }
 
    static Gate predefined(PredefinedGate gate, QubitSet &&qubits) {
      return Gate(check(raw::dqcs_gate_new_predef(
        to_raw(gate),
        qubits.get_handle(),
        0
      )));
    }
 
    static Gate predefined(PredefinedGate gate, const QubitSet &qubits) {
      return predefined(gate, QubitSet(qubits));
    }
 
    static Gate unitary(QubitSet &&targets, const Matrix &matrix) {
      return Gate(check(raw::dqcs_gate_new_unitary(
        targets.get_handle(),
        0,
        matrix.get_handle()
      )));
    }
 
    static Gate unitary(const QubitSet &targets, const Matrix &matrix) {
      return unitary(QubitSet(targets), matrix);
    }
 
    static Gate unitary(QubitSet &&targets, QubitSet &&controls, const Matrix &matrix) {
      return Gate(check(raw::dqcs_gate_new_unitary(
        targets.get_handle(),
        controls.get_handle(),
        matrix.get_handle()
      )));
    }
 
    static Gate unitary(const QubitSet &targets, const QubitSet &controls, const Matrix &matrix) {
      return unitary(QubitSet(targets), QubitSet(controls), matrix);
    }
 
    static Gate measure(QubitSet &&measures) {
      return Gate(check(raw::dqcs_gate_new_measurement(measures.get_handle(), 0)));
    }
 
    static Gate measure(const QubitSet &measures) {
      return measure(QubitSet(measures));
    }
 
    static Gate measure(QubitSet &&measures, PauliBasis basis) {
      return Gate(check(raw::dqcs_gate_new_measurement(measures.get_handle(), Matrix(basis).get_handle())));
    }
 
    static Gate measure(const QubitSet &measures, PauliBasis basis) {
      return measure(QubitSet(measures), basis);
    }
 
    static Gate measure(QubitSet &&measures, Matrix &&basis) {
      return Gate(check(raw::dqcs_gate_new_measurement(measures.get_handle(), basis.get_handle())));
    }
 
    static Gate measure(const QubitSet &measures, const Matrix &basis) {
      return measure(QubitSet(measures), Matrix(basis));
    }
 
    static Gate prep(QubitSet &&targets) {
      return Gate(check(raw::dqcs_gate_new_prep(targets.get_handle(), 0)));
    }
 
    static Gate prep(const QubitSet &targets) {
      return prep(QubitSet(targets));
    }
 
    static Gate prep(QubitSet &&targets, PauliBasis basis) {
      return Gate(check(raw::dqcs_gate_new_prep(targets.get_handle(), Matrix(basis).get_handle())));
    }
 
    static Gate prep(const QubitSet &targets, PauliBasis basis) {
      return prep(QubitSet(targets), basis);
    }
 
    static Gate prep(QubitSet &&targets, Matrix &&basis) {
      return Gate(check(raw::dqcs_gate_new_prep(targets.get_handle(), basis.get_handle())));
    }
 
    static Gate prep(const QubitSet &targets, const Matrix &basis) {
      return prep(QubitSet(targets), Matrix(basis));
    }
 
    // also TODO: gatemap prep and measure
 
    static Gate custom(
      const std::string &name,
      QubitSet &&targets,
      QubitSet &&controls,
      QubitSet &&measures,
      const Matrix &matrix
    ) {
      return Gate(check(raw::dqcs_gate_new_custom(
        name.c_str(),
        targets.get_handle(),
        controls.get_handle(),
        measures.get_handle(),
        matrix.get_handle()
      )));
    }
 
    static Gate custom(
      const std::string &name,
      const QubitSet &targets,
      const QubitSet &controls,
      const QubitSet &measures,
      const Matrix &matrix
    ) {
      return custom(
        name,
        QubitSet(targets),
        QubitSet(controls),
        QubitSet(measures),
        matrix
      );
    }
 
    static Gate custom(
      const std::string &name,
      QubitSet &&targets,
      QubitSet &&controls,
      QubitSet &&measures
    ) {
      return Gate(check(raw::dqcs_gate_new_custom(
        name.c_str(),
        targets.get_handle(),
        controls.get_handle(),
        measures.get_handle(),
        0
      )));
    }
 
    static Gate custom(
      const std::string &name,
      const QubitSet &targets,
      const QubitSet &controls,
      const QubitSet &measures
    ) {
      return custom(
        name,
        QubitSet(targets),
        QubitSet(controls),
        QubitSet(measures)
      );
    }
 
    static Gate custom(
      const std::string &name,
      QubitSet &&targets,
      QubitSet &&controls,
      const Matrix &matrix
    ) {
      return Gate(check(raw::dqcs_gate_new_custom(
        name.c_str(),
        targets.get_handle(),
        controls.get_handle(),
        0,
        matrix.get_handle()
      )));
    }
 
    static Gate custom(
      const std::string &name,
      const QubitSet &targets,
      const QubitSet &controls,
      const Matrix &matrix
    ) {
      return custom(
        name,
        QubitSet(targets),
        QubitSet(controls),
        matrix
      );
    }
 
    static Gate custom(
      const std::string &name,
      QubitSet &&targets,
      QubitSet &&controls
    ) {
      return Gate(check(raw::dqcs_gate_new_custom(
        name.c_str(),
        targets.get_handle(),
        controls.get_handle(),
        0,
        0
      )));
    }
 
    static Gate custom(
      const std::string &name,
      const QubitSet &targets,
      const QubitSet &controls
    ) {
      return custom(
        name,
        QubitSet(targets),
        QubitSet(controls)
      );
    }
 
    static Gate custom(
      const std::string &name,
      QubitSet &&targets,
      const Matrix &matrix
    ) {
      return Gate(check(raw::dqcs_gate_new_custom(
        name.c_str(),
        targets.get_handle(),
        0,
        0,
        matrix.get_handle()
      )));
    }
 
    static Gate custom(
      const std::string &name,
      const QubitSet &targets,
      const Matrix &matrix
    ) {
      return custom(
        name,
        QubitSet(targets),
        matrix
      );
    }
 
    static Gate custom(
      const std::string &name,
      QubitSet &&targets
    ) {
      return Gate(check(raw::dqcs_gate_new_custom(
        name.c_str(),
        targets.get_handle(),
        0,
        0,
        0
      )));
    }
 
    static Gate custom(
      const std::string &name,
      const QubitSet &targets
    ) {
      return custom(
        name,
        QubitSet(targets)
      );
    }
 
    static Gate custom(
      const std::string &name
    ) {
      return Gate(check(raw::dqcs_gate_new_custom(
        name.c_str(),
        0,
        0,
        0,
        0
      )));
    }
 
    GateType get_type() const {
      return check(raw::dqcs_gate_type(handle));
    }
 
    QubitSet get_targets() const {
      return QubitSet(check(raw::dqcs_gate_targets(handle)));
    }
 
    bool has_targets() const {
      return check(raw::dqcs_gate_has_targets(handle));
    }
 
    QubitSet get_controls() const {
      return QubitSet(check(raw::dqcs_gate_controls(handle)));
    }
 
    bool has_controls() const {
      return check(raw::dqcs_gate_has_controls(handle));
    }
 
    QubitSet get_measures() const {
      return QubitSet(check(raw::dqcs_gate_measures(handle)));
    }
 
    bool has_measures() const {
      return check(raw::dqcs_gate_has_measures(handle));
    }
 
    Matrix get_matrix() const {
      return Matrix(check(raw::dqcs_gate_matrix(handle)));
    }
 
    bool has_matrix() const {
      return check(raw::dqcs_gate_has_matrix(handle));
    }
 
    std::string get_name() const {
      char *data = check(raw::dqcs_gate_name(handle));
      std::string name(data);
      std::free(data);
      return name;
    }
 
    bool has_name() const {
      return check(raw::dqcs_gate_has_name(handle));
    }
 
    // Include `ArbData` builder pattern functions.
    #define ARB_BUILDER_SUBCLASS Gate
 
    ARB_BUILDER_SUBCLASS &with_json_string(const std::string &json) {
      set_arb_json_string(json);
      return *this;
    }
 
    ARB_BUILDER_SUBCLASS &with_cbor_string(const std::string &cbor) {
      set_arb_cbor_string(cbor);
      return *this;
    }
 
    template <class JSON>
    ARB_BUILDER_SUBCLASS &with_json(const JSON &json) {
      set_arb_json(json);
      return *this;
    }
 
    ARB_BUILDER_SUBCLASS &with_arg_string(const std::string &data) {
      push_arb_arg_string(data);
      return *this;
    }
 
    template <typename T>
    ARB_BUILDER_SUBCLASS &with_arg(const T &data) {
      push_arb_arg(data);
      return *this;
    }
 
    #undef ARB_BUILDER_SUBCLASS
 
  };
 
  class CustomGateConverter {
  private:
 
    // `GateMap`s are a friend, so they can take pointers to the static
    // callback entry points.
    template <class Unbound, class Bound>
    friend class GateMap;
 
    static raw::dqcs_bool_return_t raw_detector(
      const void *user_data,
      raw::dqcs_handle_t gate,
      raw::dqcs_handle_t *qubits,
      raw::dqcs_handle_t *params
    ) noexcept {
      try {
        auto converter = reinterpret_cast<const std::shared_ptr<CustomGateConverter>*>(user_data);
        Gate gate_wrapper = Gate(gate);
        QubitSet qubits_wrapper = QubitSet();
        ArbData params_wrapper = ArbData();
        params_wrapper.set_arb(gate_wrapper);
        if (!(*converter)->detect(std::move(gate_wrapper), qubits_wrapper, params_wrapper)) {
          return raw::dqcs_bool_return_t::DQCS_FALSE;
        }
        *qubits = qubits_wrapper.take_handle();
        *params = params_wrapper.take_handle();
        return raw::dqcs_bool_return_t::DQCS_TRUE;
      } catch (const std::exception &e) {
        raw::dqcs_error_set(e.what());
      }
      return raw::dqcs_bool_return_t::DQCS_BOOL_FAILURE;
    }
 
    static raw::dqcs_handle_t raw_constructor(
      const void *user_data,
      raw::dqcs_handle_t qubits,
      raw::dqcs_handle_t params
    ) noexcept {
      try {
        auto converter = reinterpret_cast<const std::shared_ptr<CustomGateConverter>*>(user_data);
        return (*converter)->construct(QubitSet(qubits), ArbData(params)).take_handle();
      } catch (const std::exception &e) {
        raw::dqcs_error_set(e.what());
      }
      return 0;
    }
 
    static void raw_deleter(void *user_data) noexcept {
      auto converter = reinterpret_cast<const std::shared_ptr<CustomGateConverter>*>(user_data);
      delete converter;
    }
 
  public:
 
    // We're using inheritance, so ensure that the destructor as virtual.
    virtual ~CustomGateConverter() = default;
 
    virtual bool detect(Gate &&gate, QubitSet &qubits, ArbData &params) const {
      return false;
    }
 
    virtual Gate construct(QubitSet &&qubits, ArbData &&params) const {
      throw std::runtime_error("detector function not implemented");
    }
 
  };
 
  class CustomUnitaryGateConverter {
  private:
 
    // `GateMap`s are a friend, so they can take pointers to the static
    // callback entry points.
    template <class Unbound, class Bound>
    friend class GateMap;
 
    static raw::dqcs_bool_return_t raw_detector(
      const void *user_data,
      raw::dqcs_handle_t matrix,
      size_t num_controls,
      raw::dqcs_handle_t *params
    ) noexcept {
      try {
        auto converter = reinterpret_cast<const std::shared_ptr<CustomUnitaryGateConverter>*>(user_data);
        ArbData params_wrapper = ArbData(*params);
        if (!(*converter)->detect(Matrix(matrix), num_controls, params_wrapper)) {
          return raw::dqcs_bool_return_t::DQCS_FALSE;
        }
        *params = params_wrapper.take_handle();
        return raw::dqcs_bool_return_t::DQCS_TRUE;
      } catch (const std::exception &e) {
        raw::dqcs_error_set(e.what());
      }
      return raw::dqcs_bool_return_t::DQCS_BOOL_FAILURE;
    }
 
    static raw::dqcs_handle_t raw_constructor(
      const void *user_data,
      raw::dqcs_handle_t *params,
      ssize_t *num_controls
    ) noexcept {
      try {
        auto converter = reinterpret_cast<const std::shared_ptr<CustomUnitaryGateConverter>*>(user_data);
        ArbData params_wrapper = ArbData(*params);
        Matrix matrix = (*converter)->construct(params_wrapper, *num_controls);
        *params = params_wrapper.take_handle();
        return matrix.take_handle();
      } catch (const std::exception &e) {
        raw::dqcs_error_set(e.what());
      }
      return 0;
    }
 
    static void raw_deleter(void *user_data) noexcept {
      auto converter = reinterpret_cast<const std::shared_ptr<CustomUnitaryGateConverter>*>(user_data);
      delete converter;
    }
 
  public:
 
    // We're using inheritance, so ensure that the destructor as virtual.
    virtual ~CustomUnitaryGateConverter() = default;
 
    virtual bool detect(Matrix &&matrix, ssize_t num_controls, ArbData &params) const {
      return false;
    }
 
    virtual Matrix construct(ArbData &params, ssize_t &num_controls) const {
      throw std::runtime_error("detector function not implemented");
    }
 
  };
 
  template <class Unbound, class Bound=Unbound>
  class GateMap : public Handle {
  private:
 
    static bool unbound_equality(const void *a, const void *b) {
      return *(const Unbound*)a == *(const Unbound*)b;
    }
 
    static uint64_t unbound_hash(const void *a) {
      return (uint64_t)std::hash<Unbound>{}(*(const Unbound*)a);
    }
 
    static void unbound_delete(void *a) {
      delete (Unbound*)a;
    }
 
  public:
 
    GateMap(HandleIndex handle) noexcept : Handle(handle) {
    }
 
    GateMap(bool strip_qubit_refs = false, bool strip_data = false)
      : Handle(check(raw::dqcs_gm_new(strip_qubit_refs, strip_data, unbound_equality, unbound_hash))) {
    }
 
    // Delete copy construct/assign.
    GateMap(const GateMap&) = delete;
    void operator=(const GateMap&) = delete;
 
    GateMap(GateMap&&) = default;
 
    GateMap &operator=(GateMap&&) = default;
 
    GateMap &&with_unitary(
      Unbound &&key,
      PredefinedGate gate,
      int num_controls = -1,
      double epsilon = 0.000001,
      bool ignore_global_phase = true
    ) {
      check(raw::dqcs_gm_add_predef_unitary(
        handle,
        unbound_delete,
        new Unbound(std::move(key)),
        to_raw(gate),
        num_controls,
        epsilon,
        ignore_global_phase
      ));
      return std::move(*this);
    }
 
    GateMap &&with_unitary(
      const Unbound &key,
      PredefinedGate gate,
      int num_controls = -1,
      double epsilon = 0.000001,
      bool ignore_global_phase = true
    ) {
      check(raw::dqcs_gm_add_predef_unitary(
        handle,
        unbound_delete,
        new Unbound(key),
        to_raw(gate),
        num_controls,
        epsilon,
        ignore_global_phase
      ));
      return std::move(*this);
    }
 
    GateMap &&with_unitary(
      Unbound &&key,
      Matrix &&matrix,
      int num_controls = -1,
      double epsilon = 0.000001,
      bool ignore_global_phase = true
    ) {
      check(raw::dqcs_gm_add_fixed_unitary(
        handle,
        unbound_delete,
        new Unbound(std::move(key)),
        matrix.get_handle(),
        num_controls,
        epsilon,
        ignore_global_phase
      ));
      return std::move(*this);
    }
 
    GateMap &&with_unitary(
      const Unbound &key,
      const Matrix &matrix,
      int num_controls = -1,
      double epsilon = 0.000001,
      bool ignore_global_phase = true
    ) {
      check(raw::dqcs_gm_add_fixed_unitary(
        handle,
        unbound_delete,
        new Unbound(key),
        Matrix(matrix).get_handle(),
        num_controls,
        epsilon,
        ignore_global_phase
      ));
      return std::move(*this);
    }
 
    GateMap &&with_unitary(
      Unbound &&key,
      const std::shared_ptr<CustomUnitaryGateConverter> &converter
    ) {
      check(raw::dqcs_gm_add_custom_unitary(
        handle,
        unbound_delete,
        new Unbound(std::move(key)),
        CustomUnitaryGateConverter::raw_detector,
        CustomUnitaryGateConverter::raw_deleter,
        new std::shared_ptr<CustomUnitaryGateConverter>(converter),
        CustomUnitaryGateConverter::raw_constructor,
        CustomUnitaryGateConverter::raw_deleter,
        new std::shared_ptr<CustomUnitaryGateConverter>(converter)
      ));
      return std::move(*this);
    }
 
    GateMap &&with_unitary(
      const Unbound &key,
      const std::shared_ptr<CustomUnitaryGateConverter> &converter
    ) {
      check(raw::dqcs_gm_add_custom_unitary(
        handle,
        unbound_delete,
        new Unbound(key),
        CustomUnitaryGateConverter::raw_detector,
        CustomUnitaryGateConverter::raw_deleter,
        new std::shared_ptr<CustomUnitaryGateConverter>(converter),
        CustomUnitaryGateConverter::raw_constructor,
        CustomUnitaryGateConverter::raw_deleter,
        new std::shared_ptr<CustomUnitaryGateConverter>(converter)
      ));
      return std::move(*this);
    }
 
    GateMap &&with_measure(
      Unbound &&key,
      PauliBasis basis = PauliBasis::Z,
      double epsilon = 0.000001,
      int num_measures = -1
    ) {
      check(raw::dqcs_gm_add_measure(
        handle,
        unbound_delete,
        new Unbound(std::move(key)),
        num_measures,
        Matrix(basis).get_handle(),
        epsilon
      ));
      return std::move(*this);
    }
 
    GateMap &&with_measure(
      const Unbound &key,
      PauliBasis basis = PauliBasis::Z,
      double epsilon = 0.000001,
      int num_measures = -1
    ) {
      check(raw::dqcs_gm_add_measure(
        handle,
        unbound_delete,
        new Unbound(key),
        num_measures,
        Matrix(basis).get_handle(),
        epsilon
      ));
      return std::move(*this);
    }
 
    GateMap &&with_measure(
      Unbound &&key,
      Matrix &&basis,
      double epsilon = 0.000001,
      int num_measures = -1
    ) {
      check(raw::dqcs_gm_add_measure(
        handle,
        unbound_delete,
        new Unbound(std::move(key)),
        num_measures,
        basis.get_handle(),
        epsilon
      ));
      return std::move(*this);
    }
 
    GateMap &&with_measure(
      const Unbound &key,
      const Matrix &basis,
      double epsilon = 0.000001,
      int num_measures = -1
    ) {
      check(raw::dqcs_gm_add_measure(
        handle,
        unbound_delete,
        new Unbound(key),
        num_measures,
        Matrix(basis).get_handle(),
        epsilon
      ));
      return std::move(*this);
    }
 
    GateMap &&with_prep(
      Unbound &&key,
      PauliBasis basis = PauliBasis::Z,
      double epsilon = 0.000001,
      int num_targets = -1
    ) {
      check(raw::dqcs_gm_add_prep(
        handle,
        unbound_delete,
        new Unbound(std::move(key)),
        num_targets,
        Matrix(basis).get_handle(),
        epsilon
      ));
      return std::move(*this);
    }
 
    GateMap &&with_prep(
      const Unbound &key,
      PauliBasis basis = PauliBasis::Z,
      double epsilon = 0.000001,
      int num_targets = -1
    ) {
      check(raw::dqcs_gm_add_prep(
        handle,
        unbound_delete,
        new Unbound(key),
        num_targets,
        Matrix(basis).get_handle(),
        epsilon
      ));
      return std::move(*this);
    }
 
    GateMap &&with_prep(
      Unbound &&key,
      Matrix &&basis,
      double epsilon = 0.000001,
      int num_targets = -1
    ) {
      check(raw::dqcs_gm_add_prep(
        handle,
        unbound_delete,
        new Unbound(std::move(key)),
        num_targets,
        basis.get_handle(),
        epsilon
      ));
      return std::move(*this);
    }
 
    GateMap &&with_prep(
      const Unbound &key,
      const Matrix &basis,
      double epsilon = 0.000001,
      int num_targets = -1
    ) {
      check(raw::dqcs_gm_add_prep(
        handle,
        unbound_delete,
        new Unbound(key),
        num_targets,
        Matrix(basis).get_handle(),
        epsilon
      ));
      return std::move(*this);
    }
 
    GateMap &&with_custom(
      Unbound &&key,
      const std::shared_ptr<CustomGateConverter> &converter
    ) {
      check(raw::dqcs_gm_add_custom(
        handle,
        unbound_delete,
        new Unbound(std::move(key)),
        CustomGateConverter::raw_detector,
        CustomGateConverter::raw_deleter,
        new std::shared_ptr<CustomGateConverter>(converter),
        CustomGateConverter::raw_constructor,
        CustomGateConverter::raw_deleter,
        new std::shared_ptr<CustomGateConverter>(converter)
      ));
      return std::move(*this);
    }
 
    GateMap &&with_custom(
      const Unbound &key,
      const std::shared_ptr<CustomGateConverter> &converter
    ) {
      check(raw::dqcs_gm_add_custom(
        handle,
        unbound_delete,
        new Unbound(key),
        CustomGateConverter::raw_detector,
        CustomGateConverter::raw_deleter,
        new std::shared_ptr<CustomGateConverter>(converter),
        CustomGateConverter::raw_constructor,
        CustomGateConverter::raw_deleter,
        new std::shared_ptr<CustomGateConverter>(converter)
      ));
      return std::move(*this);
    }
 
    bool detect(
      const Gate &gate,
      const Unbound **unbound,
      QubitSet *qubits,
      ArbData *params
    ) {
      raw::dqcs_handle_t qubits_handle = 0;
      raw::dqcs_handle_t *qubits_handle_ptr = qubits ? &qubits_handle : nullptr;
      raw::dqcs_handle_t params_handle = 0;
      raw::dqcs_handle_t *params_handle_ptr = params ? &params_handle : nullptr;
      bool match = check(raw::dqcs_gm_detect(
        handle,
        gate.get_handle(),
        (const void**)unbound,
        qubits_handle_ptr,
        params_handle_ptr
      ));
      if (qubits && qubits_handle) *qubits = QubitSet(qubits_handle);
      if (params && params_handle) *params = ArbData(params_handle);
      return match;
    }
 
    Gate construct(
      const Unbound &unbound,
      QubitSet &&qubits,
      ArbData &&params
    ) {
      return Gate(check(raw::dqcs_gm_construct(
        handle,
        &unbound,
        qubits.get_handle(),
        params.get_handle()
      )));
    }
 
    Gate construct(
      const Unbound &unbound,
      const QubitSet &qubits,
      const ArbData &params
    ) {
      return construct(unbound, QubitSet(qubits), ArbData(params));
    }
 
    Gate construct(
      const Unbound &unbound,
      QubitSet &&qubits
    ) {
      return Gate(check(raw::dqcs_gm_construct(
        handle,
        &unbound,
        qubits.get_handle(),
        0
      )));
    }
 
    Gate construct(
      const Unbound &unbound,
      const QubitSet &qubits
    ) {
      return construct(unbound, QubitSet(qubits));
    }
 
    Bound convert(const Gate &gate) {
      const Unbound *unbound = nullptr;
      QubitSet qubits(0);
      ArbData params(0);
      if (!detect(gate, &unbound, &qubits, &params)) {
        throw std::runtime_error("unknown gate");
      }
      return unbound->bind(std::move(qubits), std::move(params));
    }
 
    Gate convert(const Bound &bound) {
      return construct(
        bound.get_unbound(),
        bound.get_qubits(),
        bound.get_params()
      );
    }
 
  };
 
  class Measurement : public Arb {
  public:
 
    Measurement(HandleIndex handle) noexcept : Arb(handle) {
    }
 
    Measurement(const QubitRef &qubit, MeasurementValue value) : Arb(check(
      raw::dqcs_meas_new(qubit.get_index(), to_raw(value))
    )) {
    }
 
    Measurement(const Measurement &src) : Arb(check(
      raw::dqcs_meas_new(src.get_qubit().get_index(), to_raw(src.get_value()))
    )) {
      set_arb(src);
    }
 
    void operator=(const Measurement &src) {
      set_qubit(src.get_qubit());
      set_value(src.get_value());
      set_arb(src);
    }
 
    Measurement(Measurement &&handle) = default;
 
    Measurement &operator=(Measurement&&) = default;
 
    MeasurementValue get_value() const {
      return check(raw::dqcs_meas_value_get(handle));
    }
 
    void set_value(MeasurementValue value) {
      check(raw::dqcs_meas_value_set(handle, to_raw(value)));
    }
 
    QubitRef get_qubit() const {
      return QubitRef(check(raw::dqcs_meas_qubit_get(handle)));
    }
 
    void set_qubit(QubitRef qubit) {
      check(raw::dqcs_meas_qubit_set(handle, qubit.get_index()));
    }
 
    // Include `ArbData` builder pattern functions.
    #define ARB_BUILDER_SUBCLASS Measurement
 
    ARB_BUILDER_SUBCLASS &with_json_string(const std::string &json) {
      set_arb_json_string(json);
      return *this;
    }
 
    ARB_BUILDER_SUBCLASS &with_cbor_string(const std::string &cbor) {
      set_arb_cbor_string(cbor);
      return *this;
    }
 
    template <class JSON>
    ARB_BUILDER_SUBCLASS &with_json(const JSON &json) {
      set_arb_json(json);
      return *this;
    }
 
    ARB_BUILDER_SUBCLASS &with_arg_string(const std::string &data) {
      push_arb_arg_string(data);
      return *this;
    }
 
    template <typename T>
    ARB_BUILDER_SUBCLASS &with_arg(const T &data) {
      push_arb_arg(data);
      return *this;
    }
 
    #undef ARB_BUILDER_SUBCLASS
 
  };
 
  class MeasurementSet : public Handle {
  public:
 
    MeasurementSet(HandleIndex handle) noexcept : Handle(handle) {
    }
 
    MeasurementSet() : Handle(check(raw::dqcs_mset_new())) {
    }
 
    template <class T>
    static MeasurementSet from_iter(const T &measurements) {
      MeasurementSet result;
      for (const Measurement &measurement : measurements) {
        result.set(measurement);
      }
      return result;
    }
 
    void set(Measurement &&measurement) {
      check(raw::dqcs_mset_set(handle, measurement.get_handle()));
    }
 
    void set(const Measurement &measurement) {
      set(Measurement(measurement));
    }
 
    MeasurementSet &&with(Measurement &&measurement) {
      set(std::move(measurement));
      return std::move(*this);
    }
 
    MeasurementSet &&with(const Measurement &measurement) {
      set(measurement);
      return std::move(*this);
    }
 
    Measurement get(const QubitRef &qubit) const {
      return Measurement(check(raw::dqcs_mset_get(handle, qubit.get_index())));
    }
 
    Measurement take(const QubitRef &qubit) {
      return Measurement(check(raw::dqcs_mset_take(handle, qubit.get_index())));
    }
 
    Measurement take_any() {
      return Measurement(check(raw::dqcs_mset_take_any(handle)));
    }
 
    void remove(const QubitRef &qubit) {
      check(raw::dqcs_mset_remove(handle, qubit.get_index()));
    }
 
    size_t size() const {
      return check(raw::dqcs_mset_len(handle));
    }
 
    bool contains(const QubitRef &qubit) const {
      return check(raw::dqcs_mset_contains(handle, qubit.get_index()));
    }
 
    std::vector<Measurement> drain_into_vector() {
      std::vector<Measurement> measurements;
      while (size()) {
        measurements.emplace_back(take_any());
      }
      return measurements;
    }
 
    std::vector<Measurement> copy_into_vector() {
      std::vector<Measurement> vector = drain_into_vector();
      MeasurementSet copy = MeasurementSet::from_iter(vector);
      free();
      handle = copy.take_handle();
      return vector;
    }
 
    MeasurementSet(MeasurementSet &src) : Handle(0) {
      handle = MeasurementSet::from_iter(src.copy_into_vector()).take_handle();
    }
 
    MeasurementSet &operator=(MeasurementSet &src) {
      free();
      handle = MeasurementSet::from_iter(src.copy_into_vector()).take_handle();
      return *this;
    }
 
    MeasurementSet(MeasurementSet &&handle) = default;
 
    MeasurementSet &operator=(MeasurementSet&&) = default;
 
  };
 
  class UpstreamPluginState {
  protected:
 
    const raw::dqcs_plugin_state_t state;
 
    UpstreamPluginState(raw::dqcs_plugin_state_t state) : state(state) {
    }
 
    // Allow the C-style callbacks to construct the plugin state wrapper.
    friend class CallbackEntryPoints;
 
  public:
 
    // Delete the copy and move constructors and assignments.
    UpstreamPluginState(const UpstreamPluginState&) = delete;
    void operator=(const UpstreamPluginState&) = delete;
    UpstreamPluginState(UpstreamPluginState&&) = delete;
    UpstreamPluginState &operator=(UpstreamPluginState&&) = delete;
 
    double random_f64() noexcept {
      return raw::dqcs_plugin_random_f64(state);
    }
 
    uint64_t random_u64() noexcept {
      return raw::dqcs_plugin_random_u64(state);
    }
 
    template <typename T>
    T random() noexcept {
      uint64_t data[(sizeof(T) + 7) / 8];
      for (size_t i = 0; i < (sizeof(T) + 7) / 8; i++) {
        data = random_u64();
      }
      T retval;
      std::memcpy(&retval, data, sizeof(T));
      return retval;
    }
 
  };
 
  class PluginState : public UpstreamPluginState {
  protected:
 
    PluginState(raw::dqcs_plugin_state_t state) : UpstreamPluginState(state) {
    }
 
    // Allow the C-style callbacks to construct the plugin state wrapper.
    friend class CallbackEntryPoints;
 
  public:
 
    // Delete the copy and move constructors and assignments.
    PluginState(const PluginState&) = delete;
    void operator=(const PluginState&) = delete;
    PluginState(PluginState&&) = delete;
    PluginState &operator=(PluginState&&) = delete;
 
    QubitSet allocate(size_t num_qubits, ArbCmdQueue &&cmds) {
      return QubitSet(check(raw::dqcs_plugin_allocate(state, num_qubits, cmds.get_handle())));
    }
 
    QubitSet allocate(size_t num_qubits, ArbCmdQueue &cmds) {
      return allocate(num_qubits, ArbCmdQueue(cmds));
    }
 
    QubitSet allocate(size_t num_qubits) {
      return QubitSet(check(raw::dqcs_plugin_allocate(state, num_qubits, 0)));
    }
 
    QubitRef allocate(ArbCmdQueue &&cmds) {
      return allocate(1, std::move(cmds)).pop();
    }
 
    QubitRef allocate(ArbCmdQueue &cmds) {
      return allocate(ArbCmdQueue(cmds));
    }
 
    QubitRef allocate() {
      return allocate(1).pop();
    }
 
    void free(QubitSet &&qubits) {
      check(raw::dqcs_plugin_free(state, qubits.get_handle()));
    }
 
    void free(const QubitSet &qubits) {
      free(QubitSet(qubits));
    }
 
    void free(const QubitRef &qubit) {
      free(QubitSet().with(qubit));
    }
 
    void gate(Gate &&gate) {
      check(raw::dqcs_plugin_gate(state, gate.get_handle()));
    }
 
    void gate(const Matrix &matrix, const QubitRef &q) {
      if (matrix.size() == 2) {
        gate(Gate::unitary(QubitSet().with(q), matrix));
      } else {
        throw std::invalid_argument("matrix has incorrect size");
      }
    }
 
    void gate(const Matrix &matrix, const QubitRef &qa, const QubitRef &qb) {
      if (matrix.size() == 2) {
        gate(Gate::unitary(QubitSet().with(qb), QubitSet().with(qa), matrix));
      } else if (matrix.size() == 4) {
        gate(Gate::unitary(QubitSet().with(qa).with(qb), matrix));
      } else {
        throw std::invalid_argument("matrix has incorrect size");
      }
    }
 
    void gate(const Matrix &matrix, const QubitRef &qa, const QubitRef &qb, const QubitRef &qc) {
      if (matrix.size() == 2) {
        gate(Gate::unitary(QubitSet().with(qc), QubitSet().with(qa).with(qb), matrix));
      } else if (matrix.size() == 4) {
        gate(Gate::unitary(QubitSet().with(qb).with(qc), QubitSet().with(qa), matrix));
      } else if (matrix.size() == 8) {
        gate(Gate::unitary(QubitSet().with(qa).with(qb).with(qc), matrix));
      } else {
        throw std::invalid_argument("matrix has incorrect size");
      }
    }
 
    void measure_x(const QubitRef &q) {
      gate(Matrix(PredefinedGate::H), q);
      measure_z(q);
      gate(Matrix(PredefinedGate::H), q);
    }
 
    void measure_x(const QubitSet &qs) {
      auto qs_vec = qs.copy_into_vector();
      for (auto &q : qs_vec) gate(Matrix(PredefinedGate::H), q);
      measure_z(qs);
      for (auto &q : qs_vec) gate(Matrix(PredefinedGate::H), q);
    }
 
    void measure_y(const QubitRef &q) {
      gate(Matrix(PredefinedGate::S), q);
      gate(Matrix(PredefinedGate::Z), q);
      measure_x(q);
      gate(Matrix(PredefinedGate::S), q);
    }
 
    void measure_y(const QubitSet &qs) {
      auto qs_vec = qs.copy_into_vector();
      for (auto &q : qs_vec) gate(Matrix(PredefinedGate::S), q);
      for (auto &q : qs_vec) gate(Matrix(PredefinedGate::Z), q);
      measure_x(qs);
      for (auto &q : qs_vec) gate(Matrix(PredefinedGate::S), q);
    }
 
    void measure_z(const QubitRef &q) {
      measure_z(std::move(QubitSet().with(q)));
    }
 
    void measure_z(QubitSet &&qs) {
      gate(Gate::measure(std::move(qs)));
    }
 
    void measure_z(const QubitSet &qs) {
      measure_z(QubitSet(qs));
    }
 
    Cycle advance(Cycle cycles) {
      return check(raw::dqcs_plugin_advance(state, cycles));
    }
 
    ArbData arb(ArbCmd &&cmd) {
      return ArbData(check(raw::dqcs_plugin_arb(state, cmd.get_handle())));
    }
 
    ArbData arb(const ArbCmd &cmd) {
      return arb(ArbCmd(cmd));
    }
 
    Measurement get_measurement(const QubitRef &qubit) {
      return Measurement(check(raw::dqcs_plugin_get_measurement(state, qubit.get_index())));
    }
 
    Cycle get_cycles_since_measure(const QubitRef &qubit) {
      return check(raw::dqcs_plugin_get_cycles_since_measure(state, qubit.get_index()));
    }
 
    Cycle get_cycles_between_measures(const QubitRef &qubit) {
      return check(raw::dqcs_plugin_get_cycles_between_measures(state, qubit.get_index()));
    }
 
    Cycle get_cycle() {
      return check(raw::dqcs_plugin_get_cycle(state));
    }
 
  };
 
  class RunningPluginState : public PluginState {
  protected:
 
    RunningPluginState(raw::dqcs_plugin_state_t state) : PluginState(state) {
    }
 
    // Allow the C-style callbacks to construct the plugin state wrapper.
    friend class CallbackEntryPoints;
 
  public:
 
    // Delete the copy and move constructors and assignments.
    RunningPluginState(const RunningPluginState&) = delete;
    void operator=(const RunningPluginState&) = delete;
    RunningPluginState(RunningPluginState&&) = delete;
    RunningPluginState &operator=(RunningPluginState&&) = delete;
 
    void send(ArbData &&message) {
      check(raw::dqcs_plugin_send(state, message.get_handle()));
    }
 
    void send(const ArbData &message) {
      send(ArbData(message));
    }
 
    ArbData recv() {
      return ArbData(check(raw::dqcs_plugin_recv(state)));
    }
 
  };
 
  template <class R, class... Args>
  class Callback {
  private:
 
    template <class T, class S, class A>
    static std::function<S(A)> bind_first(S (*cb)(T, A), T user) {
      using namespace std::placeholders;
      return std::bind(cb, user, _1);
    }
 
    template <class T, class S, class A, class B>
    static std::function<S(A, B)> bind_first(S (*cb)(T, A, B), T user) {
      using namespace std::placeholders;
      return std::bind(cb, user, _1, _2);
    }
 
    template <class T, class S, class A, class B, class C>
    static std::function<S(A, B, C)> bind_first(S (*cb)(T, A, B, C), T user) {
      using namespace std::placeholders;
      return std::bind(cb, user, _1, _2, _3);
    }
 
    template <class T, class S, class A>
    static std::function<S(A)> bind_instance(T *instance, S (T::*cb)(A)) {
      using namespace std::placeholders;
      return std::bind(cb, instance, _1);
    }
 
    template <class T, class S, class A, class B>
    static std::function<S(A, B)> bind_instance(T *instance, S (T::*cb)(A, B)) {
      using namespace std::placeholders;
      return std::bind(cb, instance, _1, _2);
    }
 
    template <class T, class S, class A, class B, class C>
    static std::function<S(A, B, C)> bind_instance(T *instance, S (T::*cb)(A, B, C)) {
      using namespace std::placeholders;
      return std::bind(cb, instance, _1, _2, _3);
    }
 
    std::shared_ptr<std::function<R(Args...)>> cb;
 
    // Allow the C-style callbacks access to this class.
    friend class CallbackEntryPoints;
 
  public:
 
    Callback(R (*cb)(Args...)) noexcept
      : cb(std::make_shared<std::function<R(Args...)>>(cb))
    {}
 
    template <class T>
    Callback(R (*cb)(T, Args...), T user) noexcept
      : cb(std::make_shared<std::function<R(Args...)>>(bind_first<T, R, Args...>(cb, user)))
    {}
 
    template <class T>
    Callback(T *instance, R (T::*cb)(Args...)) noexcept
      : cb(std::make_shared<std::function<R(Args...)>>(bind_instance<T, R, Args...>(instance, cb)))
    {}
 
    Callback(std::function<R(Args...)> &&cb) noexcept
      : cb(std::make_shared<std::function<R(Args...)>>(std::move(cb)))
    {}
 
    Callback(const std::function<R(Args...)> &cb) noexcept
      : cb(std::make_shared<std::function<R(Args...)>>(cb))
    {}
 
    Callback(std::shared_ptr<std::function<R(Args...)>> &&cb) noexcept : cb(cb) {
    }
 
    Callback(const std::shared_ptr<std::function<R(Args...)>> &cb) noexcept : cb(cb) {
    }
 
  };
 
  namespace callback {
 
    typedef Callback<void, PluginState&, ArbCmdQueue&&> Initialize;
 
    typedef Callback<void, PluginState&> Drop;
 
    typedef Callback<ArbData, RunningPluginState&, ArbData&&> Run;
 
    typedef Callback<void, PluginState&, QubitSet&&, ArbCmdQueue&&> Allocate;
 
    typedef Callback<void, PluginState&, QubitSet&&> Free;
 
    typedef Callback<MeasurementSet, PluginState&, Gate&&> Gate;
 
    typedef Callback<MeasurementSet, UpstreamPluginState&, Measurement&&> ModifyMeasurement;
 
    typedef Callback<void, PluginState&, Cycle> Advance;
 
    typedef Callback<ArbData, PluginState&, ArbCmd> Arb;
 
    typedef Callback<void, std::string&&> SpawnPlugin;
 
    typedef Callback<
      void,
      std::string&&,                            // message
      std::string&&,                            // logger
      Loglevel,                                 // severity
      std::string&&,                            // module
      std::string&&,                            // file
      uint32_t,                                 // line number
      std::chrono::system_clock::time_point&&,  // timestamp
      uint32_t,                                 // process ID
      uint64_t                                  // thread ID
    > Log;
 
  } // namespace callback
 
 
  class CallbackEntryPoints {
  private:
    friend class Plugin;
    friend class SimulationConfiguration;
    friend class PluginConfigurationBuilder;
 
    static raw::dqcs_return_t initialize(
      void *user_data,
      raw::dqcs_plugin_state_t state,
      raw::dqcs_handle_t init_cmds
    ) noexcept {
 
      // Wrap inputs.
      callback::Initialize *cb_wrapper = reinterpret_cast<callback::Initialize*>(user_data);
      PluginState state_wrapper(state);
      ArbCmdQueue init_cmds_wrapper(init_cmds);
 
      // Catch exceptions thrown in the user function to convert them to
      // DQCsim's error reporting protocol.
      try {
        (*(cb_wrapper->cb))(state_wrapper, std::move(init_cmds_wrapper));
        return raw::dqcs_return_t::DQCS_SUCCESS;
      } catch (const std::exception &e) {
        raw::dqcs_error_set(e.what());
      }
      return raw::dqcs_return_t::DQCS_FAILURE;
    }
 
    static raw::dqcs_return_t drop(
      void *user_data,
      raw::dqcs_plugin_state_t state
    ) noexcept {
 
      // Wrap inputs.
      callback::Drop *cb_wrapper = reinterpret_cast<callback::Drop*>(user_data);
      PluginState state_wrapper(state);
 
      // Catch exceptions thrown in the user function to convert them to
      // DQCsim's error reporting protocol.
      try {
        (*(cb_wrapper->cb))(state_wrapper);
        return raw::dqcs_return_t::DQCS_SUCCESS;
      } catch (const std::exception &e) {
        raw::dqcs_error_set(e.what());
      }
      return raw::dqcs_return_t::DQCS_FAILURE;
    }
 
    static raw::dqcs_handle_t run(
      void *user_data,
      raw::dqcs_plugin_state_t state,
      raw::dqcs_handle_t args
    ) noexcept {
 
      // Wrap inputs.
      callback::Run *cb_wrapper = reinterpret_cast<callback::Run*>(user_data);
      RunningPluginState state_wrapper(state);
      ArbData args_wrapper(args);
 
      // Catch exceptions thrown in the user function to convert them to
      // DQCsim's error reporting protocol.
      try {
        return (*(cb_wrapper->cb))(state_wrapper, std::move(args_wrapper)).take_handle();
      } catch (const std::exception &e) {
        raw::dqcs_error_set(e.what());
      }
      return 0;
    }
 
    static raw::dqcs_return_t allocate(
      void *user_data,
      raw::dqcs_plugin_state_t state,
      raw::dqcs_handle_t qubits,
      raw::dqcs_handle_t alloc_cmds
    ) noexcept {
 
      // Wrap inputs.
      callback::Allocate *cb_wrapper = reinterpret_cast<callback::Allocate*>(user_data);
      PluginState state_wrapper(state);
      QubitSet qubits_wrapper(qubits);
      ArbCmdQueue alloc_cmds_wrapper(alloc_cmds);
 
      // Catch exceptions thrown in the user function to convert them to
      // DQCsim's error reporting protocol.
      try {
        (*(cb_wrapper->cb))(state_wrapper, std::move(qubits_wrapper), std::move(alloc_cmds_wrapper));
        return raw::dqcs_return_t::DQCS_SUCCESS;
      } catch (const std::exception &e) {
        raw::dqcs_error_set(e.what());
      }
      return raw::dqcs_return_t::DQCS_FAILURE;
    }
 
    static raw::dqcs_return_t free(
      void *user_data,
      raw::dqcs_plugin_state_t state,
      raw::dqcs_handle_t qubits
    ) noexcept {
 
      // Wrap inputs.
      callback::Free *cb_wrapper = reinterpret_cast<callback::Free*>(user_data);
      PluginState state_wrapper(state);
      QubitSet qubits_wrapper(qubits);
 
      // Catch exceptions thrown in the user function to convert them to
      // DQCsim's error reporting protocol.
      try {
        (*(cb_wrapper->cb))(state_wrapper, std::move(qubits_wrapper));
        return raw::dqcs_return_t::DQCS_SUCCESS;
      } catch (const std::exception &e) {
        raw::dqcs_error_set(e.what());
      }
      return raw::dqcs_return_t::DQCS_FAILURE;
    }
 
    static raw::dqcs_handle_t gate(
      void *user_data,
      raw::dqcs_plugin_state_t state,
      raw::dqcs_handle_t gate
    ) noexcept {
 
      // Wrap inputs.
      callback::Gate *cb_wrapper = reinterpret_cast<callback::Gate*>(user_data);
      PluginState state_wrapper(state);
      Gate gate_wrapper(gate);
 
      // Catch exceptions thrown in the user function to convert them to
      // DQCsim's error reporting protocol.
      try {
        return (*(cb_wrapper->cb))(state_wrapper, std::move(gate_wrapper)).take_handle();
      } catch (const std::exception &e) {
        raw::dqcs_error_set(e.what());
      }
      return 0;
    }
 
    static raw::dqcs_handle_t modify_measurement(
      void *user_data,
      raw::dqcs_plugin_state_t state,
      raw::dqcs_handle_t meas
    ) noexcept {
 
      // Wrap inputs.
      callback::ModifyMeasurement *cb_wrapper = reinterpret_cast<callback::ModifyMeasurement*>(user_data);
      UpstreamPluginState state_wrapper(state);
      Measurement meas_wrapper(meas);
 
      // Catch exceptions thrown in the user function to convert them to
      // DQCsim's error reporting protocol.
      try {
        return (*(cb_wrapper->cb))(state_wrapper, std::move(meas_wrapper)).take_handle();
      } catch (const std::exception &e) {
        raw::dqcs_error_set(e.what());
      }
      return 0;
    }
 
    static raw::dqcs_return_t advance(
      void *user_data,
      raw::dqcs_plugin_state_t state,
      Cycle cycles
    ) noexcept {
 
      // Wrap inputs.
      callback::Advance *cb_wrapper = reinterpret_cast<callback::Advance*>(user_data);
      PluginState state_wrapper(state);
 
      // Catch exceptions thrown in the user function to convert them to
      // DQCsim's error reporting protocol.
      try {
        (*(cb_wrapper->cb))(state_wrapper, cycles);
        return raw::dqcs_return_t::DQCS_SUCCESS;
      } catch (const std::exception &e) {
        raw::dqcs_error_set(e.what());
      }
      return raw::dqcs_return_t::DQCS_FAILURE;
    }
 
    static raw::dqcs_handle_t upstream_arb(
      void *user_data,
      raw::dqcs_plugin_state_t state,
      raw::dqcs_handle_t cmd
    ) noexcept {
 
      // Wrap inputs.
      callback::Arb *cb_wrapper = reinterpret_cast<callback::Arb*>(user_data);
      PluginState state_wrapper(state);
      ArbCmd cmd_wrapper(cmd);
 
      // Catch exceptions thrown in the user function to convert them to
      // DQCsim's error reporting protocol.
      try {
        return (*(cb_wrapper->cb))(state_wrapper, std::move(cmd_wrapper)).take_handle();
      } catch (const std::exception &e) {
        raw::dqcs_error_set(e.what());
      }
      return 0;
    }
 
    static raw::dqcs_handle_t host_arb(
      void *user_data,
      raw::dqcs_plugin_state_t state,
      raw::dqcs_handle_t cmd
    ) noexcept {
 
      // Wrap inputs.
      callback::Arb *cb_wrapper = reinterpret_cast<callback::Arb*>(user_data);
      PluginState state_wrapper(state);
      ArbCmd cmd_wrapper(cmd);
 
      // Catch exceptions thrown in the user function to convert them to
      // DQCsim's error reporting protocol.
      try {
        return (*(cb_wrapper->cb))(state_wrapper, std::move(cmd_wrapper)).take_handle();
      } catch (const std::exception &e) {
        raw::dqcs_error_set(e.what());
      }
      return 0;
    }
 
    static void spawn_plugin(
      void *user_data,
      const char *simulator
    ) noexcept {
 
      // Wrap inputs.
      callback::SpawnPlugin *cb_wrapper = reinterpret_cast<callback::SpawnPlugin*>(user_data);
      std::string simulator_wrapper(simulator);
 
      // Catch exceptions thrown in the user function to convert them to
      // DQCsim's error reporting protocol.
      try {
        (*(cb_wrapper->cb))(std::move(simulator_wrapper));
      } catch (const std::exception &e) {
        DQCSIM_FATAL("DQCsim caught std::exception in plugin thread: %s", e.what());
      }
    }
 
    static void log(
      void *user_data,
      const char *message,
      const char *logger,
      raw::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
    ) noexcept {
 
      // Wrap inputs.
      callback::Log *cb_wrapper = reinterpret_cast<callback::Log*>(user_data);
 
      // Catch exceptions thrown in the user function to convert them to
      // DQCsim's error reporting protocol.
      try {
        (*(cb_wrapper->cb))(
          std::string(message ? message : ""),
          std::string(logger ? logger : ""),
          check(level),
          std::string(module ? module : ""),
          std::string(file ? file : ""),
          line,
          std::chrono::system_clock::time_point(
            std::chrono::duration_cast<std::chrono::microseconds>(
              std::chrono::seconds(time_s)
              + std::chrono::nanoseconds(time_ns)
            )
          ),
          pid,
          tid
        );
      } catch (const std::exception &e) {
        std::cerr << "DQCsim caught std::exception in log callback: " << e.what() << std::endl;
      }
    }
 
    template <class T>
    static void user_free(void *user_data) noexcept {
      T *cb_wrapper = reinterpret_cast<T*>(user_data);
      delete cb_wrapper;
    }
 
  };
 
  class PluginJoinHandle : public Handle {
  public:
 
    PluginJoinHandle(HandleIndex handle) noexcept : Handle(handle) {
    }
 
    // Delete copy construct/assign.
    PluginJoinHandle(const PluginJoinHandle&) = delete;
    void operator=(const PluginJoinHandle&) = delete;
 
    PluginJoinHandle(PluginJoinHandle&&) = default;
 
    PluginJoinHandle &operator=(PluginJoinHandle&&) = default;
 
    void wait() {
      if (handle) {
        check(raw::dqcs_plugin_wait(handle));
        take_handle();
      }
    }
 
  };
 
  class Plugin : public Handle {
  public:
 
    Plugin(HandleIndex handle) noexcept : Handle(handle) {
    }
 
    Plugin(
      PluginType type,
      const std::string &name,
      const std::string &author,
      const std::string &version
    ) : Handle(raw::dqcs_pdef_new(
      to_raw(type), name.c_str(), author.c_str(), version.c_str()
    )) {
    }
 
    static Plugin Frontend(
      const std::string &name,
      const std::string &author,
      const std::string &version
    ) {
      return Plugin(PluginType::Frontend, name, author, version);
    }
 
    static Plugin Operator(
      const std::string &name,
      const std::string &author,
      const std::string &version
    ) {
      return Plugin(PluginType::Operator, name, author, version);
    }
 
    static Plugin Backend(
      const std::string &name,
      const std::string &author,
      const std::string &version
    ) {
      return Plugin(PluginType::Backend, name, author, version);
    }
 
    // Delete copy construct/assign.
    Plugin(const Plugin&) = delete;
    void operator=(const Plugin&) = delete;
 
    Plugin(Plugin&&) = default;
 
    Plugin &operator=(Plugin&&) = default;
 
    PluginType get_type() const {
      return check(raw::dqcs_pdef_type(handle));
    }
 
    std::string get_name() const {
      char *cstr = check(raw::dqcs_pdef_name(handle));
      std::string str(cstr);
      std::free(cstr);
      return str;
    }
 
    std::string get_author() const {
      char *cstr = check(raw::dqcs_pdef_author(handle));
      std::string str(cstr);
      std::free(cstr);
      return str;
    }
 
    std::string get_version() const {
      char *cstr = check(raw::dqcs_pdef_version(handle));
      std::string str(cstr);
      std::free(cstr);
      return str;
    }
 
    // Code below is generated using the following Python script:
    // print('    // Code below is generated using the following Python script:')
    // with open(__file__, 'r') as f:
    //     print(''.join(map(lambda x: '    // ' + x, f.readlines())), end='')
    //
    // template = """
    //   private:
    //
    //     /**
    //      * Assigns the {0[0]} callback function from a `new`-initialized
    //      * raw pointer to a `callback::{0[2]}` object. Callee will ensure that
    //      * `delete` is called.
    //      */
    //     void set_{0[1]}(callback::{0[2]} *cb) {{
    //       try {{
    //         check(raw::dqcs_pdef_set_{0[1]}_cb(
    //           handle,
    //           CallbackEntryPoints::{0[1]},
    //           CallbackEntryPoints::user_free<callback::{0[2]}>,
    //           cb));
    //       }} catch (...) {{
    //         delete cb;
    //         throw;
    //       }}
    //     }}
    //
    //   public:
    //
    //     /**
    //      * Assigns the {0[0]} callback function from a pre-existing
    //      * `callback::{0[2]}` object by copy.
    //      *
    //      * \\param cb The callback object.
    //      * \\returns `&self`, to continue building.
    //      * \\throws std::runtime_error When the current handle is invalid or of an
    //      * unsupported plugin type, or when the callback object is invalid.
    //      */
    //     Plugin &&with_{0[1]}(const callback::{0[2]} &cb) {{
    //       set_{0[1]}(new callback::{0[2]}(cb));
    //       return std::move(*this);
    //     }}
    //
    //     /**
    //      * Assigns the {0[0]} callback function from a pre-existing
    //      * `callback::{0[2]}` object by move.
    //      *
    //      * \\param cb The callback object.
    //      * \\returns `&self`, to continue building.
    //      * \\throws std::runtime_error When the current handle is invalid or of an
    //      * unsupported plugin type, or when the callback object is invalid.
    //      */
    //     Plugin &&with_{0[1]}(callback::{0[2]} &&cb) {{
    //       set_{0[1]}(new callback::{0[2]}(std::move(cb)));
    //       return std::move(*this);
    //     }}
    //
    //     /**
    //      * Assigns the {0[0]} callback function by constructing the
    //      * callback object implicitly.
    //      *
    //      * \\returns `&self`, to continue building.
    //      * \\throws std::runtime_error When the current handle is invalid or of an
    //      * unsupported plugin type, or when the callback object is invalid.
    //      */
    //     template<typename... Args>
    //     Plugin &&with_{0[1]}(Args... args) {{
    //       set_{0[1]}(new callback::{0[2]}(args...));
    //       return std::move(*this);
    //     }}
    // """
    //
    // print(''.join(map(template.format, [
    //     ('initialize',          'initialize',           'Initialize'),
    //     ('drop',                'drop',                 'Drop'),
    //     ('run',                 'run',                  'Run'),
    //     ('allocate',            'allocate',             'Allocate'),
    //     ('free',                'free',                 'Free'),
    //     ('gate',                'gate',                 'Gate'),
    //     ('modify-measurement',  'modify_measurement',   'ModifyMeasurement'),
    //     ('advance',             'advance',              'Advance'),
    //     ('upstream-arb',        'upstream_arb',         'Arb'),
    //     ('host-arb',            'host_arb',             'Arb'),
    // ])))
    //
    // print('    // End of generated code.')
 
  private:
 
    void set_initialize(callback::Initialize *cb) {
      try {
        check(raw::dqcs_pdef_set_initialize_cb(
          handle,
          CallbackEntryPoints::initialize,
          CallbackEntryPoints::user_free<callback::Initialize>,
          cb));
      } catch (...) {
        delete cb;
        throw;
      }
    }
 
  public:
 
    Plugin &&with_initialize(const callback::Initialize &cb) {
      set_initialize(new callback::Initialize(cb));
      return std::move(*this);
    }
 
    Plugin &&with_initialize(callback::Initialize &&cb) {
      set_initialize(new callback::Initialize(std::move(cb)));
      return std::move(*this);
    }
 
    template<typename... Args>
    Plugin &&with_initialize(Args... args) {
      set_initialize(new callback::Initialize(args...));
      return std::move(*this);
    }
 
  private:
 
    void set_drop(callback::Drop *cb) {
      try {
        check(raw::dqcs_pdef_set_drop_cb(
          handle,
          CallbackEntryPoints::drop,
          CallbackEntryPoints::user_free<callback::Drop>,
          cb));
      } catch (...) {
        delete cb;
        throw;
      }
    }
 
  public:
 
    Plugin &&with_drop(const callback::Drop &cb) {
      set_drop(new callback::Drop(cb));
      return std::move(*this);
    }
 
    Plugin &&with_drop(callback::Drop &&cb) {
      set_drop(new callback::Drop(std::move(cb)));
      return std::move(*this);
    }
 
    template<typename... Args>
    Plugin &&with_drop(Args... args) {
      set_drop(new callback::Drop(args...));
      return std::move(*this);
    }
 
  private:
 
    void set_run(callback::Run *cb) {
      try {
        check(raw::dqcs_pdef_set_run_cb(
          handle,
          CallbackEntryPoints::run,
          CallbackEntryPoints::user_free<callback::Run>,
          cb));
      } catch (...) {
        delete cb;
        throw;
      }
    }
 
  public:
 
    Plugin &&with_run(const callback::Run &cb) {
      set_run(new callback::Run(cb));
      return std::move(*this);
    }
 
    Plugin &&with_run(callback::Run &&cb) {
      set_run(new callback::Run(std::move(cb)));
      return std::move(*this);
    }
 
    template<typename... Args>
    Plugin &&with_run(Args... args) {
      set_run(new callback::Run(args...));
      return std::move(*this);
    }
 
  private:
 
    void set_allocate(callback::Allocate *cb) {
      try {
        check(raw::dqcs_pdef_set_allocate_cb(
          handle,
          CallbackEntryPoints::allocate,
          CallbackEntryPoints::user_free<callback::Allocate>,
          cb));
      } catch (...) {
        delete cb;
        throw;
      }
    }
 
  public:
 
    Plugin &&with_allocate(const callback::Allocate &cb) {
      set_allocate(new callback::Allocate(cb));
      return std::move(*this);
    }
 
    Plugin &&with_allocate(callback::Allocate &&cb) {
      set_allocate(new callback::Allocate(std::move(cb)));
      return std::move(*this);
    }
 
    template<typename... Args>
    Plugin &&with_allocate(Args... args) {
      set_allocate(new callback::Allocate(args...));
      return std::move(*this);
    }
 
  private:
 
    void set_free(callback::Free *cb) {
      try {
        check(raw::dqcs_pdef_set_free_cb(
          handle,
          CallbackEntryPoints::free,
          CallbackEntryPoints::user_free<callback::Free>,
          cb));
      } catch (...) {
        delete cb;
        throw;
      }
    }
 
  public:
 
    Plugin &&with_free(const callback::Free &cb) {
      set_free(new callback::Free(cb));
      return std::move(*this);
    }
 
    Plugin &&with_free(callback::Free &&cb) {
      set_free(new callback::Free(std::move(cb)));
      return std::move(*this);
    }
 
    template<typename... Args>
    Plugin &&with_free(Args... args) {
      set_free(new callback::Free(args...));
      return std::move(*this);
    }
 
  private:
 
    void set_gate(callback::Gate *cb) {
      try {
        check(raw::dqcs_pdef_set_gate_cb(
          handle,
          CallbackEntryPoints::gate,
          CallbackEntryPoints::user_free<callback::Gate>,
          cb));
      } catch (...) {
        delete cb;
        throw;
      }
    }
 
  public:
 
    Plugin &&with_gate(const callback::Gate &cb) {
      set_gate(new callback::Gate(cb));
      return std::move(*this);
    }
 
    Plugin &&with_gate(callback::Gate &&cb) {
      set_gate(new callback::Gate(std::move(cb)));
      return std::move(*this);
    }
 
    template<typename... Args>
    Plugin &&with_gate(Args... args) {
      set_gate(new callback::Gate(args...));
      return std::move(*this);
    }
 
  private:
 
    void set_modify_measurement(callback::ModifyMeasurement *cb) {
      try {
        check(raw::dqcs_pdef_set_modify_measurement_cb(
          handle,
          CallbackEntryPoints::modify_measurement,
          CallbackEntryPoints::user_free<callback::ModifyMeasurement>,
          cb));
      } catch (...) {
        delete cb;
        throw;
      }
    }
 
  public:
 
    Plugin &&with_modify_measurement(const callback::ModifyMeasurement &cb) {
      set_modify_measurement(new callback::ModifyMeasurement(cb));
      return std::move(*this);
    }
 
    Plugin &&with_modify_measurement(callback::ModifyMeasurement &&cb) {
      set_modify_measurement(new callback::ModifyMeasurement(std::move(cb)));
      return std::move(*this);
    }
 
    template<typename... Args>
    Plugin &&with_modify_measurement(Args... args) {
      set_modify_measurement(new callback::ModifyMeasurement(args...));
      return std::move(*this);
    }
 
  private:
 
    void set_advance(callback::Advance *cb) {
      try {
        check(raw::dqcs_pdef_set_advance_cb(
          handle,
          CallbackEntryPoints::advance,
          CallbackEntryPoints::user_free<callback::Advance>,
          cb));
      } catch (...) {
        delete cb;
        throw;
      }
    }
 
  public:
 
    Plugin &&with_advance(const callback::Advance &cb) {
      set_advance(new callback::Advance(cb));
      return std::move(*this);
    }
 
    Plugin &&with_advance(callback::Advance &&cb) {
      set_advance(new callback::Advance(std::move(cb)));
      return std::move(*this);
    }
 
    template<typename... Args>
    Plugin &&with_advance(Args... args) {
      set_advance(new callback::Advance(args...));
      return std::move(*this);
    }
 
  private:
 
    void set_upstream_arb(callback::Arb *cb) {
      try {
        check(raw::dqcs_pdef_set_upstream_arb_cb(
          handle,
          CallbackEntryPoints::upstream_arb,
          CallbackEntryPoints::user_free<callback::Arb>,
          cb));
      } catch (...) {
        delete cb;
        throw;
      }
    }
 
  public:
 
    Plugin &&with_upstream_arb(const callback::Arb &cb) {
      set_upstream_arb(new callback::Arb(cb));
      return std::move(*this);
    }
 
    Plugin &&with_upstream_arb(callback::Arb &&cb) {
      set_upstream_arb(new callback::Arb(std::move(cb)));
      return std::move(*this);
    }
 
    template<typename... Args>
    Plugin &&with_upstream_arb(Args... args) {
      set_upstream_arb(new callback::Arb(args...));
      return std::move(*this);
    }
 
  private:
 
    void set_host_arb(callback::Arb *cb) {
      try {
        check(raw::dqcs_pdef_set_host_arb_cb(
          handle,
          CallbackEntryPoints::host_arb,
          CallbackEntryPoints::user_free<callback::Arb>,
          cb));
      } catch (...) {
        delete cb;
        throw;
      }
    }
 
  public:
 
    Plugin &&with_host_arb(const callback::Arb &cb) {
      set_host_arb(new callback::Arb(cb));
      return std::move(*this);
    }
 
    Plugin &&with_host_arb(callback::Arb &&cb) {
      set_host_arb(new callback::Arb(std::move(cb)));
      return std::move(*this);
    }
 
    template<typename... Args>
    Plugin &&with_host_arb(Args... args) {
      set_host_arb(new callback::Arb(args...));
      return std::move(*this);
    }
 
    // End of generated code.
 
    void run(const char *simulator) {
      check(raw::dqcs_plugin_run(handle, simulator));
      take_handle();
    }
 
    int run(int argc, char *argv[]) noexcept {
      if (argc != 2) {
        DQCSIM_FATAL("Expecting exactly one command-line argument, but got %d", argc);
        return 1;
      }
      try {
        run(argv[1]);
      } catch (const std::exception &e) {
        DQCSIM_FATAL("Returning failure because of the following: %s", e.what());
        return 1;
      } catch (...) {
        DQCSIM_FATAL("Returning failure because of an unknown exception");
        return 1;
      }
      return 0;
    }
 
    PluginJoinHandle start(const char *simulator) {
      PluginJoinHandle join_handle(check(raw::dqcs_plugin_start(handle, simulator)));
      take_handle();
      return join_handle;
    }
 
  };
 
  class PluginConfiguration : public Handle {
  public:
 
    PluginConfiguration(HandleIndex handle) noexcept : Handle(handle) {
    }
 
    // Delete copy construct/assign.
    PluginConfiguration(const PluginConfiguration&) = delete;
    void operator=(const PluginConfiguration&) = delete;
 
    PluginConfiguration(PluginConfiguration&&) = default;
 
    PluginConfiguration &operator=(PluginConfiguration&&) = default;
 
    virtual PluginType get_plugin_type() const = 0;
 
    virtual std::string get_name() const = 0;
 
    virtual void add_init_cmd(ArbCmd &&cmd) = 0;
 
    void add_init_cmd(const ArbCmd &cmd) {
      add_init_cmd(ArbCmd(cmd));
    }
 
    virtual void set_verbosity(Loglevel level) = 0;
 
    virtual Loglevel get_verbosity() const = 0;
 
    virtual void log_tee(Loglevel verbosity, const std::string &filename) = 0;
 
  };
 
  class PluginProcessConfiguration : public PluginConfiguration {
  public:
 
    PluginProcessConfiguration(HandleIndex handle) noexcept : PluginConfiguration(handle) {
    }
 
    // Delete copy construct/assign.
    PluginProcessConfiguration(const PluginProcessConfiguration&) = delete;
    void operator=(const PluginProcessConfiguration&) = delete;
 
    PluginProcessConfiguration(PluginProcessConfiguration&&) = default;
 
    PluginProcessConfiguration &operator=(PluginProcessConfiguration&&) = default;
 
    PluginType get_plugin_type() const override {
      return check(raw::dqcs_pcfg_type(handle));
    }
 
    std::string get_name() const override {
      char *ptr = check(raw::dqcs_pcfg_name(handle));
      std::string retval(ptr);
      std::free(ptr);
      return retval;
    }
 
    std::string get_executable() const {
      char *ptr = check(raw::dqcs_pcfg_executable(handle));
      std::string retval(ptr);
      std::free(ptr);
      return retval;
    }
 
    std::string get_script() const {
      char *ptr = check(raw::dqcs_pcfg_script(handle));
      std::string retval(ptr);
      std::free(ptr);
      return retval;
    }
 
    void add_init_cmd(ArbCmd &&cmd) override {
      check(raw::dqcs_pcfg_init_cmd(handle, cmd.get_handle()));
    }
 
    PluginProcessConfiguration &&with_init_cmd(ArbCmd &&cmd) {
      add_init_cmd(std::move(cmd));
      return std::move(*this);
    }
 
    void set_env_var(const std::string &key, const std::string &value) {
      check(raw::dqcs_pcfg_env_set(handle, key.c_str(), value.c_str()));
    }
 
    PluginProcessConfiguration &&with_env_var(const std::string &key, const std::string &value) {
      set_env_var(key, value);
      return std::move(*this);
    }
 
    void unset_env_var(const std::string &key) {
      check(raw::dqcs_pcfg_env_unset(handle, key.c_str()));
    }
 
    PluginProcessConfiguration &&without_env_var(const std::string &key) {
      unset_env_var(key);
      return std::move(*this);
    }
 
    void set_work_dir(const std::string &dir) {
      check(raw::dqcs_pcfg_work_set(handle, dir.c_str()));
    }
 
    PluginProcessConfiguration &&with_work_dir(const std::string &dir) {
      set_work_dir(dir);
      return std::move(*this);
    }
 
    std::string get_work_dir() const {
      char *ptr = check(raw::dqcs_pcfg_work_get(handle));
      std::string retval(ptr);
      std::free(ptr);
      return retval;
    }
 
    void set_verbosity(Loglevel level) override {
      check(raw::dqcs_pcfg_verbosity_set(handle, to_raw(level)));
    }
 
    PluginProcessConfiguration &&with_verbosity(Loglevel level) {
      set_verbosity(level);
      return std::move(*this);
    }
 
    Loglevel get_verbosity() const override {
      return check(raw::dqcs_pcfg_verbosity_get(handle));
    }
 
    void log_tee(Loglevel verbosity, const std::string &filename) override {
      return check(raw::dqcs_pcfg_tee(handle, to_raw(verbosity), filename.c_str()));
    }
 
    PluginProcessConfiguration &&with_log_tee(Loglevel verbosity, const std::string &filename) {
      log_tee(verbosity, filename);
      return std::move(*this);
    }
 
    void set_stdout_loglevel(Loglevel level) {
      check(raw::dqcs_pcfg_stdout_mode_set(handle, to_raw(level)));
    }
 
    PluginProcessConfiguration &&with_stdout_loglevel(Loglevel level) {
      set_stdout_loglevel(level);
      return std::move(*this);
    }
 
    Loglevel get_stdout_loglevel() const {
      return check(raw::dqcs_pcfg_stdout_mode_get(handle));
    }
 
    void set_stderr_loglevel(Loglevel level) {
      check(raw::dqcs_pcfg_stderr_mode_set(handle, to_raw(level)));
    }
 
    PluginProcessConfiguration &&with_stderr_loglevel(Loglevel level) {
      set_stderr_loglevel(level);
      return std::move(*this);
    }
 
    Loglevel get_stderr_loglevel() const {
      return check(raw::dqcs_pcfg_stderr_mode_get(handle));
    }
 
    void set_accept_timeout(double timeout) {
      check(raw::dqcs_pcfg_accept_timeout_set(handle, timeout));
    }
 
    PluginProcessConfiguration &&with_accept_timeout(double timeout) {
      set_accept_timeout(timeout);
      return std::move(*this);
    }
 
    PluginProcessConfiguration &&without_accept_timeout() {
      set_accept_timeout(std::numeric_limits<double>::infinity());
      return std::move(*this);
    }
 
    double get_accept_timeout() const {
      return check(raw::dqcs_pcfg_accept_timeout_get(handle));
    }
 
    void set_shutdown_timeout(double timeout) {
      check(raw::dqcs_pcfg_shutdown_timeout_set(handle, timeout));
    }
 
    PluginProcessConfiguration &&with_shutdown_timeout(double timeout) {
      set_shutdown_timeout(timeout);
      return std::move(*this);
    }
 
    PluginProcessConfiguration &&without_shutdown_timeout() {
      set_shutdown_timeout(std::numeric_limits<double>::infinity());
      return std::move(*this);
    }
 
    double get_shutdown_timeout() const {
      return check(raw::dqcs_pcfg_shutdown_timeout_get(handle));
    }
 
  };
 
  class PluginThreadConfiguration : public PluginConfiguration {
  public:
 
    PluginThreadConfiguration(HandleIndex handle) noexcept : PluginConfiguration(handle) {
    }
 
    // Delete copy construct/assign.
    PluginThreadConfiguration(const PluginThreadConfiguration&) = delete;
    void operator=(const PluginThreadConfiguration&) = delete;
 
    PluginThreadConfiguration(PluginThreadConfiguration&&) = default;
 
    PluginThreadConfiguration &operator=(PluginThreadConfiguration&&) = default;
 
    PluginType get_plugin_type() const override {
      return check(raw::dqcs_tcfg_type(handle));
    }
 
    std::string get_name() const override {
      char *ptr = check(raw::dqcs_tcfg_name(handle));
      std::string retval(ptr);
      std::free(ptr);
      return retval;
    }
 
    void add_init_cmd(ArbCmd &&cmd) override {
      check(raw::dqcs_tcfg_init_cmd(handle, cmd.get_handle()));
    }
 
    PluginThreadConfiguration &&with_init_cmd(ArbCmd &&cmd) {
      add_init_cmd(std::move(cmd));
      return std::move(*this);
    }
 
    void set_verbosity(Loglevel level) override {
      check(raw::dqcs_tcfg_verbosity_set(handle, to_raw(level)));
    }
 
    PluginThreadConfiguration &&with_verbosity(Loglevel level) {
      set_verbosity(level);
      return std::move(*this);
    }
 
    Loglevel get_verbosity() const override {
      return check(raw::dqcs_tcfg_verbosity_get(handle));
    }
 
    void log_tee(Loglevel verbosity, const std::string &filename) override {
      return check(raw::dqcs_tcfg_tee(handle, to_raw(verbosity), filename.c_str()));
    }
 
    PluginThreadConfiguration &&with_log_tee(Loglevel verbosity, const std::string &filename) {
      log_tee(verbosity, filename);
      return std::move(*this);
    }
 
  };
 
  class PluginConfigurationBuilder {
  private:
    PluginType type;
    std::string name;
  public:
 
    PluginConfigurationBuilder(PluginType type) noexcept : type(type), name() {}
 
    PluginConfigurationBuilder &&with_name(const std::string &name) noexcept {
      this->name = name;
      return std::move(*this);
    }
 
    PluginProcessConfiguration with_spec(const std::string &spec) {
      return PluginProcessConfiguration(check(raw::dqcs_pcfg_new(
        to_raw(type), name.c_str(), spec.c_str()
      )));
    }
 
    PluginProcessConfiguration with_executable(const std::string &executable, const std::string &script = "") {
      return PluginProcessConfiguration(check(raw::dqcs_pcfg_new_raw(
        to_raw(type), name.c_str(), executable.c_str(), script.c_str()
      )));
    }
 
    PluginThreadConfiguration with_callbacks(Plugin &&plugin) {
      if (plugin.get_type() != type) {
        throw std::invalid_argument("plugin type does not match callback object type");
      }
      return PluginThreadConfiguration(check(raw::dqcs_tcfg_new(
        plugin.get_handle(), name.c_str()
      )));
    }
 
  private:
 
    PluginThreadConfiguration with_spawner_ptr(callback::SpawnPlugin *data) {
      return PluginThreadConfiguration(check(raw::dqcs_tcfg_new_raw(
        to_raw(type),
        name.c_str(),
        CallbackEntryPoints::spawn_plugin,
        CallbackEntryPoints::user_free<callback::SpawnPlugin>,
        data
      )));
    }
 
  public:
 
    PluginThreadConfiguration with_spawner(const callback::SpawnPlugin &data) {
      return with_spawner_ptr(new callback::SpawnPlugin(data));
    }
 
    PluginThreadConfiguration with_spawner(callback::SpawnPlugin &&data) {
      return with_spawner_ptr(new callback::SpawnPlugin(std::move(data)));
    }
 
    template<typename... Args>
    PluginThreadConfiguration with_spawner(Args... args) {
      return with_spawner_ptr(new callback::SpawnPlugin(args...));
    }
 
  };
 
  inline PluginConfigurationBuilder Frontend(const std::string &name = "") noexcept {
    return PluginConfigurationBuilder(PluginType::Frontend).with_name(name);
  }
 
  inline PluginConfigurationBuilder Operator(const std::string &name = "") noexcept {
    return PluginConfigurationBuilder(PluginType::Operator).with_name(name);
  }
 
  inline PluginConfigurationBuilder Backend(const std::string &name = "") noexcept {
    return PluginConfigurationBuilder(PluginType::Backend).with_name(name);
  }
 
  class Simulation : public Handle {
  public:
 
    Simulation(HandleIndex handle) noexcept : Handle(handle) {
    }
 
    // Delete copy construct/assign.
    Simulation(const Simulation&) = delete;
    void operator=(const Simulation&) = delete;
 
    Simulation(Simulation&&) = default;
 
    Simulation &operator=(Simulation&&) = default;
 
    void start() {
      check(raw::dqcs_sim_start(handle, 0));
    }
 
    void start(ArbData &&data) {
      check(raw::dqcs_sim_start(handle, data.get_handle()));
    }
 
    void start(const ArbData &data) {
      start(ArbData(data));
    }
 
    ArbData wait() {
      return ArbData(check(raw::dqcs_sim_wait(handle)));
    }
 
    ArbData run() {
      start();
      return wait();
    }
 
    ArbData run(ArbData &&data) {
      start(std::move(data));
      return wait();
    }
 
    ArbData run(const ArbData &data) {
      start(data);
      return wait();
    }
 
    void send() {
      check(raw::dqcs_sim_send(handle, 0));
    }
 
    void send(ArbData &&data) {
      check(raw::dqcs_sim_send(handle, data.get_handle()));
    }
 
    void send(const ArbData &data) {
      send(ArbData(data));
    }
 
    ArbData recv() {
      return ArbData(check(raw::dqcs_sim_recv(handle)));
    }
 
    void yield() {
      check(raw::dqcs_sim_yield(handle));
    }
 
    ArbData arb(const std::string &name, ArbCmd &&cmd) {
      return ArbData(check(raw::dqcs_sim_arb(handle, name.c_str(), cmd.get_handle())));
    }
 
    ArbData arb(const std::string &name, const ArbCmd &cmd) {
      return arb(name, ArbCmd(cmd));
    }
 
    ArbData arb(ssize_t index, ArbCmd &&cmd) {
      return ArbData(check(raw::dqcs_sim_arb_idx(handle, index, cmd.get_handle())));
    }
 
    ArbData arb(ssize_t index, const ArbCmd &cmd) {
      return arb(index, ArbCmd(cmd));
    }
 
    std::string get_name(const std::string &name) {
      char *ptr = check(raw::dqcs_sim_get_name(handle, name.c_str()));
      std::string str(ptr);
      std::free(ptr);
      return str;
    }
 
    std::string get_name(ssize_t index) {
      char *ptr = check(raw::dqcs_sim_get_name_idx(handle, index));
      std::string str(ptr);
      std::free(ptr);
      return str;
    }
 
    std::string get_author(const std::string &name) {
      char *ptr = check(raw::dqcs_sim_get_author(handle, name.c_str()));
      std::string str(ptr);
      std::free(ptr);
      return str;
    }
 
    std::string get_author(ssize_t index) {
      char *ptr = check(raw::dqcs_sim_get_author_idx(handle, index));
      std::string str(ptr);
      std::free(ptr);
      return str;
    }
 
    std::string get_version(const std::string &name) {
      char *ptr = check(raw::dqcs_sim_get_version(handle, name.c_str()));
      std::string str(ptr);
      std::free(ptr);
      return str;
    }
 
    std::string get_version(ssize_t index) {
      char *ptr = check(raw::dqcs_sim_get_version_idx(handle, index));
      std::string str(ptr);
      std::free(ptr);
      return str;
    }
 
    void write_reproduction_file(const std::string &filename) {
      check(raw::dqcs_sim_write_reproduction_file(handle, filename.c_str()));
    }
 
  };
 
  class SimulationConfiguration : public Handle {
  public:
 
    SimulationConfiguration(HandleIndex handle) noexcept : Handle(handle) {
    }
 
    SimulationConfiguration() : Handle(check(raw::dqcs_scfg_new())) {
    }
 
    // Delete copy construct/assign.
    SimulationConfiguration(const SimulationConfiguration&) = delete;
    void operator=(const SimulationConfiguration&) = delete;
 
    SimulationConfiguration(SimulationConfiguration&&) = default;
 
    SimulationConfiguration &operator=(SimulationConfiguration&&) = default;
 
    void add_plugin(PluginConfiguration &&plugin) {
      check(raw::dqcs_scfg_push_plugin(handle, plugin.get_handle()));
    }
 
    SimulationConfiguration &&with_plugin(PluginConfiguration &&plugin) {
      add_plugin(std::move(plugin));
      return std::move(*this);
    }
 
    void set_seed(uint64_t seed) {
      check(raw::dqcs_scfg_seed_set(handle, seed));
    }
 
    SimulationConfiguration &&with_seed(uint64_t seed) {
      set_seed(seed);
      return std::move(*this);
    }
 
    uint64_t get_seed() const noexcept {
      return raw::dqcs_scfg_seed_get(handle);
    }
 
    void set_reproduction_style(PathStyle style) {
      check(raw::dqcs_scfg_repro_path_style_set(handle, to_raw(style)));
    }
 
    SimulationConfiguration &&with_reproduction_style(PathStyle style) {
      set_reproduction_style(style);
      return std::move(*this);
    }
 
    PathStyle get_reproduction_style() const {
      return check(raw::dqcs_scfg_repro_path_style_get(handle));
    }
 
    void disable_reproduction() {
      check(raw::dqcs_scfg_repro_disable(handle));
    }
 
    SimulationConfiguration &&without_reproduction() {
      check(raw::dqcs_scfg_repro_disable(handle));
      return std::move(*this);
    }
 
    void set_dqcsim_verbosity(Loglevel level) {
      check(raw::dqcs_scfg_dqcsim_verbosity_set(handle, to_raw(level)));
    }
 
    SimulationConfiguration &&with_dqcsim_verbosity(Loglevel level) {
      set_dqcsim_verbosity(level);
      return std::move(*this);
    }
 
    Loglevel get_dqcsim_verbosity() const {
      return check(raw::dqcs_scfg_dqcsim_verbosity_get(handle));
    }
 
    void set_stderr_verbosity(Loglevel level) {
      check(raw::dqcs_scfg_stderr_verbosity_set(handle, to_raw(level)));
    }
 
    SimulationConfiguration &&with_stderr_verbosity(Loglevel level) {
      set_stderr_verbosity(level);
      return std::move(*this);
    }
 
    Loglevel get_stderr_verbosity() const {
      return check(raw::dqcs_scfg_stderr_verbosity_get(handle));
    }
 
    void log_tee(Loglevel verbosity, const std::string &filename) {
      return check(raw::dqcs_scfg_tee(handle, to_raw(verbosity), filename.c_str()));
    }
 
    SimulationConfiguration &&with_log_tee(Loglevel verbosity, const std::string &filename) {
      log_tee(verbosity, filename);
      return std::move(*this);
    }
 
  private:
 
    void set_log_callback_ptr(Loglevel verbosity, callback::Log *data) {
      check(raw::dqcs_scfg_log_callback(
        handle,
        to_raw(verbosity),
        CallbackEntryPoints::log,
        CallbackEntryPoints::user_free<callback::Log>,
        data
      ));
    }
 
  public:
 
    void set_log_callback(Loglevel verbosity, const callback::Log &data) {
      set_log_callback_ptr(verbosity, new callback::Log(data));
    }
 
    void set_log_callback(Loglevel verbosity, callback::Log &&data) {
      set_log_callback_ptr(verbosity, new callback::Log(std::move(data)));
    }
 
    template<typename... Args>
    void set_log_callback(Loglevel verbosity, Args... args) {
      set_log_callback_ptr(verbosity, new callback::Log(args...));
    }
 
    SimulationConfiguration &&with_log_callback(Loglevel verbosity, const callback::Log &data) {
      set_log_callback_ptr(verbosity, new callback::Log(data));
      return std::move(*this);
    }
 
    SimulationConfiguration &&with_log_callback(Loglevel verbosity, callback::Log &&data) {
      set_log_callback_ptr(verbosity, new callback::Log(std::move(data)));
      return std::move(*this);
    }
 
    template<typename... Args>
    SimulationConfiguration &&with_log_callback(Loglevel verbosity, Args... args) {
      set_log_callback_ptr(verbosity, new callback::Log(args...));
      return std::move(*this);
    }
 
    Simulation build() {
      return Simulation(check(raw::dqcs_sim_new(handle)));
    }
 
    Simulation run() {
      Simulation sim = build();
      sim.run();
      return sim;
    }
 
    Simulation run(ArbData &&data) {
      Simulation sim = build();
      sim.run(std::move(data));
      return sim;
    }
 
    Simulation run(const ArbData &data) {
      Simulation sim = build();
      sim.run(data);
      return sim;
    }
 
  };
 
} // namespace wrap
 
} // namespace dqcsim
 
#endif
 
#ifdef DQCSIM_SHORT_LOGGING_MACROS
 
#ifndef _DQCSIM_LOGGING_INCLUDED_
#define _DQCSIM_LOGGING_INCLUDED_
 
#define TRACE DQCSIM_TRACE
 
#define DEBUG DQCSIM_DEBUG
 
#define INFO DQCSIM_INFO
 
#define NOTE DQCSIM_NOTE
 
#define WARN DQCSIM_WARN
 
#define WARNING DQCSIM_WARNING
 
#define ERROR DQCSIM_ERROR
 
#define FATAL DQCSIM_FATAL
 
#define LOG DQCSIM_LOG
 
#endif // _DQCSIM_LOGGING_INCLUDED_
 
#endif // DQCSIM_SHORT_LOGGING_MACROS