#![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 localization_service_s_d_k_data_types;
pub trait TLocalizationServiceSyncClient {
fn switch_language(&mut self, language: String, load_all_context: bool, remove_old: bool) -> thrift::Result<bool>;
fn get_current_language(&mut self) -> thrift::Result<String>;
fn switch_context(&mut self, context: String, language: String) -> thrift::Result<bool>;
fn hint_context(&mut self) -> thrift::Result<String>;
fn get_string(&mut self, key: String, context: String, language: String) -> thrift::Result<String>;
fn get_strings(&mut self, filter: String, context: String, language: String) -> thrift::Result<BTreeMap<String, String>>;
fn get_file_name(&mut self, filename: String, is_virtual_path: bool, context: String) -> thrift::Result<String>;
}
pub trait TLocalizationServiceSyncClientMarker {}
pub struct LocalizationServiceSyncClient<IP, OP> where IP: TInputProtocol, OP: TOutputProtocol {
_i_prot: IP,
_o_prot: OP,
_sequence_number: i32,
}
impl <IP, OP> LocalizationServiceSyncClient<IP, OP> where IP: TInputProtocol, OP: TOutputProtocol {
pub fn new(input_protocol: IP, output_protocol: OP) -> LocalizationServiceSyncClient<IP, OP> {
LocalizationServiceSyncClient { _i_prot: input_protocol, _o_prot: output_protocol, _sequence_number: 0 }
}
}
impl <IP, OP> TThriftClient for LocalizationServiceSyncClient<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> TLocalizationServiceSyncClientMarker for LocalizationServiceSyncClient<IP, OP> where IP: TInputProtocol, OP: TOutputProtocol {}
impl <C: TThriftClient + TLocalizationServiceSyncClientMarker> TLocalizationServiceSyncClient for C {
fn switch_language(&mut self, language: String, load_all_context: bool, remove_old: bool) -> thrift::Result<bool> {
(
{
self.increment_sequence_number();
let message_ident = TMessageIdentifier::new("SwitchLanguage", TMessageType::Call, self.sequence_number());
let call_args = LocalizationServiceSwitchLanguageArgs { language: language, load_all_context: load_all_context, remove_old: remove_old };
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("SwitchLanguage", &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 = LocalizationServiceSwitchLanguageResult::read_from_in_protocol(self.i_prot_mut())?;
self.i_prot_mut().read_message_end()?;
result.ok_or()
}
}
fn get_current_language(&mut self) -> thrift::Result<String> {
(
{
self.increment_sequence_number();
let message_ident = TMessageIdentifier::new("GetCurrentLanguage", TMessageType::Call, self.sequence_number());
let call_args = LocalizationServiceGetCurrentLanguageArgs { };
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("GetCurrentLanguage", &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 = LocalizationServiceGetCurrentLanguageResult::read_from_in_protocol(self.i_prot_mut())?;
self.i_prot_mut().read_message_end()?;
result.ok_or()
}
}
fn switch_context(&mut self, context: String, language: String) -> thrift::Result<bool> {
(
{
self.increment_sequence_number();
let message_ident = TMessageIdentifier::new("SwitchContext", TMessageType::Call, self.sequence_number());
let call_args = LocalizationServiceSwitchContextArgs { context: context, language: language };
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("SwitchContext", &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 = LocalizationServiceSwitchContextResult::read_from_in_protocol(self.i_prot_mut())?;
self.i_prot_mut().read_message_end()?;
result.ok_or()
}
}
fn hint_context(&mut self) -> thrift::Result<String> {
(
{
self.increment_sequence_number();
let message_ident = TMessageIdentifier::new("HintContext", TMessageType::Call, self.sequence_number());
let call_args = LocalizationServiceHintContextArgs { };
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("HintContext", &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 = LocalizationServiceHintContextResult::read_from_in_protocol(self.i_prot_mut())?;
self.i_prot_mut().read_message_end()?;
result.ok_or()
}
}
fn get_string(&mut self, key: String, context: String, language: String) -> thrift::Result<String> {
(
{
self.increment_sequence_number();
let message_ident = TMessageIdentifier::new("GetString", TMessageType::Call, self.sequence_number());
let call_args = LocalizationServiceGetStringArgs { key: key, context: context, language: language };
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("GetString", &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 = LocalizationServiceGetStringResult::read_from_in_protocol(self.i_prot_mut())?;
self.i_prot_mut().read_message_end()?;
result.ok_or()
}
}
fn get_strings(&mut self, filter: String, context: String, language: String) -> thrift::Result<BTreeMap<String, String>> {
(
{
self.increment_sequence_number();
let message_ident = TMessageIdentifier::new("GetStrings", TMessageType::Call, self.sequence_number());
let call_args = LocalizationServiceGetStringsArgs { filter: filter, context: context, language: language };
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("GetStrings", &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 = LocalizationServiceGetStringsResult::read_from_in_protocol(self.i_prot_mut())?;
self.i_prot_mut().read_message_end()?;
result.ok_or()
}
}
fn get_file_name(&mut self, filename: String, is_virtual_path: bool, context: String) -> thrift::Result<String> {
(
{
self.increment_sequence_number();
let message_ident = TMessageIdentifier::new("GetFileName", TMessageType::Call, self.sequence_number());
let call_args = LocalizationServiceGetFileNameArgs { filename: filename, is_virtual_path: is_virtual_path, context: context };
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("GetFileName", &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 = LocalizationServiceGetFileNameResult::read_from_in_protocol(self.i_prot_mut())?;
self.i_prot_mut().read_message_end()?;
result.ok_or()
}
}
}
pub trait LocalizationServiceSyncHandler {
fn handle_switch_language(&self, language: String, load_all_context: bool, remove_old: bool) -> thrift::Result<bool>;
fn handle_get_current_language(&self) -> thrift::Result<String>;
fn handle_switch_context(&self, context: String, language: String) -> thrift::Result<bool>;
fn handle_hint_context(&self) -> thrift::Result<String>;
fn handle_get_string(&self, key: String, context: String, language: String) -> thrift::Result<String>;
fn handle_get_strings(&self, filter: String, context: String, language: String) -> thrift::Result<BTreeMap<String, String>>;
fn handle_get_file_name(&self, filename: String, is_virtual_path: bool, context: String) -> thrift::Result<String>;
}
pub struct LocalizationServiceSyncProcessor<H: LocalizationServiceSyncHandler> {
handler: H,
}
impl <H: LocalizationServiceSyncHandler> LocalizationServiceSyncProcessor<H> {
pub fn new(handler: H) -> LocalizationServiceSyncProcessor<H> {
LocalizationServiceSyncProcessor {
handler,
}
}
fn process_switch_language(&self, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
TLocalizationServiceProcessFunctions::process_switch_language(&self.handler, incoming_sequence_number, i_prot, o_prot)
}
fn process_get_current_language(&self, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
TLocalizationServiceProcessFunctions::process_get_current_language(&self.handler, incoming_sequence_number, i_prot, o_prot)
}
fn process_switch_context(&self, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
TLocalizationServiceProcessFunctions::process_switch_context(&self.handler, incoming_sequence_number, i_prot, o_prot)
}
fn process_hint_context(&self, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
TLocalizationServiceProcessFunctions::process_hint_context(&self.handler, incoming_sequence_number, i_prot, o_prot)
}
fn process_get_string(&self, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
TLocalizationServiceProcessFunctions::process_get_string(&self.handler, incoming_sequence_number, i_prot, o_prot)
}
fn process_get_strings(&self, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
TLocalizationServiceProcessFunctions::process_get_strings(&self.handler, incoming_sequence_number, i_prot, o_prot)
}
fn process_get_file_name(&self, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
TLocalizationServiceProcessFunctions::process_get_file_name(&self.handler, incoming_sequence_number, i_prot, o_prot)
}
}
pub struct TLocalizationServiceProcessFunctions;
impl TLocalizationServiceProcessFunctions {
pub fn process_switch_language<H: LocalizationServiceSyncHandler>(handler: &H, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let args = LocalizationServiceSwitchLanguageArgs::read_from_in_protocol(i_prot)?;
match handler.handle_switch_language(args.language, args.load_all_context, args.remove_old) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier::new("SwitchLanguage", TMessageType::Reply, incoming_sequence_number);
o_prot.write_message_begin(&message_ident)?;
let ret = LocalizationServiceSwitchLanguageResult { 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("SwitchLanguage", 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("SwitchLanguage", 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_get_current_language<H: LocalizationServiceSyncHandler>(handler: &H, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let _ = LocalizationServiceGetCurrentLanguageArgs::read_from_in_protocol(i_prot)?;
match handler.handle_get_current_language() {
Ok(handler_return) => {
let message_ident = TMessageIdentifier::new("GetCurrentLanguage", TMessageType::Reply, incoming_sequence_number);
o_prot.write_message_begin(&message_ident)?;
let ret = LocalizationServiceGetCurrentLanguageResult { 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("GetCurrentLanguage", 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("GetCurrentLanguage", 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_switch_context<H: LocalizationServiceSyncHandler>(handler: &H, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let args = LocalizationServiceSwitchContextArgs::read_from_in_protocol(i_prot)?;
match handler.handle_switch_context(args.context, args.language) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier::new("SwitchContext", TMessageType::Reply, incoming_sequence_number);
o_prot.write_message_begin(&message_ident)?;
let ret = LocalizationServiceSwitchContextResult { 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("SwitchContext", 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("SwitchContext", 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_hint_context<H: LocalizationServiceSyncHandler>(handler: &H, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let _ = LocalizationServiceHintContextArgs::read_from_in_protocol(i_prot)?;
match handler.handle_hint_context() {
Ok(handler_return) => {
let message_ident = TMessageIdentifier::new("HintContext", TMessageType::Reply, incoming_sequence_number);
o_prot.write_message_begin(&message_ident)?;
let ret = LocalizationServiceHintContextResult { 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("HintContext", 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("HintContext", 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_get_string<H: LocalizationServiceSyncHandler>(handler: &H, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let args = LocalizationServiceGetStringArgs::read_from_in_protocol(i_prot)?;
match handler.handle_get_string(args.key, args.context, args.language) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier::new("GetString", TMessageType::Reply, incoming_sequence_number);
o_prot.write_message_begin(&message_ident)?;
let ret = LocalizationServiceGetStringResult { 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("GetString", 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("GetString", 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_get_strings<H: LocalizationServiceSyncHandler>(handler: &H, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let args = LocalizationServiceGetStringsArgs::read_from_in_protocol(i_prot)?;
match handler.handle_get_strings(args.filter, args.context, args.language) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier::new("GetStrings", TMessageType::Reply, incoming_sequence_number);
o_prot.write_message_begin(&message_ident)?;
let ret = LocalizationServiceGetStringsResult { 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("GetStrings", 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("GetStrings", 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_get_file_name<H: LocalizationServiceSyncHandler>(handler: &H, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let args = LocalizationServiceGetFileNameArgs::read_from_in_protocol(i_prot)?;
match handler.handle_get_file_name(args.filename, args.is_virtual_path, args.context) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier::new("GetFileName", TMessageType::Reply, incoming_sequence_number);
o_prot.write_message_begin(&message_ident)?;
let ret = LocalizationServiceGetFileNameResult { 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("GetFileName", 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("GetFileName", 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: LocalizationServiceSyncHandler> TProcessor for LocalizationServiceSyncProcessor<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 {
"SwitchLanguage" => {
self.process_switch_language(message_ident.sequence_number, i_prot, o_prot)
},
"GetCurrentLanguage" => {
self.process_get_current_language(message_ident.sequence_number, i_prot, o_prot)
},
"SwitchContext" => {
self.process_switch_context(message_ident.sequence_number, i_prot, o_prot)
},
"HintContext" => {
self.process_hint_context(message_ident.sequence_number, i_prot, o_prot)
},
"GetString" => {
self.process_get_string(message_ident.sequence_number, i_prot, o_prot)
},
"GetStrings" => {
self.process_get_strings(message_ident.sequence_number, i_prot, o_prot)
},
"GetFileName" => {
self.process_get_file_name(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 LocalizationServiceSwitchLanguageArgs {
language: String,
load_all_context: bool,
remove_old: bool,
}
impl LocalizationServiceSwitchLanguageArgs {
fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<LocalizationServiceSwitchLanguageArgs> {
i_prot.read_struct_begin()?;
let mut f_1: Option<String> = None;
let mut f_2: Option<bool> = None;
let mut f_3: 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 {
1 => {
let val = i_prot.read_string()?;
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()?;
verify_required_field_exists("LocalizationServiceSwitchLanguageArgs.language", &f_1)?;
verify_required_field_exists("LocalizationServiceSwitchLanguageArgs.load_all_context", &f_2)?;
verify_required_field_exists("LocalizationServiceSwitchLanguageArgs.remove_old", &f_3)?;
let ret = LocalizationServiceSwitchLanguageArgs {
language: f_1.expect("auto-generated code should have checked for presence of required fields"),
load_all_context: f_2.expect("auto-generated code should have checked for presence of required fields"),
remove_old: f_3.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("SwitchLanguage_args");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("language", TType::String, 1))?;
o_prot.write_string(&self.language)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("loadAllContext", TType::Bool, 2))?;
o_prot.write_bool(self.load_all_context)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("removeOld", TType::Bool, 3))?;
o_prot.write_bool(self.remove_old)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
struct LocalizationServiceSwitchLanguageResult {
result_value: Option<bool>,
}
impl LocalizationServiceSwitchLanguageResult {
fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<LocalizationServiceSwitchLanguageResult> {
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 = LocalizationServiceSwitchLanguageResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("LocalizationServiceSwitchLanguageResult");
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 LocalizationServiceSwitchLanguage"
)
)
)
}
}
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
struct LocalizationServiceGetCurrentLanguageArgs {
}
impl LocalizationServiceGetCurrentLanguageArgs {
fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<LocalizationServiceGetCurrentLanguageArgs> {
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 = LocalizationServiceGetCurrentLanguageArgs {};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("GetCurrentLanguage_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 LocalizationServiceGetCurrentLanguageResult {
result_value: Option<String>,
}
impl LocalizationServiceGetCurrentLanguageResult {
fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<LocalizationServiceGetCurrentLanguageResult> {
i_prot.read_struct_begin()?;
let mut f_0: Option<String> = 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_string()?;
f_0 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = LocalizationServiceGetCurrentLanguageResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("LocalizationServiceGetCurrentLanguageResult");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(ref fld_var) = self.result_value {
o_prot.write_field_begin(&TFieldIdentifier::new("result_value", TType::String, 0))?;
o_prot.write_string(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
fn ok_or(self) -> thrift::Result<String> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
thrift::Error::Application(
ApplicationError::new(
ApplicationErrorKind::MissingResult,
"no result received for LocalizationServiceGetCurrentLanguage"
)
)
)
}
}
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
struct LocalizationServiceSwitchContextArgs {
context: String,
language: String,
}
impl LocalizationServiceSwitchContextArgs {
fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<LocalizationServiceSwitchContextArgs> {
i_prot.read_struct_begin()?;
let mut f_1: Option<String> = None;
let mut f_2: Option<String> = 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_string()?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_string()?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("LocalizationServiceSwitchContextArgs.context", &f_1)?;
verify_required_field_exists("LocalizationServiceSwitchContextArgs.language", &f_2)?;
let ret = LocalizationServiceSwitchContextArgs {
context: f_1.expect("auto-generated code should have checked for presence of required fields"),
language: f_2.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("SwitchContext_args");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("context", TType::String, 1))?;
o_prot.write_string(&self.context)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("language", TType::String, 2))?;
o_prot.write_string(&self.language)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
struct LocalizationServiceSwitchContextResult {
result_value: Option<bool>,
}
impl LocalizationServiceSwitchContextResult {
fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<LocalizationServiceSwitchContextResult> {
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 = LocalizationServiceSwitchContextResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("LocalizationServiceSwitchContextResult");
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 LocalizationServiceSwitchContext"
)
)
)
}
}
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
struct LocalizationServiceHintContextArgs {
}
impl LocalizationServiceHintContextArgs {
fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<LocalizationServiceHintContextArgs> {
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 = LocalizationServiceHintContextArgs {};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("HintContext_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 LocalizationServiceHintContextResult {
result_value: Option<String>,
}
impl LocalizationServiceHintContextResult {
fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<LocalizationServiceHintContextResult> {
i_prot.read_struct_begin()?;
let mut f_0: Option<String> = 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_string()?;
f_0 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = LocalizationServiceHintContextResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("LocalizationServiceHintContextResult");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(ref fld_var) = self.result_value {
o_prot.write_field_begin(&TFieldIdentifier::new("result_value", TType::String, 0))?;
o_prot.write_string(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
fn ok_or(self) -> thrift::Result<String> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
thrift::Error::Application(
ApplicationError::new(
ApplicationErrorKind::MissingResult,
"no result received for LocalizationServiceHintContext"
)
)
)
}
}
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
struct LocalizationServiceGetStringArgs {
key: String,
context: String,
language: String,
}
impl LocalizationServiceGetStringArgs {
fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<LocalizationServiceGetStringArgs> {
i_prot.read_struct_begin()?;
let mut f_1: Option<String> = None;
let mut f_2: Option<String> = None;
let mut f_3: Option<String> = 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_string()?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_string()?;
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()?;
verify_required_field_exists("LocalizationServiceGetStringArgs.key", &f_1)?;
verify_required_field_exists("LocalizationServiceGetStringArgs.context", &f_2)?;
verify_required_field_exists("LocalizationServiceGetStringArgs.language", &f_3)?;
let ret = LocalizationServiceGetStringArgs {
key: f_1.expect("auto-generated code should have checked for presence of required fields"),
context: f_2.expect("auto-generated code should have checked for presence of required fields"),
language: f_3.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("GetString_args");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("key", TType::String, 1))?;
o_prot.write_string(&self.key)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("context", TType::String, 2))?;
o_prot.write_string(&self.context)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("language", TType::String, 3))?;
o_prot.write_string(&self.language)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
struct LocalizationServiceGetStringResult {
result_value: Option<String>,
}
impl LocalizationServiceGetStringResult {
fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<LocalizationServiceGetStringResult> {
i_prot.read_struct_begin()?;
let mut f_0: Option<String> = 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_string()?;
f_0 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = LocalizationServiceGetStringResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("LocalizationServiceGetStringResult");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(ref fld_var) = self.result_value {
o_prot.write_field_begin(&TFieldIdentifier::new("result_value", TType::String, 0))?;
o_prot.write_string(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
fn ok_or(self) -> thrift::Result<String> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
thrift::Error::Application(
ApplicationError::new(
ApplicationErrorKind::MissingResult,
"no result received for LocalizationServiceGetString"
)
)
)
}
}
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
struct LocalizationServiceGetStringsArgs {
filter: String,
context: String,
language: String,
}
impl LocalizationServiceGetStringsArgs {
fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<LocalizationServiceGetStringsArgs> {
i_prot.read_struct_begin()?;
let mut f_1: Option<String> = None;
let mut f_2: Option<String> = None;
let mut f_3: Option<String> = 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_string()?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_string()?;
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()?;
verify_required_field_exists("LocalizationServiceGetStringsArgs.filter", &f_1)?;
verify_required_field_exists("LocalizationServiceGetStringsArgs.context", &f_2)?;
verify_required_field_exists("LocalizationServiceGetStringsArgs.language", &f_3)?;
let ret = LocalizationServiceGetStringsArgs {
filter: f_1.expect("auto-generated code should have checked for presence of required fields"),
context: f_2.expect("auto-generated code should have checked for presence of required fields"),
language: f_3.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("GetStrings_args");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("filter", TType::String, 1))?;
o_prot.write_string(&self.filter)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("context", TType::String, 2))?;
o_prot.write_string(&self.context)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("language", TType::String, 3))?;
o_prot.write_string(&self.language)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
struct LocalizationServiceGetStringsResult {
result_value: Option<BTreeMap<String, String>>,
}
impl LocalizationServiceGetStringsResult {
fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<LocalizationServiceGetStringsResult> {
i_prot.read_struct_begin()?;
let mut f_0: Option<BTreeMap<String, String>> = 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 map_ident = i_prot.read_map_begin()?;
let mut val: BTreeMap<String, String> = BTreeMap::new();
for _ in 0..map_ident.size {
let map_key_0 = i_prot.read_string()?;
let map_val_1 = i_prot.read_string()?;
val.insert(map_key_0, map_val_1);
}
i_prot.read_map_end()?;
f_0 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = LocalizationServiceGetStringsResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("LocalizationServiceGetStringsResult");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(ref fld_var) = self.result_value {
o_prot.write_field_begin(&TFieldIdentifier::new("result_value", TType::Map, 0))?;
o_prot.write_map_begin(&TMapIdentifier::new(TType::String, TType::String, fld_var.len() as i32))?;
for (k, v) in fld_var {
o_prot.write_string(k)?;
o_prot.write_string(v)?;
o_prot.write_map_end()?;
}
o_prot.write_field_end()?;
()
} else {
()
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
fn ok_or(self) -> thrift::Result<BTreeMap<String, String>> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
thrift::Error::Application(
ApplicationError::new(
ApplicationErrorKind::MissingResult,
"no result received for LocalizationServiceGetStrings"
)
)
)
}
}
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
struct LocalizationServiceGetFileNameArgs {
filename: String,
is_virtual_path: bool,
context: String,
}
impl LocalizationServiceGetFileNameArgs {
fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<LocalizationServiceGetFileNameArgs> {
i_prot.read_struct_begin()?;
let mut f_1: Option<String> = None;
let mut f_2: Option<bool> = None;
let mut f_3: Option<String> = 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_string()?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_bool()?;
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()?;
verify_required_field_exists("LocalizationServiceGetFileNameArgs.filename", &f_1)?;
verify_required_field_exists("LocalizationServiceGetFileNameArgs.is_virtual_path", &f_2)?;
verify_required_field_exists("LocalizationServiceGetFileNameArgs.context", &f_3)?;
let ret = LocalizationServiceGetFileNameArgs {
filename: f_1.expect("auto-generated code should have checked for presence of required fields"),
is_virtual_path: f_2.expect("auto-generated code should have checked for presence of required fields"),
context: f_3.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("GetFileName_args");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("filename", TType::String, 1))?;
o_prot.write_string(&self.filename)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("isVirtualPath", TType::Bool, 2))?;
o_prot.write_bool(self.is_virtual_path)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("context", TType::String, 3))?;
o_prot.write_string(&self.context)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
struct LocalizationServiceGetFileNameResult {
result_value: Option<String>,
}
impl LocalizationServiceGetFileNameResult {
fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<LocalizationServiceGetFileNameResult> {
i_prot.read_struct_begin()?;
let mut f_0: Option<String> = 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_string()?;
f_0 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = LocalizationServiceGetFileNameResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("LocalizationServiceGetFileNameResult");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(ref fld_var) = self.result_value {
o_prot.write_field_begin(&TFieldIdentifier::new("result_value", TType::String, 0))?;
o_prot.write_string(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
fn ok_or(self) -> thrift::Result<String> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
thrift::Error::Application(
ApplicationError::new(
ApplicationErrorKind::MissingResult,
"no result received for LocalizationServiceGetFileName"
)
)
)
}
}
}