vars_process_operators.h

Go to the documentation of this file.

// WARNING: Automated generated files, do not edit
#pragma once
 
#if __cplusplus > 201703L
    #include <array>
    #define STD_TO_ARRAY std::to_array
#else
    #include <experimental/array>
    #define STD_TO_ARRAY std::experimental::to_array
#endif
 
//  =============================
//  ========= operators  ========
//  =============================
//  =============================
//  ========== structs  =========
//  =============================
// === struct peakhold ===
static inline bool operator==(const json_peakhold &a, const json_peakhold &b) {
  return true
      && (a.hold == b.hold)
      && (a.pk == b.pk)
      ;
}
static inline bool operator!=(const json_peakhold &a, const json_peakhold &b) {
      return !(a==b);
}
 
// === struct peakhold_stereo ===
static inline bool operator==(const json_peakhold_stereo &a, const json_peakhold_stereo &b) {
  return true
      && (STD_TO_ARRAY(a.hold) == STD_TO_ARRAY(b.hold))
      && (STD_TO_ARRAY(a.pk) == STD_TO_ARRAY(b.pk))
      ;
}
static inline bool operator!=(const json_peakhold_stereo &a, const json_peakhold_stereo &b) {
      return !(a==b);
}
 
// === struct vupeakhold_stereo ===
static inline bool operator==(const json_vupeakhold_stereo &a, const json_vupeakhold_stereo &b) {
  return true
      && (STD_TO_ARRAY(a.hold) == STD_TO_ARRAY(b.hold))
      && (STD_TO_ARRAY(a.pk) == STD_TO_ARRAY(b.pk))
      && (STD_TO_ARRAY(a.vu) == STD_TO_ARRAY(b.vu))
      ;
}
static inline bool operator!=(const json_vupeakhold_stereo &a, const json_vupeakhold_stereo &b) {
      return !(a==b);
}
 
// === struct peak_percent ===
static inline bool operator==(const json_peak_percent &a, const json_peak_percent &b) {
  return true
      && (a.hold == b.hold)
      && (a.pk == b.pk)
      ;
}
static inline bool operator!=(const json_peak_percent &a, const json_peak_percent &b) {
      return !(a==b);
}
 
// === struct band_peakhold ===
static inline bool operator==(const json_band_peakhold &a, const json_band_peakhold &b) {
  return true
      && (STD_TO_ARRAY(a.hold) == STD_TO_ARRAY(b.hold))
      && (STD_TO_ARRAY(a.pk) == STD_TO_ARRAY(b.pk))
      ;
}
static inline bool operator!=(const json_band_peakhold &a, const json_band_peakhold &b) {
      return !(a==b);
}
 
// === struct bandlim_peakhold ===
static inline bool operator==(const json_bandlim_peakhold &a, const json_bandlim_peakhold &b) {
  return true
      && (STD_TO_ARRAY(a.hold) == STD_TO_ARRAY(b.hold))
      && (STD_TO_ARRAY(a.pk) == STD_TO_ARRAY(b.pk))
      ;
}
static inline bool operator!=(const json_bandlim_peakhold &a, const json_bandlim_peakhold &b) {
      return !(a==b);
}
 
 
//  =============================
//  ========== objects  =========
//  =============================
// === object preset_setup Preset ===
static inline bool operator==(const json_preset_setup &a, const json_preset_setup &b) {
  return true
      && (a.gate_on == b.gate_on)
      && (a.gate == b.gate)
      && (a.hp_on == b.hp_on)
      && (a.hp_freq == b.hp_freq)
      && (a.stereo_link == b.stereo_link)
      && (a.display_agc == b.display_agc)
      && (a.display_tonefx == b.display_tonefx)
      && (a.display_stereofx == b.display_stereofx)
      && (a.display_bandprocess == b.display_bandprocess)
      && (a.display_bandlimiter == b.display_bandlimiter)
      ;
}
static inline bool operator!=(const json_preset_setup &a, const json_preset_setup &b) {
      return !(a==b);
}
 
// === object preset_setup VU ===
static inline bool operator==(const jsonvu_preset_setup &a, const jsonvu_preset_setup &b) {
  return true
      ;
}
static inline bool operator!=(const jsonvu_preset_setup &a, const jsonvu_preset_setup &b) {
      return !(a==b);
}
 
// === object input Preset ===
static inline bool operator==(const json_input &a, const json_input &b) {
  return true
      ;
}
static inline bool operator!=(const json_input &a, const json_input &b) {
      return !(a==b);
}
 
// === object input VU ===
static inline bool operator==(const jsonvu_input &a, const jsonvu_input &b) {
  return true
      && (a.vu == b.vu)
      && (a.standby == b.standby)
      && (a.vuout == b.vuout)
      && (a.bs_moment == b.bs_moment)
      && (a.bs_short == b.bs_short)
      && (a.bs_long == b.bs_long)
      && (a.bs_user == b.bs_user)
      && (a.bs_psr == b.bs_psr)
      && (a.bs_plr == b.bs_plr)
      ;
}
static inline bool operator!=(const jsonvu_input &a, const jsonvu_input &b) {
      return !(a==b);
}
 
// === object agc Preset ===
static inline bool operator==(const json_agc &a, const json_agc &b) {
  return true
      && (a.on == b.on)
      && (a.hp_on == b.hp_on)
      && (a.hp_freq == b.hp_freq)
      && (a.drive_on == b.drive_on)
      && (a.drive == b.drive)
      && (a.threshold == b.threshold)
      && (a.postgain == b.postgain)
      && (a.ratio == b.ratio)
      && (a.attack == b.attack)
      && (a.release == b.release)
      && (a.impact == b.impact)
      ;
}
static inline bool operator!=(const json_agc &a, const json_agc &b) {
      return !(a==b);
}
 
// === object agc VU ===
static inline bool operator==(const jsonvu_agc &a, const jsonvu_agc &b) {
  return true
      && (a.vu == b.vu)
      ;
}
static inline bool operator!=(const jsonvu_agc &a, const jsonvu_agc &b) {
      return !(a==b);
}
 
// === object tonefx Preset ===
static inline bool operator==(const json_tonefx &a, const json_tonefx &b) {
  return true
      && (a.on == b.on)
      && (STD_TO_ARRAY(a.eq_on) == STD_TO_ARRAY(b.eq_on))
      && (STD_TO_ARRAY(a.eq_freq) == STD_TO_ARRAY(b.eq_freq))
      && (STD_TO_ARRAY(a.eq_Q) == STD_TO_ARRAY(b.eq_Q))
      && (STD_TO_ARRAY(a.eq_gain) == STD_TO_ARRAY(b.eq_gain))
      && (a.bass_on == b.bass_on)
      && (a.bass_gain == b.bass_gain)
      && (a.bass_freq == b.bass_freq)
      && (a.treble_on == b.treble_on)
      && (a.treble_value == b.treble_value)
      && (a.treble_range == b.treble_range)
      ;
}
static inline bool operator!=(const json_tonefx &a, const json_tonefx &b) {
      return !(a==b);
}
 
// === object tonefx VU ===
static inline bool operator==(const jsonvu_tonefx &a, const jsonvu_tonefx &b) {
  return true
      ;
}
static inline bool operator!=(const jsonvu_tonefx &a, const jsonvu_tonefx &b) {
      return !(a==b);
}
 
// === object stereofx Preset ===
static inline bool operator==(const json_stereofx &a, const json_stereofx &b) {
  return true
      && (a.on == b.on)
      && (a.enh_on == b.enh_on)
      && (a.enh_width == b.enh_width)
      && (a.enh_attack == b.enh_attack)
      && (a.enh_release == b.enh_release)
      && (a.enh_threshold == b.enh_threshold)
      && (a.enh_thresLR == b.enh_thresLR)
      && (a.lim_on == b.lim_on)
      && (a.lim_threshold == b.lim_threshold)
      && (a.lim_release == b.lim_release)
      ;
}
static inline bool operator!=(const json_stereofx &a, const json_stereofx &b) {
      return !(a==b);
}
 
// === object stereofx VU ===
static inline bool operator==(const jsonvu_stereofx &a, const jsonvu_stereofx &b) {
  return true
      && (a.enh_vu == b.enh_vu)
      && (a.lim_vu == b.lim_vu)
      ;
}
static inline bool operator!=(const jsonvu_stereofx &a, const jsonvu_stereofx &b) {
      return !(a==b);
}
 
// === object bandprocess Preset ===
static inline bool operator==(const json_bandprocess &a, const json_bandprocess &b) {
  return true
      && (a.on == b.on)
      && (STD_TO_ARRAY(a.freq) == STD_TO_ARRAY(b.freq))
      && (a.gate_on == b.gate_on)
      && (STD_TO_ARRAY(a.gate) == STD_TO_ARRAY(b.gate))
      && (a.fidelity_on == b.fidelity_on)
      && (a.fidelity_speed == b.fidelity_speed)
      && (STD_TO_ARRAY(a.fidelity) == STD_TO_ARRAY(b.fidelity))
      && (a.drive_on == b.drive_on)
      && (STD_TO_ARRAY(a.drive) == STD_TO_ARRAY(b.drive))
      && (a.threshold_on == b.threshold_on)
      && (STD_TO_ARRAY(a.threshold) == STD_TO_ARRAY(b.threshold))
      && (STD_TO_ARRAY(a.base_thres) == STD_TO_ARRAY(b.base_thres))
      && (STD_TO_ARRAY(a.ratio) == STD_TO_ARRAY(b.ratio))
      && (a.impact_on == b.impact_on)
      && (STD_TO_ARRAY(a.impact) == STD_TO_ARRAY(b.impact))
      && (STD_TO_ARRAY(a.postgain) == STD_TO_ARRAY(b.postgain))
      && (STD_TO_ARRAY(a.attack) == STD_TO_ARRAY(b.attack))
      && (STD_TO_ARRAY(a.release) == STD_TO_ARRAY(b.release))
      && (STD_TO_ARRAY(a.avgspeed) == STD_TO_ARRAY(b.avgspeed))
      && (STD_TO_ARRAY(a.delta_up) == STD_TO_ARRAY(b.delta_up))
      && (STD_TO_ARRAY(a.attack_up) == STD_TO_ARRAY(b.attack_up))
      && (STD_TO_ARRAY(a.release_up) == STD_TO_ARRAY(b.release_up))
      && (STD_TO_ARRAY(a.delta_dn) == STD_TO_ARRAY(b.delta_dn))
      && (STD_TO_ARRAY(a.attack_dn) == STD_TO_ARRAY(b.attack_dn))
      && (STD_TO_ARRAY(a.release_dn) == STD_TO_ARRAY(b.release_dn))
      && (a.listen == b.listen)
      ;
}
static inline bool operator!=(const json_bandprocess &a, const json_bandprocess &b) {
      return !(a==b);
}
 
// === object bandprocess VU ===
static inline bool operator==(const jsonvu_bandprocess &a, const jsonvu_bandprocess &b) {
  return true
      && (a.in == b.in)
      && (STD_TO_ARRAY(a.gated) == STD_TO_ARRAY(b.gated))
      && (a.fidel == b.fidel)
      && (a.mes_in == b.mes_in)
      && (a.in_avg == b.in_avg)
      && (a.gain == b.gain)
      && (a.out == b.out)
      ;
}
static inline bool operator!=(const jsonvu_bandprocess &a, const jsonvu_bandprocess &b) {
      return !(a==b);
}
 
// === object bandlimiter Preset ===
static inline bool operator==(const json_bandlimiter &a, const json_bandlimiter &b) {
  return true
      && (a.on == b.on)
      && (a.drive_on == b.drive_on)
      && (STD_TO_ARRAY(a.drive) == STD_TO_ARRAY(b.drive))
      && (a.threshold_on == b.threshold_on)
      && (STD_TO_ARRAY(a.threshold) == STD_TO_ARRAY(b.threshold))
      && (STD_TO_ARRAY(a.base_thres) == STD_TO_ARRAY(b.base_thres))
      && (STD_TO_ARRAY(a.postgain) == STD_TO_ARRAY(b.postgain))
      && (a.mix_on == b.mix_on)
      && (STD_TO_ARRAY(a.mix) == STD_TO_ARRAY(b.mix))
      && (a.preview == b.preview)
      && (a.asymmetric == b.asymmetric)
      && (a.he_on == b.he_on)
      && (STD_TO_ARRAY(a.he_freq) == STD_TO_ARRAY(b.he_freq))
      && (a.he_drive_on == b.he_drive_on)
      && (a.he_drive == b.he_drive)
      && (a.he_mix_on == b.he_mix_on)
      && (a.he_mix == b.he_mix)
      && (STD_TO_ARRAY(a.he_threshold) == STD_TO_ARRAY(b.he_threshold))
      ;
}
static inline bool operator!=(const json_bandlimiter &a, const json_bandlimiter &b) {
      return !(a==b);
}
 
// === object bandlimiter VU ===
static inline bool operator==(const jsonvu_bandlimiter &a, const jsonvu_bandlimiter &b) {
  return true
      && (a.gain == b.gain)
      && (a.out == b.out)
      ;
}
static inline bool operator!=(const jsonvu_bandlimiter &a, const jsonvu_bandlimiter &b) {
      return !(a==b);
}
 
// === object limiter Preset ===
static inline bool operator==(const json_limiter &a, const json_limiter &b) {
  return true
      && (a.mode == b.mode)
      && (a.drive == b.drive)
      && (a.base_drive == b.base_drive)
      && (a.lk_drive_on == b.lk_drive_on)
      && (a.lk_drive == b.lk_drive)
      && (a.lk_base_drive == b.lk_base_drive)
      && (a.lk_len == b.lk_len)
      && (a.lk_attack == b.lk_attack)
      && (a.lk_release == b.lk_release)
      && (a.lk_postgain_on == b.lk_postgain_on)
      && (a.lk_postgain == b.lk_postgain)
      && (a.lk_factor == b.lk_factor)
      && (STD_TO_ARRAY(a.lk_rel_tab) == STD_TO_ARRAY(b.lk_rel_tab))
      && (a.lk_mode == b.lk_mode)
      ;
}
static inline bool operator!=(const json_limiter &a, const json_limiter &b) {
      return !(a==b);
}
 
// === object limiter VU ===
static inline bool operator==(const jsonvu_limiter &a, const jsonvu_limiter &b) {
  return true
      && (a.gain == b.gain)
      && (a.lkatt == b.lkatt)
      && (a.over == b.over)
      ;
}
static inline bool operator!=(const jsonvu_limiter &a, const jsonvu_limiter &b) {
      return !(a==b);
}
 
// === object output Preset ===
static inline bool operator==(const json_output &a, const json_output &b) {
  return true
      ;
}
static inline bool operator!=(const json_output &a, const json_output &b) {
      return !(a==b);
}
 
// === object output VU ===
static inline bool operator==(const jsonvu_output &a, const jsonvu_output &b) {
  return true
      && (a.vu == b.vu)
      ;
}
static inline bool operator!=(const jsonvu_output &a, const jsonvu_output &b) {
      return !(a==b);
}
 
// === object r128 Preset ===
static inline bool operator==(const json_r128 &a, const json_r128 &b) {
  return true
      && (a.on == b.on)
      && (a.target == b.target)
      && (a.attack == b.attack)
      && (a.release == b.release)
      ;
}
static inline bool operator!=(const json_r128 &a, const json_r128 &b) {
      return !(a==b);
}
 
// === object r128 VU ===
static inline bool operator==(const jsonvu_r128 &a, const jsonvu_r128 &b) {
  return true
      && (a.vu_on == b.vu_on)
      && (a.vu_target == b.vu_target)
      && (a.bs_moment == b.bs_moment)
      && (a.bs_short == b.bs_short)
      && (a.bs_long == b.bs_long)
      && (a.bs_user == b.bs_user)
      && (a.gain == b.gain)
      && (a.bs_psr == b.bs_psr)
      && (a.bs_plr == b.bs_plr)
      && (a.bs_moment_pk == b.bs_moment_pk)
      && (a.bs_short_pk == b.bs_short_pk)
      && (a.bs_long_pk == b.bs_long_pk)
      && (a.bs_user_pk == b.bs_user_pk)
      ;
}
static inline bool operator!=(const jsonvu_r128 &a, const jsonvu_r128 &b) {
      return !(a==b);
}
 
// === object settings_gain Preset ===
static inline bool operator==(const json_settings_gain &a, const json_settings_gain &b) {
  return true
      && (a.in == b.in)
      && (a.out == b.out)
      ;
}
static inline bool operator!=(const json_settings_gain &a, const json_settings_gain &b) {
      return !(a==b);
}
 
// === object settings_gain VU ===
static inline bool operator==(const jsonvu_settings_gain &a, const jsonvu_settings_gain &b) {
  return true
      ;
}
static inline bool operator!=(const jsonvu_settings_gain &a, const jsonvu_settings_gain &b) {
      return !(a==b);
}
 
// === object r128_settings Preset ===
static inline bool operator==(const json_r128_settings &a, const json_r128_settings &b) {
  return true
      && (a.longterm_time == b.longterm_time)
      && (a.vutype == b.vutype)
      && (a.on == b.on)
      && (a.truepeak_protect == b.truepeak_protect)
      && (a.target == b.target)
      ;
}
static inline bool operator!=(const json_r128_settings &a, const json_r128_settings &b) {
      return !(a==b);
}
 
// === object r128_settings VU ===
static inline bool operator==(const jsonvu_r128_settings &a, const jsonvu_r128_settings &b) {
  return true
      ;
}
static inline bool operator!=(const jsonvu_r128_settings &a, const jsonvu_r128_settings &b) {
      return !(a==b);
}
 
// === object settings_general Preset ===
static inline bool operator==(const json_settings_general &a, const json_settings_general &b) {
  return true
      && (a.operate == b.operate)
      && (a.history_unit == b.history_unit)
      ;
}
static inline bool operator!=(const json_settings_general &a, const json_settings_general &b) {
      return !(a==b);
}
 
// === object settings_general VU ===
static inline bool operator==(const jsonvu_settings_general &a, const jsonvu_settings_general &b) {
  return true
      ;
}
static inline bool operator!=(const jsonvu_settings_general &a, const jsonvu_settings_general &b) {
      return !(a==b);
}
 
 
//  =============================
//  ========== settings =========
//  =============================
static inline bool operator==(const json_settings &a, const json_settings &b) {
  return true
      && (a.general == b.general)
      && (a.gain == b.gain)
      && (a.r128 == b.r128)
      ;
}
static inline bool operator!=(const json_settings &a, const json_settings &b) {
      return !(a==b);
}
 
//  =============================
//  ======== settings VU ========
//  =============================
static inline bool operator==(const jsonvu_settings &a, const jsonvu_settings &b) {
  return true
      && (a.general == b.general)
      && (a.gain == b.gain)
      && (a.r128 == b.r128)
      ;
}
static inline bool operator!=(const jsonvu_settings &a, const jsonvu_settings &b) {
      return !(a==b);
}
 
//  =============================
//  ========== preset ===========
//  =============================
static inline bool operator==(const json_preset &a, const json_preset &b) {
  return true
      && (a.setup == b.setup)
      && (a.in == b.in)
      && (a.agc == b.agc)
      && (a.tonefx == b.tonefx)
      && (a.stereofx == b.stereofx)
      && (a.bandprocess == b.bandprocess)
      && (a.bandlimiter == b.bandlimiter)
      && (a.limiter == b.limiter)
      && (a.out == b.out)
      && (a.r128 == b.r128)
      ;
}
static inline bool operator!=(const json_preset &a, const json_preset &b) {
      return !(a==b);
}
 
//  =============================
//  ========== preset VU ========
//  =============================
static inline bool operator==(const json_vu &a, const json_vu &b) {
  return true
      && (a.setup == b.setup)
      && (a.in == b.in)
      && (a.agc == b.agc)
      && (a.tonefx == b.tonefx)
      && (a.stereofx == b.stereofx)
      && (a.bandprocess == b.bandprocess)
      && (a.bandlimiter == b.bandlimiter)
      && (a.limiter == b.limiter)
      && (a.out == b.out)
      && (a.r128 == b.r128)
      && (a.settings == b.settings)
      ;
}
static inline bool operator!=(const json_vu &a, const json_vu &b) {
      return !(a==b);
}