Google Git
Sign in
apache/iotdb-client-rust/HEAD/./src/protocol/common.rs
blob: fcbfc0a3448a7473a37ddcfeb06dbe97cc11436d [file]
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
// Autogenerated by Thrift Compiler (0.14.1)
// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#![allow(unused_imports)]
#![allow(unused_extern_crates)]
#![allow(clippy::too_many_arguments, clippy::type_complexity)]
#![cfg_attr(rustfmt, rustfmt_skip)]
use std::cell::RefCell;
use std::collections::{BTreeMap, BTreeSet};
use std::convert::{From, TryFrom};
use std::default::Default;
use std::error::Error;
use std::fmt;
use std::fmt::{Display, Formatter};
use std::rc::Rc;
use thrift::OrderedFloat;
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;
#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum TConsensusGroupType {
ConfigRegion = 0,
DataRegion = 1,
SchemaRegion = 2,
}
impl TConsensusGroupType {
pub fn write_to_out_protocol(self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
o_prot.write_i32(self as i32)
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TConsensusGroupType> {
let enum_value = i_prot.read_i32()?;
TConsensusGroupType::try_from(enum_value) }
}
impl TryFrom<i32> for TConsensusGroupType {
type Error = thrift::Error; fn try_from(i: i32) -> Result<Self, Self::Error> {
match i {
0 => Ok(TConsensusGroupType::ConfigRegion),
1 => Ok(TConsensusGroupType::DataRegion),
2 => Ok(TConsensusGroupType::SchemaRegion),
_ => {
Err(
thrift::Error::Protocol(
ProtocolError::new(
ProtocolErrorKind::InvalidData,
format!("cannot convert enum constant {} to TConsensusGroupType", i)
)
)
)
},
}
}
}
#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum TRegionMigrateFailedType {
AddPeerFailed = 0,
RemovePeerFailed = 1,
RemoveConsensusGroupFailed = 2,
DeleteRegionFailed = 3,
CreateRegionFailed = 4,
Disconnect = 5,
}
impl TRegionMigrateFailedType {
pub fn write_to_out_protocol(self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
o_prot.write_i32(self as i32)
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TRegionMigrateFailedType> {
let enum_value = i_prot.read_i32()?;
TRegionMigrateFailedType::try_from(enum_value) }
}
impl TryFrom<i32> for TRegionMigrateFailedType {
type Error = thrift::Error; fn try_from(i: i32) -> Result<Self, Self::Error> {
match i {
0 => Ok(TRegionMigrateFailedType::AddPeerFailed),
1 => Ok(TRegionMigrateFailedType::RemovePeerFailed),
2 => Ok(TRegionMigrateFailedType::RemoveConsensusGroupFailed),
3 => Ok(TRegionMigrateFailedType::DeleteRegionFailed),
4 => Ok(TRegionMigrateFailedType::CreateRegionFailed),
5 => Ok(TRegionMigrateFailedType::Disconnect),
_ => {
Err(
thrift::Error::Protocol(
ProtocolError::new(
ProtocolErrorKind::InvalidData,
format!("cannot convert enum constant {} to TRegionMigrateFailedType", i)
)
)
)
},
}
}
}
#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum TRegionMaintainTaskStatus {
TaskNotExist = 0,
Processing = 1,
Success = 2,
Fail = 3,
}
impl TRegionMaintainTaskStatus {
pub fn write_to_out_protocol(self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
o_prot.write_i32(self as i32)
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TRegionMaintainTaskStatus> {
let enum_value = i_prot.read_i32()?;
TRegionMaintainTaskStatus::try_from(enum_value) }
}
impl TryFrom<i32> for TRegionMaintainTaskStatus {
type Error = thrift::Error; fn try_from(i: i32) -> Result<Self, Self::Error> {
match i {
0 => Ok(TRegionMaintainTaskStatus::TaskNotExist),
1 => Ok(TRegionMaintainTaskStatus::Processing),
2 => Ok(TRegionMaintainTaskStatus::Success),
3 => Ok(TRegionMaintainTaskStatus::Fail),
_ => {
Err(
thrift::Error::Protocol(
ProtocolError::new(
ProtocolErrorKind::InvalidData,
format!("cannot convert enum constant {} to TRegionMaintainTaskStatus", i)
)
)
)
},
}
}
}
#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum ThrottleType {
RequestNumber = 0,
RequestSize = 1,
WriteNumber = 2,
WriteSize = 3,
ReadNumber = 4,
ReadSize = 5,
}
impl ThrottleType {
pub fn write_to_out_protocol(self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
o_prot.write_i32(self as i32)
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<ThrottleType> {
let enum_value = i_prot.read_i32()?;
ThrottleType::try_from(enum_value) }
}
impl TryFrom<i32> for ThrottleType {
type Error = thrift::Error; fn try_from(i: i32) -> Result<Self, Self::Error> {
match i {
0 => Ok(ThrottleType::RequestNumber),
1 => Ok(ThrottleType::RequestSize),
2 => Ok(ThrottleType::WriteNumber),
3 => Ok(ThrottleType::WriteSize),
4 => Ok(ThrottleType::ReadNumber),
5 => Ok(ThrottleType::ReadSize),
_ => {
Err(
thrift::Error::Protocol(
ProtocolError::new(
ProtocolErrorKind::InvalidData,
format!("cannot convert enum constant {} to ThrottleType", i)
)
)
)
},
}
}
}
#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum TServiceType {
ConfigNodeInternalService = 0,
DataNodeInternalService = 1,
DataNodeMPPService = 2,
DataNodeExternalService = 3,
}
impl TServiceType {
pub fn write_to_out_protocol(self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
o_prot.write_i32(self as i32)
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TServiceType> {
let enum_value = i_prot.read_i32()?;
TServiceType::try_from(enum_value) }
}
impl TryFrom<i32> for TServiceType {
type Error = thrift::Error; fn try_from(i: i32) -> Result<Self, Self::Error> {
match i {
0 => Ok(TServiceType::ConfigNodeInternalService),
1 => Ok(TServiceType::DataNodeInternalService),
2 => Ok(TServiceType::DataNodeMPPService),
3 => Ok(TServiceType::DataNodeExternalService),
_ => {
Err(
thrift::Error::Protocol(
ProtocolError::new(
ProtocolErrorKind::InvalidData,
format!("cannot convert enum constant {} to TServiceType", i)
)
)
)
},
}
}
}
#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum TAggregationType {
Count = 0,
Avg = 1,
Sum = 2,
FirstValue = 3,
LastValue = 4,
MaxTime = 5,
MinTime = 6,
MaxValue = 7,
MinValue = 8,
Extreme = 9,
CountIf = 10,
TimeDuration = 11,
Mode = 12,
CountTime = 13,
Stddev = 14,
StddevPop = 15,
StddevSamp = 16,
Variance = 17,
VarPop = 18,
VarSamp = 19,
MaxBy = 20,
MinBy = 21,
Udaf = 22,
First = 23,
Last = 24,
FirstBy = 25,
LastBy = 26,
Min = 27,
Max = 28,
CountAll = 29,
ApproxCountDistinct = 30,
ApproxMostFrequent = 31,
ApproxPercentile = 32,
Corr = 33,
CovarPop = 34,
CovarSamp = 35,
RegrSlope = 36,
RegrIntercept = 37,
Skewness = 38,
Kurtosis = 39,
Percentile = 40,
}
impl TAggregationType {
pub fn write_to_out_protocol(self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
o_prot.write_i32(self as i32)
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TAggregationType> {
let enum_value = i_prot.read_i32()?;
TAggregationType::try_from(enum_value) }
}
impl TryFrom<i32> for TAggregationType {
type Error = thrift::Error; fn try_from(i: i32) -> Result<Self, Self::Error> {
match i {
0 => Ok(TAggregationType::Count),
1 => Ok(TAggregationType::Avg),
2 => Ok(TAggregationType::Sum),
3 => Ok(TAggregationType::FirstValue),
4 => Ok(TAggregationType::LastValue),
5 => Ok(TAggregationType::MaxTime),
6 => Ok(TAggregationType::MinTime),
7 => Ok(TAggregationType::MaxValue),
8 => Ok(TAggregationType::MinValue),
9 => Ok(TAggregationType::Extreme),
10 => Ok(TAggregationType::CountIf),
11 => Ok(TAggregationType::TimeDuration),
12 => Ok(TAggregationType::Mode),
13 => Ok(TAggregationType::CountTime),
14 => Ok(TAggregationType::Stddev),
15 => Ok(TAggregationType::StddevPop),
16 => Ok(TAggregationType::StddevSamp),
17 => Ok(TAggregationType::Variance),
18 => Ok(TAggregationType::VarPop),
19 => Ok(TAggregationType::VarSamp),
20 => Ok(TAggregationType::MaxBy),
21 => Ok(TAggregationType::MinBy),
22 => Ok(TAggregationType::Udaf),
23 => Ok(TAggregationType::First),
24 => Ok(TAggregationType::Last),
25 => Ok(TAggregationType::FirstBy),
26 => Ok(TAggregationType::LastBy),
27 => Ok(TAggregationType::Min),
28 => Ok(TAggregationType::Max),
29 => Ok(TAggregationType::CountAll),
30 => Ok(TAggregationType::ApproxCountDistinct),
31 => Ok(TAggregationType::ApproxMostFrequent),
32 => Ok(TAggregationType::ApproxPercentile),
33 => Ok(TAggregationType::Corr),
34 => Ok(TAggregationType::CovarPop),
35 => Ok(TAggregationType::CovarSamp),
36 => Ok(TAggregationType::RegrSlope),
37 => Ok(TAggregationType::RegrIntercept),
38 => Ok(TAggregationType::Skewness),
39 => Ok(TAggregationType::Kurtosis),
40 => Ok(TAggregationType::Percentile),
_ => {
Err(
thrift::Error::Protocol(
ProtocolError::new(
ProtocolErrorKind::InvalidData,
format!("cannot convert enum constant {} to TAggregationType", i)
)
)
)
},
}
}
}
#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum TrainingState {
Pending = 0,
Running = 1,
Finished = 2,
Failed = 3,
Dropping = 4,
}
impl TrainingState {
pub fn write_to_out_protocol(self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
o_prot.write_i32(self as i32)
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TrainingState> {
let enum_value = i_prot.read_i32()?;
TrainingState::try_from(enum_value) }
}
impl TryFrom<i32> for TrainingState {
type Error = thrift::Error; fn try_from(i: i32) -> Result<Self, Self::Error> {
match i {
0 => Ok(TrainingState::Pending),
1 => Ok(TrainingState::Running),
2 => Ok(TrainingState::Finished),
3 => Ok(TrainingState::Failed),
4 => Ok(TrainingState::Dropping),
_ => {
Err(
thrift::Error::Protocol(
ProtocolError::new(
ProtocolErrorKind::InvalidData,
format!("cannot convert enum constant {} to TrainingState", i)
)
)
)
},
}
}
}
#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum Model {
Tree = 0,
Table = 1,
}
impl Model {
pub fn write_to_out_protocol(self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
o_prot.write_i32(self as i32)
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<Model> {
let enum_value = i_prot.read_i32()?;
Model::try_from(enum_value) }
}
impl TryFrom<i32> for Model {
type Error = thrift::Error; fn try_from(i: i32) -> Result<Self, Self::Error> {
match i {
0 => Ok(Model::Tree),
1 => Ok(Model::Table),
_ => {
Err(
thrift::Error::Protocol(
ProtocolError::new(
ProtocolErrorKind::InvalidData,
format!("cannot convert enum constant {} to Model", i)
)
)
)
},
}
}
}
#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum FunctionType {
None = 0,
Scalar = 1,
Aggregate = 2,
Table = 3,
}
impl FunctionType {
pub fn write_to_out_protocol(self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
o_prot.write_i32(self as i32)
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<FunctionType> {
let enum_value = i_prot.read_i32()?;
FunctionType::try_from(enum_value) }
}
impl TryFrom<i32> for FunctionType {
type Error = thrift::Error; fn try_from(i: i32) -> Result<Self, Self::Error> {
match i {
0 => Ok(FunctionType::None),
1 => Ok(FunctionType::Scalar),
2 => Ok(FunctionType::Aggregate),
3 => Ok(FunctionType::Table),
_ => {
Err(
thrift::Error::Protocol(
ProtocolError::new(
ProtocolErrorKind::InvalidData,
format!("cannot convert enum constant {} to FunctionType", i)
)
)
)
},
}
}
}
//
// TEndPoint
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TEndPoint {
pub ip: String,
pub port: i32,
}
impl TEndPoint {
pub fn new(ip: String, port: i32) -> TEndPoint {
TEndPoint {
ip,
port,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TEndPoint> {
i_prot.read_struct_begin()?;
let mut f_1: Option<String> = None;
let mut f_2: Option<i32> = 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_i32()?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TEndPoint.ip", &f_1)?;
verify_required_field_exists("TEndPoint.port", &f_2)?;
let ret = TEndPoint {
ip: f_1.expect("auto-generated code should have checked for presence of required fields"),
port: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TEndPoint");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("ip", TType::String, 1))?;
o_prot.write_string(&self.ip)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("port", TType::I32, 2))?;
o_prot.write_i32(self.port)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TSStatus
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TSStatus {
pub code: i32,
pub message: Option<String>,
pub sub_status: Option<Vec<Box<TSStatus>>>,
pub redirect_node: Option<TEndPoint>,
pub need_retry: Option<bool>,
pub response_data: Option<Vec<u8>>,
}
impl TSStatus {
pub fn new<F2, F3, F4, F5, F6>(code: i32, message: F2, sub_status: F3, redirect_node: F4, need_retry: F5, response_data: F6) -> TSStatus where F2: Into<Option<String>>, F3: Into<Option<Vec<Box<TSStatus>>>>, F4: Into<Option<TEndPoint>>, F5: Into<Option<bool>>, F6: Into<Option<Vec<u8>>> {
TSStatus {
code,
message: message.into(),
sub_status: sub_status.into(),
redirect_node: redirect_node.into(),
need_retry: need_retry.into(),
response_data: response_data.into(),
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TSStatus> {
i_prot.read_struct_begin()?;
let mut f_1: Option<i32> = None;
let mut f_2: Option<String> = None;
let mut f_3: Option<Vec<Box<TSStatus>>> = None;
let mut f_4: Option<TEndPoint> = None;
let mut f_5: Option<bool> = None;
let mut f_6: Option<Vec<u8>> = 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_i32()?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_string()?;
f_2 = Some(val);
},
3 => {
let list_ident = i_prot.read_list_begin()?;
let mut val: Vec<Box<TSStatus>> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_0 = Box::new(TSStatus::read_from_in_protocol(i_prot)?);
val.push(list_elem_0);
}
i_prot.read_list_end()?;
f_3 = Some(val);
},
4 => {
let val = TEndPoint::read_from_in_protocol(i_prot)?;
f_4 = Some(val);
},
5 => {
let val = i_prot.read_bool()?;
f_5 = Some(val);
},
6 => {
let val = i_prot.read_bytes()?;
f_6 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TSStatus.code", &f_1)?;
let ret = TSStatus {
code: f_1.expect("auto-generated code should have checked for presence of required fields"),
message: f_2,
sub_status: f_3,
redirect_node: f_4,
need_retry: f_5,
response_data: f_6,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TSStatus");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("code", TType::I32, 1))?;
o_prot.write_i32(self.code)?;
o_prot.write_field_end()?;
if let Some(ref fld_var) = self.message {
o_prot.write_field_begin(&TFieldIdentifier::new("message", TType::String, 2))?;
o_prot.write_string(fld_var)?;
o_prot.write_field_end()?
}
if let Some(ref fld_var) = self.sub_status {
o_prot.write_field_begin(&TFieldIdentifier::new("subStatus", TType::List, 3))?;
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()?
}
if let Some(ref fld_var) = self.redirect_node {
o_prot.write_field_begin(&TFieldIdentifier::new("redirectNode", TType::Struct, 4))?;
fld_var.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?
}
if let Some(fld_var) = self.need_retry {
o_prot.write_field_begin(&TFieldIdentifier::new("needRetry", TType::Bool, 5))?;
o_prot.write_bool(fld_var)?;
o_prot.write_field_end()?
}
if let Some(ref fld_var) = self.response_data {
o_prot.write_field_begin(&TFieldIdentifier::new("responseData", TType::String, 6))?;
o_prot.write_bytes(fld_var)?;
o_prot.write_field_end()?
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TConsensusGroupId
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TConsensusGroupId {
pub type_: TConsensusGroupType,
pub id: i32,
}
impl TConsensusGroupId {
pub fn new(type_: TConsensusGroupType, id: i32) -> TConsensusGroupId {
TConsensusGroupId {
type_,
id,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TConsensusGroupId> {
i_prot.read_struct_begin()?;
let mut f_1: Option<TConsensusGroupType> = None;
let mut f_2: Option<i32> = 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 = TConsensusGroupType::read_from_in_protocol(i_prot)?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_i32()?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TConsensusGroupId.type_", &f_1)?;
verify_required_field_exists("TConsensusGroupId.id", &f_2)?;
let ret = TConsensusGroupId {
type_: f_1.expect("auto-generated code should have checked for presence of required fields"),
id: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TConsensusGroupId");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("type", TType::I32, 1))?;
self.type_.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("id", TType::I32, 2))?;
o_prot.write_i32(self.id)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TSeriesPartitionSlot
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TSeriesPartitionSlot {
pub slot_id: i32,
}
impl TSeriesPartitionSlot {
pub fn new(slot_id: i32) -> TSeriesPartitionSlot {
TSeriesPartitionSlot {
slot_id,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TSeriesPartitionSlot> {
i_prot.read_struct_begin()?;
let mut f_1: Option<i32> = 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_i32()?;
f_1 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TSeriesPartitionSlot.slot_id", &f_1)?;
let ret = TSeriesPartitionSlot {
slot_id: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TSeriesPartitionSlot");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("slotId", TType::I32, 1))?;
o_prot.write_i32(self.slot_id)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TTimePartitionSlot
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TTimePartitionSlot {
pub start_time: i64,
}
impl TTimePartitionSlot {
pub fn new(start_time: i64) -> TTimePartitionSlot {
TTimePartitionSlot {
start_time,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TTimePartitionSlot> {
i_prot.read_struct_begin()?;
let mut f_1: Option<i64> = 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_i64()?;
f_1 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TTimePartitionSlot.start_time", &f_1)?;
let ret = TTimePartitionSlot {
start_time: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TTimePartitionSlot");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("startTime", TType::I64, 1))?;
o_prot.write_i64(self.start_time)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TRegionReplicaSet
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TRegionReplicaSet {
pub region_id: TConsensusGroupId,
pub data_node_locations: Vec<Box<TDataNodeLocation>>,
}
impl TRegionReplicaSet {
pub fn new(region_id: TConsensusGroupId, data_node_locations: Vec<Box<TDataNodeLocation>>) -> TRegionReplicaSet {
TRegionReplicaSet {
region_id,
data_node_locations,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TRegionReplicaSet> {
i_prot.read_struct_begin()?;
let mut f_1: Option<TConsensusGroupId> = None;
let mut f_2: Option<Vec<Box<TDataNodeLocation>>> = 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 = TConsensusGroupId::read_from_in_protocol(i_prot)?;
f_1 = Some(val);
},
2 => {
let list_ident = i_prot.read_list_begin()?;
let mut val: Vec<Box<TDataNodeLocation>> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_1 = Box::new(TDataNodeLocation::read_from_in_protocol(i_prot)?);
val.push(list_elem_1);
}
i_prot.read_list_end()?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TRegionReplicaSet.region_id", &f_1)?;
verify_required_field_exists("TRegionReplicaSet.data_node_locations", &f_2)?;
let ret = TRegionReplicaSet {
region_id: f_1.expect("auto-generated code should have checked for presence of required fields"),
data_node_locations: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TRegionReplicaSet");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("regionId", TType::Struct, 1))?;
self.region_id.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("dataNodeLocations", TType::List, 2))?;
o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, self.data_node_locations.len() as i32))?;
for e in &self.data_node_locations {
e.write_to_out_protocol(o_prot)?;
o_prot.write_list_end()?;
}
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TNodeResource
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TNodeResource {
pub cpu_core_num: i32,
pub max_memory: i64,
}
impl TNodeResource {
pub fn new(cpu_core_num: i32, max_memory: i64) -> TNodeResource {
TNodeResource {
cpu_core_num,
max_memory,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TNodeResource> {
i_prot.read_struct_begin()?;
let mut f_1: Option<i32> = None;
let mut f_2: Option<i64> = 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_i32()?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_i64()?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TNodeResource.cpu_core_num", &f_1)?;
verify_required_field_exists("TNodeResource.max_memory", &f_2)?;
let ret = TNodeResource {
cpu_core_num: f_1.expect("auto-generated code should have checked for presence of required fields"),
max_memory: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TNodeResource");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("cpuCoreNum", TType::I32, 1))?;
o_prot.write_i32(self.cpu_core_num)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("maxMemory", TType::I64, 2))?;
o_prot.write_i64(self.max_memory)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TConfigNodeLocation
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TConfigNodeLocation {
pub config_node_id: i32,
pub internal_end_point: TEndPoint,
pub consensus_end_point: TEndPoint,
}
impl TConfigNodeLocation {
pub fn new(config_node_id: i32, internal_end_point: TEndPoint, consensus_end_point: TEndPoint) -> TConfigNodeLocation {
TConfigNodeLocation {
config_node_id,
internal_end_point,
consensus_end_point,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TConfigNodeLocation> {
i_prot.read_struct_begin()?;
let mut f_1: Option<i32> = None;
let mut f_2: Option<TEndPoint> = None;
let mut f_3: Option<TEndPoint> = 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_i32()?;
f_1 = Some(val);
},
2 => {
let val = TEndPoint::read_from_in_protocol(i_prot)?;
f_2 = Some(val);
},
3 => {
let val = TEndPoint::read_from_in_protocol(i_prot)?;
f_3 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TConfigNodeLocation.config_node_id", &f_1)?;
verify_required_field_exists("TConfigNodeLocation.internal_end_point", &f_2)?;
verify_required_field_exists("TConfigNodeLocation.consensus_end_point", &f_3)?;
let ret = TConfigNodeLocation {
config_node_id: f_1.expect("auto-generated code should have checked for presence of required fields"),
internal_end_point: f_2.expect("auto-generated code should have checked for presence of required fields"),
consensus_end_point: f_3.expect("auto-generated code should have checked for presence of required fields"),
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TConfigNodeLocation");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("configNodeId", TType::I32, 1))?;
o_prot.write_i32(self.config_node_id)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("internalEndPoint", TType::Struct, 2))?;
self.internal_end_point.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("consensusEndPoint", TType::Struct, 3))?;
self.consensus_end_point.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TDataNodeLocation
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TDataNodeLocation {
pub data_node_id: i32,
pub client_rpc_end_point: TEndPoint,
pub internal_end_point: TEndPoint,
pub m_p_p_data_exchange_end_point: TEndPoint,
pub data_region_consensus_end_point: TEndPoint,
pub schema_region_consensus_end_point: TEndPoint,
}
impl TDataNodeLocation {
pub fn new(data_node_id: i32, client_rpc_end_point: TEndPoint, internal_end_point: TEndPoint, m_p_p_data_exchange_end_point: TEndPoint, data_region_consensus_end_point: TEndPoint, schema_region_consensus_end_point: TEndPoint) -> TDataNodeLocation {
TDataNodeLocation {
data_node_id,
client_rpc_end_point,
internal_end_point,
m_p_p_data_exchange_end_point,
data_region_consensus_end_point,
schema_region_consensus_end_point,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TDataNodeLocation> {
i_prot.read_struct_begin()?;
let mut f_1: Option<i32> = None;
let mut f_2: Option<TEndPoint> = None;
let mut f_3: Option<TEndPoint> = None;
let mut f_4: Option<TEndPoint> = None;
let mut f_5: Option<TEndPoint> = None;
let mut f_6: Option<TEndPoint> = 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_i32()?;
f_1 = Some(val);
},
2 => {
let val = TEndPoint::read_from_in_protocol(i_prot)?;
f_2 = Some(val);
},
3 => {
let val = TEndPoint::read_from_in_protocol(i_prot)?;
f_3 = Some(val);
},
4 => {
let val = TEndPoint::read_from_in_protocol(i_prot)?;
f_4 = Some(val);
},
5 => {
let val = TEndPoint::read_from_in_protocol(i_prot)?;
f_5 = Some(val);
},
6 => {
let val = TEndPoint::read_from_in_protocol(i_prot)?;
f_6 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TDataNodeLocation.data_node_id", &f_1)?;
verify_required_field_exists("TDataNodeLocation.client_rpc_end_point", &f_2)?;
verify_required_field_exists("TDataNodeLocation.internal_end_point", &f_3)?;
verify_required_field_exists("TDataNodeLocation.m_p_p_data_exchange_end_point", &f_4)?;
verify_required_field_exists("TDataNodeLocation.data_region_consensus_end_point", &f_5)?;
verify_required_field_exists("TDataNodeLocation.schema_region_consensus_end_point", &f_6)?;
let ret = TDataNodeLocation {
data_node_id: f_1.expect("auto-generated code should have checked for presence of required fields"),
client_rpc_end_point: f_2.expect("auto-generated code should have checked for presence of required fields"),
internal_end_point: f_3.expect("auto-generated code should have checked for presence of required fields"),
m_p_p_data_exchange_end_point: f_4.expect("auto-generated code should have checked for presence of required fields"),
data_region_consensus_end_point: f_5.expect("auto-generated code should have checked for presence of required fields"),
schema_region_consensus_end_point: f_6.expect("auto-generated code should have checked for presence of required fields"),
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TDataNodeLocation");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("dataNodeId", TType::I32, 1))?;
o_prot.write_i32(self.data_node_id)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("clientRpcEndPoint", TType::Struct, 2))?;
self.client_rpc_end_point.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("internalEndPoint", TType::Struct, 3))?;
self.internal_end_point.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("mPPDataExchangeEndPoint", TType::Struct, 4))?;
self.m_p_p_data_exchange_end_point.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("dataRegionConsensusEndPoint", TType::Struct, 5))?;
self.data_region_consensus_end_point.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("schemaRegionConsensusEndPoint", TType::Struct, 6))?;
self.schema_region_consensus_end_point.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TAINodeLocation
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TAINodeLocation {
pub ai_node_id: i32,
pub internal_end_point: TEndPoint,
}
impl TAINodeLocation {
pub fn new(ai_node_id: i32, internal_end_point: TEndPoint) -> TAINodeLocation {
TAINodeLocation {
ai_node_id,
internal_end_point,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TAINodeLocation> {
i_prot.read_struct_begin()?;
let mut f_1: Option<i32> = None;
let mut f_2: Option<TEndPoint> = 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_i32()?;
f_1 = Some(val);
},
2 => {
let val = TEndPoint::read_from_in_protocol(i_prot)?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TAINodeLocation.ai_node_id", &f_1)?;
verify_required_field_exists("TAINodeLocation.internal_end_point", &f_2)?;
let ret = TAINodeLocation {
ai_node_id: f_1.expect("auto-generated code should have checked for presence of required fields"),
internal_end_point: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TAINodeLocation");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("aiNodeId", TType::I32, 1))?;
o_prot.write_i32(self.ai_node_id)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("internalEndPoint", TType::Struct, 2))?;
self.internal_end_point.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TDataNodeConfiguration
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TDataNodeConfiguration {
pub location: TDataNodeLocation,
pub resource: TNodeResource,
}
impl TDataNodeConfiguration {
pub fn new(location: TDataNodeLocation, resource: TNodeResource) -> TDataNodeConfiguration {
TDataNodeConfiguration {
location,
resource,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TDataNodeConfiguration> {
i_prot.read_struct_begin()?;
let mut f_1: Option<TDataNodeLocation> = None;
let mut f_2: Option<TNodeResource> = 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 = TDataNodeLocation::read_from_in_protocol(i_prot)?;
f_1 = Some(val);
},
2 => {
let val = TNodeResource::read_from_in_protocol(i_prot)?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TDataNodeConfiguration.location", &f_1)?;
verify_required_field_exists("TDataNodeConfiguration.resource", &f_2)?;
let ret = TDataNodeConfiguration {
location: f_1.expect("auto-generated code should have checked for presence of required fields"),
resource: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TDataNodeConfiguration");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("location", TType::Struct, 1))?;
self.location.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("resource", TType::Struct, 2))?;
self.resource.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TAINodeConfiguration
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TAINodeConfiguration {
pub location: TAINodeLocation,
pub resource: TNodeResource,
}
impl TAINodeConfiguration {
pub fn new(location: TAINodeLocation, resource: TNodeResource) -> TAINodeConfiguration {
TAINodeConfiguration {
location,
resource,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TAINodeConfiguration> {
i_prot.read_struct_begin()?;
let mut f_1: Option<TAINodeLocation> = None;
let mut f_2: Option<TNodeResource> = 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 = TAINodeLocation::read_from_in_protocol(i_prot)?;
f_1 = Some(val);
},
2 => {
let val = TNodeResource::read_from_in_protocol(i_prot)?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TAINodeConfiguration.location", &f_1)?;
verify_required_field_exists("TAINodeConfiguration.resource", &f_2)?;
let ret = TAINodeConfiguration {
location: f_1.expect("auto-generated code should have checked for presence of required fields"),
resource: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TAINodeConfiguration");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("location", TType::Struct, 1))?;
self.location.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("resource", TType::Struct, 2))?;
self.resource.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TFlushReq
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TFlushReq {
pub is_seq: Option<String>,
pub storage_groups: Option<Vec<String>>,
pub region_ids: Option<Vec<String>>,
}
impl TFlushReq {
pub fn new<F1, F2, F3>(is_seq: F1, storage_groups: F2, region_ids: F3) -> TFlushReq where F1: Into<Option<String>>, F2: Into<Option<Vec<String>>>, F3: Into<Option<Vec<String>>> {
TFlushReq {
is_seq: is_seq.into(),
storage_groups: storage_groups.into(),
region_ids: region_ids.into(),
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TFlushReq> {
i_prot.read_struct_begin()?;
let mut f_1: Option<String> = None;
let mut f_2: Option<Vec<String>> = None;
let mut f_3: Option<Vec<String>> = None;
loop {
let field_ident = i_prot.read_field_begin()?;
if field_ident.field_type == TType::Stop {
break;
}
let field_id = field_id(&field_ident)?;
match field_id {
1 => {
let val = i_prot.read_string()?;
f_1 = Some(val);
},
2 => {
let list_ident = 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_2 = i_prot.read_string()?;
val.push(list_elem_2);
}
i_prot.read_list_end()?;
f_2 = Some(val);
},
3 => {
let list_ident = 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_3 = i_prot.read_string()?;
val.push(list_elem_3);
}
i_prot.read_list_end()?;
f_3 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = TFlushReq {
is_seq: f_1,
storage_groups: f_2,
region_ids: f_3,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TFlushReq");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(ref fld_var) = self.is_seq {
o_prot.write_field_begin(&TFieldIdentifier::new("isSeq", TType::String, 1))?;
o_prot.write_string(fld_var)?;
o_prot.write_field_end()?
}
if let Some(ref fld_var) = self.storage_groups {
o_prot.write_field_begin(&TFieldIdentifier::new("storageGroups", TType::List, 2))?;
o_prot.write_list_begin(&TListIdentifier::new(TType::String, fld_var.len() as i32))?;
for e in fld_var {
o_prot.write_string(e)?;
o_prot.write_list_end()?;
}
o_prot.write_field_end()?
}
if let Some(ref fld_var) = self.region_ids {
o_prot.write_field_begin(&TFieldIdentifier::new("regionIds", TType::List, 3))?;
o_prot.write_list_begin(&TListIdentifier::new(TType::String, fld_var.len() as i32))?;
for e in fld_var {
o_prot.write_string(e)?;
o_prot.write_list_end()?;
}
o_prot.write_field_end()?
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
impl Default for TFlushReq {
fn default() -> Self {
TFlushReq{
is_seq: Some("".to_owned()),
storage_groups: Some(Vec::new()),
region_ids: Some(Vec::new()),
}
}
}
//
// TSettleReq
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TSettleReq {
pub paths: Vec<String>,
}
impl TSettleReq {
pub fn new(paths: Vec<String>) -> TSettleReq {
TSettleReq {
paths,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TSettleReq> {
i_prot.read_struct_begin()?;
let mut f_1: Option<Vec<String>> = None;
loop {
let field_ident = i_prot.read_field_begin()?;
if field_ident.field_type == TType::Stop {
break;
}
let field_id = field_id(&field_ident)?;
match field_id {
1 => {
let list_ident = 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_4 = i_prot.read_string()?;
val.push(list_elem_4);
}
i_prot.read_list_end()?;
f_1 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TSettleReq.paths", &f_1)?;
let ret = TSettleReq {
paths: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TSettleReq");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("paths", TType::List, 1))?;
o_prot.write_list_begin(&TListIdentifier::new(TType::String, self.paths.len() as i32))?;
for e in &self.paths {
o_prot.write_string(e)?;
o_prot.write_list_end()?;
}
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TSchemaNode
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TSchemaNode {
pub node_name: String,
pub node_type: i8,
}
impl TSchemaNode {
pub fn new(node_name: String, node_type: i8) -> TSchemaNode {
TSchemaNode {
node_name,
node_type,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TSchemaNode> {
i_prot.read_struct_begin()?;
let mut f_1: Option<String> = None;
let mut f_2: Option<i8> = 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_i8()?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TSchemaNode.node_name", &f_1)?;
verify_required_field_exists("TSchemaNode.node_type", &f_2)?;
let ret = TSchemaNode {
node_name: f_1.expect("auto-generated code should have checked for presence of required fields"),
node_type: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TSchemaNode");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("nodeName", TType::String, 1))?;
o_prot.write_string(&self.node_name)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("nodeType", TType::I08, 2))?;
o_prot.write_i8(self.node_type)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TSetConfigurationReq
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TSetConfigurationReq {
pub configs: BTreeMap<String, String>,
pub node_id: i32,
}
impl TSetConfigurationReq {
pub fn new(configs: BTreeMap<String, String>, node_id: i32) -> TSetConfigurationReq {
TSetConfigurationReq {
configs,
node_id,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TSetConfigurationReq> {
i_prot.read_struct_begin()?;
let mut f_1: Option<BTreeMap<String, String>> = None;
let mut f_2: Option<i32> = 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 map_ident = i_prot.read_map_begin()?;
let mut val: BTreeMap<String, String> = BTreeMap::new();
for _ in 0..map_ident.size {
let map_key_5 = i_prot.read_string()?;
let map_val_6 = i_prot.read_string()?;
val.insert(map_key_5, map_val_6);
}
i_prot.read_map_end()?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_i32()?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TSetConfigurationReq.configs", &f_1)?;
verify_required_field_exists("TSetConfigurationReq.node_id", &f_2)?;
let ret = TSetConfigurationReq {
configs: f_1.expect("auto-generated code should have checked for presence of required fields"),
node_id: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TSetConfigurationReq");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("configs", TType::Map, 1))?;
o_prot.write_map_begin(&TMapIdentifier::new(TType::String, TType::String, self.configs.len() as i32))?;
for (k, v) in &self.configs {
o_prot.write_string(k)?;
o_prot.write_string(v)?;
o_prot.write_map_end()?;
}
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("nodeId", TType::I32, 2))?;
o_prot.write_i32(self.node_id)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TSetTTLReq
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TSetTTLReq {
pub path_pattern: Vec<String>,
pub t_t_l: i64,
pub is_data_base: bool,
}
impl TSetTTLReq {
pub fn new(path_pattern: Vec<String>, t_t_l: i64, is_data_base: bool) -> TSetTTLReq {
TSetTTLReq {
path_pattern,
t_t_l,
is_data_base,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TSetTTLReq> {
i_prot.read_struct_begin()?;
let mut f_1: Option<Vec<String>> = None;
let mut f_2: Option<i64> = None;
let mut f_3: Option<bool> = None;
loop {
let field_ident = i_prot.read_field_begin()?;
if field_ident.field_type == TType::Stop {
break;
}
let field_id = field_id(&field_ident)?;
match field_id {
1 => {
let list_ident = 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_7 = i_prot.read_string()?;
val.push(list_elem_7);
}
i_prot.read_list_end()?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_i64()?;
f_2 = Some(val);
},
3 => {
let val = i_prot.read_bool()?;
f_3 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TSetTTLReq.path_pattern", &f_1)?;
verify_required_field_exists("TSetTTLReq.t_t_l", &f_2)?;
verify_required_field_exists("TSetTTLReq.is_data_base", &f_3)?;
let ret = TSetTTLReq {
path_pattern: f_1.expect("auto-generated code should have checked for presence of required fields"),
t_t_l: f_2.expect("auto-generated code should have checked for presence of required fields"),
is_data_base: f_3.expect("auto-generated code should have checked for presence of required fields"),
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TSetTTLReq");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("pathPattern", TType::List, 1))?;
o_prot.write_list_begin(&TListIdentifier::new(TType::String, self.path_pattern.len() as i32))?;
for e in &self.path_pattern {
o_prot.write_string(e)?;
o_prot.write_list_end()?;
}
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("TTL", TType::I64, 2))?;
o_prot.write_i64(self.t_t_l)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("isDataBase", TType::Bool, 3))?;
o_prot.write_bool(self.is_data_base)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TShowTTLReq
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TShowTTLReq {
pub path_pattern: Vec<String>,
}
impl TShowTTLReq {
pub fn new(path_pattern: Vec<String>) -> TShowTTLReq {
TShowTTLReq {
path_pattern,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TShowTTLReq> {
i_prot.read_struct_begin()?;
let mut f_1: Option<Vec<String>> = None;
loop {
let field_ident = i_prot.read_field_begin()?;
if field_ident.field_type == TType::Stop {
break;
}
let field_id = field_id(&field_ident)?;
match field_id {
1 => {
let list_ident = 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_8 = i_prot.read_string()?;
val.push(list_elem_8);
}
i_prot.read_list_end()?;
f_1 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TShowTTLReq.path_pattern", &f_1)?;
let ret = TShowTTLReq {
path_pattern: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TShowTTLReq");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("pathPattern", TType::List, 1))?;
o_prot.write_list_begin(&TListIdentifier::new(TType::String, self.path_pattern.len() as i32))?;
for e in &self.path_pattern {
o_prot.write_string(e)?;
o_prot.write_list_end()?;
}
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TFile
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TFile {
pub file_name: String,
pub file: Vec<u8>,
}
impl TFile {
pub fn new(file_name: String, file: Vec<u8>) -> TFile {
TFile {
file_name,
file,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TFile> {
i_prot.read_struct_begin()?;
let mut f_1: Option<String> = None;
let mut f_2: Option<Vec<u8>> = 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_bytes()?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TFile.file_name", &f_1)?;
verify_required_field_exists("TFile.file", &f_2)?;
let ret = TFile {
file_name: f_1.expect("auto-generated code should have checked for presence of required fields"),
file: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TFile");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("fileName", TType::String, 1))?;
o_prot.write_string(&self.file_name)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("file", TType::String, 2))?;
o_prot.write_bytes(&self.file)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TFilesResp
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TFilesResp {
pub status: TSStatus,
pub files: Vec<TFile>,
}
impl TFilesResp {
pub fn new(status: TSStatus, files: Vec<TFile>) -> TFilesResp {
TFilesResp {
status,
files,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TFilesResp> {
i_prot.read_struct_begin()?;
let mut f_1: Option<TSStatus> = None;
let mut f_2: Option<Vec<TFile>> = 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 = TSStatus::read_from_in_protocol(i_prot)?;
f_1 = Some(val);
},
2 => {
let list_ident = i_prot.read_list_begin()?;
let mut val: Vec<TFile> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_9 = TFile::read_from_in_protocol(i_prot)?;
val.push(list_elem_9);
}
i_prot.read_list_end()?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TFilesResp.status", &f_1)?;
verify_required_field_exists("TFilesResp.files", &f_2)?;
let ret = TFilesResp {
status: f_1.expect("auto-generated code should have checked for presence of required fields"),
files: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TFilesResp");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("status", TType::Struct, 1))?;
self.status.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("files", TType::List, 2))?;
o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, self.files.len() as i32))?;
for e in &self.files {
e.write_to_out_protocol(o_prot)?;
o_prot.write_list_end()?;
}
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TSpaceQuota
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TSpaceQuota {
pub disk_size: Option<i64>,
pub device_num: Option<i64>,
pub timeserie_num: Option<i64>,
}
impl TSpaceQuota {
pub fn new<F1, F2, F3>(disk_size: F1, device_num: F2, timeserie_num: F3) -> TSpaceQuota where F1: Into<Option<i64>>, F2: Into<Option<i64>>, F3: Into<Option<i64>> {
TSpaceQuota {
disk_size: disk_size.into(),
device_num: device_num.into(),
timeserie_num: timeserie_num.into(),
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TSpaceQuota> {
i_prot.read_struct_begin()?;
let mut f_1: Option<i64> = None;
let mut f_2: Option<i64> = None;
let mut f_3: Option<i64> = 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_i64()?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_i64()?;
f_2 = Some(val);
},
3 => {
let val = i_prot.read_i64()?;
f_3 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = TSpaceQuota {
disk_size: f_1,
device_num: f_2,
timeserie_num: f_3,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TSpaceQuota");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(fld_var) = self.disk_size {
o_prot.write_field_begin(&TFieldIdentifier::new("diskSize", TType::I64, 1))?;
o_prot.write_i64(fld_var)?;
o_prot.write_field_end()?
}
if let Some(fld_var) = self.device_num {
o_prot.write_field_begin(&TFieldIdentifier::new("deviceNum", TType::I64, 2))?;
o_prot.write_i64(fld_var)?;
o_prot.write_field_end()?
}
if let Some(fld_var) = self.timeserie_num {
o_prot.write_field_begin(&TFieldIdentifier::new("timeserieNum", TType::I64, 3))?;
o_prot.write_i64(fld_var)?;
o_prot.write_field_end()?
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
impl Default for TSpaceQuota {
fn default() -> Self {
TSpaceQuota{
disk_size: Some(0),
device_num: Some(0),
timeserie_num: Some(0),
}
}
}
//
// TTimedQuota
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TTimedQuota {
pub time_unit: i64,
pub soft_limit: i64,
}
impl TTimedQuota {
pub fn new(time_unit: i64, soft_limit: i64) -> TTimedQuota {
TTimedQuota {
time_unit,
soft_limit,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TTimedQuota> {
i_prot.read_struct_begin()?;
let mut f_1: Option<i64> = None;
let mut f_2: Option<i64> = 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_i64()?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_i64()?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TTimedQuota.time_unit", &f_1)?;
verify_required_field_exists("TTimedQuota.soft_limit", &f_2)?;
let ret = TTimedQuota {
time_unit: f_1.expect("auto-generated code should have checked for presence of required fields"),
soft_limit: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TTimedQuota");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("timeUnit", TType::I64, 1))?;
o_prot.write_i64(self.time_unit)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("softLimit", TType::I64, 2))?;
o_prot.write_i64(self.soft_limit)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TThrottleQuota
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TThrottleQuota {
pub throttle_limit: Option<BTreeMap<ThrottleType, TTimedQuota>>,
pub mem_limit: Option<i64>,
pub cpu_limit: Option<i32>,
}
impl TThrottleQuota {
pub fn new<F1, F2, F3>(throttle_limit: F1, mem_limit: F2, cpu_limit: F3) -> TThrottleQuota where F1: Into<Option<BTreeMap<ThrottleType, TTimedQuota>>>, F2: Into<Option<i64>>, F3: Into<Option<i32>> {
TThrottleQuota {
throttle_limit: throttle_limit.into(),
mem_limit: mem_limit.into(),
cpu_limit: cpu_limit.into(),
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TThrottleQuota> {
i_prot.read_struct_begin()?;
let mut f_1: Option<BTreeMap<ThrottleType, TTimedQuota>> = None;
let mut f_2: Option<i64> = None;
let mut f_3: Option<i32> = 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 map_ident = i_prot.read_map_begin()?;
let mut val: BTreeMap<ThrottleType, TTimedQuota> = BTreeMap::new();
for _ in 0..map_ident.size {
let map_key_10 = ThrottleType::read_from_in_protocol(i_prot)?;
let map_val_11 = TTimedQuota::read_from_in_protocol(i_prot)?;
val.insert(map_key_10, map_val_11);
}
i_prot.read_map_end()?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_i64()?;
f_2 = Some(val);
},
3 => {
let val = i_prot.read_i32()?;
f_3 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = TThrottleQuota {
throttle_limit: f_1,
mem_limit: f_2,
cpu_limit: f_3,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TThrottleQuota");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(ref fld_var) = self.throttle_limit {
o_prot.write_field_begin(&TFieldIdentifier::new("throttleLimit", TType::Map, 1))?;
o_prot.write_map_begin(&TMapIdentifier::new(TType::I32, TType::Struct, fld_var.len() as i32))?;
for (k, v) in fld_var {
k.write_to_out_protocol(o_prot)?;
v.write_to_out_protocol(o_prot)?;
o_prot.write_map_end()?;
}
o_prot.write_field_end()?
}
if let Some(fld_var) = self.mem_limit {
o_prot.write_field_begin(&TFieldIdentifier::new("memLimit", TType::I64, 2))?;
o_prot.write_i64(fld_var)?;
o_prot.write_field_end()?
}
if let Some(fld_var) = self.cpu_limit {
o_prot.write_field_begin(&TFieldIdentifier::new("cpuLimit", TType::I32, 3))?;
o_prot.write_i32(fld_var)?;
o_prot.write_field_end()?
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
impl Default for TThrottleQuota {
fn default() -> Self {
TThrottleQuota{
throttle_limit: Some(BTreeMap::new()),
mem_limit: Some(0),
cpu_limit: Some(0),
}
}
}
//
// TSetSpaceQuotaReq
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TSetSpaceQuotaReq {
pub database: Vec<String>,
pub space_limit: TSpaceQuota,
}
impl TSetSpaceQuotaReq {
pub fn new(database: Vec<String>, space_limit: TSpaceQuota) -> TSetSpaceQuotaReq {
TSetSpaceQuotaReq {
database,
space_limit,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TSetSpaceQuotaReq> {
i_prot.read_struct_begin()?;
let mut f_1: Option<Vec<String>> = None;
let mut f_2: Option<TSpaceQuota> = 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 list_ident = 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_12 = i_prot.read_string()?;
val.push(list_elem_12);
}
i_prot.read_list_end()?;
f_1 = Some(val);
},
2 => {
let val = TSpaceQuota::read_from_in_protocol(i_prot)?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TSetSpaceQuotaReq.database", &f_1)?;
verify_required_field_exists("TSetSpaceQuotaReq.space_limit", &f_2)?;
let ret = TSetSpaceQuotaReq {
database: f_1.expect("auto-generated code should have checked for presence of required fields"),
space_limit: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TSetSpaceQuotaReq");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("database", TType::List, 1))?;
o_prot.write_list_begin(&TListIdentifier::new(TType::String, self.database.len() as i32))?;
for e in &self.database {
o_prot.write_string(e)?;
o_prot.write_list_end()?;
}
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("spaceLimit", TType::Struct, 2))?;
self.space_limit.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TSetThrottleQuotaReq
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TSetThrottleQuotaReq {
pub user_name: String,
pub throttle_quota: TThrottleQuota,
}
impl TSetThrottleQuotaReq {
pub fn new(user_name: String, throttle_quota: TThrottleQuota) -> TSetThrottleQuotaReq {
TSetThrottleQuotaReq {
user_name,
throttle_quota,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TSetThrottleQuotaReq> {
i_prot.read_struct_begin()?;
let mut f_1: Option<String> = None;
let mut f_2: Option<TThrottleQuota> = 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 = TThrottleQuota::read_from_in_protocol(i_prot)?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TSetThrottleQuotaReq.user_name", &f_1)?;
verify_required_field_exists("TSetThrottleQuotaReq.throttle_quota", &f_2)?;
let ret = TSetThrottleQuotaReq {
user_name: f_1.expect("auto-generated code should have checked for presence of required fields"),
throttle_quota: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TSetThrottleQuotaReq");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("userName", TType::String, 1))?;
o_prot.write_string(&self.user_name)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("throttleQuota", TType::Struct, 2))?;
self.throttle_quota.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TPipeHeartbeatResp
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TPipeHeartbeatResp {
pub pipe_meta_list: Vec<Vec<u8>>,
pub pipe_completed_list: Option<Vec<bool>>,
pub pipe_remaining_event_count_list: Option<Vec<i64>>,
pub pipe_remaining_time_list: Option<Vec<OrderedFloat<f64>>>,
pub pipe_degraded_status_list: Option<Vec<i32>>,
}
impl TPipeHeartbeatResp {
pub fn new<F2, F3, F4, F5>(pipe_meta_list: Vec<Vec<u8>>, pipe_completed_list: F2, pipe_remaining_event_count_list: F3, pipe_remaining_time_list: F4, pipe_degraded_status_list: F5) -> TPipeHeartbeatResp where F2: Into<Option<Vec<bool>>>, F3: Into<Option<Vec<i64>>>, F4: Into<Option<Vec<OrderedFloat<f64>>>>, F5: Into<Option<Vec<i32>>> {
TPipeHeartbeatResp {
pipe_meta_list,
pipe_completed_list: pipe_completed_list.into(),
pipe_remaining_event_count_list: pipe_remaining_event_count_list.into(),
pipe_remaining_time_list: pipe_remaining_time_list.into(),
pipe_degraded_status_list: pipe_degraded_status_list.into(),
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TPipeHeartbeatResp> {
i_prot.read_struct_begin()?;
let mut f_1: Option<Vec<Vec<u8>>> = None;
let mut f_2: Option<Vec<bool>> = None;
let mut f_3: Option<Vec<i64>> = None;
let mut f_4: Option<Vec<OrderedFloat<f64>>> = None;
let mut f_5: Option<Vec<i32>> = 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 list_ident = i_prot.read_list_begin()?;
let mut val: Vec<Vec<u8>> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_13 = i_prot.read_bytes()?;
val.push(list_elem_13);
}
i_prot.read_list_end()?;
f_1 = Some(val);
},
2 => {
let list_ident = i_prot.read_list_begin()?;
let mut val: Vec<bool> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_14 = i_prot.read_bool()?;
val.push(list_elem_14);
}
i_prot.read_list_end()?;
f_2 = Some(val);
},
3 => {
let list_ident = i_prot.read_list_begin()?;
let mut val: Vec<i64> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_15 = i_prot.read_i64()?;
val.push(list_elem_15);
}
i_prot.read_list_end()?;
f_3 = Some(val);
},
4 => {
let list_ident = i_prot.read_list_begin()?;
let mut val: Vec<OrderedFloat<f64>> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_16 = OrderedFloat::from(i_prot.read_double()?);
val.push(list_elem_16);
}
i_prot.read_list_end()?;
f_4 = Some(val);
},
5 => {
let list_ident = 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_17 = i_prot.read_i32()?;
val.push(list_elem_17);
}
i_prot.read_list_end()?;
f_5 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TPipeHeartbeatResp.pipe_meta_list", &f_1)?;
let ret = TPipeHeartbeatResp {
pipe_meta_list: f_1.expect("auto-generated code should have checked for presence of required fields"),
pipe_completed_list: f_2,
pipe_remaining_event_count_list: f_3,
pipe_remaining_time_list: f_4,
pipe_degraded_status_list: f_5,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TPipeHeartbeatResp");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("pipeMetaList", TType::List, 1))?;
o_prot.write_list_begin(&TListIdentifier::new(TType::String, self.pipe_meta_list.len() as i32))?;
for e in &self.pipe_meta_list {
o_prot.write_bytes(e)?;
o_prot.write_list_end()?;
}
o_prot.write_field_end()?;
if let Some(ref fld_var) = self.pipe_completed_list {
o_prot.write_field_begin(&TFieldIdentifier::new("pipeCompletedList", TType::List, 2))?;
o_prot.write_list_begin(&TListIdentifier::new(TType::Bool, fld_var.len() as i32))?;
for e in fld_var {
o_prot.write_bool(*e)?;
o_prot.write_list_end()?;
}
o_prot.write_field_end()?
}
if let Some(ref fld_var) = self.pipe_remaining_event_count_list {
o_prot.write_field_begin(&TFieldIdentifier::new("pipeRemainingEventCountList", TType::List, 3))?;
o_prot.write_list_begin(&TListIdentifier::new(TType::I64, fld_var.len() as i32))?;
for e in fld_var {
o_prot.write_i64(*e)?;
o_prot.write_list_end()?;
}
o_prot.write_field_end()?
}
if let Some(ref fld_var) = self.pipe_remaining_time_list {
o_prot.write_field_begin(&TFieldIdentifier::new("pipeRemainingTimeList", TType::List, 4))?;
o_prot.write_list_begin(&TListIdentifier::new(TType::Double, fld_var.len() as i32))?;
for e in fld_var {
o_prot.write_double((*e).into())?;
o_prot.write_list_end()?;
}
o_prot.write_field_end()?
}
if let Some(ref fld_var) = self.pipe_degraded_status_list {
o_prot.write_field_begin(&TFieldIdentifier::new("pipeDegradedStatusList", TType::List, 5))?;
o_prot.write_list_begin(&TListIdentifier::new(TType::I32, fld_var.len() as i32))?;
for e in fld_var {
o_prot.write_i32(*e)?;
o_prot.write_list_end()?;
}
o_prot.write_field_end()?
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TLicense
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TLicense {
pub license_issue_timestamp: i64,
pub expire_timestamp: i64,
pub data_node_num_limit: i16,
pub cpu_core_num_limit: i32,
pub device_num_limit: i64,
pub sensor_num_limit: i64,
pub disconnection_from_active_node_time_limit: i64,
pub ml_node_num_limit: i16,
}
impl TLicense {
pub fn new(license_issue_timestamp: i64, expire_timestamp: i64, data_node_num_limit: i16, cpu_core_num_limit: i32, device_num_limit: i64, sensor_num_limit: i64, disconnection_from_active_node_time_limit: i64, ml_node_num_limit: i16) -> TLicense {
TLicense {
license_issue_timestamp,
expire_timestamp,
data_node_num_limit,
cpu_core_num_limit,
device_num_limit,
sensor_num_limit,
disconnection_from_active_node_time_limit,
ml_node_num_limit,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TLicense> {
i_prot.read_struct_begin()?;
let mut f_1: Option<i64> = None;
let mut f_2: Option<i64> = None;
let mut f_4: Option<i16> = None;
let mut f_5: Option<i32> = None;
let mut f_6: Option<i64> = None;
let mut f_7: Option<i64> = None;
let mut f_8: Option<i64> = None;
let mut f_9: Option<i16> = 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_i64()?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_i64()?;
f_2 = Some(val);
},
4 => {
let val = i_prot.read_i16()?;
f_4 = Some(val);
},
5 => {
let val = i_prot.read_i32()?;
f_5 = Some(val);
},
6 => {
let val = i_prot.read_i64()?;
f_6 = Some(val);
},
7 => {
let val = i_prot.read_i64()?;
f_7 = Some(val);
},
8 => {
let val = i_prot.read_i64()?;
f_8 = Some(val);
},
9 => {
let val = i_prot.read_i16()?;
f_9 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TLicense.license_issue_timestamp", &f_1)?;
verify_required_field_exists("TLicense.expire_timestamp", &f_2)?;
verify_required_field_exists("TLicense.data_node_num_limit", &f_4)?;
verify_required_field_exists("TLicense.cpu_core_num_limit", &f_5)?;
verify_required_field_exists("TLicense.device_num_limit", &f_6)?;
verify_required_field_exists("TLicense.sensor_num_limit", &f_7)?;
verify_required_field_exists("TLicense.disconnection_from_active_node_time_limit", &f_8)?;
verify_required_field_exists("TLicense.ml_node_num_limit", &f_9)?;
let ret = TLicense {
license_issue_timestamp: f_1.expect("auto-generated code should have checked for presence of required fields"),
expire_timestamp: f_2.expect("auto-generated code should have checked for presence of required fields"),
data_node_num_limit: f_4.expect("auto-generated code should have checked for presence of required fields"),
cpu_core_num_limit: f_5.expect("auto-generated code should have checked for presence of required fields"),
device_num_limit: f_6.expect("auto-generated code should have checked for presence of required fields"),
sensor_num_limit: f_7.expect("auto-generated code should have checked for presence of required fields"),
disconnection_from_active_node_time_limit: f_8.expect("auto-generated code should have checked for presence of required fields"),
ml_node_num_limit: f_9.expect("auto-generated code should have checked for presence of required fields"),
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TLicense");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("licenseIssueTimestamp", TType::I64, 1))?;
o_prot.write_i64(self.license_issue_timestamp)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("expireTimestamp", TType::I64, 2))?;
o_prot.write_i64(self.expire_timestamp)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("dataNodeNumLimit", TType::I16, 4))?;
o_prot.write_i16(self.data_node_num_limit)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("cpuCoreNumLimit", TType::I32, 5))?;
o_prot.write_i32(self.cpu_core_num_limit)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("deviceNumLimit", TType::I64, 6))?;
o_prot.write_i64(self.device_num_limit)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("sensorNumLimit", TType::I64, 7))?;
o_prot.write_i64(self.sensor_num_limit)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("disconnectionFromActiveNodeTimeLimit", TType::I64, 8))?;
o_prot.write_i64(self.disconnection_from_active_node_time_limit)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("mlNodeNumLimit", TType::I16, 9))?;
o_prot.write_i16(self.ml_node_num_limit)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TLoadSample
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TLoadSample {
pub cpu_usage_rate: OrderedFloat<f64>,
pub memory_usage_rate: OrderedFloat<f64>,
pub disk_usage_rate: OrderedFloat<f64>,
pub free_disk_space: OrderedFloat<f64>,
}
impl TLoadSample {
pub fn new(cpu_usage_rate: OrderedFloat<f64>, memory_usage_rate: OrderedFloat<f64>, disk_usage_rate: OrderedFloat<f64>, free_disk_space: OrderedFloat<f64>) -> TLoadSample {
TLoadSample {
cpu_usage_rate,
memory_usage_rate,
disk_usage_rate,
free_disk_space,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TLoadSample> {
i_prot.read_struct_begin()?;
let mut f_1: Option<OrderedFloat<f64>> = None;
let mut f_2: Option<OrderedFloat<f64>> = None;
let mut f_3: Option<OrderedFloat<f64>> = None;
let mut f_4: Option<OrderedFloat<f64>> = 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 = OrderedFloat::from(i_prot.read_double()?);
f_1 = Some(val);
},
2 => {
let val = OrderedFloat::from(i_prot.read_double()?);
f_2 = Some(val);
},
3 => {
let val = OrderedFloat::from(i_prot.read_double()?);
f_3 = Some(val);
},
4 => {
let val = OrderedFloat::from(i_prot.read_double()?);
f_4 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TLoadSample.cpu_usage_rate", &f_1)?;
verify_required_field_exists("TLoadSample.memory_usage_rate", &f_2)?;
verify_required_field_exists("TLoadSample.disk_usage_rate", &f_3)?;
verify_required_field_exists("TLoadSample.free_disk_space", &f_4)?;
let ret = TLoadSample {
cpu_usage_rate: f_1.expect("auto-generated code should have checked for presence of required fields"),
memory_usage_rate: f_2.expect("auto-generated code should have checked for presence of required fields"),
disk_usage_rate: f_3.expect("auto-generated code should have checked for presence of required fields"),
free_disk_space: f_4.expect("auto-generated code should have checked for presence of required fields"),
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TLoadSample");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("cpuUsageRate", TType::Double, 1))?;
o_prot.write_double(self.cpu_usage_rate.into())?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("memoryUsageRate", TType::Double, 2))?;
o_prot.write_double(self.memory_usage_rate.into())?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("diskUsageRate", TType::Double, 3))?;
o_prot.write_double(self.disk_usage_rate.into())?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("freeDiskSpace", TType::Double, 4))?;
o_prot.write_double(self.free_disk_space.into())?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TServiceProvider
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TServiceProvider {
pub end_point: TEndPoint,
pub service_type: TServiceType,
pub node_id: i32,
}
impl TServiceProvider {
pub fn new(end_point: TEndPoint, service_type: TServiceType, node_id: i32) -> TServiceProvider {
TServiceProvider {
end_point,
service_type,
node_id,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TServiceProvider> {
i_prot.read_struct_begin()?;
let mut f_1: Option<TEndPoint> = None;
let mut f_2: Option<TServiceType> = None;
let mut f_3: Option<i32> = 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 = TEndPoint::read_from_in_protocol(i_prot)?;
f_1 = Some(val);
},
2 => {
let val = TServiceType::read_from_in_protocol(i_prot)?;
f_2 = Some(val);
},
3 => {
let val = i_prot.read_i32()?;
f_3 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TServiceProvider.end_point", &f_1)?;
verify_required_field_exists("TServiceProvider.service_type", &f_2)?;
verify_required_field_exists("TServiceProvider.node_id", &f_3)?;
let ret = TServiceProvider {
end_point: f_1.expect("auto-generated code should have checked for presence of required fields"),
service_type: f_2.expect("auto-generated code should have checked for presence of required fields"),
node_id: f_3.expect("auto-generated code should have checked for presence of required fields"),
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TServiceProvider");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("endPoint", TType::Struct, 1))?;
self.end_point.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("serviceType", TType::I32, 2))?;
self.service_type.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("nodeId", TType::I32, 3))?;
o_prot.write_i32(self.node_id)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TSender
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TSender {
pub data_node_location: Option<TDataNodeLocation>,
pub config_node_location: Option<TConfigNodeLocation>,
}
impl TSender {
pub fn new<F1, F2>(data_node_location: F1, config_node_location: F2) -> TSender where F1: Into<Option<TDataNodeLocation>>, F2: Into<Option<TConfigNodeLocation>> {
TSender {
data_node_location: data_node_location.into(),
config_node_location: config_node_location.into(),
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TSender> {
i_prot.read_struct_begin()?;
let mut f_1: Option<TDataNodeLocation> = None;
let mut f_2: Option<TConfigNodeLocation> = 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 = TDataNodeLocation::read_from_in_protocol(i_prot)?;
f_1 = Some(val);
},
2 => {
let val = TConfigNodeLocation::read_from_in_protocol(i_prot)?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = TSender {
data_node_location: f_1,
config_node_location: f_2,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TSender");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(ref fld_var) = self.data_node_location {
o_prot.write_field_begin(&TFieldIdentifier::new("dataNodeLocation", TType::Struct, 1))?;
fld_var.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?
}
if let Some(ref fld_var) = self.config_node_location {
o_prot.write_field_begin(&TFieldIdentifier::new("configNodeLocation", TType::Struct, 2))?;
fld_var.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
impl Default for TSender {
fn default() -> Self {
TSender{
data_node_location: None,
config_node_location: None,
}
}
}
//
// TTestConnectionResult
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TTestConnectionResult {
pub service_provider: TServiceProvider,
pub sender: TSender,
pub success: bool,
pub reason: Option<String>,
}
impl TTestConnectionResult {
pub fn new<F4>(service_provider: TServiceProvider, sender: TSender, success: bool, reason: F4) -> TTestConnectionResult where F4: Into<Option<String>> {
TTestConnectionResult {
service_provider,
sender,
success,
reason: reason.into(),
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TTestConnectionResult> {
i_prot.read_struct_begin()?;
let mut f_1: Option<TServiceProvider> = None;
let mut f_2: Option<TSender> = None;
let mut f_3: Option<bool> = None;
let mut f_4: Option<String> = None;
loop {
let field_ident = i_prot.read_field_begin()?;
if field_ident.field_type == TType::Stop {
break;
}
let field_id = field_id(&field_ident)?;
match field_id {
1 => {
let val = TServiceProvider::read_from_in_protocol(i_prot)?;
f_1 = Some(val);
},
2 => {
let val = TSender::read_from_in_protocol(i_prot)?;
f_2 = Some(val);
},
3 => {
let val = i_prot.read_bool()?;
f_3 = Some(val);
},
4 => {
let val = i_prot.read_string()?;
f_4 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TTestConnectionResult.service_provider", &f_1)?;
verify_required_field_exists("TTestConnectionResult.sender", &f_2)?;
verify_required_field_exists("TTestConnectionResult.success", &f_3)?;
let ret = TTestConnectionResult {
service_provider: f_1.expect("auto-generated code should have checked for presence of required fields"),
sender: f_2.expect("auto-generated code should have checked for presence of required fields"),
success: f_3.expect("auto-generated code should have checked for presence of required fields"),
reason: f_4,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TTestConnectionResult");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("serviceProvider", TType::Struct, 1))?;
self.service_provider.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("sender", TType::Struct, 2))?;
self.sender.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("success", TType::Bool, 3))?;
o_prot.write_bool(self.success)?;
o_prot.write_field_end()?;
if let Some(ref fld_var) = self.reason {
o_prot.write_field_begin(&TFieldIdentifier::new("reason", TType::String, 4))?;
o_prot.write_string(fld_var)?;
o_prot.write_field_end()?
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TTestConnectionResp
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TTestConnectionResp {
pub status: TSStatus,
pub result_list: Vec<TTestConnectionResult>,
}
impl TTestConnectionResp {
pub fn new(status: TSStatus, result_list: Vec<TTestConnectionResult>) -> TTestConnectionResp {
TTestConnectionResp {
status,
result_list,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TTestConnectionResp> {
i_prot.read_struct_begin()?;
let mut f_1: Option<TSStatus> = None;
let mut f_2: Option<Vec<TTestConnectionResult>> = 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 = TSStatus::read_from_in_protocol(i_prot)?;
f_1 = Some(val);
},
2 => {
let list_ident = i_prot.read_list_begin()?;
let mut val: Vec<TTestConnectionResult> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_18 = TTestConnectionResult::read_from_in_protocol(i_prot)?;
val.push(list_elem_18);
}
i_prot.read_list_end()?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TTestConnectionResp.status", &f_1)?;
verify_required_field_exists("TTestConnectionResp.result_list", &f_2)?;
let ret = TTestConnectionResp {
status: f_1.expect("auto-generated code should have checked for presence of required fields"),
result_list: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TTestConnectionResp");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("status", TType::Struct, 1))?;
self.status.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("resultList", TType::List, 2))?;
o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, self.result_list.len() as i32))?;
for e in &self.result_list {
e.write_to_out_protocol(o_prot)?;
o_prot.write_list_end()?;
}
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TNodeLocations
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TNodeLocations {
pub config_node_locations: Option<Vec<TConfigNodeLocation>>,
pub data_node_locations: Option<Vec<TDataNodeLocation>>,
}
impl TNodeLocations {
pub fn new<F1, F2>(config_node_locations: F1, data_node_locations: F2) -> TNodeLocations where F1: Into<Option<Vec<TConfigNodeLocation>>>, F2: Into<Option<Vec<TDataNodeLocation>>> {
TNodeLocations {
config_node_locations: config_node_locations.into(),
data_node_locations: data_node_locations.into(),
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TNodeLocations> {
i_prot.read_struct_begin()?;
let mut f_1: Option<Vec<TConfigNodeLocation>> = None;
let mut f_2: Option<Vec<TDataNodeLocation>> = 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 list_ident = i_prot.read_list_begin()?;
let mut val: Vec<TConfigNodeLocation> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_19 = TConfigNodeLocation::read_from_in_protocol(i_prot)?;
val.push(list_elem_19);
}
i_prot.read_list_end()?;
f_1 = Some(val);
},
2 => {
let list_ident = i_prot.read_list_begin()?;
let mut val: Vec<TDataNodeLocation> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_20 = TDataNodeLocation::read_from_in_protocol(i_prot)?;
val.push(list_elem_20);
}
i_prot.read_list_end()?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
let ret = TNodeLocations {
config_node_locations: f_1,
data_node_locations: f_2,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TNodeLocations");
o_prot.write_struct_begin(&struct_ident)?;
if let Some(ref fld_var) = self.config_node_locations {
o_prot.write_field_begin(&TFieldIdentifier::new("configNodeLocations", TType::List, 1))?;
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()?
}
if let Some(ref fld_var) = self.data_node_locations {
o_prot.write_field_begin(&TFieldIdentifier::new("dataNodeLocations", TType::List, 2))?;
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()?
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
impl Default for TNodeLocations {
fn default() -> Self {
TNodeLocations{
config_node_locations: Some(Vec::new()),
data_node_locations: Some(Vec::new()),
}
}
}
//
// TExternalServiceListResp
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TExternalServiceListResp {
pub status: TSStatus,
pub external_service_infos: Vec<Box<TExternalServiceEntry>>,
}
impl TExternalServiceListResp {
pub fn new(status: TSStatus, external_service_infos: Vec<Box<TExternalServiceEntry>>) -> TExternalServiceListResp {
TExternalServiceListResp {
status,
external_service_infos,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TExternalServiceListResp> {
i_prot.read_struct_begin()?;
let mut f_1: Option<TSStatus> = None;
let mut f_2: Option<Vec<Box<TExternalServiceEntry>>> = 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 = TSStatus::read_from_in_protocol(i_prot)?;
f_1 = Some(val);
},
2 => {
let list_ident = i_prot.read_list_begin()?;
let mut val: Vec<Box<TExternalServiceEntry>> = Vec::with_capacity(list_ident.size as usize);
for _ in 0..list_ident.size {
let list_elem_21 = Box::new(TExternalServiceEntry::read_from_in_protocol(i_prot)?);
val.push(list_elem_21);
}
i_prot.read_list_end()?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TExternalServiceListResp.status", &f_1)?;
verify_required_field_exists("TExternalServiceListResp.external_service_infos", &f_2)?;
let ret = TExternalServiceListResp {
status: f_1.expect("auto-generated code should have checked for presence of required fields"),
external_service_infos: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TExternalServiceListResp");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("status", TType::Struct, 1))?;
self.status.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("externalServiceInfos", TType::List, 2))?;
o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, self.external_service_infos.len() as i32))?;
for e in &self.external_service_infos {
e.write_to_out_protocol(o_prot)?;
o_prot.write_list_end()?;
}
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TExternalServiceEntry
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TExternalServiceEntry {
pub service_name: String,
pub class_name: String,
pub state: i8,
pub data_node_id: i32,
pub service_type: i8,
}
impl TExternalServiceEntry {
pub fn new(service_name: String, class_name: String, state: i8, data_node_id: i32, service_type: i8) -> TExternalServiceEntry {
TExternalServiceEntry {
service_name,
class_name,
state,
data_node_id,
service_type,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TExternalServiceEntry> {
i_prot.read_struct_begin()?;
let mut f_1: Option<String> = None;
let mut f_2: Option<String> = None;
let mut f_3: Option<i8> = None;
let mut f_4: Option<i32> = None;
let mut f_5: Option<i8> = 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_i8()?;
f_3 = Some(val);
},
4 => {
let val = i_prot.read_i32()?;
f_4 = Some(val);
},
5 => {
let val = i_prot.read_i8()?;
f_5 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TExternalServiceEntry.service_name", &f_1)?;
verify_required_field_exists("TExternalServiceEntry.class_name", &f_2)?;
verify_required_field_exists("TExternalServiceEntry.state", &f_3)?;
verify_required_field_exists("TExternalServiceEntry.data_node_id", &f_4)?;
verify_required_field_exists("TExternalServiceEntry.service_type", &f_5)?;
let ret = TExternalServiceEntry {
service_name: f_1.expect("auto-generated code should have checked for presence of required fields"),
class_name: f_2.expect("auto-generated code should have checked for presence of required fields"),
state: f_3.expect("auto-generated code should have checked for presence of required fields"),
data_node_id: f_4.expect("auto-generated code should have checked for presence of required fields"),
service_type: f_5.expect("auto-generated code should have checked for presence of required fields"),
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TExternalServiceEntry");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("serviceName", TType::String, 1))?;
o_prot.write_string(&self.service_name)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("className", TType::String, 2))?;
o_prot.write_string(&self.class_name)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("state", TType::I08, 3))?;
o_prot.write_i8(self.state)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("dataNodeId", TType::I32, 4))?;
o_prot.write_i32(self.data_node_id)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("serviceType", TType::I08, 5))?;
o_prot.write_i8(self.service_type)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TShowConfigurationTemplateResp
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TShowConfigurationTemplateResp {
pub status: TSStatus,
pub content: String,
}
impl TShowConfigurationTemplateResp {
pub fn new(status: TSStatus, content: String) -> TShowConfigurationTemplateResp {
TShowConfigurationTemplateResp {
status,
content,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TShowConfigurationTemplateResp> {
i_prot.read_struct_begin()?;
let mut f_1: Option<TSStatus> = None;
let mut f_2: Option<String> = None;
loop {
let field_ident = i_prot.read_field_begin()?;
if field_ident.field_type == TType::Stop {
break;
}
let field_id = field_id(&field_ident)?;
match field_id {
1 => {
let val = TSStatus::read_from_in_protocol(i_prot)?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_string()?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TShowConfigurationTemplateResp.status", &f_1)?;
verify_required_field_exists("TShowConfigurationTemplateResp.content", &f_2)?;
let ret = TShowConfigurationTemplateResp {
status: f_1.expect("auto-generated code should have checked for presence of required fields"),
content: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TShowConfigurationTemplateResp");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("status", TType::Struct, 1))?;
self.status.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("content", TType::String, 2))?;
o_prot.write_string(&self.content)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TShowConfigurationResp
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TShowConfigurationResp {
pub status: TSStatus,
pub content: String,
}
impl TShowConfigurationResp {
pub fn new(status: TSStatus, content: String) -> TShowConfigurationResp {
TShowConfigurationResp {
status,
content,
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TShowConfigurationResp> {
i_prot.read_struct_begin()?;
let mut f_1: Option<TSStatus> = None;
let mut f_2: Option<String> = None;
loop {
let field_ident = i_prot.read_field_begin()?;
if field_ident.field_type == TType::Stop {
break;
}
let field_id = field_id(&field_ident)?;
match field_id {
1 => {
let val = TSStatus::read_from_in_protocol(i_prot)?;
f_1 = Some(val);
},
2 => {
let val = i_prot.read_string()?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TShowConfigurationResp.status", &f_1)?;
verify_required_field_exists("TShowConfigurationResp.content", &f_2)?;
let ret = TShowConfigurationResp {
status: f_1.expect("auto-generated code should have checked for presence of required fields"),
content: 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 dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TShowConfigurationResp");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("status", TType::Struct, 1))?;
self.status.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
o_prot.write_field_begin(&TFieldIdentifier::new("content", TType::String, 2))?;
o_prot.write_string(&self.content)?;
o_prot.write_field_end()?;
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}
//
// TShowAppliedConfigurationsResp
//
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TShowAppliedConfigurationsResp {
pub status: TSStatus,
pub data: Option<BTreeMap<String, String>>,
}
impl TShowAppliedConfigurationsResp {
pub fn new<F2>(status: TSStatus, data: F2) -> TShowAppliedConfigurationsResp where F2: Into<Option<BTreeMap<String, String>>> {
TShowAppliedConfigurationsResp {
status,
data: data.into(),
}
}
pub fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol) -> thrift::Result<TShowAppliedConfigurationsResp> {
i_prot.read_struct_begin()?;
let mut f_1: Option<TSStatus> = None;
let mut f_2: Option<BTreeMap<String, String>> = None;
loop {
let field_ident = i_prot.read_field_begin()?;
if field_ident.field_type == TType::Stop {
break;
}
let field_id = field_id(&field_ident)?;
match field_id {
1 => {
let val = TSStatus::read_from_in_protocol(i_prot)?;
f_1 = Some(val);
},
2 => {
let map_ident = i_prot.read_map_begin()?;
let mut val: BTreeMap<String, String> = BTreeMap::new();
for _ in 0..map_ident.size {
let map_key_22 = i_prot.read_string()?;
let map_val_23 = i_prot.read_string()?;
val.insert(map_key_22, map_val_23);
}
i_prot.read_map_end()?;
f_2 = Some(val);
},
_ => {
i_prot.skip(field_ident.field_type)?;
},
};
i_prot.read_field_end()?;
}
i_prot.read_struct_end()?;
verify_required_field_exists("TShowAppliedConfigurationsResp.status", &f_1)?;
let ret = TShowAppliedConfigurationsResp {
status: f_1.expect("auto-generated code should have checked for presence of required fields"),
data: f_2,
};
Ok(ret)
}
pub fn write_to_out_protocol(&self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("TShowAppliedConfigurationsResp");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("status", TType::Struct, 1))?;
self.status.write_to_out_protocol(o_prot)?;
o_prot.write_field_end()?;
if let Some(ref fld_var) = self.data {
o_prot.write_field_begin(&TFieldIdentifier::new("data", TType::Map, 2))?;
o_prot.write_map_begin(&TMapIdentifier::new(TType::String, TType::String, fld_var.len() as i32))?;
for (k, v) in fld_var {
o_prot.write_string(k)?;
o_prot.write_string(v)?;
o_prot.write_map_end()?;
}
o_prot.write_field_end()?
}
o_prot.write_field_stop()?;
o_prot.write_struct_end()
}
}