#![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;
use overlay_manager_s_d_k_data_types;
pub trait TOverlayExternalServiceSyncClient {
fn show_in_game_overlay(&mut self, arguments: overlay_manager_s_d_k_data_types::OverlayState) -> thrift::Result<()>;
fn take_screen_shot(&mut self) -> thrift::Result<bool>;
fn video_capture(&mut self, arguments: overlay_manager_s_d_k_data_types::VideoCaptureState) -> thrift::Result<()>;
}
pub trait TOverlayExternalServiceSyncClientMarker {}
pub struct OverlayExternalServiceSyncClient<IP, OP> where IP: TInputProtocol, OP: TOutputProtocol {
_i_prot: IP,
_o_prot: OP,
_sequence_number: i32,
}
impl <IP, OP> OverlayExternalServiceSyncClient<IP, OP> where IP: TInputProtocol, OP: TOutputProtocol {
pub fn new(input_protocol: IP, output_protocol: OP) -> OverlayExternalServiceSyncClient<IP, OP> {
OverlayExternalServiceSyncClient { _i_prot: input_protocol, _o_prot: output_protocol, _sequence_number: 0 }
}
}
impl <IP, OP> TThriftClient for OverlayExternalServiceSyncClient<IP, OP> where IP: TInputProtocol, OP: TOutputProtocol {
fn i_prot_mut(&mut self) -> &mut TInputProtocol { &mut self._i_prot }
fn o_prot_mut(&mut self) -> &mut TOutputProtocol { &mut self._o_prot }
fn sequence_number(&self) -> i32 { self._sequence_number }
fn increment_sequence_number(&mut self) -> i32 { self._sequence_number += 1; self._sequence_number }
}
impl <IP, OP> TOverlayExternalServiceSyncClientMarker for OverlayExternalServiceSyncClient<IP, OP> where IP: TInputProtocol, OP: TOutputProtocol {}
impl <C: TThriftClient + TOverlayExternalServiceSyncClientMarker> TOverlayExternalServiceSyncClient for C {
fn show_in_game_overlay(&mut self, arguments: overlay_manager_s_d_k_data_types::OverlayState) -> thrift::Result<()> {
(
{
self.increment_sequence_number();
let message_ident = TMessageIdentifier::new("ShowInGameOverlay", TMessageType::Call, self.sequence_number());
let call_args = OverlayExternalServiceShowInGameOverlayArgs { arguments: arguments };
self.o_prot_mut().write_message_begin(&message_ident)?;
call_args.write_to_out_protocol(self.o_prot_mut())?;
self.o_prot_mut().write_message_end()?;
self.o_prot_mut().flush()
}
)?;
{
let message_ident = self.i_prot_mut().read_message_begin()?;
verify_expected_sequence_number(self.sequence_number(), message_ident.sequence_number)?;
verify_expected_service_call("ShowInGameOverlay", &message_ident.name)?;
if message_ident.message_type == TMessageType::Exception {
let remote_error = thrift::Error::read_application_error_from_in_protocol(self.i_prot_mut())?;
self.i_prot_mut().read_message_end()?;
return Err(thrift::Error::Application(remote_error))
}
verify_expected_message_type(TMessageType::Reply, message_ident.message_type)?;
let result = OverlayExternalServiceShowInGameOverlayResult::read_from_in_protocol(self.i_prot_mut())?;
self.i_prot_mut().read_message_end()?;
result.ok_or()
}
}
fn take_screen_shot(&mut self) -> thrift::Result<bool> {
(
{
self.increment_sequence_number();
let message_ident = TMessageIdentifier::new("TakeScreenShot", TMessageType::Call, self.sequence_number());
let call_args = OverlayExternalServiceTakeScreenShotArgs { };
self.o_prot_mut().write_message_begin(&message_ident)?;
call_args.write_to_out_protocol(self.o_prot_mut())?;
self.o_prot_mut().write_message_end()?;
self.o_prot_mut().flush()
}
)?;
{
let message_ident = self.i_prot_mut().read_message_begin()?;
verify_expected_sequence_number(self.sequence_number(), message_ident.sequence_number)?;
verify_expected_service_call("TakeScreenShot", &message_ident.name)?;
if message_ident.message_type == TMessageType::Exception {
let remote_error = thrift::Error::read_application_error_from_in_protocol(self.i_prot_mut())?;
self.i_prot_mut().read_message_end()?;
return Err(thrift::Error::Application(remote_error))
}
verify_expected_message_type(TMessageType::Reply, message_ident.message_type)?;
let result = OverlayExternalServiceTakeScreenShotResult::read_from_in_protocol(self.i_prot_mut())?;
self.i_prot_mut().read_message_end()?;
result.ok_or()
}
}
fn video_capture(&mut self, arguments: overlay_manager_s_d_k_data_types::VideoCaptureState) -> thrift::Result<()> {
(
{
self.increment_sequence_number();
let message_ident = TMessageIdentifier::new("VideoCapture", TMessageType::Call, self.sequence_number());
let call_args = OverlayExternalServiceVideoCaptureArgs { arguments: arguments };
self.o_prot_mut().write_message_begin(&message_ident)?;
call_args.write_to_out_protocol(self.o_prot_mut())?;
self.o_prot_mut().write_message_end()?;
self.o_prot_mut().flush()
}
)?;
{
let message_ident = self.i_prot_mut().read_message_begin()?;
verify_expected_sequence_number(self.sequence_number(), message_ident.sequence_number)?;
verify_expected_service_call("VideoCapture", &message_ident.name)?;
if message_ident.message_type == TMessageType::Exception {
let remote_error = thrift::Error::read_application_error_from_in_protocol(self.i_prot_mut())?;
self.i_prot_mut().read_message_end()?;
return Err(thrift::Error::Application(remote_error))
}
verify_expected_message_type(TMessageType::Reply, message_ident.message_type)?;
let result = OverlayExternalServiceVideoCaptureResult::read_from_in_protocol(self.i_prot_mut())?;
self.i_prot_mut().read_message_end()?;
result.ok_or()
}
}
}
pub trait OverlayExternalServiceSyncHandler {
fn handle_show_in_game_overlay(&self, arguments: overlay_manager_s_d_k_data_types::OverlayState) -> thrift::Result<()>;
fn handle_take_screen_shot(&self) -> thrift::Result<bool>;
fn handle_video_capture(&self, arguments: overlay_manager_s_d_k_data_types::VideoCaptureState) -> thrift::Result<()>;
}
pub struct OverlayExternalServiceSyncProcessor<H: OverlayExternalServiceSyncHandler> {
handler: H,
}
impl <H: OverlayExternalServiceSyncHandler> OverlayExternalServiceSyncProcessor<H> {
pub fn new(handler: H) -> OverlayExternalServiceSyncProcessor<H> {
OverlayExternalServiceSyncProcessor {
handler,
}
}
fn process_show_in_game_overlay(&self, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
TOverlayExternalServiceProcessFunctions::process_show_in_game_overlay(&self.handler, incoming_sequence_number, i_prot, o_prot)
}
fn process_take_screen_shot(&self, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
TOverlayExternalServiceProcessFunctions::process_take_screen_shot(&self.handler, incoming_sequence_number, i_prot, o_prot)
}
fn process_video_capture(&self, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
TOverlayExternalServiceProcessFunctions::process_video_capture(&self.handler, incoming_sequence_number, i_prot, o_prot)
}
}
pub struct TOverlayExternalServiceProcessFunctions;
impl TOverlayExternalServiceProcessFunctions {
pub fn process_show_in_game_overlay<H: OverlayExternalServiceSyncHandler>(handler: &H, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let args = OverlayExternalServiceShowInGameOverlayArgs::read_from_in_protocol(i_prot)?;
match handler.handle_show_in_game_overlay(args.arguments) {
Ok(_) => {
let message_ident = TMessageIdentifier::new("ShowInGameOverlay", TMessageType::Reply, incoming_sequence_number);
o_prot.write_message_begin(&message_ident)?;
let ret = OverlayExternalServiceShowInGameOverlayResult { };
ret.write_to_out_protocol(o_prot)?;
o_prot.write_message_end()?;
o_prot.flush()
},
Err(e) => {
match e {
thrift::Error::Application(app_err) => {
let message_ident = TMessageIdentifier::new("ShowInGameOverlay", TMessageType::Exception, incoming_sequence_number);
o_prot.write_message_begin(&message_ident)?;
thrift::Error::write_application_error_to_out_protocol(&app_err, o_prot)?;
o_prot.write_message_end()?;
o_prot.flush()
},
_ => {
let ret_err = {
ApplicationError::new(
ApplicationErrorKind::Unknown,
e.description()
)
};
let message_ident = TMessageIdentifier::new("ShowInGameOverlay", TMessageType::Exception, incoming_sequence_number);
o_prot.write_message_begin(&message_ident)?;
thrift::Error::write_application_error_to_out_protocol(&ret_err, o_prot)?;
o_prot.write_message_end()?;
o_prot.flush()
},
}
},
}
}
pub fn process_take_screen_shot<H: OverlayExternalServiceSyncHandler>(handler: &H, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let _ = OverlayExternalServiceTakeScreenShotArgs::read_from_in_protocol(i_prot)?;
match handler.handle_take_screen_shot() {
Ok(handler_return) => {
let message_ident = TMessageIdentifier::new("TakeScreenShot", TMessageType::Reply, incoming_sequence_number);
o_prot.write_message_begin(&message_ident)?;
let ret = OverlayExternalServiceTakeScreenShotResult { result_value: Some(handler_return) };
ret.write_to_out_protocol(o_prot)?;
o_prot.write_message_end()?;
o_prot.flush()
},
Err(e) => {
match e {
thrift::Error::Application(app_err) => {
let message_ident = TMessageIdentifier::new("TakeScreenShot", TMessageType::Exception, incoming_sequence_number);
o_prot.write_message_begin(&message_ident)?;
thrift::Error::write_application_error_to_out_protocol(&app_err, o_prot)?;
o_prot.write_message_end()?;
o_prot.flush()
},
_ => {
let ret_err = {
ApplicationError::new(
ApplicationErrorKind::Unknown,
e.description()
)
};
let message_ident = TMessageIdentifier::new("TakeScreenShot", TMessageType::Exception, incoming_sequence_number);
o_prot.write_message_begin(&message_ident)?;
thrift::Error::write_application_error_to_out_protocol(&ret_err, o_prot)?;
o_prot.write_message_end()?;
o_prot.flush()
},
}
},
}
}
pub fn process_video_capture<H: OverlayExternalServiceSyncHandler>(handler: &H, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let args = OverlayExternalServiceVideoCaptureArgs::read_from_in_protocol(i_prot)?;
match handler.handle_video_capture(args.arguments) {
Ok(_) => {
let message_ident = TMessageIdentifier::new("VideoCapture", TMessageType::Reply, incoming_sequence_number);
o_prot.write_message_begin(&message_ident)?;
let ret = OverlayExternalServiceVideoCaptureResult { };
ret.write_to_out_protocol(o_prot)?;
o_prot.write_message_end()?;
o_prot.flush()
},
Err(e) => {
match e {
thrift::Error::Application(app_err) => {
let message_ident = TMessageIdentifier::new("VideoCapture", TMessageType::Exception, incoming_sequence_number);
o_prot.write_message_begin(&message_ident)?;
thrift::Error::write_application_error_to_out_protocol(&app_err, o_prot)?;
o_prot.write_message_end()?;
o_prot.flush()
},
_ => {
let ret_err = {
ApplicationError::new(
ApplicationErrorKind::Unknown,
e.description()
)
};
let message_ident = TMessageIdentifier::new("VideoCapture", TMessageType::Exception, incoming_sequence_number);
o_prot.write_message_begin(&message_ident)?;
thrift::Error::write_application_error_to_out_protocol(&ret_err, o_prot)?;
o_prot.write_message_end()?;
o_prot.flush()
},
}
},
}
}
}
impl <H: OverlayExternalServiceSyncHandler> TProcessor for OverlayExternalServiceSyncProcessor<H> {
fn process(&self, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let message_ident = i_prot.read_message_begin()?;
let res = match &*message_ident.name {
"ShowInGameOverlay" => {
self.process_show_in_game_overlay(message_ident.sequence_number, i_prot, o_prot)
},
"TakeScreenShot" => {
self.process_take_screen_shot(message_ident.sequence_number, i_prot, o_prot)
},
"VideoCapture" => {
self.process_video_capture(message_ident.sequence_number, i_prot, o_prot)
},
method => {
Err(
thrift::Error::Application(
ApplicationError::new(
ApplicationErrorKind::UnknownMethod,
format!("unknown method {}", method)
)
)
)
},
};
thrift::server::handle_process_result(&message_ident, res, o_prot)
}
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
struct OverlayExternalServiceShowInGameOverlayArgs {
arguments: overlay_manager_s_d_k_data_types::OverlayState,
}
impl OverlayExternalServiceShowInGameOverlayArgs {
fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<OverlayExternalServiceShowInGameOverlayArgs> {
i_prot.read_struct_begin()?;
let mut f_1: Option<overlay_manager_s_d_k_data_types::OverlayState> = 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 = overlay_manager_s_d_k_data_types::OverlayState::read_from_in_protocol(i_prot)?;
f_1 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("OverlayExternalServiceShowInGameOverlayArgs.arguments", &f_1)?;
let ret = OverlayExternalServiceShowInGameOverlayArgs {
arguments: f_1.expect("auto-generated code should have checked for presence of required fields"),
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("ShowInGameOverlay_args");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("arguments", TType::Struct, 1))?;
self.arguments.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
struct OverlayExternalServiceShowInGameOverlayResult {
}
impl OverlayExternalServiceShowInGameOverlayResult {
fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<OverlayExternalServiceShowInGameOverlayResult> {
i_prot.read_struct_begin()?;
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 {
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = OverlayExternalServiceShowInGameOverlayResult {};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("OverlayExternalServiceShowInGameOverlayResult");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
fn ok_or(self) -> thrift::Result<()> {
Ok(())
}
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
struct OverlayExternalServiceTakeScreenShotArgs {
}
impl OverlayExternalServiceTakeScreenShotArgs {
fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<OverlayExternalServiceTakeScreenShotArgs> {
i_prot.read_struct_begin()?;
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 {
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = OverlayExternalServiceTakeScreenShotArgs {};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TakeScreenShot_args");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
struct OverlayExternalServiceTakeScreenShotResult {
result_value: Option<bool>,
}
impl OverlayExternalServiceTakeScreenShotResult {
fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<OverlayExternalServiceTakeScreenShotResult> {
i_prot.read_struct_begin()?;
let mut f_0: Option<bool> = 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 {
0 => {
let val = i_prot.read_bool()?;
f_0 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = OverlayExternalServiceTakeScreenShotResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("OverlayExternalServiceTakeScreenShotResult");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(fld_var) = self.result_value {
o_prot.write_field_begin(&TFieldIdentifier::new("result_value", TType::Bool, 0))?;
o_prot.write_bool(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
fn ok_or(self) -> thrift::Result<bool> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
thrift::Error::Application(
ApplicationError::new(
ApplicationErrorKind::MissingResult,
"no result received for OverlayExternalServiceTakeScreenShot"
)
)
)
}
}
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
struct OverlayExternalServiceVideoCaptureArgs {
arguments: overlay_manager_s_d_k_data_types::VideoCaptureState,
}
impl OverlayExternalServiceVideoCaptureArgs {
fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<OverlayExternalServiceVideoCaptureArgs> {
i_prot.read_struct_begin()?;
let mut f_1: Option<overlay_manager_s_d_k_data_types::VideoCaptureState> = 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 = overlay_manager_s_d_k_data_types::VideoCaptureState::read_from_in_protocol(i_prot)?;
f_1 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("OverlayExternalServiceVideoCaptureArgs.arguments", &f_1)?;
let ret = OverlayExternalServiceVideoCaptureArgs {
arguments: f_1.expect("auto-generated code should have checked for presence of required fields"),
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("VideoCapture_args");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("arguments", TType::Struct, 1))?;
self.arguments.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
struct OverlayExternalServiceVideoCaptureResult {
}
impl OverlayExternalServiceVideoCaptureResult {
fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<OverlayExternalServiceVideoCaptureResult> {
i_prot.read_struct_begin()?;
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 {
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = OverlayExternalServiceVideoCaptureResult {};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("OverlayExternalServiceVideoCaptureResult");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
fn ok_or(self) -> thrift::Result<()> {
Ok(())
}
}