#![allow(unused_imports)]
#![allow(unused_extern_crates)]
#![cfg_attr(feature = "cargo-clippy", allow(too_many_arguments, type_complexity))]
#![cfg_attr(rustfmt, rustfmt_skip)]
extern crate ordered_float;
extern crate thrift;
extern crate try_from;
use ordered_float::OrderedFloat;
use std::cell::RefCell;
use std::collections::{BTreeMap, BTreeSet};
use std::convert::From;
use std::default::Default;
use std::error::Error;
use std::fmt;
use std::fmt::{Display, Formatter};
use std::rc::Rc;
use try_from::TryFrom;
use thrift::{ApplicationError, ApplicationErrorKind, ProtocolError, ProtocolErrorKind, TThriftClient};
use thrift::protocol::{TFieldIdentifier, TListIdentifier, TMapIdentifier, TMessageIdentifier, TMessageType, TInputProtocol, TOutputProtocol, TSetIdentifier, TStructIdentifier, TType};
use thrift::protocol::field_id;
use thrift::protocol::verify_expected_message_type;
use thrift::protocol::verify_expected_sequence_number;
use thrift::protocol::verify_expected_service_call;
use thrift::protocol::verify_required_field_exists;
use thrift::server::TProcessor;
use common_type_s_d_k_data_types;
#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum UserGender {
Unknown = 0,
Male = 1,
Female = 2,
}
impl UserGender {
pub fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
o_prot.write_i32(*self as i32)
}
pub fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<UserGender> {
let enum_value = i_prot.read_i32()?;
UserGender::try_from(enum_value) }
}
impl TryFrom<i32> for UserGender {
type Err = thrift::Error; fn try_from(i: i32) -> Result<Self, Self::Err> {
match i {
0 => Ok(UserGender::Unknown),
1 => Ok(UserGender::Male),
2 => Ok(UserGender::Female),
_ => {
Err(
thrift::Error::Protocol(
ProtocolError::new(
ProtocolErrorKind::InvalidData,
format!("cannot convert enum constant {} to UserGender", i)
)
)
)
},
}
}
}
pub type JSON = String;
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TriggerKeys {
pub device_type: Option<i8>,
pub key: Option<i32>,
pub new_value: Option<i8>,
pub old_value: Option<i8>,
}
impl TriggerKeys {
pub fn new<F1, F2, F3, F4>(device_type: F1, key: F2, new_value: F3, old_value: F4) -> TriggerKeys where F1: Into<Option<i8>>, F2: Into<Option<i32>>, F3: Into<Option<i8>>, F4: Into<Option<i8>> {
TriggerKeys {
device_type: device_type.into(),
key: key.into(),
new_value: new_value.into(),
old_value: old_value.into(),
}
}
pub fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<TriggerKeys> {
i_prot.read_struct_begin()?;
let mut f_1: Option<i8> = Some(0);
let mut f_2: Option<i32> = Some(0);
let mut f_3: Option<i8> = Some(0);
let mut f_4: Option<i8> = Some(0);
loop {
let field_ident = i_prot.read_field_begin()?;
if field_ident.field_type == TType::Stop {
break;
}
let field_id = field_id(&field_ident)?;
match field_id {
1 => {
let val = i_prot.read_i8()?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_i32()?;
f_2 = Some(val);
},
3 => {
let val = i_prot.read_i8()?;
f_3 = Some(val);
},
4 => {
let val = i_prot.read_i8()?;
f_4 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = TriggerKeys {
device_type: f_1,
key: f_2,
new_value: f_3,
old_value: f_4,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TriggerKeys");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(fld_var) = self.device_type {
o_prot.write_field_begin(&TFieldIdentifier::new("DeviceType", TType::I08, 1))?;
o_prot.write_i8(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(fld_var) = self.key {
o_prot.write_field_begin(&TFieldIdentifier::new("Key", TType::I32, 2))?;
o_prot.write_i32(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(fld_var) = self.new_value {
o_prot.write_field_begin(&TFieldIdentifier::new("NewValue", TType::I08, 3))?;
o_prot.write_i8(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(fld_var) = self.old_value {
o_prot.write_field_begin(&TFieldIdentifier::new("OldValue", TType::I08, 4))?;
o_prot.write_i8(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
impl Default for TriggerKeys {
fn default() -> Self {
TriggerKeys{
device_type: Some(0),
key: Some(0),
new_value: Some(0),
old_value: Some(0),
}
}
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct InputActionEvent {
pub user_id: Option<String>,
pub action: Option<String>,
pub timestamp: Option<i64>,
pub triggers: Option<Vec<TriggerKeys>>,
}
impl InputActionEvent {
pub fn new<F1, F2, F3, F4>(user_id: F1, action: F2, timestamp: F3, triggers: F4) -> InputActionEvent where F1: Into<Option<String>>, F2: Into<Option<String>>, F3: Into<Option<i64>>, F4: Into<Option<Vec<TriggerKeys>>> {
InputActionEvent {
user_id: user_id.into(),
action: action.into(),
timestamp: timestamp.into(),
triggers: triggers.into(),
}
}
pub fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<InputActionEvent> {
i_prot.read_struct_begin()?;
let mut f_1: Option<String> = Some("".to_owned());
let mut f_2: Option<String> = Some("".to_owned());
let mut f_3: Option<i64> = Some(0);
let mut f_4: Option<Vec<TriggerKeys>> = Some(Vec::new());
loop {
let field_ident = i_prot.read_field_begin()?;
if field_ident.field_type == TType::Stop {
break;
}
let field_id = field_id(&field_ident)?;
match field_id {
1 => {
let val = i_prot.read_string()?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_string()?;
f_2 = Some(val);
},
3 => {
let val = i_prot.read_i64()?;
f_3 = Some(val);
},
4 => {
let list_ident = i_prot.read_list_begin()?;
let mut val: Vec<TriggerKeys> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_0 = TriggerKeys::read_from_in_protocol(i_prot)?;
val.push(list_elem_0);
}
i_prot.read_list_end()?;
f_4 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = InputActionEvent {
user_id: f_1,
action: f_2,
timestamp: f_3,
triggers: f_4,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("InputActionEvent");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(ref fld_var) = self.user_id {
o_prot.write_field_begin(&TFieldIdentifier::new("userId", TType::String, 1))?;
o_prot.write_string(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(ref fld_var) = self.action {
o_prot.write_field_begin(&TFieldIdentifier::new("action", TType::String, 2))?;
o_prot.write_string(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(fld_var) = self.timestamp {
o_prot.write_field_begin(&TFieldIdentifier::new("timestamp", TType::I64, 3))?;
o_prot.write_i64(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(ref fld_var) = self.triggers {
o_prot.write_field_begin(&TFieldIdentifier::new("Triggers", TType::List, 4))?;
o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, fld_var.len() as i32))?;
for e in fld_var {
e.write_to_out_protocol(o_prot)?;
o_prot.write_list_end()?;
}
o_prot.write_field_end()?;
()
} else {
()
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
impl Default for InputActionEvent {
fn default() -> Self {
InputActionEvent{
user_id: Some("".to_owned()),
action: Some("".to_owned()),
timestamp: Some(0),
triggers: Some(Vec::new()),
}
}
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct UserEvent {
pub user_id: Option<String>,
pub action: Option<String>,
pub json_data: Option<JSON>,
}
impl UserEvent {
pub fn new<F1, F2, F3>(user_id: F1, action: F2, json_data: F3) -> UserEvent where F1: Into<Option<String>>, F2: Into<Option<String>>, F3: Into<Option<JSON>> {
UserEvent {
user_id: user_id.into(),
action: action.into(),
json_data: json_data.into(),
}
}
pub fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<UserEvent> {
i_prot.read_struct_begin()?;
let mut f_1: Option<String> = Some("".to_owned());
let mut f_2: Option<String> = Some("".to_owned());
let mut f_3: Option<JSON> = Some("".to_owned());
loop {
let field_ident = i_prot.read_field_begin()?;
if field_ident.field_type == TType::Stop {
break;
}
let field_id = field_id(&field_ident)?;
match field_id {
1 => {
let val = i_prot.read_string()?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_string()?;
f_2 = Some(val);
},
3 => {
let val = i_prot.read_string()?;
f_3 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = UserEvent {
user_id: f_1,
action: f_2,
json_data: f_3,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("UserEvent");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(ref fld_var) = self.user_id {
o_prot.write_field_begin(&TFieldIdentifier::new("userId", TType::String, 1))?;
o_prot.write_string(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(ref fld_var) = self.action {
o_prot.write_field_begin(&TFieldIdentifier::new("action", TType::String, 2))?;
o_prot.write_string(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(ref fld_var) = self.json_data {
o_prot.write_field_begin(&TFieldIdentifier::new("jsonData", TType::String, 3))?;
o_prot.write_string(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
impl Default for UserEvent {
fn default() -> Self {
UserEvent{
user_id: Some("".to_owned()),
action: Some("".to_owned()),
json_data: Some("".to_owned()),
}
}
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct UserInfoPublic {
pub user_id: Option<String>,
pub nickname: Option<String>,
pub portrait: Option<String>,
pub gender: Option<UserGender>,
}
impl UserInfoPublic {
pub fn new<F1, F2, F3, F4>(user_id: F1, nickname: F2, portrait: F3, gender: F4) -> UserInfoPublic where F1: Into<Option<String>>, F2: Into<Option<String>>, F3: Into<Option<String>>, F4: Into<Option<UserGender>> {
UserInfoPublic {
user_id: user_id.into(),
nickname: nickname.into(),
portrait: portrait.into(),
gender: gender.into(),
}
}
pub fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<UserInfoPublic> {
i_prot.read_struct_begin()?;
let mut f_1: Option<String> = Some("".to_owned());
let mut f_2: Option<String> = Some("".to_owned());
let mut f_3: Option<String> = Some("".to_owned());
let mut f_4: Option<UserGender> = None;
loop {
let field_ident = i_prot.read_field_begin()?;
if field_ident.field_type == TType::Stop {
break;
}
let field_id = field_id(&field_ident)?;
match field_id {
1 => {
let val = i_prot.read_string()?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_string()?;
f_2 = Some(val);
},
3 => {
let val = i_prot.read_string()?;
f_3 = Some(val);
},
4 => {
let val = UserGender::read_from_in_protocol(i_prot)?;
f_4 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = UserInfoPublic {
user_id: f_1,
nickname: f_2,
portrait: f_3,
gender: f_4,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("UserInfo_Public");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(ref fld_var) = self.user_id {
o_prot.write_field_begin(&TFieldIdentifier::new("userId", TType::String, 1))?;
o_prot.write_string(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(ref fld_var) = self.nickname {
o_prot.write_field_begin(&TFieldIdentifier::new("nickname", TType::String, 2))?;
o_prot.write_string(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(ref fld_var) = self.portrait {
o_prot.write_field_begin(&TFieldIdentifier::new("portrait", TType::String, 3))?;
o_prot.write_string(fld_var)?;
o_prot.write_field_end()?;
()
} else {
()
}
if let Some(ref fld_var) = self.gender {
o_prot.write_field_begin(&TFieldIdentifier::new("gender", TType::I32, 4))?;
fld_var.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
()
} else {
()
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
impl Default for UserInfoPublic {
fn default() -> Self {
UserInfoPublic{
user_id: Some("".to_owned()),
nickname: Some("".to_owned()),
portrait: Some("".to_owned()),
gender: None,
}
}
}