// Autogenerated by Thrift Compiler (0.12.0)
// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#![allow(unused_imports)]
#![allow(unused_extern_crates)]
#![cfg_attr(feature = "cargo-clippy", allow(too_many_arguments, type_complexity))]
#![cfg_attr(rustfmt, rustfmt_skip)]
extern crate ordered_float;
extern crate thrift;
extern crate try_from;
use ordered_float::OrderedFloat;
use std::cell::RefCell;
use std::collections::{BTreeMap, BTreeSet};
use std::convert::From;
use std::default::Default;
use std::error::Error;
use std::fmt;
use std::fmt::{Display, Formatter};
use std::rc::Rc;
use try_from::TryFrom;
use thrift::{ApplicationError, ApplicationErrorKind, ProtocolError, ProtocolErrorKind, TThriftClient};
use thrift::protocol::{TFieldIdentifier, TListIdentifier, TMapIdentifier, TMessageIdentifier, TMessageType, TInputProtocol, TOutputProtocol, TSetIdentifier, TStructIdentifier, TType};
use thrift::protocol::field_id;
use thrift::protocol::verify_expected_message_type;
use thrift::protocol::verify_expected_sequence_number;
use thrift::protocol::verify_expected_service_call;
use thrift::protocol::verify_required_field_exists;
use thrift::server::TProcessor;
/// @OverlayGameType_desc
#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum OverlayGameType {
Standalone = 0,
Web = 1,
}
impl OverlayGameType {
pub fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
o_prot.write_i32(*self as i32)
}
pub fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<OverlayGameType> {
let enum_value = i_prot.read_i32()?;
OverlayGameType::try_from(enum_value) }
}
impl TryFrom<i32> for OverlayGameType {
type Err = thrift::Error; fn try_from(i: i32) -> Result<Self, Self::Err> {
match i {
0 => Ok(OverlayGameType::Standalone),
1 => Ok(OverlayGameType::Web),
_ => {
Err(
thrift::Error::Protocol(
ProtocolError::new(
ProtocolErrorKind::InvalidData,
format!("cannot convert enum constant {} to OverlayGameType", i)
)
)
)
},
}
}
}
/// @OverlayForceBindAdapter_desc
#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum OverlayForceBindAdapter {
All = 0,
Evolve = 1,
}
impl OverlayForceBindAdapter {
pub fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
o_prot.write_i32(*self as i32)
}
pub fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<OverlayForceBindAdapter> {
let enum_value = i_prot.read_i32()?;
OverlayForceBindAdapter::try_from(enum_value) }
}
impl TryFrom<i32> for OverlayForceBindAdapter {
type Err = thrift::Error; fn try_from(i: i32) -> Result<Self, Self::Err> {
match i {
0 => Ok(OverlayForceBindAdapter::All),
1 => Ok(OverlayForceBindAdapter::Evolve),
_ => {
Err(
thrift::Error::Protocol(
ProtocolError::new(
ProtocolErrorKind::InvalidData,
format!("cannot convert enum constant {} to OverlayForceBindAdapter", i)
)
)
)
},
}
}
}
/// @OverlayRenderer_desc
#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum OverlayRenderer {
Unspecified = 0,
Direct3D = 1,
OpenGL = 2,
}
impl OverlayRenderer {
pub fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
o_prot.write_i32(*self as i32)
}
pub fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<OverlayRenderer> {
let enum_value = i_prot.read_i32()?;
OverlayRenderer::try_from(enum_value) }
}
impl TryFrom<i32> for OverlayRenderer {
type Err = thrift::Error; fn try_from(i: i32) -> Result<Self, Self::Err> {
match i {
0 => Ok(OverlayRenderer::Unspecified),
1 => Ok(OverlayRenderer::Direct3D),
2 => Ok(OverlayRenderer::OpenGL),
_ => {
Err(
thrift::Error::Protocol(
ProtocolError::new(
ProtocolErrorKind::InvalidData,
format!("cannot convert enum constant {} to OverlayRenderer", i)
)
)
)
},
}
}
}
/// @OverlayRendererHooking_desc
#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum OverlayRendererHooking {
Normal = 0,
Factory = 1,
Intrusive = 2,
}
impl OverlayRendererHooking {
pub fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
o_prot.write_i32(*self as i32)
}
pub fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<OverlayRendererHooking> {
let enum_value = i_prot.read_i32()?;
OverlayRendererHooking::try_from(enum_value) }
}
impl TryFrom<i32> for OverlayRendererHooking {
type Err = thrift::Error; fn try_from(i: i32) -> Result<Self, Self::Err> {
match i {
0 => Ok(OverlayRendererHooking::Normal),
1 => Ok(OverlayRendererHooking::Factory),
2 => Ok(OverlayRendererHooking::Intrusive),
_ => {
Err(
thrift::Error::Protocol(
ProtocolError::new(
ProtocolErrorKind::InvalidData,
format!("cannot convert enum constant {} to OverlayRendererHooking", i)
)
)
)
},
}
}
}
/// @OverlayCursor_desc
#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum OverlayCursor {
Auto = 0,
Hardware = 1,
Software = 2,
}
impl OverlayCursor {
pub fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
o_prot.write_i32(*self as i32)
}
pub fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<OverlayCursor> {
let enum_value = i_prot.read_i32()?;
OverlayCursor::try_from(enum_value) }
}
impl TryFrom<i32> for OverlayCursor {
type Err = thrift::Error; fn try_from(i: i32) -> Result<Self, Self::Err> {
match i {
0 => Ok(OverlayCursor::Auto),
1 => Ok(OverlayCursor::Hardware),
2 => Ok(OverlayCursor::Software),
_ => {
Err(
thrift::Error::Protocol(
ProtocolError::new(
ProtocolErrorKind::InvalidData,
format!("cannot convert enum constant {} to OverlayCursor", i)
)
)
)
},
}
}
}
/// @CondType_desc
#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum CondType {
ExePresent = 0,
FilePresent = 1,
FileAbsent = 2,
ArgPresent = 3,
ArgAbsent = 4,
}
impl CondType {
pub fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
o_prot.write_i32(*self as i32)
}
pub fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<CondType> {
let enum_value = i_prot.read_i32()?;
CondType::try_from(enum_value) }
}
impl TryFrom<i32> for CondType {
type Err = thrift::Error; fn try_from(i: i32) -> Result<Self, Self::Err> {
match i {
0 => Ok(CondType::ExePresent),
1 => Ok(CondType::FilePresent),
2 => Ok(CondType::FileAbsent),
3 => Ok(CondType::ArgPresent),
4 => Ok(CondType::ArgAbsent),
_ => {
Err(
thrift::Error::Protocol(
ProtocolError::new(
ProtocolErrorKind::InvalidData,
format!("cannot convert enum constant {} to CondType", i)
)
)
)
},
}
}
}
//
// Features
//
/// @Features_desc
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Features {
/// @Features_overlay_desc
pub overlay: Option<bool>,
/// @Features_forcebind_desc
pub forcebind: Option<bool>,
/// @Features_forcebind-adapter_desc
pub forcebind_adapter: Option<OverlayForceBindAdapter>,
/// @Features_forcetopmost_desc
pub forcetopmost: Option<bool>,
/// @Features_opengl-vbo-rendering_desc
pub opengl_vbo_rendering: Option<bool>,
/// @Features_opengl-state-hooking_desc
pub opengl_state_hooking: Option<bool>,
/// @Features_game-window-subclassing_desc
pub game_window_subclassing: Option<bool>,
/// @Features_forcerenderer_desc
pub forcerenderer: Option<OverlayRenderer>,
/// @Features_renderer-hooking_desc
pub renderer_hooking: Option<OverlayRendererHooking>,
/// @Features_forcecursor_desc
pub forcecursor: Option<OverlayCursor>,
}
impl Features {
pub fn new<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10>(overlay: F1, forcebind: F2, forcebind_adapter: F3, forcetopmost: F4, opengl_vbo_rendering: F5, opengl_state_hooking: F6, game_window_subclassing: F7, forcerenderer: F8, renderer_hooking: F9, forcecursor: F10) -> Features where F1: Into<Option<bool>>, F2: Into<Option<bool>>, F3: Into<Option<OverlayForceBindAdapter>>, F4: Into<Option<bool>>, F5: Into<Option<bool>>, F6: Into<Option<bool>>, F7: Into<Option<bool>>, F8: Into<Option<OverlayRenderer>>, F9: Into<Option<OverlayRendererHooking>>, F10: Into<Option<OverlayCursor>> {
Features {
overlay: overlay.into(),
forcebind: forcebind.into(),
forcebind_adapter: forcebind_adapter.into(),
forcetopmost: forcetopmost.into(),
opengl_vbo_rendering: opengl_vbo_rendering.into(),
opengl_state_hooking: opengl_state_hooking.into(),
game_window_subclassing: game_window_subclassing.into(),
forcerenderer: forcerenderer.into(),
renderer_hooking: renderer_hooking.into(),
forcecursor: forcecursor.into(),
}
}
pub fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<Features> {
i_prot.read_struct_begin()?;
let mut f_1: Option<bool> = Some(false);
let mut f_2: Option<bool> = Some(false);
let mut f_3: Option<OverlayForceBindAdapter> = None;
let mut f_4: Option<bool> = Some(false);
let mut f_5: Option<bool> = Some(false);
let mut f_6: Option<bool> = Some(false);
let mut f_7: Option<bool> = Some(false);
let mut f_8: Option<OverlayRenderer> = None;
let mut f_9: Option<OverlayRendererHooking> = None;
let mut f_10: Option<OverlayCursor> = None;
loop {
let field_ident = i_prot.read_field_begin()?;
if field_ident.field_type == TType::Stop {
break;
}
let field_id = field_id(&field_ident)?;
match field_id {
1 => {
let val = i_prot.read_bool()?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_bool()?;
f_2 = Some(val);
},
3 => {
let val = OverlayForceBindAdapter::read_from_in_protocol(i_prot)?;
f_3 = Some(val);
},
4 => {
let val = i_prot.read_bool()?;
f_4 = Some(val);
},
5 => {
let val = i_prot.read_bool()?;
f_5 = Some(val);
},
6 => {
let val = i_prot.read_bool()?;
f_6 = Some(val);
},
7 => {
let val = i_prot.read_bool()?;
f_7 = Some(val);
},
8 => {
let val = OverlayRenderer::read_from_in_protocol(i_prot)?;
f_8 = Some(val);
},
9 => {
let val = OverlayRendererHooking::read_from_in_protocol(i_prot)?;
f_9 = Some(val);
},
10 => {
let val = OverlayCursor::read_from_in_protocol(i_prot)?;
f_10 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = Features {
overlay: f_1,
forcebind: f_2,
forcebind_adapter: f_3,
forcetopmost: f_4,
opengl_vbo_rendering: f_5,
opengl_state_hooking: f_6,
game_window_subclassing: f_7,
forcerenderer: f_8,
renderer_hooking: f_9,
forcecursor: f_10,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("Features");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(fld_var) = self.overlay {
o_prot.write_field_begin(&TFieldIdentifier::new("overlay", TType::Bool, 1))?;
o_prot.write_bool(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(fld_var) = self.forcebind {
o_prot.write_field_begin(&TFieldIdentifier::new("forcebind", TType::Bool, 2))?;
o_prot.write_bool(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(ref fld_var) = self.forcebind_adapter {
o_prot.write_field_begin(&TFieldIdentifier::new("forcebind_adapter", TType::I32, 3))?;
fld_var.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(fld_var) = self.forcetopmost {
o_prot.write_field_begin(&TFieldIdentifier::new("forcetopmost", TType::Bool, 4))?;
o_prot.write_bool(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(fld_var) = self.opengl_vbo_rendering {
o_prot.write_field_begin(&TFieldIdentifier::new("opengl_vbo_rendering", TType::Bool, 5))?;
o_prot.write_bool(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(fld_var) = self.opengl_state_hooking {
o_prot.write_field_begin(&TFieldIdentifier::new("opengl_state_hooking", TType::Bool, 6))?;
o_prot.write_bool(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(fld_var) = self.game_window_subclassing {
o_prot.write_field_begin(&TFieldIdentifier::new("game_window_subclassing", TType::Bool, 7))?;
o_prot.write_bool(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(ref fld_var) = self.forcerenderer {
o_prot.write_field_begin(&TFieldIdentifier::new("forcerenderer", TType::I32, 8))?;
fld_var.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(ref fld_var) = self.renderer_hooking {
o_prot.write_field_begin(&TFieldIdentifier::new("renderer_hooking", TType::I32, 9))?;
fld_var.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(ref fld_var) = self.forcecursor {
o_prot.write_field_begin(&TFieldIdentifier::new("forcecursor", TType::I32, 10))?;
fld_var.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
()
} else {
()
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
impl Default for Features {
fn default() -> Self {
Features{
overlay: Some(false),
forcebind: Some(false),
forcebind_adapter: None,
forcetopmost: Some(false),
opengl_vbo_rendering: Some(false),
opengl_state_hooking: Some(false),
game_window_subclassing: Some(false),
forcerenderer: None,
renderer_hooking: None,
forcecursor: None,
}
}
}
//
// RuyiFeatures
//
/// @RuyiFeatures_desc
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RuyiFeatures {
/// @RuyiFeatures_ruyi_xinput_desc
pub ruyi_xinput: Option<bool>,
/// @RuyiFeatures_ruyi_dinput_desc
pub ruyi_dinput: Option<bool>,
/// @RuyiFeatures_ruyi_sdkinput_desc
pub ruyi_sdkinput: Option<bool>,
}
impl RuyiFeatures {
pub fn new<F1, F2, F3>(ruyi_xinput: F1, ruyi_dinput: F2, ruyi_sdkinput: F3) -> RuyiFeatures where F1: Into<Option<bool>>, F2: Into<Option<bool>>, F3: Into<Option<bool>> {
RuyiFeatures {
ruyi_xinput: ruyi_xinput.into(),
ruyi_dinput: ruyi_dinput.into(),
ruyi_sdkinput: ruyi_sdkinput.into(),
}
}
pub fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<RuyiFeatures> {
i_prot.read_struct_begin()?;
let mut f_1: Option<bool> = Some(false);
let mut f_2: Option<bool> = Some(false);
let mut f_3: Option<bool> = Some(false);
loop {
let field_ident = i_prot.read_field_begin()?;
if field_ident.field_type == TType::Stop {
break;
}
let field_id = field_id(&field_ident)?;
match field_id {
1 => {
let val = i_prot.read_bool()?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_bool()?;
f_2 = Some(val);
},
3 => {
let val = i_prot.read_bool()?;
f_3 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = RuyiFeatures {
ruyi_xinput: f_1,
ruyi_dinput: f_2,
ruyi_sdkinput: f_3,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("RuyiFeatures");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(fld_var) = self.ruyi_xinput {
o_prot.write_field_begin(&TFieldIdentifier::new("ruyi_xinput", TType::Bool, 1))?;
o_prot.write_bool(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(fld_var) = self.ruyi_dinput {
o_prot.write_field_begin(&TFieldIdentifier::new("ruyi_dinput", TType::Bool, 2))?;
o_prot.write_bool(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(fld_var) = self.ruyi_sdkinput {
o_prot.write_field_begin(&TFieldIdentifier::new("ruyi_sdkinput", TType::Bool, 3))?;
o_prot.write_bool(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
impl Default for RuyiFeatures {
fn default() -> Self {
RuyiFeatures{
ruyi_xinput: Some(false),
ruyi_dinput: Some(false),
ruyi_sdkinput: Some(false),
}
}
}
//
// Runtime
//
/// @Runtime_desc
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Runtime {
/// @Runtime_features_desc
pub features: Option<Features>,
/// @Runtime_ruyiFeatures_desc
pub ruyi_features: Option<RuyiFeatures>,
}
impl Runtime {
pub fn new<F1, F2>(features: F1, ruyi_features: F2) -> Runtime where F1: Into<Option<Features>>, F2: Into<Option<RuyiFeatures>> {
Runtime {
features: features.into(),
ruyi_features: ruyi_features.into(),
}
}
pub fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<Runtime> {
i_prot.read_struct_begin()?;
let mut f_1: Option<Features> = None;
let mut f_2: Option<RuyiFeatures> = None;
loop {
let field_ident = i_prot.read_field_begin()?;
if field_ident.field_type == TType::Stop {
break;
}
let field_id = field_id(&field_ident)?;
match field_id {
1 => {
let val = Features::read_from_in_protocol(i_prot)?;
f_1 = Some(val);
},
2 => {
let val = RuyiFeatures::read_from_in_protocol(i_prot)?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = Runtime {
features: f_1,
ruyi_features: f_2,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("Runtime");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(ref fld_var) = self.features {
o_prot.write_field_begin(&TFieldIdentifier::new("features", TType::Struct, 1))?;
fld_var.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(ref fld_var) = self.ruyi_features {
o_prot.write_field_begin(&TFieldIdentifier::new("ruyiFeatures", TType::Struct, 2))?;
fld_var.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
()
} else {
()
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
impl Default for Runtime {
fn default() -> Self {
Runtime{
features: None,
ruyi_features: None,
}
}
}
//
// GameDB
//
/// @GameDB_desc
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct GameDB {
/// @GameDB_type_desc
pub type_: Option<OverlayGameType>,
/// @GameDB_id_desc
pub id: Option<i32>,
/// @GameDB_name_desc
pub name: Option<String>,
/// @GameDB_conditions_desc
pub conditions: Option<Vec<Box<Cond>>>,
/// @GameDB_detection_desc
pub detection: Option<Vec<Box<Variant>>>,
/// @GameDB_runtime_desc
pub runtime: Option<Runtime>,
}
impl GameDB {
pub fn new<F1, F2, F3, F4, F5, F6>(type_: F1, id: F2, name: F3, conditions: F4, detection: F5, runtime: F6) -> GameDB where F1: Into<Option<OverlayGameType>>, F2: Into<Option<i32>>, F3: Into<Option<String>>, F4: Into<Option<Vec<Box<Cond>>>>, F5: Into<Option<Vec<Box<Variant>>>>, F6: Into<Option<Runtime>> {
GameDB {
type_: type_.into(),
id: id.into(),
name: name.into(),
conditions: conditions.into(),
detection: detection.into(),
runtime: runtime.into(),
}
}
pub fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<GameDB> {
i_prot.read_struct_begin()?;
let mut f_1: Option<OverlayGameType> = None;
let mut f_2: Option<i32> = Some(0);
let mut f_3: Option<String> = Some("".to_owned());
let mut f_4: Option<Vec<Box<Cond>>> = Some(Vec::new());
let mut f_5: Option<Vec<Box<Variant>>> = Some(Vec::new());
let mut f_6: Option<Runtime> = None;
loop {
let field_ident = i_prot.read_field_begin()?;
if field_ident.field_type == TType::Stop {
break;
}
let field_id = field_id(&field_ident)?;
match field_id {
1 => {
let val = OverlayGameType::read_from_in_protocol(i_prot)?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_i32()?;
f_2 = Some(val);
},
3 => {
let val = i_prot.read_string()?;
f_3 = Some(val);
},
4 => {
let list_ident = i_prot.read_list_begin()?;
let mut val: Vec<Box<Cond>> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_0 = Box::new(Cond::read_from_in_protocol(i_prot)?);
val.push(list_elem_0);
}
i_prot.read_list_end()?;
f_4 = Some(val);
},
5 => {
let list_ident = i_prot.read_list_begin()?;
let mut val: Vec<Box<Variant>> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_1 = Box::new(Variant::read_from_in_protocol(i_prot)?);
val.push(list_elem_1);
}
i_prot.read_list_end()?;
f_5 = Some(val);
},
6 => {
let val = Runtime::read_from_in_protocol(i_prot)?;
f_6 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = GameDB {
type_: f_1,
id: f_2,
name: f_3,
conditions: f_4,
detection: f_5,
runtime: f_6,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("GameDB");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(ref fld_var) = self.type_ {
o_prot.write_field_begin(&TFieldIdentifier::new("type", TType::I32, 1))?;
fld_var.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(fld_var) = self.id {
o_prot.write_field_begin(&TFieldIdentifier::new("id", TType::I32, 2))?;
o_prot.write_i32(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(ref fld_var) = self.name {
o_prot.write_field_begin(&TFieldIdentifier::new("name", TType::String, 3))?;
o_prot.write_string(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(ref fld_var) = self.conditions {
o_prot.write_field_begin(&TFieldIdentifier::new("conditions", TType::List, 4))?;
o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, fld_var.len() as i32))?;
for e in fld_var {
e.write_to_out_protocol(o_prot)?;
o_prot.write_list_end()?;
}
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(ref fld_var) = self.detection {
o_prot.write_field_begin(&TFieldIdentifier::new("detection", TType::List, 5))?;
o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, fld_var.len() as i32))?;
for e in fld_var {
e.write_to_out_protocol(o_prot)?;
o_prot.write_list_end()?;
}
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(ref fld_var) = self.runtime {
o_prot.write_field_begin(&TFieldIdentifier::new("runtime", TType::Struct, 6))?;
fld_var.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
()
} else {
()
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
impl Default for GameDB {
fn default() -> Self {
GameDB{
type_: None,
id: Some(0),
name: Some("".to_owned()),
conditions: Some(Vec::new()),
detection: Some(Vec::new()),
runtime: None,
}
}
}
//
// Cond
//
/// @Cond_desc
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Cond {
/// @Cond_name_desc
pub name: Option<String>,
/// @Cond_type_desc
pub type_: Option<CondType>,
/// @Cond_additionalArg_desc
pub additional_arg: Option<String>,
}
impl Cond {
pub fn new<F1, F2, F3>(name: F1, type_: F2, additional_arg: F3) -> Cond where F1: Into<Option<String>>, F2: Into<Option<CondType>>, F3: Into<Option<String>> {
Cond {
name: name.into(),
type_: type_.into(),
additional_arg: additional_arg.into(),
}
}
pub fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<Cond> {
i_prot.read_struct_begin()?;
let mut f_1: Option<String> = Some("".to_owned());
let mut f_2: Option<CondType> = None;
let mut f_3: Option<String> = Some("".to_owned());
loop {
let field_ident = i_prot.read_field_begin()?;
if field_ident.field_type == TType::Stop {
break;
}
let field_id = field_id(&field_ident)?;
match field_id {
1 => {
let val = i_prot.read_string()?;
f_1 = Some(val);
},
2 => {
let val = CondType::read_from_in_protocol(i_prot)?;
f_2 = Some(val);
},
3 => {
let val = i_prot.read_string()?;
f_3 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = Cond {
name: f_1,
type_: f_2,
additional_arg: f_3,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("Cond");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(ref fld_var) = self.name {
o_prot.write_field_begin(&TFieldIdentifier::new("name", TType::String, 1))?;
o_prot.write_string(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(ref fld_var) = self.type_ {
o_prot.write_field_begin(&TFieldIdentifier::new("type", TType::I32, 2))?;
fld_var.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(ref fld_var) = self.additional_arg {
o_prot.write_field_begin(&TFieldIdentifier::new("additionalArg", TType::String, 3))?;
o_prot.write_string(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
impl Default for Cond {
fn default() -> Self {
Cond{
name: Some("".to_owned()),
type_: None,
additional_arg: Some("".to_owned()),
}
}
}
//
// Variant
//
/// @Variant_desc
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Variant {
/// @Variant_name_desc
pub name: Option<String>,
/// @Variant_id_desc
pub id: Option<String>,
/// @Variant_order_desc
pub order: Option<i32>,
/// @Variant_rules_desc
pub rules: Option<Vec<Box<If>>>,
}
impl Variant {
pub fn new<F1, F2, F3, F4>(name: F1, id: F2, order: F3, rules: F4) -> Variant where F1: Into<Option<String>>, F2: Into<Option<String>>, F3: Into<Option<i32>>, F4: Into<Option<Vec<Box<If>>>> {
Variant {
name: name.into(),
id: id.into(),
order: order.into(),
rules: rules.into(),
}
}
pub fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<Variant> {
i_prot.read_struct_begin()?;
let mut f_1: Option<String> = Some("".to_owned());
let mut f_2: Option<String> = Some("".to_owned());
let mut f_3: Option<i32> = Some(0);
let mut f_4: Option<Vec<Box<If>>> = Some(Vec::new());
loop {
let field_ident = i_prot.read_field_begin()?;
if field_ident.field_type == TType::Stop {
break;
}
let field_id = field_id(&field_ident)?;
match field_id {
1 => {
let val = i_prot.read_string()?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_string()?;
f_2 = Some(val);
},
3 => {
let val = i_prot.read_i32()?;
f_3 = Some(val);
},
4 => {
let list_ident = i_prot.read_list_begin()?;
let mut val: Vec<Box<If>> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_2 = Box::new(If::read_from_in_protocol(i_prot)?);
val.push(list_elem_2);
}
i_prot.read_list_end()?;
f_4 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = Variant {
name: f_1,
id: f_2,
order: f_3,
rules: f_4,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("Variant");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(ref fld_var) = self.name {
o_prot.write_field_begin(&TFieldIdentifier::new("name", TType::String, 1))?;
o_prot.write_string(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(ref fld_var) = self.id {
o_prot.write_field_begin(&TFieldIdentifier::new("id", TType::String, 2))?;
o_prot.write_string(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(fld_var) = self.order {
o_prot.write_field_begin(&TFieldIdentifier::new("order", TType::I32, 3))?;
o_prot.write_i32(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(ref fld_var) = self.rules {
o_prot.write_field_begin(&TFieldIdentifier::new("rules", TType::List, 4))?;
o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, fld_var.len() as i32))?;
for e in fld_var {
e.write_to_out_protocol(o_prot)?;
o_prot.write_list_end()?;
}
o_prot.write_field_end()?;
()
} else {
()
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
impl Default for Variant {
fn default() -> Self {
Variant{
name: Some("".to_owned()),
id: Some("".to_owned()),
order: Some(0),
rules: Some(Vec::new()),
}
}
}
//
// If
//
/// @If_desc
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct If {
/// @If_cond_desc
pub cond: Option<String>,
}
impl If {
pub fn new<F1>(cond: F1) -> If where F1: Into<Option<String>> {
If {
cond: cond.into(),
}
}
pub fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<If> {
i_prot.read_struct_begin()?;
let mut f_1: Option<String> = Some("".to_owned());
loop {
let field_ident = i_prot.read_field_begin()?;
if field_ident.field_type == TType::Stop {
break;
}
let field_id = field_id(&field_ident)?;
match field_id {
1 => {
let val = i_prot.read_string()?;
f_1 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = If {
cond: f_1,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("If");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(ref fld_var) = self.cond {
o_prot.write_field_begin(&TFieldIdentifier::new("cond", TType::String, 1))?;
o_prot.write_string(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
impl Default for If {
fn default() -> Self {
If{
cond: Some("".to_owned()),
}
}
}