Skip to content

Instantly share code, notes, and snippets.

@allengeorge

allengeorge/thrift_test.rs

Created December 18, 2016 17:09
Show Gist options
  • Save allengeorge/5e602bf40ba68ebe0eb2d3117b5d943d to your computer and use it in GitHub Desktop.
Save allengeorge/5e602bf40ba68ebe0eb2d3117b5d943d to your computer and use it in GitHub Desktop.
Download ZIP
Auto-generated rust code for ThriftTest.thrift
Raw
thrift_test.rs
// Autogenerated by Thrift Compiler (0.10.0)
// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#![allow(unused_imports)]
extern crate ordered_float;
extern crate rift;
extern crate try_from;
use ordered_float::OrderedFloat;
use std::cell::RefCell;
use std::collections::{BTreeMap, BTreeSet};
use std::convert::From;
use std::error::Error;
use std::fmt;
use std::fmt::{Display, Formatter};
use std::rc::Rc;
use try_from::TryFrom;
use rift::{ApplicationError, ApplicationErrorKind, ProtocolError, ProtocolErrorKind};
use rift::protocol::{TFieldIdentifier, TListIdentifier, TMapIdentifier, TMessageIdentifier, TMessageType, TProtocol, TSetIdentifier, TStructIdentifier, TType};
use rift::protocol::field_id;
use rift::protocol::verify_expected_message_type;
use rift::protocol::verify_expected_sequence_number;
use rift::protocol::verify_expected_service_call;
use rift::protocol::verify_required_field_exists;
use rift::server::TProcessor;
#[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub enum Numberz {
ONE = 1,
TWO = 2,
THREE = 3,
FIVE = 5,
SIX = 6,
EIGHT = 8,
}
impl Numberz {
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
o_prot.write_i32(*self as i32)
}
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<Numberz> {
let enum_value = try!(i_prot.read_i32());
Numberz::try_from(enum_value) }
}
impl TryFrom<i32> for Numberz {
type Err = rift::Error; fn try_from(i: i32) -> Result<Self, Self::Err> {
match i {
1 => Ok(Numberz::ONE),
2 => Ok(Numberz::TWO),
3 => Ok(Numberz::THREE),
5 => Ok(Numberz::FIVE),
6 => Ok(Numberz::SIX),
8 => Ok(Numberz::EIGHT),
_ => {
Err(
rift::Error::Protocol(
ProtocolError {
kind: ProtocolErrorKind::InvalidData,
message: format!("cannot convert enum constant {} to Numberz", i),
}
)
)
},
}
}
}
pub type StringListMapType = BTreeMap<String, Vec<String>>;
pub type UserId = i64;
pub type MapType = BTreeMap<String, Bonk>;
//
// Bonk
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct Bonk {
pub message: Option<String>,
pub typo: Option<i32>,
}
impl Bonk {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<Bonk> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<String> = Some("".to_owned());
let mut f_2: Option<i32> = Some(0);
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_string());
f_1 = Some(val);
},
2 => {
let val = try!(i_prot.read_i32());
f_2 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = Bonk {
message: f_1,
typo: f_2,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "Bonk".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.message {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("message".to_owned()), field_type: TType::String, id: Some(1) }));
try!(o_prot.write_string(&fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(fld_var) = self.typo {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("typo".to_owned()), field_type: TType::I32, id: Some(2) }));
try!(o_prot.write_i32(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// Bools
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct Bools {
pub im_true: Option<bool>,
pub im_false: Option<bool>,
}
impl Bools {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<Bools> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<bool> = Some(false);
let mut f_2: Option<bool> = Some(false);
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_bool());
f_1 = Some(val);
},
2 => {
let val = try!(i_prot.read_bool());
f_2 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = Bools {
im_true: f_1,
im_false: f_2,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "Bools".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(fld_var) = self.im_true {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("im_true".to_owned()), field_type: TType::Bool, id: Some(1) }));
try!(o_prot.write_bool(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(fld_var) = self.im_false {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("im_false".to_owned()), field_type: TType::Bool, id: Some(2) }));
try!(o_prot.write_bool(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// Xtruct
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct Xtruct {
pub string_thing: Option<String>,
pub byte_thing: Option<i8>,
pub i32_thing: Option<i32>,
pub i64_thing: Option<i64>,
}
impl Xtruct {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<Xtruct> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<String> = Some("".to_owned());
let mut f_4: Option<i8> = Some(0);
let mut f_9: Option<i32> = Some(0);
let mut f_11: Option<i64> = Some(0);
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_string());
f_1 = Some(val);
},
4 => {
let val = try!(i_prot.read_i8());
f_4 = Some(val);
},
9 => {
let val = try!(i_prot.read_i32());
f_9 = Some(val);
},
11 => {
let val = try!(i_prot.read_i64());
f_11 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = Xtruct {
string_thing: f_1,
byte_thing: f_4,
i32_thing: f_9,
i64_thing: f_11,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "Xtruct".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.string_thing {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("string_thing".to_owned()), field_type: TType::String, id: Some(1) }));
try!(o_prot.write_string(&fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(fld_var) = self.byte_thing {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("byte_thing".to_owned()), field_type: TType::I08, id: Some(4) }));
try!(o_prot.write_i8(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(fld_var) = self.i32_thing {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("i32_thing".to_owned()), field_type: TType::I32, id: Some(9) }));
try!(o_prot.write_i32(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(fld_var) = self.i64_thing {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("i64_thing".to_owned()), field_type: TType::I64, id: Some(11) }));
try!(o_prot.write_i64(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// Xtruct2
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct Xtruct2 {
pub byte_thing: Option<i8>,
pub struct_thing: Option<Xtruct>,
pub i32_thing: Option<i32>,
}
impl Xtruct2 {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<Xtruct2> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<i8> = Some(0);
let mut f_2: Option<Xtruct> = None;
let mut f_3: Option<i32> = Some(0);
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_i8());
f_1 = Some(val);
},
2 => {
let val = try!(Xtruct::read_from_in_protocol(i_prot));
f_2 = Some(val);
},
3 => {
let val = try!(i_prot.read_i32());
f_3 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = Xtruct2 {
byte_thing: f_1,
struct_thing: f_2,
i32_thing: f_3,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "Xtruct2".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(fld_var) = self.byte_thing {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("byte_thing".to_owned()), field_type: TType::I08, id: Some(1) }));
try!(o_prot.write_i8(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.struct_thing {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("struct_thing".to_owned()), field_type: TType::Struct, id: Some(2) }));
try!(fld_var.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(fld_var) = self.i32_thing {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("i32_thing".to_owned()), field_type: TType::I32, id: Some(3) }));
try!(o_prot.write_i32(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// Xtruct3
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct Xtruct3 {
pub string_thing: Option<String>,
pub changed: Option<i32>,
pub i32_thing: Option<i32>,
pub i64_thing: Option<i64>,
}
impl Xtruct3 {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<Xtruct3> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<String> = Some("".to_owned());
let mut f_4: Option<i32> = Some(0);
let mut f_9: Option<i32> = Some(0);
let mut f_11: Option<i64> = Some(0);
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_string());
f_1 = Some(val);
},
4 => {
let val = try!(i_prot.read_i32());
f_4 = Some(val);
},
9 => {
let val = try!(i_prot.read_i32());
f_9 = Some(val);
},
11 => {
let val = try!(i_prot.read_i64());
f_11 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = Xtruct3 {
string_thing: f_1,
changed: f_4,
i32_thing: f_9,
i64_thing: f_11,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "Xtruct3".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.string_thing {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("string_thing".to_owned()), field_type: TType::String, id: Some(1) }));
try!(o_prot.write_string(&fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(fld_var) = self.changed {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("changed".to_owned()), field_type: TType::I32, id: Some(4) }));
try!(o_prot.write_i32(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(fld_var) = self.i32_thing {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("i32_thing".to_owned()), field_type: TType::I32, id: Some(9) }));
try!(o_prot.write_i32(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(fld_var) = self.i64_thing {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("i64_thing".to_owned()), field_type: TType::I64, id: Some(11) }));
try!(o_prot.write_i64(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// Insanity
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct Insanity {
pub user_map: Option<BTreeMap<Numberz, UserId>>,
pub xtructs: Option<Vec<Xtruct>>,
}
impl Insanity {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<Insanity> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<BTreeMap<Numberz, UserId>> = Some(BTreeMap::new());
let mut f_2: Option<Vec<Xtruct>> = Some(Vec::new());
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let map_ident = try!(i_prot.read_map_begin());
let mut val: BTreeMap<Numberz, UserId> = BTreeMap::new();
for _ in 0..map_ident.size {
let map_key_0 = try!(Numberz::read_from_in_protocol(i_prot));
let map_val_1 = try!(i_prot.read_i64());
val.insert(map_key_0, map_val_1);
}
try!(i_prot.read_map_end());
f_1 = Some(val);
},
2 => {
let list_ident = try!(i_prot.read_list_begin());
let mut val: Vec<Xtruct> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_2 = try!(Xtruct::read_from_in_protocol(i_prot));
val.push(list_elem_2);
}
try!(i_prot.read_list_end());
f_2 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = Insanity {
user_map: f_1,
xtructs: f_2,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "Insanity".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.user_map {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("userMap".to_owned()), field_type: TType::Map, id: Some(1) }));
try!(o_prot.write_map_begin(&TMapIdentifier { key_type: TType::I32, value_type: TType::I64, size: fld_var.len() as i32 }));
for (k, v) in fld_var.iter() {
try!(k.write_to_out_protocol(o_prot));
try!(o_prot.write_i64(*v));
try!(o_prot.write_map_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.xtructs {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("xtructs".to_owned()), field_type: TType::List, id: Some(2) }));
try!(o_prot.write_list_begin(&TListIdentifier { element_type: TType::Struct, size: fld_var.len() as i32 }));
for e in fld_var.iter() {
try!(e.write_to_out_protocol(o_prot));
try!(o_prot.write_list_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// CrazyNesting
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct CrazyNesting {
pub string_field: Option<String>,
pub set_field: Option<BTreeSet<Insanity>>,
pub list_field: Vec<BTreeMap<BTreeSet<i32>, BTreeMap<i32, BTreeSet<Vec<BTreeMap<Insanity, String>>>>>>,
pub binary_field: Option<Vec<u8>>,
}
impl CrazyNesting {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<CrazyNesting> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<String> = Some("".to_owned());
let mut f_2: Option<BTreeSet<Insanity>> = None;
let mut f_3: Option<Vec<BTreeMap<BTreeSet<i32>, BTreeMap<i32, BTreeSet<Vec<BTreeMap<Insanity, String>>>>>>> = None;
let mut f_4: Option<Vec<u8>> = Some(Vec::new());
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_string());
f_1 = Some(val);
},
2 => {
let set_ident = try!(i_prot.read_set_begin());
let mut val: BTreeSet<Insanity> = BTreeSet::new();
for _ in 0..set_ident.size {
let set_elem_3 = try!(Insanity::read_from_in_protocol(i_prot));
val.insert(set_elem_3);
}
try!(i_prot.read_set_end());
f_2 = Some(val);
},
3 => {
let list_ident = try!(i_prot.read_list_begin());
let mut val: Vec<BTreeMap<BTreeSet<i32>, BTreeMap<i32, BTreeSet<Vec<BTreeMap<Insanity, String>>>>>> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let map_ident = try!(i_prot.read_map_begin());
let mut list_elem_4: BTreeMap<BTreeSet<i32>, BTreeMap<i32, BTreeSet<Vec<BTreeMap<Insanity, String>>>>> = BTreeMap::new();
for _ in 0..map_ident.size {
let set_ident = try!(i_prot.read_set_begin());
let mut map_key_5: BTreeSet<i32> = BTreeSet::new();
for _ in 0..set_ident.size {
let set_elem_6 = try!(i_prot.read_i32());
map_key_5.insert(set_elem_6);
}
try!(i_prot.read_set_end());
let map_ident = try!(i_prot.read_map_begin());
let mut map_val_7: BTreeMap<i32, BTreeSet<Vec<BTreeMap<Insanity, String>>>> = BTreeMap::new();
for _ in 0..map_ident.size {
let map_key_8 = try!(i_prot.read_i32());
let set_ident = try!(i_prot.read_set_begin());
let mut map_val_9: BTreeSet<Vec<BTreeMap<Insanity, String>>> = BTreeSet::new();
for _ in 0..set_ident.size {
let list_ident = try!(i_prot.read_list_begin());
let mut set_elem_10: Vec<BTreeMap<Insanity, String>> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let map_ident = try!(i_prot.read_map_begin());
let mut list_elem_11: BTreeMap<Insanity, String> = BTreeMap::new();
for _ in 0..map_ident.size {
let map_key_12 = try!(Insanity::read_from_in_protocol(i_prot));
let map_val_13 = try!(i_prot.read_string());
list_elem_11.insert(map_key_12, map_val_13);
}
try!(i_prot.read_map_end());
set_elem_10.push(list_elem_11);
}
try!(i_prot.read_list_end());
map_val_9.insert(set_elem_10);
}
try!(i_prot.read_set_end());
map_val_7.insert(map_key_8, map_val_9);
}
try!(i_prot.read_map_end());
list_elem_4.insert(map_key_5, map_val_7);
}
try!(i_prot.read_map_end());
val.push(list_elem_4);
}
try!(i_prot.read_list_end());
f_3 = Some(val);
},
4 => {
let val = try!(i_prot.read_bytes());
f_4 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("CrazyNesting.list_field", &f_3));
let ret = CrazyNesting {
string_field: f_1,
set_field: f_2,
list_field: f_3.expect("auto-generated code should have checked for presence of required fields"),
binary_field: f_4,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "CrazyNesting".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.string_field {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("string_field".to_owned()), field_type: TType::String, id: Some(1) }));
try!(o_prot.write_string(&fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.set_field {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("set_field".to_owned()), field_type: TType::Set, id: Some(2) }));
try!(o_prot.write_set_begin(&TSetIdentifier { element_type: TType::Struct, size: fld_var.len() as i32 }));
for e in fld_var.iter() {
try!(e.write_to_out_protocol(o_prot));
try!(o_prot.write_set_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("list_field".to_owned()), field_type: TType::List, id: Some(3) }));
try!(o_prot.write_list_begin(&TListIdentifier { element_type: TType::Map, size: self.list_field.len() as i32 }));
for e in self.list_field.iter() {
try!(o_prot.write_map_begin(&TMapIdentifier { key_type: TType::Set, value_type: TType::Map, size: e.len() as i32 }));
for (k, v) in e.iter() {
try!(o_prot.write_set_begin(&TSetIdentifier { element_type: TType::I32, size: k.len() as i32 }));
for e in k.iter() {
try!(o_prot.write_i32(*e));
try!(o_prot.write_set_end());
}
try!(o_prot.write_map_begin(&TMapIdentifier { key_type: TType::I32, value_type: TType::Set, size: v.len() as i32 }));
for (k, v) in v.iter() {
try!(o_prot.write_i32(*k));
try!(o_prot.write_set_begin(&TSetIdentifier { element_type: TType::List, size: v.len() as i32 }));
for e in v.iter() {
try!(o_prot.write_list_begin(&TListIdentifier { element_type: TType::Map, size: e.len() as i32 }));
for e in e.iter() {
try!(o_prot.write_map_begin(&TMapIdentifier { key_type: TType::Struct, value_type: TType::String, size: e.len() as i32 }));
for (k, v) in e.iter() {
try!(k.write_to_out_protocol(o_prot));
try!(o_prot.write_string(&v));
try!(o_prot.write_map_end());
}
try!(o_prot.write_list_end());
}
try!(o_prot.write_set_end());
}
try!(o_prot.write_map_end());
}
try!(o_prot.write_map_end());
}
try!(o_prot.write_list_end());
}
try!(o_prot.write_field_end());
if let Some(ref fld_var) = self.binary_field {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("binary_field".to_owned()), field_type: TType::String, id: Some(4) }));
try!(o_prot.write_bytes(&fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// Xception
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct Xception {
pub error_code: Option<i32>,
pub message: Option<String>,
}
impl Xception {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<Xception> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<i32> = Some(0);
let mut f_2: Option<String> = Some("".to_owned());
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_i32());
f_1 = Some(val);
},
2 => {
let val = try!(i_prot.read_string());
f_2 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = Xception {
error_code: f_1,
message: f_2,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "Xception".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(fld_var) = self.error_code {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("errorCode".to_owned()), field_type: TType::I32, id: Some(1) }));
try!(o_prot.write_i32(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.message {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("message".to_owned()), field_type: TType::String, id: Some(2) }));
try!(o_prot.write_string(&fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
impl Error for Xception {
fn description(&self) -> &str {
"remote service threw Xception"
}
}
impl From<Xception> for rift::Error {
fn from(e: Xception) -> Self {
rift::Error::User(Box::new(e))
}
}
impl Display for Xception {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
self.description().fmt(f)
}
}
//
// Xception2
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct Xception2 {
pub error_code: Option<i32>,
pub struct_thing: Option<Xtruct>,
}
impl Xception2 {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<Xception2> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<i32> = Some(0);
let mut f_2: Option<Xtruct> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_i32());
f_1 = Some(val);
},
2 => {
let val = try!(Xtruct::read_from_in_protocol(i_prot));
f_2 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = Xception2 {
error_code: f_1,
struct_thing: f_2,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "Xception2".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(fld_var) = self.error_code {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("errorCode".to_owned()), field_type: TType::I32, id: Some(1) }));
try!(o_prot.write_i32(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.struct_thing {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("struct_thing".to_owned()), field_type: TType::Struct, id: Some(2) }));
try!(fld_var.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
impl Error for Xception2 {
fn description(&self) -> &str {
"remote service threw Xception2"
}
}
impl From<Xception2> for rift::Error {
fn from(e: Xception2) -> Self {
rift::Error::User(Box::new(e))
}
}
impl Display for Xception2 {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
self.description().fmt(f)
}
}
//
// EmptyStruct
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct EmptyStruct {
}
impl EmptyStruct {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<EmptyStruct> {
try!(i_prot.read_struct_begin());
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = EmptyStruct {};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "EmptyStruct".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// OneField
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct OneField {
pub field: Option<EmptyStruct>,
}
impl OneField {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<OneField> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<EmptyStruct> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(EmptyStruct::read_from_in_protocol(i_prot));
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = OneField {
field: f_1,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "OneField".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.field {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("field".to_owned()), field_type: TType::Struct, id: Some(1) }));
try!(fld_var.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// SomeUnion
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub enum SomeUnion {
MapThing(BTreeMap<Numberz, UserId>),
StringThing(String),
I32Thing(i32),
XtructThing(Xtruct3),
InsanityThing(Insanity),
}
impl SomeUnion {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<SomeUnion> {
let mut ret: Option<SomeUnion> = None;
let mut received_field_count = 0;
try!(i_prot.read_struct_begin());
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let map_ident = try!(i_prot.read_map_begin());
let mut val: BTreeMap<Numberz, UserId> = BTreeMap::new();
for _ in 0..map_ident.size {
let map_key_14 = try!(Numberz::read_from_in_protocol(i_prot));
let map_val_15 = try!(i_prot.read_i64());
val.insert(map_key_14, map_val_15);
}
try!(i_prot.read_map_end());
if let None = ret {
ret = Some(SomeUnion::MapThing(val));
}
received_field_count += 1;
},
2 => {
let val = try!(i_prot.read_string());
if let None = ret {
ret = Some(SomeUnion::StringThing(val));
}
received_field_count += 1;
},
3 => {
let val = try!(i_prot.read_i32());
if let None = ret {
ret = Some(SomeUnion::I32Thing(val));
}
received_field_count += 1;
},
4 => {
let val = try!(Xtruct3::read_from_in_protocol(i_prot));
if let None = ret {
ret = Some(SomeUnion::XtructThing(val));
}
received_field_count += 1;
},
5 => {
let val = try!(Insanity::read_from_in_protocol(i_prot));
if let None = ret {
ret = Some(SomeUnion::InsanityThing(val));
}
received_field_count += 1;
},
_ => {
try!(i_prot.skip(field_ident.field_type));
received_field_count += 1;
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
if received_field_count > 1 {
Err(
rift::Error::Protocol(
ProtocolError {
kind: ProtocolErrorKind::InvalidData,
message: "received multiple fields from remote for union SomeUnion".to_owned(),
}
)
)
} else {
Ok(ret.expect("return value should have been constructed"))
}
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "SomeUnion".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
match *self {
SomeUnion::MapThing(ref f) => {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("map_thing".to_owned()), field_type: TType::Map, id: Some(1) }));
try!(o_prot.write_map_begin(&TMapIdentifier { key_type: TType::I32, value_type: TType::I64, size: f.len() as i32 }));
for (k, v) in f.iter() {
try!(k.write_to_out_protocol(o_prot));
try!(o_prot.write_i64(*v));
try!(o_prot.write_map_end());
}
try!(o_prot.write_field_end());
},
SomeUnion::StringThing(ref f) => {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("string_thing".to_owned()), field_type: TType::String, id: Some(2) }));
try!(o_prot.write_string(&f));
try!(o_prot.write_field_end());
},
SomeUnion::I32Thing(f) => {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("i32_thing".to_owned()), field_type: TType::I32, id: Some(3) }));
try!(o_prot.write_i32(f));
try!(o_prot.write_field_end());
},
SomeUnion::XtructThing(ref f) => {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("xtruct_thing".to_owned()), field_type: TType::Struct, id: Some(4) }));
try!(f.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
},
SomeUnion::InsanityThing(ref f) => {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("insanity_thing".to_owned()), field_type: TType::Struct, id: Some(5) }));
try!(f.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
},
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// VersioningTestV1
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct VersioningTestV1 {
pub begin_in_both: Option<i32>,
pub old_string: Option<String>,
pub end_in_both: Option<i32>,
}
impl VersioningTestV1 {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<VersioningTestV1> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<i32> = Some(0);
let mut f_3: Option<String> = Some("".to_owned());
let mut f_12: Option<i32> = Some(0);
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_i32());
f_1 = Some(val);
},
3 => {
let val = try!(i_prot.read_string());
f_3 = Some(val);
},
12 => {
let val = try!(i_prot.read_i32());
f_12 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = VersioningTestV1 {
begin_in_both: f_1,
old_string: f_3,
end_in_both: f_12,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "VersioningTestV1".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(fld_var) = self.begin_in_both {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("begin_in_both".to_owned()), field_type: TType::I32, id: Some(1) }));
try!(o_prot.write_i32(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.old_string {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("old_string".to_owned()), field_type: TType::String, id: Some(3) }));
try!(o_prot.write_string(&fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(fld_var) = self.end_in_both {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("end_in_both".to_owned()), field_type: TType::I32, id: Some(12) }));
try!(o_prot.write_i32(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// VersioningTestV2
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct VersioningTestV2 {
pub begin_in_both: Option<i32>,
pub newint: Option<i32>,
pub newbyte: Option<i8>,
pub newshort: Option<i16>,
pub newlong: Option<i64>,
pub newdouble: Option<OrderedFloat<f64>>,
pub newstruct: Option<Bonk>,
pub newlist: Option<Vec<i32>>,
pub newset: Option<BTreeSet<i32>>,
pub newmap: Option<BTreeMap<i32, i32>>,
pub newstring: Option<String>,
pub end_in_both: Option<i32>,
}
impl VersioningTestV2 {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<VersioningTestV2> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<i32> = Some(0);
let mut f_2: Option<i32> = Some(0);
let mut f_3: Option<i8> = Some(0);
let mut f_4: Option<i16> = Some(0);
let mut f_5: Option<i64> = Some(0);
let mut f_6: Option<OrderedFloat<f64>> = Some(OrderedFloat::from(0.0));
let mut f_7: Option<Bonk> = None;
let mut f_8: Option<Vec<i32>> = Some(Vec::new());
let mut f_9: Option<BTreeSet<i32>> = Some(BTreeSet::new());
let mut f_10: Option<BTreeMap<i32, i32>> = Some(BTreeMap::new());
let mut f_11: Option<String> = Some("".to_owned());
let mut f_12: Option<i32> = Some(0);
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_i32());
f_1 = Some(val);
},
2 => {
let val = try!(i_prot.read_i32());
f_2 = Some(val);
},
3 => {
let val = try!(i_prot.read_i8());
f_3 = Some(val);
},
4 => {
let val = try!(i_prot.read_i16());
f_4 = Some(val);
},
5 => {
let val = try!(i_prot.read_i64());
f_5 = Some(val);
},
6 => {
let val = OrderedFloat::from(try!(i_prot.read_double()));
f_6 = Some(val);
},
7 => {
let val = try!(Bonk::read_from_in_protocol(i_prot));
f_7 = Some(val);
},
8 => {
let list_ident = try!(i_prot.read_list_begin());
let mut val: Vec<i32> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_16 = try!(i_prot.read_i32());
val.push(list_elem_16);
}
try!(i_prot.read_list_end());
f_8 = Some(val);
},
9 => {
let set_ident = try!(i_prot.read_set_begin());
let mut val: BTreeSet<i32> = BTreeSet::new();
for _ in 0..set_ident.size {
let set_elem_17 = try!(i_prot.read_i32());
val.insert(set_elem_17);
}
try!(i_prot.read_set_end());
f_9 = Some(val);
},
10 => {
let map_ident = try!(i_prot.read_map_begin());
let mut val: BTreeMap<i32, i32> = BTreeMap::new();
for _ in 0..map_ident.size {
let map_key_18 = try!(i_prot.read_i32());
let map_val_19 = try!(i_prot.read_i32());
val.insert(map_key_18, map_val_19);
}
try!(i_prot.read_map_end());
f_10 = Some(val);
},
11 => {
let val = try!(i_prot.read_string());
f_11 = Some(val);
},
12 => {
let val = try!(i_prot.read_i32());
f_12 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = VersioningTestV2 {
begin_in_both: f_1,
newint: f_2,
newbyte: f_3,
newshort: f_4,
newlong: f_5,
newdouble: f_6,
newstruct: f_7,
newlist: f_8,
newset: f_9,
newmap: f_10,
newstring: f_11,
end_in_both: f_12,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "VersioningTestV2".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(fld_var) = self.begin_in_both {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("begin_in_both".to_owned()), field_type: TType::I32, id: Some(1) }));
try!(o_prot.write_i32(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(fld_var) = self.newint {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("newint".to_owned()), field_type: TType::I32, id: Some(2) }));
try!(o_prot.write_i32(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(fld_var) = self.newbyte {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("newbyte".to_owned()), field_type: TType::I08, id: Some(3) }));
try!(o_prot.write_i8(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(fld_var) = self.newshort {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("newshort".to_owned()), field_type: TType::I16, id: Some(4) }));
try!(o_prot.write_i16(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(fld_var) = self.newlong {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("newlong".to_owned()), field_type: TType::I64, id: Some(5) }));
try!(o_prot.write_i64(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(fld_var) = self.newdouble {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("newdouble".to_owned()), field_type: TType::Double, id: Some(6) }));
try!(o_prot.write_double(fld_var.into()));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.newstruct {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("newstruct".to_owned()), field_type: TType::Struct, id: Some(7) }));
try!(fld_var.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.newlist {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("newlist".to_owned()), field_type: TType::List, id: Some(8) }));
try!(o_prot.write_list_begin(&TListIdentifier { element_type: TType::I32, size: fld_var.len() as i32 }));
for e in fld_var.iter() {
try!(o_prot.write_i32(*e));
try!(o_prot.write_list_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.newset {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("newset".to_owned()), field_type: TType::Set, id: Some(9) }));
try!(o_prot.write_set_begin(&TSetIdentifier { element_type: TType::I32, size: fld_var.len() as i32 }));
for e in fld_var.iter() {
try!(o_prot.write_i32(*e));
try!(o_prot.write_set_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.newmap {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("newmap".to_owned()), field_type: TType::Map, id: Some(10) }));
try!(o_prot.write_map_begin(&TMapIdentifier { key_type: TType::I32, value_type: TType::I32, size: fld_var.len() as i32 }));
for (k, v) in fld_var.iter() {
try!(o_prot.write_i32(*k));
try!(o_prot.write_i32(*v));
try!(o_prot.write_map_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.newstring {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("newstring".to_owned()), field_type: TType::String, id: Some(11) }));
try!(o_prot.write_string(&fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(fld_var) = self.end_in_both {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("end_in_both".to_owned()), field_type: TType::I32, id: Some(12) }));
try!(o_prot.write_i32(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// ListTypeVersioningV1
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct ListTypeVersioningV1 {
pub myints: Option<Vec<i32>>,
pub hello: Option<String>,
}
impl ListTypeVersioningV1 {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<ListTypeVersioningV1> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<Vec<i32>> = Some(Vec::new());
let mut f_2: Option<String> = Some("".to_owned());
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let list_ident = try!(i_prot.read_list_begin());
let mut val: Vec<i32> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_20 = try!(i_prot.read_i32());
val.push(list_elem_20);
}
try!(i_prot.read_list_end());
f_1 = Some(val);
},
2 => {
let val = try!(i_prot.read_string());
f_2 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = ListTypeVersioningV1 {
myints: f_1,
hello: f_2,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "ListTypeVersioningV1".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.myints {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("myints".to_owned()), field_type: TType::List, id: Some(1) }));
try!(o_prot.write_list_begin(&TListIdentifier { element_type: TType::I32, size: fld_var.len() as i32 }));
for e in fld_var.iter() {
try!(o_prot.write_i32(*e));
try!(o_prot.write_list_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.hello {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("hello".to_owned()), field_type: TType::String, id: Some(2) }));
try!(o_prot.write_string(&fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// ListTypeVersioningV2
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct ListTypeVersioningV2 {
pub strings: Option<Vec<String>>,
pub hello: Option<String>,
}
impl ListTypeVersioningV2 {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<ListTypeVersioningV2> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<Vec<String>> = Some(Vec::new());
let mut f_2: Option<String> = Some("".to_owned());
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let list_ident = try!(i_prot.read_list_begin());
let mut val: Vec<String> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_21 = try!(i_prot.read_string());
val.push(list_elem_21);
}
try!(i_prot.read_list_end());
f_1 = Some(val);
},
2 => {
let val = try!(i_prot.read_string());
f_2 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = ListTypeVersioningV2 {
strings: f_1,
hello: f_2,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "ListTypeVersioningV2".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.strings {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("strings".to_owned()), field_type: TType::List, id: Some(1) }));
try!(o_prot.write_list_begin(&TListIdentifier { element_type: TType::String, size: fld_var.len() as i32 }));
for e in fld_var.iter() {
try!(o_prot.write_string(&e));
try!(o_prot.write_list_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.hello {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("hello".to_owned()), field_type: TType::String, id: Some(2) }));
try!(o_prot.write_string(&fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// GuessProtocolStruct
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct GuessProtocolStruct {
pub map_field: Option<BTreeMap<String, String>>,
}
impl GuessProtocolStruct {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<GuessProtocolStruct> {
try!(i_prot.read_struct_begin());
let mut f_7: Option<BTreeMap<String, String>> = Some(BTreeMap::new());
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
7 => {
let map_ident = try!(i_prot.read_map_begin());
let mut val: BTreeMap<String, String> = BTreeMap::new();
for _ in 0..map_ident.size {
let map_key_22 = try!(i_prot.read_string());
let map_val_23 = try!(i_prot.read_string());
val.insert(map_key_22, map_val_23);
}
try!(i_prot.read_map_end());
f_7 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = GuessProtocolStruct {
map_field: f_7,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "GuessProtocolStruct".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.map_field {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("map_field".to_owned()), field_type: TType::Map, id: Some(7) }));
try!(o_prot.write_map_begin(&TMapIdentifier { key_type: TType::String, value_type: TType::String, size: fld_var.len() as i32 }));
for (k, v) in fld_var.iter() {
try!(o_prot.write_string(&k));
try!(o_prot.write_string(&v));
try!(o_prot.write_map_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// LargeDeltas
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct LargeDeltas {
pub b1: Option<Bools>,
pub b10: Option<Bools>,
pub b100: Option<Bools>,
pub check_true: Option<bool>,
pub b1000: Option<Bools>,
pub check_false: Option<bool>,
pub vertwo2000: Option<VersioningTestV2>,
pub a_set2500: Option<BTreeSet<String>>,
pub vertwo3000: Option<VersioningTestV2>,
pub big_numbers: Option<Vec<i32>>,
}
impl LargeDeltas {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<LargeDeltas> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<Bools> = None;
let mut f_10: Option<Bools> = None;
let mut f_100: Option<Bools> = None;
let mut f_500: Option<bool> = Some(false);
let mut f_1000: Option<Bools> = None;
let mut f_1500: Option<bool> = Some(false);
let mut f_2000: Option<VersioningTestV2> = None;
let mut f_2500: Option<BTreeSet<String>> = Some(BTreeSet::new());
let mut f_3000: Option<VersioningTestV2> = None;
let mut f_4000: Option<Vec<i32>> = Some(Vec::new());
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(Bools::read_from_in_protocol(i_prot));
f_1 = Some(val);
},
10 => {
let val = try!(Bools::read_from_in_protocol(i_prot));
f_10 = Some(val);
},
100 => {
let val = try!(Bools::read_from_in_protocol(i_prot));
f_100 = Some(val);
},
500 => {
let val = try!(i_prot.read_bool());
f_500 = Some(val);
},
1000 => {
let val = try!(Bools::read_from_in_protocol(i_prot));
f_1000 = Some(val);
},
1500 => {
let val = try!(i_prot.read_bool());
f_1500 = Some(val);
},
2000 => {
let val = try!(VersioningTestV2::read_from_in_protocol(i_prot));
f_2000 = Some(val);
},
2500 => {
let set_ident = try!(i_prot.read_set_begin());
let mut val: BTreeSet<String> = BTreeSet::new();
for _ in 0..set_ident.size {
let set_elem_24 = try!(i_prot.read_string());
val.insert(set_elem_24);
}
try!(i_prot.read_set_end());
f_2500 = Some(val);
},
3000 => {
let val = try!(VersioningTestV2::read_from_in_protocol(i_prot));
f_3000 = Some(val);
},
4000 => {
let list_ident = try!(i_prot.read_list_begin());
let mut val: Vec<i32> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_25 = try!(i_prot.read_i32());
val.push(list_elem_25);
}
try!(i_prot.read_list_end());
f_4000 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = LargeDeltas {
b1: f_1,
b10: f_10,
b100: f_100,
check_true: f_500,
b1000: f_1000,
check_false: f_1500,
vertwo2000: f_2000,
a_set2500: f_2500,
vertwo3000: f_3000,
big_numbers: f_4000,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "LargeDeltas".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.b1 {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("b1".to_owned()), field_type: TType::Struct, id: Some(1) }));
try!(fld_var.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.b10 {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("b10".to_owned()), field_type: TType::Struct, id: Some(10) }));
try!(fld_var.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.b100 {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("b100".to_owned()), field_type: TType::Struct, id: Some(100) }));
try!(fld_var.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(fld_var) = self.check_true {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("check_true".to_owned()), field_type: TType::Bool, id: Some(500) }));
try!(o_prot.write_bool(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.b1000 {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("b1000".to_owned()), field_type: TType::Struct, id: Some(1000) }));
try!(fld_var.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(fld_var) = self.check_false {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("check_false".to_owned()), field_type: TType::Bool, id: Some(1500) }));
try!(o_prot.write_bool(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.vertwo2000 {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("vertwo2000".to_owned()), field_type: TType::Struct, id: Some(2000) }));
try!(fld_var.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.a_set2500 {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("a_set2500".to_owned()), field_type: TType::Set, id: Some(2500) }));
try!(o_prot.write_set_begin(&TSetIdentifier { element_type: TType::String, size: fld_var.len() as i32 }));
for e in fld_var.iter() {
try!(o_prot.write_string(&e));
try!(o_prot.write_set_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.vertwo3000 {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("vertwo3000".to_owned()), field_type: TType::Struct, id: Some(3000) }));
try!(fld_var.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.big_numbers {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("big_numbers".to_owned()), field_type: TType::List, id: Some(4000) }));
try!(o_prot.write_list_begin(&TListIdentifier { element_type: TType::I32, size: fld_var.len() as i32 }));
for e in fld_var.iter() {
try!(o_prot.write_i32(*e));
try!(o_prot.write_list_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// NestedListsI32x2
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct NestedListsI32x2 {
pub integerlist: Option<Vec<Vec<i32>>>,
}
impl NestedListsI32x2 {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<NestedListsI32x2> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<Vec<Vec<i32>>> = Some(Vec::new());
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let list_ident = try!(i_prot.read_list_begin());
let mut val: Vec<Vec<i32>> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_ident = try!(i_prot.read_list_begin());
let mut list_elem_26: Vec<i32> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_27 = try!(i_prot.read_i32());
list_elem_26.push(list_elem_27);
}
try!(i_prot.read_list_end());
val.push(list_elem_26);
}
try!(i_prot.read_list_end());
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = NestedListsI32x2 {
integerlist: f_1,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "NestedListsI32x2".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.integerlist {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("integerlist".to_owned()), field_type: TType::List, id: Some(1) }));
try!(o_prot.write_list_begin(&TListIdentifier { element_type: TType::List, size: fld_var.len() as i32 }));
for e in fld_var.iter() {
try!(o_prot.write_list_begin(&TListIdentifier { element_type: TType::I32, size: e.len() as i32 }));
for e in e.iter() {
try!(o_prot.write_i32(*e));
try!(o_prot.write_list_end());
}
try!(o_prot.write_list_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// NestedListsI32x3
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct NestedListsI32x3 {
pub integerlist: Option<Vec<Vec<Vec<i32>>>>,
}
impl NestedListsI32x3 {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<NestedListsI32x3> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<Vec<Vec<Vec<i32>>>> = Some(Vec::new());
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let list_ident = try!(i_prot.read_list_begin());
let mut val: Vec<Vec<Vec<i32>>> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_ident = try!(i_prot.read_list_begin());
let mut list_elem_28: Vec<Vec<i32>> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_ident = try!(i_prot.read_list_begin());
let mut list_elem_29: Vec<i32> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_30 = try!(i_prot.read_i32());
list_elem_29.push(list_elem_30);
}
try!(i_prot.read_list_end());
list_elem_28.push(list_elem_29);
}
try!(i_prot.read_list_end());
val.push(list_elem_28);
}
try!(i_prot.read_list_end());
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = NestedListsI32x3 {
integerlist: f_1,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "NestedListsI32x3".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.integerlist {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("integerlist".to_owned()), field_type: TType::List, id: Some(1) }));
try!(o_prot.write_list_begin(&TListIdentifier { element_type: TType::List, size: fld_var.len() as i32 }));
for e in fld_var.iter() {
try!(o_prot.write_list_begin(&TListIdentifier { element_type: TType::List, size: e.len() as i32 }));
for e in e.iter() {
try!(o_prot.write_list_begin(&TListIdentifier { element_type: TType::I32, size: e.len() as i32 }));
for e in e.iter() {
try!(o_prot.write_i32(*e));
try!(o_prot.write_list_end());
}
try!(o_prot.write_list_end());
}
try!(o_prot.write_list_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// NestedMixedx2
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct NestedMixedx2 {
pub int_set_list: Option<Vec<BTreeSet<i32>>>,
pub map_int_strset: Option<BTreeMap<i32, BTreeSet<String>>>,
pub map_int_strset_list: Option<Vec<BTreeMap<i32, BTreeSet<String>>>>,
}
impl NestedMixedx2 {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<NestedMixedx2> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<Vec<BTreeSet<i32>>> = Some(Vec::new());
let mut f_2: Option<BTreeMap<i32, BTreeSet<String>>> = Some(BTreeMap::new());
let mut f_3: Option<Vec<BTreeMap<i32, BTreeSet<String>>>> = Some(Vec::new());
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let list_ident = try!(i_prot.read_list_begin());
let mut val: Vec<BTreeSet<i32>> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let set_ident = try!(i_prot.read_set_begin());
let mut list_elem_31: BTreeSet<i32> = BTreeSet::new();
for _ in 0..set_ident.size {
let set_elem_32 = try!(i_prot.read_i32());
list_elem_31.insert(set_elem_32);
}
try!(i_prot.read_set_end());
val.push(list_elem_31);
}
try!(i_prot.read_list_end());
f_1 = Some(val);
},
2 => {
let map_ident = try!(i_prot.read_map_begin());
let mut val: BTreeMap<i32, BTreeSet<String>> = BTreeMap::new();
for _ in 0..map_ident.size {
let map_key_33 = try!(i_prot.read_i32());
let set_ident = try!(i_prot.read_set_begin());
let mut map_val_34: BTreeSet<String> = BTreeSet::new();
for _ in 0..set_ident.size {
let set_elem_35 = try!(i_prot.read_string());
map_val_34.insert(set_elem_35);
}
try!(i_prot.read_set_end());
val.insert(map_key_33, map_val_34);
}
try!(i_prot.read_map_end());
f_2 = Some(val);
},
3 => {
let list_ident = try!(i_prot.read_list_begin());
let mut val: Vec<BTreeMap<i32, BTreeSet<String>>> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let map_ident = try!(i_prot.read_map_begin());
let mut list_elem_36: BTreeMap<i32, BTreeSet<String>> = BTreeMap::new();
for _ in 0..map_ident.size {
let map_key_37 = try!(i_prot.read_i32());
let set_ident = try!(i_prot.read_set_begin());
let mut map_val_38: BTreeSet<String> = BTreeSet::new();
for _ in 0..set_ident.size {
let set_elem_39 = try!(i_prot.read_string());
map_val_38.insert(set_elem_39);
}
try!(i_prot.read_set_end());
list_elem_36.insert(map_key_37, map_val_38);
}
try!(i_prot.read_map_end());
val.push(list_elem_36);
}
try!(i_prot.read_list_end());
f_3 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = NestedMixedx2 {
int_set_list: f_1,
map_int_strset: f_2,
map_int_strset_list: f_3,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "NestedMixedx2".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.int_set_list {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("int_set_list".to_owned()), field_type: TType::List, id: Some(1) }));
try!(o_prot.write_list_begin(&TListIdentifier { element_type: TType::Set, size: fld_var.len() as i32 }));
for e in fld_var.iter() {
try!(o_prot.write_set_begin(&TSetIdentifier { element_type: TType::I32, size: e.len() as i32 }));
for e in e.iter() {
try!(o_prot.write_i32(*e));
try!(o_prot.write_set_end());
}
try!(o_prot.write_list_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.map_int_strset {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("map_int_strset".to_owned()), field_type: TType::Map, id: Some(2) }));
try!(o_prot.write_map_begin(&TMapIdentifier { key_type: TType::I32, value_type: TType::Set, size: fld_var.len() as i32 }));
for (k, v) in fld_var.iter() {
try!(o_prot.write_i32(*k));
try!(o_prot.write_set_begin(&TSetIdentifier { element_type: TType::String, size: v.len() as i32 }));
for e in v.iter() {
try!(o_prot.write_string(&e));
try!(o_prot.write_set_end());
}
try!(o_prot.write_map_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.map_int_strset_list {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("map_int_strset_list".to_owned()), field_type: TType::List, id: Some(3) }));
try!(o_prot.write_list_begin(&TListIdentifier { element_type: TType::Map, size: fld_var.len() as i32 }));
for e in fld_var.iter() {
try!(o_prot.write_map_begin(&TMapIdentifier { key_type: TType::I32, value_type: TType::Set, size: e.len() as i32 }));
for (k, v) in e.iter() {
try!(o_prot.write_i32(*k));
try!(o_prot.write_set_begin(&TSetIdentifier { element_type: TType::String, size: v.len() as i32 }));
for e in v.iter() {
try!(o_prot.write_string(&e));
try!(o_prot.write_set_end());
}
try!(o_prot.write_map_end());
}
try!(o_prot.write_list_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// ListBonks
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct ListBonks {
pub bonk: Option<Vec<Bonk>>,
}
impl ListBonks {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<ListBonks> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<Vec<Bonk>> = Some(Vec::new());
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let list_ident = try!(i_prot.read_list_begin());
let mut val: Vec<Bonk> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_40 = try!(Bonk::read_from_in_protocol(i_prot));
val.push(list_elem_40);
}
try!(i_prot.read_list_end());
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = ListBonks {
bonk: f_1,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "ListBonks".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.bonk {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("bonk".to_owned()), field_type: TType::List, id: Some(1) }));
try!(o_prot.write_list_begin(&TListIdentifier { element_type: TType::Struct, size: fld_var.len() as i32 }));
for e in fld_var.iter() {
try!(e.write_to_out_protocol(o_prot));
try!(o_prot.write_list_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// NestedListsBonk
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct NestedListsBonk {
pub bonk: Option<Vec<Vec<Vec<Bonk>>>>,
}
impl NestedListsBonk {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<NestedListsBonk> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<Vec<Vec<Vec<Bonk>>>> = Some(Vec::new());
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let list_ident = try!(i_prot.read_list_begin());
let mut val: Vec<Vec<Vec<Bonk>>> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_ident = try!(i_prot.read_list_begin());
let mut list_elem_41: Vec<Vec<Bonk>> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_ident = try!(i_prot.read_list_begin());
let mut list_elem_42: Vec<Bonk> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_43 = try!(Bonk::read_from_in_protocol(i_prot));
list_elem_42.push(list_elem_43);
}
try!(i_prot.read_list_end());
list_elem_41.push(list_elem_42);
}
try!(i_prot.read_list_end());
val.push(list_elem_41);
}
try!(i_prot.read_list_end());
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = NestedListsBonk {
bonk: f_1,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "NestedListsBonk".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.bonk {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("bonk".to_owned()), field_type: TType::List, id: Some(1) }));
try!(o_prot.write_list_begin(&TListIdentifier { element_type: TType::List, size: fld_var.len() as i32 }));
for e in fld_var.iter() {
try!(o_prot.write_list_begin(&TListIdentifier { element_type: TType::List, size: e.len() as i32 }));
for e in e.iter() {
try!(o_prot.write_list_begin(&TListIdentifier { element_type: TType::Struct, size: e.len() as i32 }));
for e in e.iter() {
try!(e.write_to_out_protocol(o_prot));
try!(o_prot.write_list_end());
}
try!(o_prot.write_list_end());
}
try!(o_prot.write_list_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// BoolTest
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct BoolTest {
pub b: Option<bool>,
pub s: Option<String>,
}
impl BoolTest {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<BoolTest> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<bool> = None;
let mut f_2: Option<String> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_bool());
f_1 = Some(val);
},
2 => {
let val = try!(i_prot.read_string());
f_2 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = BoolTest {
b: f_1,
s: f_2,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "BoolTest".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(fld_var) = self.b {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("b".to_owned()), field_type: TType::Bool, id: Some(1) }));
try!(o_prot.write_bool(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.s {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("s".to_owned()), field_type: TType::String, id: Some(2) }));
try!(o_prot.write_string(&fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// StructA
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct StructA {
pub s: String,
}
impl StructA {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<StructA> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<String> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_string());
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("StructA.s", &f_1));
let ret = StructA {
s: f_1.expect("auto-generated code should have checked for presence of required fields"),
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "StructA".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("s".to_owned()), field_type: TType::String, id: Some(1) }));
try!(o_prot.write_string(&self.s));
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// StructB
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct StructB {
pub aa: Option<StructA>,
pub ab: StructA,
}
impl StructB {
pub fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<StructB> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<StructA> = None;
let mut f_2: Option<StructA> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(StructA::read_from_in_protocol(i_prot));
f_1 = Some(val);
},
2 => {
let val = try!(StructA::read_from_in_protocol(i_prot));
f_2 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("StructB.ab", &f_2));
let ret = StructB {
aa: f_1,
ab: f_2.expect("auto-generated code should have checked for presence of required fields"),
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "StructB".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.aa {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("aa".to_owned()), field_type: TType::Struct, id: Some(1) }));
try!(fld_var.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("ab".to_owned()), field_type: TType::Struct, id: Some(2) }));
try!(self.ab.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
pub struct ConstMyNumberz;
impl ConstMyNumberz {
pub fn const_value() -> Numberz {
{
Numberz::try_from(1).expect("expecting valid const value")
}
}
}
pub struct ConstUrNested;
impl ConstUrNested {
pub fn const_value() -> StringListMapType {
{
let mut m: BTreeMap<String, Vec<String>> = BTreeMap::new();
let k = "foo".to_owned();
let v = {
{
let mut l: Vec<String> = Vec::new();
l.push("bar".to_owned());
l.push("baz".to_owned());
l
}
};
m.insert(k, v);
let k = "hey".to_owned();
let v = {
{
let mut l: Vec<String> = Vec::new();
l.push("nonny".to_owned());
l.push("no".to_owned());
l
}
};
m.insert(k, v);
m
}
}
}
//
// ThriftTest service client
//
pub trait TAbstractThriftTestSyncClient {
fn test_void(&mut self) -> rift::Result<()>;
fn test_string(&mut self, thing: String) -> rift::Result<String>;
fn test_bool(&mut self, thing: bool) -> rift::Result<bool>;
fn test_byte(&mut self, thing: i8) -> rift::Result<i8>;
fn test_i32(&mut self, thing: i32) -> rift::Result<i32>;
fn test_i64(&mut self, thing: i64) -> rift::Result<i64>;
fn test_double(&mut self, thing: OrderedFloat<f64>) -> rift::Result<OrderedFloat<f64>>;
fn test_binary(&mut self, thing: Vec<u8>) -> rift::Result<Vec<u8>>;
fn test_struct(&mut self, thing: Xtruct) -> rift::Result<Xtruct>;
fn test_nest(&mut self, thing: Xtruct2) -> rift::Result<Xtruct2>;
fn test_map(&mut self, thing: BTreeMap<i32, i32>) -> rift::Result<BTreeMap<i32, i32>>;
fn test_string_map(&mut self, thing: BTreeMap<String, String>) -> rift::Result<BTreeMap<String, String>>;
fn test_set(&mut self, thing: BTreeSet<i32>) -> rift::Result<BTreeSet<i32>>;
fn test_list(&mut self, thing: Vec<i32>) -> rift::Result<Vec<i32>>;
fn test_enum(&mut self, thing: Numberz) -> rift::Result<Numberz>;
fn test_typedef(&mut self, thing: UserId) -> rift::Result<UserId>;
fn test_map_map(&mut self, hello: i32) -> rift::Result<BTreeMap<i32, BTreeMap<i32, i32>>>;
fn test_insanity(&mut self, argument: Insanity) -> rift::Result<BTreeMap<UserId, BTreeMap<Numberz, Insanity>>>;
fn test_multi(&mut self, arg0: i8, arg1: i32, arg2: i64, arg3: BTreeMap<i16, String>, arg4: Numberz, arg5: UserId) -> rift::Result<Xtruct>;
fn test_exception(&mut self, arg: String) -> rift::Result<()>;
fn test_multi_exception(&mut self, arg0: String, arg1: String) -> rift::Result<Xtruct>;
fn test_oneway(&mut self, seconds_to_sleep: i32) -> rift::Result<()>;
}
pub struct TThriftTestSyncClient {
i_prot: Rc<RefCell<Box<TProtocol>>>,
o_prot: Rc<RefCell<Box<TProtocol>>>,
sequence_number: i32,
}
impl TThriftTestSyncClient {
pub fn new(protocol: Box<TProtocol>) -> TThriftTestSyncClient {
let p = Rc::new(RefCell::new(protocol));
TThriftTestSyncClient { i_prot: p.clone(), o_prot: p.clone(), sequence_number: 0 }
}
pub fn with_separate_protocols(input_protocol: Box<TProtocol>, output_protocol: Box<TProtocol>) -> TThriftTestSyncClient {
TThriftTestSyncClient { i_prot: Rc::new(RefCell::new(input_protocol)), o_prot: Rc::new(RefCell::new(output_protocol)), sequence_number: 0 }
}
fn send_test_void(&mut self) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testVoid".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = TestVoidArgs { };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_test_void(&mut self) -> rift::Result<()> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("testVoid", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(TestVoidResult::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_test_string(&mut self, thing: String) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testString".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = TestStringArgs { thing: thing };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_test_string(&mut self) -> rift::Result<String> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("testString", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(TestStringResult::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_test_bool(&mut self, thing: bool) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testBool".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = TestBoolArgs { thing: thing };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_test_bool(&mut self) -> rift::Result<bool> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("testBool", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(TestBoolResult::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_test_byte(&mut self, thing: i8) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testByte".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = TestByteArgs { thing: thing };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_test_byte(&mut self) -> rift::Result<i8> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("testByte", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(TestByteResult::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_test_i32(&mut self, thing: i32) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testI32".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = TestI32Args { thing: thing };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_test_i32(&mut self) -> rift::Result<i32> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("testI32", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(TestI32Result::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_test_i64(&mut self, thing: i64) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testI64".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = TestI64Args { thing: thing };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_test_i64(&mut self) -> rift::Result<i64> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("testI64", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(TestI64Result::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_test_double(&mut self, thing: OrderedFloat<f64>) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testDouble".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = TestDoubleArgs { thing: thing };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_test_double(&mut self) -> rift::Result<OrderedFloat<f64>> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("testDouble", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(TestDoubleResult::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_test_binary(&mut self, thing: Vec<u8>) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testBinary".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = TestBinaryArgs { thing: thing };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_test_binary(&mut self) -> rift::Result<Vec<u8>> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("testBinary", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(TestBinaryResult::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_test_struct(&mut self, thing: Xtruct) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testStruct".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = TestStructArgs { thing: thing };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_test_struct(&mut self) -> rift::Result<Xtruct> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("testStruct", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(TestStructResult::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_test_nest(&mut self, thing: Xtruct2) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testNest".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = TestNestArgs { thing: thing };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_test_nest(&mut self) -> rift::Result<Xtruct2> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("testNest", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(TestNestResult::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_test_map(&mut self, thing: BTreeMap<i32, i32>) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testMap".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = TestMapArgs { thing: thing };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_test_map(&mut self) -> rift::Result<BTreeMap<i32, i32>> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("testMap", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(TestMapResult::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_test_string_map(&mut self, thing: BTreeMap<String, String>) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testStringMap".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = TestStringMapArgs { thing: thing };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_test_string_map(&mut self) -> rift::Result<BTreeMap<String, String>> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("testStringMap", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(TestStringMapResult::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_test_set(&mut self, thing: BTreeSet<i32>) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testSet".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = TestSetArgs { thing: thing };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_test_set(&mut self) -> rift::Result<BTreeSet<i32>> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("testSet", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(TestSetResult::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_test_list(&mut self, thing: Vec<i32>) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testList".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = TestListArgs { thing: thing };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_test_list(&mut self) -> rift::Result<Vec<i32>> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("testList", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(TestListResult::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_test_enum(&mut self, thing: Numberz) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testEnum".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = TestEnumArgs { thing: thing };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_test_enum(&mut self) -> rift::Result<Numberz> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("testEnum", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(TestEnumResult::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_test_typedef(&mut self, thing: UserId) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testTypedef".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = TestTypedefArgs { thing: thing };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_test_typedef(&mut self) -> rift::Result<UserId> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("testTypedef", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(TestTypedefResult::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_test_map_map(&mut self, hello: i32) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testMapMap".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = TestMapMapArgs { hello: hello };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_test_map_map(&mut self) -> rift::Result<BTreeMap<i32, BTreeMap<i32, i32>>> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("testMapMap", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(TestMapMapResult::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_test_insanity(&mut self, argument: Insanity) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testInsanity".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = TestInsanityArgs { argument: argument };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_test_insanity(&mut self) -> rift::Result<BTreeMap<UserId, BTreeMap<Numberz, Insanity>>> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("testInsanity", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(TestInsanityResult::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_test_multi(&mut self, arg0: i8, arg1: i32, arg2: i64, arg3: BTreeMap<i16, String>, arg4: Numberz, arg5: UserId) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testMulti".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = TestMultiArgs { arg0: arg0, arg1: arg1, arg2: arg2, arg3: arg3, arg4: arg4, arg5: arg5 };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_test_multi(&mut self) -> rift::Result<Xtruct> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("testMulti", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(TestMultiResult::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_test_exception(&mut self, arg: String) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testException".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = TestExceptionArgs { arg: arg };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_test_exception(&mut self) -> rift::Result<()> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("testException", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(TestExceptionResult::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_test_multi_exception(&mut self, arg0: String, arg1: String) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testMultiException".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = TestMultiExceptionArgs { arg0: arg0, arg1: arg1 };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_test_multi_exception(&mut self) -> rift::Result<Xtruct> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("testMultiException", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(TestMultiExceptionResult::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_test_oneway(&mut self, seconds_to_sleep: i32) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"testOneway".to_owned(), message_type: TMessageType::OneWay, sequence_number: self.sequence_number };
let call_args = TestOnewayArgs { seconds_to_sleep: seconds_to_sleep };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
}
impl TAbstractThriftTestSyncClient for TThriftTestSyncClient {
fn test_void(&mut self) -> rift::Result<()> {
try!(self.send_test_void());
self.recv_test_void()
}
fn test_string(&mut self, thing: String) -> rift::Result<String> {
try!(self.send_test_string(thing));
self.recv_test_string()
}
fn test_bool(&mut self, thing: bool) -> rift::Result<bool> {
try!(self.send_test_bool(thing));
self.recv_test_bool()
}
fn test_byte(&mut self, thing: i8) -> rift::Result<i8> {
try!(self.send_test_byte(thing));
self.recv_test_byte()
}
fn test_i32(&mut self, thing: i32) -> rift::Result<i32> {
try!(self.send_test_i32(thing));
self.recv_test_i32()
}
fn test_i64(&mut self, thing: i64) -> rift::Result<i64> {
try!(self.send_test_i64(thing));
self.recv_test_i64()
}
fn test_double(&mut self, thing: OrderedFloat<f64>) -> rift::Result<OrderedFloat<f64>> {
try!(self.send_test_double(thing));
self.recv_test_double()
}
fn test_binary(&mut self, thing: Vec<u8>) -> rift::Result<Vec<u8>> {
try!(self.send_test_binary(thing));
self.recv_test_binary()
}
fn test_struct(&mut self, thing: Xtruct) -> rift::Result<Xtruct> {
try!(self.send_test_struct(thing));
self.recv_test_struct()
}
fn test_nest(&mut self, thing: Xtruct2) -> rift::Result<Xtruct2> {
try!(self.send_test_nest(thing));
self.recv_test_nest()
}
fn test_map(&mut self, thing: BTreeMap<i32, i32>) -> rift::Result<BTreeMap<i32, i32>> {
try!(self.send_test_map(thing));
self.recv_test_map()
}
fn test_string_map(&mut self, thing: BTreeMap<String, String>) -> rift::Result<BTreeMap<String, String>> {
try!(self.send_test_string_map(thing));
self.recv_test_string_map()
}
fn test_set(&mut self, thing: BTreeSet<i32>) -> rift::Result<BTreeSet<i32>> {
try!(self.send_test_set(thing));
self.recv_test_set()
}
fn test_list(&mut self, thing: Vec<i32>) -> rift::Result<Vec<i32>> {
try!(self.send_test_list(thing));
self.recv_test_list()
}
fn test_enum(&mut self, thing: Numberz) -> rift::Result<Numberz> {
try!(self.send_test_enum(thing));
self.recv_test_enum()
}
fn test_typedef(&mut self, thing: UserId) -> rift::Result<UserId> {
try!(self.send_test_typedef(thing));
self.recv_test_typedef()
}
fn test_map_map(&mut self, hello: i32) -> rift::Result<BTreeMap<i32, BTreeMap<i32, i32>>> {
try!(self.send_test_map_map(hello));
self.recv_test_map_map()
}
fn test_insanity(&mut self, argument: Insanity) -> rift::Result<BTreeMap<UserId, BTreeMap<Numberz, Insanity>>> {
try!(self.send_test_insanity(argument));
self.recv_test_insanity()
}
fn test_multi(&mut self, arg0: i8, arg1: i32, arg2: i64, arg3: BTreeMap<i16, String>, arg4: Numberz, arg5: UserId) -> rift::Result<Xtruct> {
try!(self.send_test_multi(arg0, arg1, arg2, arg3, arg4, arg5));
self.recv_test_multi()
}
fn test_exception(&mut self, arg: String) -> rift::Result<()> {
try!(self.send_test_exception(arg));
self.recv_test_exception()
}
fn test_multi_exception(&mut self, arg0: String, arg1: String) -> rift::Result<Xtruct> {
try!(self.send_test_multi_exception(arg0, arg1));
self.recv_test_multi_exception()
}
fn test_oneway(&mut self, seconds_to_sleep: i32) -> rift::Result<()> {
try!(self.send_test_oneway(seconds_to_sleep));
Ok(())
}
}
//
// ThriftTest service server
//
pub trait TAbstractThriftTestSyncHandler {
fn handle_test_void(&mut self) -> rift::Result<()>;
fn handle_test_string(&mut self, thing: String) -> rift::Result<String>;
fn handle_test_bool(&mut self, thing: bool) -> rift::Result<bool>;
fn handle_test_byte(&mut self, thing: i8) -> rift::Result<i8>;
fn handle_test_i32(&mut self, thing: i32) -> rift::Result<i32>;
fn handle_test_i64(&mut self, thing: i64) -> rift::Result<i64>;
fn handle_test_double(&mut self, thing: OrderedFloat<f64>) -> rift::Result<OrderedFloat<f64>>;
fn handle_test_binary(&mut self, thing: Vec<u8>) -> rift::Result<Vec<u8>>;
fn handle_test_struct(&mut self, thing: Xtruct) -> rift::Result<Xtruct>;
fn handle_test_nest(&mut self, thing: Xtruct2) -> rift::Result<Xtruct2>;
fn handle_test_map(&mut self, thing: BTreeMap<i32, i32>) -> rift::Result<BTreeMap<i32, i32>>;
fn handle_test_string_map(&mut self, thing: BTreeMap<String, String>) -> rift::Result<BTreeMap<String, String>>;
fn handle_test_set(&mut self, thing: BTreeSet<i32>) -> rift::Result<BTreeSet<i32>>;
fn handle_test_list(&mut self, thing: Vec<i32>) -> rift::Result<Vec<i32>>;
fn handle_test_enum(&mut self, thing: Numberz) -> rift::Result<Numberz>;
fn handle_test_typedef(&mut self, thing: UserId) -> rift::Result<UserId>;
fn handle_test_map_map(&mut self, hello: i32) -> rift::Result<BTreeMap<i32, BTreeMap<i32, i32>>>;
fn handle_test_insanity(&mut self, argument: Insanity) -> rift::Result<BTreeMap<UserId, BTreeMap<Numberz, Insanity>>>;
fn handle_test_multi(&mut self, arg0: i8, arg1: i32, arg2: i64, arg3: BTreeMap<i16, String>, arg4: Numberz, arg5: UserId) -> rift::Result<Xtruct>;
fn handle_test_exception(&mut self, arg: String) -> rift::Result<()>;
fn handle_test_multi_exception(&mut self, arg0: String, arg1: String) -> rift::Result<Xtruct>;
fn handle_test_oneway(&mut self, seconds_to_sleep: i32) -> rift::Result<()>;
}
pub struct TThriftTestProcessor<H: TAbstractThriftTestSyncHandler> {
handler: H,
}
impl <H: TAbstractThriftTestSyncHandler> TThriftTestProcessor<H> {
pub fn new(handler: H) -> TThriftTestProcessor<H> {
TThriftTestProcessor { handler: handler }
}
fn process_test_void(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let _ = try!(TestVoidArgs::read_from_in_protocol(i_prot));
match self.handler.handle_test_void() {
Ok(_) => {
let message_ident = TMessageIdentifier { name: "testVoid".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = TestVoidResult { };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testVoid".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_test_string(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let args = try!(TestStringArgs::read_from_in_protocol(i_prot));
match self.handler.handle_test_string(args.thing) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier { name: "testString".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = TestStringResult { result_value: Some(handler_return) };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testString".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_test_bool(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let args = try!(TestBoolArgs::read_from_in_protocol(i_prot));
match self.handler.handle_test_bool(args.thing) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier { name: "testBool".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = TestBoolResult { result_value: Some(handler_return) };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testBool".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_test_byte(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let args = try!(TestByteArgs::read_from_in_protocol(i_prot));
match self.handler.handle_test_byte(args.thing) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier { name: "testByte".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = TestByteResult { result_value: Some(handler_return) };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testByte".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_test_i32(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let args = try!(TestI32Args::read_from_in_protocol(i_prot));
match self.handler.handle_test_i32(args.thing) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier { name: "testI32".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = TestI32Result { result_value: Some(handler_return) };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testI32".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_test_i64(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let args = try!(TestI64Args::read_from_in_protocol(i_prot));
match self.handler.handle_test_i64(args.thing) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier { name: "testI64".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = TestI64Result { result_value: Some(handler_return) };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testI64".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_test_double(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let args = try!(TestDoubleArgs::read_from_in_protocol(i_prot));
match self.handler.handle_test_double(args.thing) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier { name: "testDouble".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = TestDoubleResult { result_value: Some(handler_return) };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testDouble".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_test_binary(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let args = try!(TestBinaryArgs::read_from_in_protocol(i_prot));
match self.handler.handle_test_binary(args.thing) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier { name: "testBinary".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = TestBinaryResult { result_value: Some(handler_return) };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testBinary".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_test_struct(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let args = try!(TestStructArgs::read_from_in_protocol(i_prot));
match self.handler.handle_test_struct(args.thing) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier { name: "testStruct".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = TestStructResult { result_value: Some(handler_return) };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testStruct".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_test_nest(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let args = try!(TestNestArgs::read_from_in_protocol(i_prot));
match self.handler.handle_test_nest(args.thing) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier { name: "testNest".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = TestNestResult { result_value: Some(handler_return) };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testNest".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_test_map(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let args = try!(TestMapArgs::read_from_in_protocol(i_prot));
match self.handler.handle_test_map(args.thing) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier { name: "testMap".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = TestMapResult { result_value: Some(handler_return) };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testMap".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_test_string_map(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let args = try!(TestStringMapArgs::read_from_in_protocol(i_prot));
match self.handler.handle_test_string_map(args.thing) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier { name: "testStringMap".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = TestStringMapResult { result_value: Some(handler_return) };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testStringMap".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_test_set(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let args = try!(TestSetArgs::read_from_in_protocol(i_prot));
match self.handler.handle_test_set(args.thing) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier { name: "testSet".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = TestSetResult { result_value: Some(handler_return) };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testSet".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_test_list(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let args = try!(TestListArgs::read_from_in_protocol(i_prot));
match self.handler.handle_test_list(args.thing) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier { name: "testList".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = TestListResult { result_value: Some(handler_return) };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testList".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_test_enum(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let args = try!(TestEnumArgs::read_from_in_protocol(i_prot));
match self.handler.handle_test_enum(args.thing) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier { name: "testEnum".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = TestEnumResult { result_value: Some(handler_return) };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testEnum".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_test_typedef(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let args = try!(TestTypedefArgs::read_from_in_protocol(i_prot));
match self.handler.handle_test_typedef(args.thing) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier { name: "testTypedef".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = TestTypedefResult { result_value: Some(handler_return) };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testTypedef".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_test_map_map(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let args = try!(TestMapMapArgs::read_from_in_protocol(i_prot));
match self.handler.handle_test_map_map(args.hello) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier { name: "testMapMap".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = TestMapMapResult { result_value: Some(handler_return) };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testMapMap".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_test_insanity(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let args = try!(TestInsanityArgs::read_from_in_protocol(i_prot));
match self.handler.handle_test_insanity(args.argument) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier { name: "testInsanity".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = TestInsanityResult { result_value: Some(handler_return) };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testInsanity".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_test_multi(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let args = try!(TestMultiArgs::read_from_in_protocol(i_prot));
match self.handler.handle_test_multi(args.arg0, args.arg1, args.arg2, args.arg3, args.arg4, args.arg5) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier { name: "testMulti".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = TestMultiResult { result_value: Some(handler_return) };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testMulti".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_test_exception(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let args = try!(TestExceptionArgs::read_from_in_protocol(i_prot));
match self.handler.handle_test_exception(args.arg) {
Ok(_) => {
let message_ident = TMessageIdentifier { name: "testException".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = TestExceptionResult { err1: None };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
rift::Error::User(usr_err) => {
if usr_err.downcast_ref::<Xception>().is_some() {
let err = usr_err.downcast::<Xception>().expect("downcast already checked");
let ret_err = TestExceptionResult{ err1: Some(*err) };
let message_ident = TMessageIdentifier { name: "testException".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(ret_err.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
} else {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: usr_err.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testException".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
}
},
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testException".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_test_multi_exception(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let args = try!(TestMultiExceptionArgs::read_from_in_protocol(i_prot));
match self.handler.handle_test_multi_exception(args.arg0, args.arg1) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier { name: "testMultiException".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = TestMultiExceptionResult { result_value: Some(handler_return), err1: None, err2: None };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
rift::Error::User(usr_err) => {
if usr_err.downcast_ref::<Xception>().is_some() {
let err = usr_err.downcast::<Xception>().expect("downcast already checked");
let ret_err = TestMultiExceptionResult{ result_value: None, err1: Some(*err), err2: None };
let message_ident = TMessageIdentifier { name: "testMultiException".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(ret_err.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
} else if usr_err.downcast_ref::<Xception2>().is_some() {
let err = usr_err.downcast::<Xception2>().expect("downcast already checked");
let ret_err = TestMultiExceptionResult{ result_value: None, err1: None, err2: Some(*err) };
let message_ident = TMessageIdentifier { name: "testMultiException".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(ret_err.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
} else {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: usr_err.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testMultiException".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
}
},
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "testMultiException".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_test_oneway(&mut self, _: i32, i_prot: &mut TProtocol, _: &mut TProtocol) -> rift::Result<()> {
let args = try!(TestOnewayArgs::read_from_in_protocol(i_prot));
match self.handler.handle_test_oneway(args.seconds_to_sleep) {
Ok(_) => {
Ok(())
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
Err(rift::Error::Application(ret_err))
},
}
},
}
}
}
impl <H: TAbstractThriftTestSyncHandler> TProcessor for TThriftTestProcessor<H> {
fn process(&mut self, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let message_ident = try!(i_prot.read_message_begin());
match &*message_ident.name {
"testVoid" => {
self.process_test_void(message_ident.sequence_number, i_prot, o_prot)
},
"testString" => {
self.process_test_string(message_ident.sequence_number, i_prot, o_prot)
},
"testBool" => {
self.process_test_bool(message_ident.sequence_number, i_prot, o_prot)
},
"testByte" => {
self.process_test_byte(message_ident.sequence_number, i_prot, o_prot)
},
"testI32" => {
self.process_test_i32(message_ident.sequence_number, i_prot, o_prot)
},
"testI64" => {
self.process_test_i64(message_ident.sequence_number, i_prot, o_prot)
},
"testDouble" => {
self.process_test_double(message_ident.sequence_number, i_prot, o_prot)
},
"testBinary" => {
self.process_test_binary(message_ident.sequence_number, i_prot, o_prot)
},
"testStruct" => {
self.process_test_struct(message_ident.sequence_number, i_prot, o_prot)
},
"testNest" => {
self.process_test_nest(message_ident.sequence_number, i_prot, o_prot)
},
"testMap" => {
self.process_test_map(message_ident.sequence_number, i_prot, o_prot)
},
"testStringMap" => {
self.process_test_string_map(message_ident.sequence_number, i_prot, o_prot)
},
"testSet" => {
self.process_test_set(message_ident.sequence_number, i_prot, o_prot)
},
"testList" => {
self.process_test_list(message_ident.sequence_number, i_prot, o_prot)
},
"testEnum" => {
self.process_test_enum(message_ident.sequence_number, i_prot, o_prot)
},
"testTypedef" => {
self.process_test_typedef(message_ident.sequence_number, i_prot, o_prot)
},
"testMapMap" => {
self.process_test_map_map(message_ident.sequence_number, i_prot, o_prot)
},
"testInsanity" => {
self.process_test_insanity(message_ident.sequence_number, i_prot, o_prot)
},
"testMulti" => {
self.process_test_multi(message_ident.sequence_number, i_prot, o_prot)
},
"testException" => {
self.process_test_exception(message_ident.sequence_number, i_prot, o_prot)
},
"testMultiException" => {
self.process_test_multi_exception(message_ident.sequence_number, i_prot, o_prot)
},
"testOneway" => {
self.process_test_oneway(message_ident.sequence_number, i_prot, o_prot)
},
method => {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::UnknownMethod,
message: format!("unknown method {}", method),
}
)
)
},
}
}
}
//
// TestVoidArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestVoidArgs {
}
impl TestVoidArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestVoidArgs> {
try!(i_prot.read_struct_begin());
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestVoidArgs {};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testVoid_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// TestVoidResult
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestVoidResult {
}
impl TestVoidResult {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestVoidResult> {
try!(i_prot.read_struct_begin());
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestVoidResult {};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "TestVoidResult".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<()> {
Ok(())
}
}
//
// TestStringArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestStringArgs {
thing: String,
}
impl TestStringArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestStringArgs> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<String> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_string());
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("TestStringArgs.thing", &f_1));
let ret = TestStringArgs {
thing: 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 TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testString_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("thing".to_owned()), field_type: TType::String, id: Some(1) }));
try!(o_prot.write_string(&self.thing));
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// TestStringResult
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestStringResult {
result_value: Option<String>,
}
impl TestStringResult {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestStringResult> {
try!(i_prot.read_struct_begin());
let mut f_0: Option<String> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
0 => {
let val = try!(i_prot.read_string());
f_0 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestStringResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "TestStringResult".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.result_value {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("result_value".to_owned()), field_type: TType::String, id: Some(0) }));
try!(o_prot.write_string(&fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<String> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::MissingResult,
message: "no result received for TestString".to_owned(),
}
)
)
}
}
}
//
// TestBoolArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestBoolArgs {
thing: bool,
}
impl TestBoolArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestBoolArgs> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<bool> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_bool());
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("TestBoolArgs.thing", &f_1));
let ret = TestBoolArgs {
thing: 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 TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testBool_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("thing".to_owned()), field_type: TType::Bool, id: Some(1) }));
try!(o_prot.write_bool(self.thing));
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// TestBoolResult
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestBoolResult {
result_value: Option<bool>,
}
impl TestBoolResult {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestBoolResult> {
try!(i_prot.read_struct_begin());
let mut f_0: Option<bool> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
0 => {
let val = try!(i_prot.read_bool());
f_0 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestBoolResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "TestBoolResult".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(fld_var) = self.result_value {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("result_value".to_owned()), field_type: TType::Bool, id: Some(0) }));
try!(o_prot.write_bool(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<bool> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::MissingResult,
message: "no result received for TestBool".to_owned(),
}
)
)
}
}
}
//
// TestByteArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestByteArgs {
thing: i8,
}
impl TestByteArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestByteArgs> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<i8> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_i8());
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("TestByteArgs.thing", &f_1));
let ret = TestByteArgs {
thing: 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 TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testByte_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("thing".to_owned()), field_type: TType::I08, id: Some(1) }));
try!(o_prot.write_i8(self.thing));
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// TestByteResult
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestByteResult {
result_value: Option<i8>,
}
impl TestByteResult {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestByteResult> {
try!(i_prot.read_struct_begin());
let mut f_0: Option<i8> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
0 => {
let val = try!(i_prot.read_i8());
f_0 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestByteResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "TestByteResult".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(fld_var) = self.result_value {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("result_value".to_owned()), field_type: TType::I08, id: Some(0) }));
try!(o_prot.write_i8(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<i8> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::MissingResult,
message: "no result received for TestByte".to_owned(),
}
)
)
}
}
}
//
// TestI32Args
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestI32Args {
thing: i32,
}
impl TestI32Args {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestI32Args> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<i32> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_i32());
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("TestI32Args.thing", &f_1));
let ret = TestI32Args {
thing: 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 TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testI32_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("thing".to_owned()), field_type: TType::I32, id: Some(1) }));
try!(o_prot.write_i32(self.thing));
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// TestI32Result
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestI32Result {
result_value: Option<i32>,
}
impl TestI32Result {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestI32Result> {
try!(i_prot.read_struct_begin());
let mut f_0: Option<i32> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
0 => {
let val = try!(i_prot.read_i32());
f_0 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestI32Result {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "TestI32Result".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(fld_var) = self.result_value {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("result_value".to_owned()), field_type: TType::I32, id: Some(0) }));
try!(o_prot.write_i32(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<i32> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::MissingResult,
message: "no result received for TestI32".to_owned(),
}
)
)
}
}
}
//
// TestI64Args
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestI64Args {
thing: i64,
}
impl TestI64Args {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestI64Args> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<i64> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_i64());
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("TestI64Args.thing", &f_1));
let ret = TestI64Args {
thing: 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 TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testI64_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("thing".to_owned()), field_type: TType::I64, id: Some(1) }));
try!(o_prot.write_i64(self.thing));
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// TestI64Result
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestI64Result {
result_value: Option<i64>,
}
impl TestI64Result {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestI64Result> {
try!(i_prot.read_struct_begin());
let mut f_0: Option<i64> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
0 => {
let val = try!(i_prot.read_i64());
f_0 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestI64Result {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "TestI64Result".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(fld_var) = self.result_value {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("result_value".to_owned()), field_type: TType::I64, id: Some(0) }));
try!(o_prot.write_i64(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<i64> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::MissingResult,
message: "no result received for TestI64".to_owned(),
}
)
)
}
}
}
//
// TestDoubleArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestDoubleArgs {
thing: OrderedFloat<f64>,
}
impl TestDoubleArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestDoubleArgs> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<OrderedFloat<f64>> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = OrderedFloat::from(try!(i_prot.read_double()));
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("TestDoubleArgs.thing", &f_1));
let ret = TestDoubleArgs {
thing: 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 TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testDouble_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("thing".to_owned()), field_type: TType::Double, id: Some(1) }));
try!(o_prot.write_double(self.thing.into()));
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// TestDoubleResult
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestDoubleResult {
result_value: Option<OrderedFloat<f64>>,
}
impl TestDoubleResult {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestDoubleResult> {
try!(i_prot.read_struct_begin());
let mut f_0: Option<OrderedFloat<f64>> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
0 => {
let val = OrderedFloat::from(try!(i_prot.read_double()));
f_0 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestDoubleResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "TestDoubleResult".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(fld_var) = self.result_value {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("result_value".to_owned()), field_type: TType::Double, id: Some(0) }));
try!(o_prot.write_double(fld_var.into()));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<OrderedFloat<f64>> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::MissingResult,
message: "no result received for TestDouble".to_owned(),
}
)
)
}
}
}
//
// TestBinaryArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestBinaryArgs {
thing: Vec<u8>,
}
impl TestBinaryArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestBinaryArgs> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<Vec<u8>> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_bytes());
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("TestBinaryArgs.thing", &f_1));
let ret = TestBinaryArgs {
thing: 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 TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testBinary_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("thing".to_owned()), field_type: TType::String, id: Some(1) }));
try!(o_prot.write_bytes(&self.thing));
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// TestBinaryResult
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestBinaryResult {
result_value: Option<Vec<u8>>,
}
impl TestBinaryResult {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestBinaryResult> {
try!(i_prot.read_struct_begin());
let mut f_0: Option<Vec<u8>> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
0 => {
let val = try!(i_prot.read_bytes());
f_0 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestBinaryResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "TestBinaryResult".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.result_value {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("result_value".to_owned()), field_type: TType::String, id: Some(0) }));
try!(o_prot.write_bytes(&fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<Vec<u8>> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::MissingResult,
message: "no result received for TestBinary".to_owned(),
}
)
)
}
}
}
//
// TestStructArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestStructArgs {
thing: Xtruct,
}
impl TestStructArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestStructArgs> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<Xtruct> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(Xtruct::read_from_in_protocol(i_prot));
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("TestStructArgs.thing", &f_1));
let ret = TestStructArgs {
thing: 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 TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testStruct_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("thing".to_owned()), field_type: TType::Struct, id: Some(1) }));
try!(self.thing.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// TestStructResult
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestStructResult {
result_value: Option<Xtruct>,
}
impl TestStructResult {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestStructResult> {
try!(i_prot.read_struct_begin());
let mut f_0: Option<Xtruct> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
0 => {
let val = try!(Xtruct::read_from_in_protocol(i_prot));
f_0 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestStructResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "TestStructResult".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.result_value {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("result_value".to_owned()), field_type: TType::Struct, id: Some(0) }));
try!(fld_var.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<Xtruct> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::MissingResult,
message: "no result received for TestStruct".to_owned(),
}
)
)
}
}
}
//
// TestNestArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestNestArgs {
thing: Xtruct2,
}
impl TestNestArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestNestArgs> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<Xtruct2> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(Xtruct2::read_from_in_protocol(i_prot));
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("TestNestArgs.thing", &f_1));
let ret = TestNestArgs {
thing: 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 TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testNest_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("thing".to_owned()), field_type: TType::Struct, id: Some(1) }));
try!(self.thing.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// TestNestResult
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestNestResult {
result_value: Option<Xtruct2>,
}
impl TestNestResult {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestNestResult> {
try!(i_prot.read_struct_begin());
let mut f_0: Option<Xtruct2> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
0 => {
let val = try!(Xtruct2::read_from_in_protocol(i_prot));
f_0 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestNestResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "TestNestResult".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.result_value {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("result_value".to_owned()), field_type: TType::Struct, id: Some(0) }));
try!(fld_var.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<Xtruct2> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::MissingResult,
message: "no result received for TestNest".to_owned(),
}
)
)
}
}
}
//
// TestMapArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestMapArgs {
thing: BTreeMap<i32, i32>,
}
impl TestMapArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestMapArgs> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<BTreeMap<i32, i32>> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let map_ident = try!(i_prot.read_map_begin());
let mut val: BTreeMap<i32, i32> = BTreeMap::new();
for _ in 0..map_ident.size {
let map_key_44 = try!(i_prot.read_i32());
let map_val_45 = try!(i_prot.read_i32());
val.insert(map_key_44, map_val_45);
}
try!(i_prot.read_map_end());
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("TestMapArgs.thing", &f_1));
let ret = TestMapArgs {
thing: 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 TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testMap_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("thing".to_owned()), field_type: TType::Map, id: Some(1) }));
try!(o_prot.write_map_begin(&TMapIdentifier { key_type: TType::I32, value_type: TType::I32, size: self.thing.len() as i32 }));
for (k, v) in self.thing.iter() {
try!(o_prot.write_i32(*k));
try!(o_prot.write_i32(*v));
try!(o_prot.write_map_end());
}
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// TestMapResult
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestMapResult {
result_value: Option<BTreeMap<i32, i32>>,
}
impl TestMapResult {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestMapResult> {
try!(i_prot.read_struct_begin());
let mut f_0: Option<BTreeMap<i32, i32>> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
0 => {
let map_ident = try!(i_prot.read_map_begin());
let mut val: BTreeMap<i32, i32> = BTreeMap::new();
for _ in 0..map_ident.size {
let map_key_46 = try!(i_prot.read_i32());
let map_val_47 = try!(i_prot.read_i32());
val.insert(map_key_46, map_val_47);
}
try!(i_prot.read_map_end());
f_0 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestMapResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "TestMapResult".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.result_value {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("result_value".to_owned()), field_type: TType::Map, id: Some(0) }));
try!(o_prot.write_map_begin(&TMapIdentifier { key_type: TType::I32, value_type: TType::I32, size: fld_var.len() as i32 }));
for (k, v) in fld_var.iter() {
try!(o_prot.write_i32(*k));
try!(o_prot.write_i32(*v));
try!(o_prot.write_map_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<BTreeMap<i32, i32>> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::MissingResult,
message: "no result received for TestMap".to_owned(),
}
)
)
}
}
}
//
// TestStringMapArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestStringMapArgs {
thing: BTreeMap<String, String>,
}
impl TestStringMapArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestStringMapArgs> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<BTreeMap<String, String>> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let map_ident = try!(i_prot.read_map_begin());
let mut val: BTreeMap<String, String> = BTreeMap::new();
for _ in 0..map_ident.size {
let map_key_48 = try!(i_prot.read_string());
let map_val_49 = try!(i_prot.read_string());
val.insert(map_key_48, map_val_49);
}
try!(i_prot.read_map_end());
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("TestStringMapArgs.thing", &f_1));
let ret = TestStringMapArgs {
thing: 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 TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testStringMap_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("thing".to_owned()), field_type: TType::Map, id: Some(1) }));
try!(o_prot.write_map_begin(&TMapIdentifier { key_type: TType::String, value_type: TType::String, size: self.thing.len() as i32 }));
for (k, v) in self.thing.iter() {
try!(o_prot.write_string(&k));
try!(o_prot.write_string(&v));
try!(o_prot.write_map_end());
}
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// TestStringMapResult
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestStringMapResult {
result_value: Option<BTreeMap<String, String>>,
}
impl TestStringMapResult {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestStringMapResult> {
try!(i_prot.read_struct_begin());
let mut f_0: Option<BTreeMap<String, String>> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
0 => {
let map_ident = try!(i_prot.read_map_begin());
let mut val: BTreeMap<String, String> = BTreeMap::new();
for _ in 0..map_ident.size {
let map_key_50 = try!(i_prot.read_string());
let map_val_51 = try!(i_prot.read_string());
val.insert(map_key_50, map_val_51);
}
try!(i_prot.read_map_end());
f_0 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestStringMapResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "TestStringMapResult".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.result_value {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("result_value".to_owned()), field_type: TType::Map, id: Some(0) }));
try!(o_prot.write_map_begin(&TMapIdentifier { key_type: TType::String, value_type: TType::String, size: fld_var.len() as i32 }));
for (k, v) in fld_var.iter() {
try!(o_prot.write_string(&k));
try!(o_prot.write_string(&v));
try!(o_prot.write_map_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<BTreeMap<String, String>> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::MissingResult,
message: "no result received for TestStringMap".to_owned(),
}
)
)
}
}
}
//
// TestSetArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestSetArgs {
thing: BTreeSet<i32>,
}
impl TestSetArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestSetArgs> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<BTreeSet<i32>> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let set_ident = try!(i_prot.read_set_begin());
let mut val: BTreeSet<i32> = BTreeSet::new();
for _ in 0..set_ident.size {
let set_elem_52 = try!(i_prot.read_i32());
val.insert(set_elem_52);
}
try!(i_prot.read_set_end());
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("TestSetArgs.thing", &f_1));
let ret = TestSetArgs {
thing: 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 TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testSet_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("thing".to_owned()), field_type: TType::Set, id: Some(1) }));
try!(o_prot.write_set_begin(&TSetIdentifier { element_type: TType::I32, size: self.thing.len() as i32 }));
for e in self.thing.iter() {
try!(o_prot.write_i32(*e));
try!(o_prot.write_set_end());
}
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// TestSetResult
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestSetResult {
result_value: Option<BTreeSet<i32>>,
}
impl TestSetResult {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestSetResult> {
try!(i_prot.read_struct_begin());
let mut f_0: Option<BTreeSet<i32>> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
0 => {
let set_ident = try!(i_prot.read_set_begin());
let mut val: BTreeSet<i32> = BTreeSet::new();
for _ in 0..set_ident.size {
let set_elem_53 = try!(i_prot.read_i32());
val.insert(set_elem_53);
}
try!(i_prot.read_set_end());
f_0 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestSetResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "TestSetResult".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.result_value {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("result_value".to_owned()), field_type: TType::Set, id: Some(0) }));
try!(o_prot.write_set_begin(&TSetIdentifier { element_type: TType::I32, size: fld_var.len() as i32 }));
for e in fld_var.iter() {
try!(o_prot.write_i32(*e));
try!(o_prot.write_set_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<BTreeSet<i32>> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::MissingResult,
message: "no result received for TestSet".to_owned(),
}
)
)
}
}
}
//
// TestListArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestListArgs {
thing: Vec<i32>,
}
impl TestListArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestListArgs> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<Vec<i32>> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let list_ident = try!(i_prot.read_list_begin());
let mut val: Vec<i32> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_54 = try!(i_prot.read_i32());
val.push(list_elem_54);
}
try!(i_prot.read_list_end());
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("TestListArgs.thing", &f_1));
let ret = TestListArgs {
thing: 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 TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testList_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("thing".to_owned()), field_type: TType::List, id: Some(1) }));
try!(o_prot.write_list_begin(&TListIdentifier { element_type: TType::I32, size: self.thing.len() as i32 }));
for e in self.thing.iter() {
try!(o_prot.write_i32(*e));
try!(o_prot.write_list_end());
}
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// TestListResult
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestListResult {
result_value: Option<Vec<i32>>,
}
impl TestListResult {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestListResult> {
try!(i_prot.read_struct_begin());
let mut f_0: Option<Vec<i32>> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
0 => {
let list_ident = try!(i_prot.read_list_begin());
let mut val: Vec<i32> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_55 = try!(i_prot.read_i32());
val.push(list_elem_55);
}
try!(i_prot.read_list_end());
f_0 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestListResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "TestListResult".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.result_value {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("result_value".to_owned()), field_type: TType::List, id: Some(0) }));
try!(o_prot.write_list_begin(&TListIdentifier { element_type: TType::I32, size: fld_var.len() as i32 }));
for e in fld_var.iter() {
try!(o_prot.write_i32(*e));
try!(o_prot.write_list_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<Vec<i32>> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::MissingResult,
message: "no result received for TestList".to_owned(),
}
)
)
}
}
}
//
// TestEnumArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestEnumArgs {
thing: Numberz,
}
impl TestEnumArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestEnumArgs> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<Numberz> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(Numberz::read_from_in_protocol(i_prot));
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("TestEnumArgs.thing", &f_1));
let ret = TestEnumArgs {
thing: 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 TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testEnum_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("thing".to_owned()), field_type: TType::I32, id: Some(1) }));
try!(self.thing.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// TestEnumResult
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestEnumResult {
result_value: Option<Numberz>,
}
impl TestEnumResult {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestEnumResult> {
try!(i_prot.read_struct_begin());
let mut f_0: Option<Numberz> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
0 => {
let val = try!(Numberz::read_from_in_protocol(i_prot));
f_0 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestEnumResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "TestEnumResult".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.result_value {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("result_value".to_owned()), field_type: TType::I32, id: Some(0) }));
try!(fld_var.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<Numberz> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::MissingResult,
message: "no result received for TestEnum".to_owned(),
}
)
)
}
}
}
//
// TestTypedefArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestTypedefArgs {
thing: UserId,
}
impl TestTypedefArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestTypedefArgs> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<UserId> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_i64());
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("TestTypedefArgs.thing", &f_1));
let ret = TestTypedefArgs {
thing: 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 TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testTypedef_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("thing".to_owned()), field_type: TType::I64, id: Some(1) }));
try!(o_prot.write_i64(self.thing));
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// TestTypedefResult
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestTypedefResult {
result_value: Option<UserId>,
}
impl TestTypedefResult {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestTypedefResult> {
try!(i_prot.read_struct_begin());
let mut f_0: Option<UserId> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
0 => {
let val = try!(i_prot.read_i64());
f_0 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestTypedefResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "TestTypedefResult".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(fld_var) = self.result_value {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("result_value".to_owned()), field_type: TType::I64, id: Some(0) }));
try!(o_prot.write_i64(fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<UserId> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::MissingResult,
message: "no result received for TestTypedef".to_owned(),
}
)
)
}
}
}
//
// TestMapMapArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestMapMapArgs {
hello: i32,
}
impl TestMapMapArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestMapMapArgs> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<i32> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_i32());
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("TestMapMapArgs.hello", &f_1));
let ret = TestMapMapArgs {
hello: 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 TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testMapMap_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("hello".to_owned()), field_type: TType::I32, id: Some(1) }));
try!(o_prot.write_i32(self.hello));
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// TestMapMapResult
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestMapMapResult {
result_value: Option<BTreeMap<i32, BTreeMap<i32, i32>>>,
}
impl TestMapMapResult {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestMapMapResult> {
try!(i_prot.read_struct_begin());
let mut f_0: Option<BTreeMap<i32, BTreeMap<i32, i32>>> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
0 => {
let map_ident = try!(i_prot.read_map_begin());
let mut val: BTreeMap<i32, BTreeMap<i32, i32>> = BTreeMap::new();
for _ in 0..map_ident.size {
let map_key_56 = try!(i_prot.read_i32());
let map_ident = try!(i_prot.read_map_begin());
let mut map_val_57: BTreeMap<i32, i32> = BTreeMap::new();
for _ in 0..map_ident.size {
let map_key_58 = try!(i_prot.read_i32());
let map_val_59 = try!(i_prot.read_i32());
map_val_57.insert(map_key_58, map_val_59);
}
try!(i_prot.read_map_end());
val.insert(map_key_56, map_val_57);
}
try!(i_prot.read_map_end());
f_0 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestMapMapResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "TestMapMapResult".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.result_value {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("result_value".to_owned()), field_type: TType::Map, id: Some(0) }));
try!(o_prot.write_map_begin(&TMapIdentifier { key_type: TType::I32, value_type: TType::Map, size: fld_var.len() as i32 }));
for (k, v) in fld_var.iter() {
try!(o_prot.write_i32(*k));
try!(o_prot.write_map_begin(&TMapIdentifier { key_type: TType::I32, value_type: TType::I32, size: v.len() as i32 }));
for (k, v) in v.iter() {
try!(o_prot.write_i32(*k));
try!(o_prot.write_i32(*v));
try!(o_prot.write_map_end());
}
try!(o_prot.write_map_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<BTreeMap<i32, BTreeMap<i32, i32>>> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::MissingResult,
message: "no result received for TestMapMap".to_owned(),
}
)
)
}
}
}
//
// TestInsanityArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestInsanityArgs {
argument: Insanity,
}
impl TestInsanityArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestInsanityArgs> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<Insanity> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(Insanity::read_from_in_protocol(i_prot));
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("TestInsanityArgs.argument", &f_1));
let ret = TestInsanityArgs {
argument: 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 TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testInsanity_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("argument".to_owned()), field_type: TType::Struct, id: Some(1) }));
try!(self.argument.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// TestInsanityResult
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestInsanityResult {
result_value: Option<BTreeMap<UserId, BTreeMap<Numberz, Insanity>>>,
}
impl TestInsanityResult {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestInsanityResult> {
try!(i_prot.read_struct_begin());
let mut f_0: Option<BTreeMap<UserId, BTreeMap<Numberz, Insanity>>> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
0 => {
let map_ident = try!(i_prot.read_map_begin());
let mut val: BTreeMap<UserId, BTreeMap<Numberz, Insanity>> = BTreeMap::new();
for _ in 0..map_ident.size {
let map_key_60 = try!(i_prot.read_i64());
let map_ident = try!(i_prot.read_map_begin());
let mut map_val_61: BTreeMap<Numberz, Insanity> = BTreeMap::new();
for _ in 0..map_ident.size {
let map_key_62 = try!(Numberz::read_from_in_protocol(i_prot));
let map_val_63 = try!(Insanity::read_from_in_protocol(i_prot));
map_val_61.insert(map_key_62, map_val_63);
}
try!(i_prot.read_map_end());
val.insert(map_key_60, map_val_61);
}
try!(i_prot.read_map_end());
f_0 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestInsanityResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "TestInsanityResult".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.result_value {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("result_value".to_owned()), field_type: TType::Map, id: Some(0) }));
try!(o_prot.write_map_begin(&TMapIdentifier { key_type: TType::I64, value_type: TType::Map, size: fld_var.len() as i32 }));
for (k, v) in fld_var.iter() {
try!(o_prot.write_i64(*k));
try!(o_prot.write_map_begin(&TMapIdentifier { key_type: TType::I32, value_type: TType::Struct, size: v.len() as i32 }));
for (k, v) in v.iter() {
try!(k.write_to_out_protocol(o_prot));
try!(v.write_to_out_protocol(o_prot));
try!(o_prot.write_map_end());
}
try!(o_prot.write_map_end());
}
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<BTreeMap<UserId, BTreeMap<Numberz, Insanity>>> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::MissingResult,
message: "no result received for TestInsanity".to_owned(),
}
)
)
}
}
}
//
// TestMultiArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestMultiArgs {
arg0: i8,
arg1: i32,
arg2: i64,
arg3: BTreeMap<i16, String>,
arg4: Numberz,
arg5: UserId,
}
impl TestMultiArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestMultiArgs> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<i8> = None;
let mut f_2: Option<i32> = None;
let mut f_3: Option<i64> = None;
let mut f_4: Option<BTreeMap<i16, String>> = None;
let mut f_5: Option<Numberz> = None;
let mut f_6: Option<UserId> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_i8());
f_1 = Some(val);
},
2 => {
let val = try!(i_prot.read_i32());
f_2 = Some(val);
},
3 => {
let val = try!(i_prot.read_i64());
f_3 = Some(val);
},
4 => {
let map_ident = try!(i_prot.read_map_begin());
let mut val: BTreeMap<i16, String> = BTreeMap::new();
for _ in 0..map_ident.size {
let map_key_64 = try!(i_prot.read_i16());
let map_val_65 = try!(i_prot.read_string());
val.insert(map_key_64, map_val_65);
}
try!(i_prot.read_map_end());
f_4 = Some(val);
},
5 => {
let val = try!(Numberz::read_from_in_protocol(i_prot));
f_5 = Some(val);
},
6 => {
let val = try!(i_prot.read_i64());
f_6 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("TestMultiArgs.arg0", &f_1));
try!(verify_required_field_exists("TestMultiArgs.arg1", &f_2));
try!(verify_required_field_exists("TestMultiArgs.arg2", &f_3));
try!(verify_required_field_exists("TestMultiArgs.arg3", &f_4));
try!(verify_required_field_exists("TestMultiArgs.arg4", &f_5));
try!(verify_required_field_exists("TestMultiArgs.arg5", &f_6));
let ret = TestMultiArgs {
arg0: f_1.expect("auto-generated code should have checked for presence of required fields"),
arg1: f_2.expect("auto-generated code should have checked for presence of required fields"),
arg2: f_3.expect("auto-generated code should have checked for presence of required fields"),
arg3: f_4.expect("auto-generated code should have checked for presence of required fields"),
arg4: f_5.expect("auto-generated code should have checked for presence of required fields"),
arg5: f_6.expect("auto-generated code should have checked for presence of required fields"),
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testMulti_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("arg0".to_owned()), field_type: TType::I08, id: Some(1) }));
try!(o_prot.write_i8(self.arg0));
try!(o_prot.write_field_end());
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("arg1".to_owned()), field_type: TType::I32, id: Some(2) }));
try!(o_prot.write_i32(self.arg1));
try!(o_prot.write_field_end());
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("arg2".to_owned()), field_type: TType::I64, id: Some(3) }));
try!(o_prot.write_i64(self.arg2));
try!(o_prot.write_field_end());
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("arg3".to_owned()), field_type: TType::Map, id: Some(4) }));
try!(o_prot.write_map_begin(&TMapIdentifier { key_type: TType::I16, value_type: TType::String, size: self.arg3.len() as i32 }));
for (k, v) in self.arg3.iter() {
try!(o_prot.write_i16(*k));
try!(o_prot.write_string(&v));
try!(o_prot.write_map_end());
}
try!(o_prot.write_field_end());
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("arg4".to_owned()), field_type: TType::I32, id: Some(5) }));
try!(self.arg4.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("arg5".to_owned()), field_type: TType::I64, id: Some(6) }));
try!(o_prot.write_i64(self.arg5));
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// TestMultiResult
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestMultiResult {
result_value: Option<Xtruct>,
}
impl TestMultiResult {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestMultiResult> {
try!(i_prot.read_struct_begin());
let mut f_0: Option<Xtruct> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
0 => {
let val = try!(Xtruct::read_from_in_protocol(i_prot));
f_0 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestMultiResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "TestMultiResult".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.result_value {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("result_value".to_owned()), field_type: TType::Struct, id: Some(0) }));
try!(fld_var.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<Xtruct> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::MissingResult,
message: "no result received for TestMulti".to_owned(),
}
)
)
}
}
}
//
// TestExceptionArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestExceptionArgs {
arg: String,
}
impl TestExceptionArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestExceptionArgs> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<String> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_string());
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("TestExceptionArgs.arg", &f_1));
let ret = TestExceptionArgs {
arg: 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 TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testException_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("arg".to_owned()), field_type: TType::String, id: Some(1) }));
try!(o_prot.write_string(&self.arg));
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// TestExceptionResult
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestExceptionResult {
err1: Option<Xception>,
}
impl TestExceptionResult {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestExceptionResult> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<Xception> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(Xception::read_from_in_protocol(i_prot));
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestExceptionResult {
err1: f_1,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "TestExceptionResult".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.err1 {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("err1".to_owned()), field_type: TType::Struct, id: Some(1) }));
try!(fld_var.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<()> {
if self.err1.is_some() {
Err(rift::Error::User(Box::new(self.err1.unwrap())))
} else {
Ok(())
}
}
}
//
// TestMultiExceptionArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestMultiExceptionArgs {
arg0: String,
arg1: String,
}
impl TestMultiExceptionArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestMultiExceptionArgs> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<String> = None;
let mut f_2: Option<String> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_string());
f_1 = Some(val);
},
2 => {
let val = try!(i_prot.read_string());
f_2 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("TestMultiExceptionArgs.arg0", &f_1));
try!(verify_required_field_exists("TestMultiExceptionArgs.arg1", &f_2));
let ret = TestMultiExceptionArgs {
arg0: f_1.expect("auto-generated code should have checked for presence of required fields"),
arg1: 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 TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testMultiException_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("arg0".to_owned()), field_type: TType::String, id: Some(1) }));
try!(o_prot.write_string(&self.arg0));
try!(o_prot.write_field_end());
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("arg1".to_owned()), field_type: TType::String, id: Some(2) }));
try!(o_prot.write_string(&self.arg1));
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// TestMultiExceptionResult
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestMultiExceptionResult {
result_value: Option<Xtruct>,
err1: Option<Xception>,
err2: Option<Xception2>,
}
impl TestMultiExceptionResult {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestMultiExceptionResult> {
try!(i_prot.read_struct_begin());
let mut f_0: Option<Xtruct> = None;
let mut f_1: Option<Xception> = None;
let mut f_2: Option<Xception2> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
0 => {
let val = try!(Xtruct::read_from_in_protocol(i_prot));
f_0 = Some(val);
},
1 => {
let val = try!(Xception::read_from_in_protocol(i_prot));
f_1 = Some(val);
},
2 => {
let val = try!(Xception2::read_from_in_protocol(i_prot));
f_2 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = TestMultiExceptionResult {
result_value: f_0,
err1: f_1,
err2: f_2,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "TestMultiExceptionResult".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.result_value {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("result_value".to_owned()), field_type: TType::Struct, id: Some(0) }));
try!(fld_var.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.err1 {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("err1".to_owned()), field_type: TType::Struct, id: Some(1) }));
try!(fld_var.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
()
} else {
()
}
if let Some(ref fld_var) = self.err2 {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("err2".to_owned()), field_type: TType::Struct, id: Some(2) }));
try!(fld_var.write_to_out_protocol(o_prot));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<Xtruct> {
if self.err1.is_some() {
Err(rift::Error::User(Box::new(self.err1.unwrap())))
} else if self.err2.is_some() {
Err(rift::Error::User(Box::new(self.err2.unwrap())))
} else if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::MissingResult,
message: "no result received for TestMultiException".to_owned(),
}
)
)
}
}
}
//
// TestOnewayArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct TestOnewayArgs {
seconds_to_sleep: i32,
}
impl TestOnewayArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<TestOnewayArgs> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<i32> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_i32());
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("TestOnewayArgs.seconds_to_sleep", &f_1));
let ret = TestOnewayArgs {
seconds_to_sleep: 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 TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "testOneway_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("secondsToSleep".to_owned()), field_type: TType::I32, id: Some(1) }));
try!(o_prot.write_i32(self.seconds_to_sleep));
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// SecondService service client
//
pub trait TAbstractSecondServiceSyncClient {
fn blah_blah(&mut self) -> rift::Result<()>;
fn secondtest_string(&mut self, thing: String) -> rift::Result<String>;
}
pub struct TSecondServiceSyncClient {
i_prot: Rc<RefCell<Box<TProtocol>>>,
o_prot: Rc<RefCell<Box<TProtocol>>>,
sequence_number: i32,
}
impl TSecondServiceSyncClient {
pub fn new(protocol: Box<TProtocol>) -> TSecondServiceSyncClient {
let p = Rc::new(RefCell::new(protocol));
TSecondServiceSyncClient { i_prot: p.clone(), o_prot: p.clone(), sequence_number: 0 }
}
pub fn with_separate_protocols(input_protocol: Box<TProtocol>, output_protocol: Box<TProtocol>) -> TSecondServiceSyncClient {
TSecondServiceSyncClient { i_prot: Rc::new(RefCell::new(input_protocol)), o_prot: Rc::new(RefCell::new(output_protocol)), sequence_number: 0 }
}
fn send_blah_blah(&mut self) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"blahBlah".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = BlahBlahArgs { };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_blah_blah(&mut self) -> rift::Result<()> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("blahBlah", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(BlahBlahResult::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
fn send_secondtest_string(&mut self, thing: String) -> rift::Result<()> {
self.sequence_number = self.sequence_number + 1;
let message_ident = TMessageIdentifier { name:"secondtestString".to_owned(), message_type: TMessageType::Call, sequence_number: self.sequence_number };
let call_args = SecondtestStringArgs { thing: thing };
try!(self.o_prot.borrow_mut().write_message_begin(&message_ident));
try!(call_args.write_to_out_protocol(&mut **self.o_prot.borrow_mut()));
try!(self.o_prot.borrow_mut().write_message_end());
self.o_prot.borrow_mut().flush()
}
fn recv_secondtest_string(&mut self) -> rift::Result<String> {
let message_ident = try!(self.i_prot.borrow_mut().read_message_begin());
try!(verify_expected_sequence_number(self.sequence_number, message_ident.sequence_number));
try!(verify_expected_service_call("secondtestString", &message_ident.name));
if message_ident.message_type == TMessageType::Exception {
let remote_error = try!(rift::Error::read_application_error_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
return Err(rift::Error::Application(remote_error))
}
try!(verify_expected_message_type(TMessageType::Reply, message_ident.message_type));
let result = try!(SecondtestStringResult::read_from_in_protocol(&mut **self.i_prot.borrow_mut()));
try!(self.i_prot.borrow_mut().read_message_end());
result.ok_or()
}
}
impl TAbstractSecondServiceSyncClient for TSecondServiceSyncClient {
fn blah_blah(&mut self) -> rift::Result<()> {
try!(self.send_blah_blah());
self.recv_blah_blah()
}
fn secondtest_string(&mut self, thing: String) -> rift::Result<String> {
try!(self.send_secondtest_string(thing));
self.recv_secondtest_string()
}
}
//
// SecondService service server
//
pub trait TAbstractSecondServiceSyncHandler {
fn handle_blah_blah(&mut self) -> rift::Result<()>;
fn handle_secondtest_string(&mut self, thing: String) -> rift::Result<String>;
}
pub struct TSecondServiceProcessor<H: TAbstractSecondServiceSyncHandler> {
handler: H,
}
impl <H: TAbstractSecondServiceSyncHandler> TSecondServiceProcessor<H> {
pub fn new(handler: H) -> TSecondServiceProcessor<H> {
TSecondServiceProcessor { handler: handler }
}
fn process_blah_blah(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let _ = try!(BlahBlahArgs::read_from_in_protocol(i_prot));
match self.handler.handle_blah_blah() {
Ok(_) => {
let message_ident = TMessageIdentifier { name: "blahBlah".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = BlahBlahResult { };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "blahBlah".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
fn process_secondtest_string(&mut self, incoming_sequence_number: i32, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let args = try!(SecondtestStringArgs::read_from_in_protocol(i_prot));
match self.handler.handle_secondtest_string(args.thing) {
Ok(handler_return) => {
let message_ident = TMessageIdentifier { name: "secondtestString".to_owned(), message_type: TMessageType::Reply, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
let ret = SecondtestStringResult { result_value: Some(handler_return) };
try!(ret.write_to_out_protocol(o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
Err(e) => {
match e {
_ => {
let ret_err = {
ApplicationError {
kind: ApplicationErrorKind::Unknown,
message: e.description().to_owned(),
}
};
let message_ident = TMessageIdentifier { name: "secondtestString".to_owned(), message_type: TMessageType::Exception, sequence_number: incoming_sequence_number };
try!(o_prot.write_message_begin(&message_ident));
try!(rift::Error::write_application_error_to_out_protocol(&ret_err, o_prot));
try!(o_prot.write_message_end());
o_prot.flush()
},
}
},
}
}
}
impl <H: TAbstractSecondServiceSyncHandler> TProcessor for TSecondServiceProcessor<H> {
fn process(&mut self, i_prot: &mut TProtocol, o_prot: &mut TProtocol) -> rift::Result<()> {
let message_ident = try!(i_prot.read_message_begin());
match &*message_ident.name {
"blahBlah" => {
self.process_blah_blah(message_ident.sequence_number, i_prot, o_prot)
},
"secondtestString" => {
self.process_secondtest_string(message_ident.sequence_number, i_prot, o_prot)
},
method => {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::UnknownMethod,
message: format!("unknown method {}", method),
}
)
)
},
}
}
}
//
// BlahBlahArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct BlahBlahArgs {
}
impl BlahBlahArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<BlahBlahArgs> {
try!(i_prot.read_struct_begin());
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = BlahBlahArgs {};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "blahBlah_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// BlahBlahResult
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct BlahBlahResult {
}
impl BlahBlahResult {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<BlahBlahResult> {
try!(i_prot.read_struct_begin());
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = BlahBlahResult {};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "BlahBlahResult".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<()> {
Ok(())
}
}
//
// SecondtestStringArgs
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct SecondtestStringArgs {
thing: String,
}
impl SecondtestStringArgs {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<SecondtestStringArgs> {
try!(i_prot.read_struct_begin());
let mut f_1: Option<String> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
1 => {
let val = try!(i_prot.read_string());
f_1 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
try!(verify_required_field_exists("SecondtestStringArgs.thing", &f_1));
let ret = SecondtestStringArgs {
thing: 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 TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "secondtestString_args".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("thing".to_owned()), field_type: TType::String, id: Some(1) }));
try!(o_prot.write_string(&self.thing));
try!(o_prot.write_field_end());
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
}
//
// SecondtestStringResult
//
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct SecondtestStringResult {
result_value: Option<String>,
}
impl SecondtestStringResult {
fn read_from_in_protocol(i_prot: &mut TProtocol) -> rift::Result<SecondtestStringResult> {
try!(i_prot.read_struct_begin());
let mut f_0: Option<String> = None;
loop {
let field_ident = try!(i_prot.read_field_begin());
if field_ident.field_type == TType::Stop {
break;
}
let field_id = try!(field_id(&field_ident));
match field_id {
0 => {
let val = try!(i_prot.read_string());
f_0 = Some(val);
},
_ => {
try!(i_prot.skip(field_ident.field_type));
},
};
try!(i_prot.read_field_end());
}
try!(i_prot.read_struct_end());
let ret = SecondtestStringResult {
result_value: f_0,
};
Ok(ret)
}
fn write_to_out_protocol(&self, o_prot: &mut TProtocol) -> rift::Result<()> {
let struct_ident = TStructIdentifier { name: "SecondtestStringResult".to_owned() };
try!(o_prot.write_struct_begin(&struct_ident));
if let Some(ref fld_var) = self.result_value {
try!(o_prot.write_field_begin(&TFieldIdentifier {name: Some("result_value".to_owned()), field_type: TType::String, id: Some(0) }));
try!(o_prot.write_string(&fld_var));
try!(o_prot.write_field_end());
()
} else {
()
}
try!(o_prot.write_field_stop());
o_prot.write_struct_end()
}
fn ok_or(self) -> rift::Result<String> {
if self.result_value.is_some() {
Ok(self.result_value.unwrap())
} else {
Err(
rift::Error::Application(
ApplicationError {
kind: ApplicationErrorKind::MissingResult,
message: "no result received for SecondtestString".to_owned(),
}
)
)
}
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment