#![allow(non_camel_case_types, non_snake_case, non_upper_case_globals, unused_crate_dependencies)]
pub use self::consts::*;
pub use self::errors::*;
pub use self::types::*;
pub mod consts {
lazy_static::lazy_static! {
pub static ref kInvalidValueType: crate::types::ValueType = crate::types::ValueType {
type_: crate::types::SupportedType::UNKNOWN,
value_type: ::std::default::Default::default(),
schema: ::std::default::Default::default(),
};
}
}
pub mod types {
#![allow(clippy::redundant_closure)]
pub type GraphSpaceID = ::std::primitive::i32;
pub type PartitionID = ::std::primitive::i32;
pub type TagID = ::std::primitive::i32;
pub type EdgeType = ::std::primitive::i32;
pub type EdgeRanking = ::std::primitive::i64;
pub type VertexID = ::std::primitive::i64;
pub type IndexID = ::std::primitive::i32;
pub type IPv4 = ::std::primitive::i32;
pub type Port = ::std::primitive::i32;
pub type SchemaVer = ::std::primitive::i64;
pub type ClusterID = ::std::primitive::i64;
#[derive(Clone, Debug, PartialEq)]
pub struct ValueType {
pub type_: crate::types::SupportedType,
pub value_type: ::std::option::Option<Box<crate::types::ValueType>>,
pub schema: ::std::option::Option<crate::types::Schema>,
}
#[derive(Clone, Debug, PartialEq)]
pub enum Value {
int_value(::std::primitive::i64),
bool_value(::std::primitive::bool),
double_value(::std::primitive::f64),
string_value(::std::string::String),
timestamp(::std::primitive::i64),
UnknownField(::std::primitive::i32),
}
#[derive(Clone, Debug, PartialEq)]
pub struct ColumnDef {
pub name: ::std::string::String,
pub type_: crate::types::ValueType,
pub default_value: ::std::option::Option<crate::types::Value>,
}
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct SchemaProp {
pub ttl_duration: ::std::option::Option<::std::primitive::i64>,
pub ttl_col: ::std::option::Option<::std::string::String>,
}
#[derive(Clone, Debug, PartialEq)]
pub struct Schema {
pub columns: ::std::vec::Vec<crate::types::ColumnDef>,
pub schema_prop: crate::types::SchemaProp,
}
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum SchemaID {
tag_id(crate::types::TagID),
edge_type(crate::types::EdgeType),
UnknownField(::std::primitive::i32),
}
#[derive(Clone, Debug, PartialEq)]
pub struct IndexItem {
pub index_id: crate::types::IndexID,
pub index_name: ::std::string::String,
pub schema_id: crate::types::SchemaID,
pub schema_name: ::std::string::String,
pub fields: ::std::vec::Vec<crate::types::ColumnDef>,
}
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct HostAddr {
pub ip: crate::types::IPv4,
pub port: crate::types::Port,
}
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Pair {
pub key: ::std::string::String,
pub value: ::std::string::String,
}
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct RoleItem {
pub user: ::std::string::String,
pub space_id: crate::types::GraphSpaceID,
pub role_type: crate::types::RoleType,
}
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct SupportedType(pub ::std::primitive::i32);
impl SupportedType {
pub const UNKNOWN: Self = SupportedType(0i32);
pub const BOOL: Self = SupportedType(1i32);
pub const INT: Self = SupportedType(2i32);
pub const VID: Self = SupportedType(3i32);
pub const FLOAT: Self = SupportedType(4i32);
pub const DOUBLE: Self = SupportedType(5i32);
pub const STRING: Self = SupportedType(6i32);
pub const TIMESTAMP: Self = SupportedType(21i32);
pub const YEAR: Self = SupportedType(22i32);
pub const YEARMONTH: Self = SupportedType(23i32);
pub const DATE: Self = SupportedType(24i32);
pub const DATETIME: Self = SupportedType(25i32);
pub const PATH: Self = SupportedType(41i32);
pub fn variants() -> &'static [&'static str] {
&[
"UNKNOWN",
"BOOL",
"INT",
"VID",
"FLOAT",
"DOUBLE",
"STRING",
"TIMESTAMP",
"YEAR",
"YEARMONTH",
"DATE",
"DATETIME",
"PATH",
]
}
}
impl ::std::default::Default for SupportedType {
fn default() -> Self {
SupportedType(::fbthrift::__UNKNOWN_ID)
}
}
impl<'a> ::std::convert::From<&'a SupportedType> for ::std::primitive::i32 {
#[inline]
fn from(x: &'a SupportedType) -> Self {
x.0
}
}
impl ::std::convert::From<SupportedType> for ::std::primitive::i32 {
#[inline]
fn from(x: SupportedType) -> Self {
x.0
}
}
impl ::std::convert::From<::std::primitive::i32> for SupportedType {
#[inline]
fn from(x: ::std::primitive::i32) -> Self {
Self(x)
}
}
impl ::std::fmt::Display for SupportedType {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let s: &::std::primitive::str = match *self {
SupportedType::UNKNOWN => "UNKNOWN",
SupportedType::BOOL => "BOOL",
SupportedType::INT => "INT",
SupportedType::VID => "VID",
SupportedType::FLOAT => "FLOAT",
SupportedType::DOUBLE => "DOUBLE",
SupportedType::STRING => "STRING",
SupportedType::TIMESTAMP => "TIMESTAMP",
SupportedType::YEAR => "YEAR",
SupportedType::YEARMONTH => "YEARMONTH",
SupportedType::DATE => "DATE",
SupportedType::DATETIME => "DATETIME",
SupportedType::PATH => "PATH",
SupportedType(x) => return write!(fmt, "{}", x),
};
write!(fmt, "{}", s)
}
}
impl ::std::fmt::Debug for SupportedType {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(fmt, "SupportedType::{}", self)
}
}
impl ::std::str::FromStr for SupportedType {
type Err = ::anyhow::Error;
fn from_str(string: &::std::primitive::str) -> ::std::result::Result<Self, Self::Err> {
match string {
"UNKNOWN" => ::std::result::Result::Ok(SupportedType::UNKNOWN),
"BOOL" => ::std::result::Result::Ok(SupportedType::BOOL),
"INT" => ::std::result::Result::Ok(SupportedType::INT),
"VID" => ::std::result::Result::Ok(SupportedType::VID),
"FLOAT" => ::std::result::Result::Ok(SupportedType::FLOAT),
"DOUBLE" => ::std::result::Result::Ok(SupportedType::DOUBLE),
"STRING" => ::std::result::Result::Ok(SupportedType::STRING),
"TIMESTAMP" => ::std::result::Result::Ok(SupportedType::TIMESTAMP),
"YEAR" => ::std::result::Result::Ok(SupportedType::YEAR),
"YEARMONTH" => ::std::result::Result::Ok(SupportedType::YEARMONTH),
"DATE" => ::std::result::Result::Ok(SupportedType::DATE),
"DATETIME" => ::std::result::Result::Ok(SupportedType::DATETIME),
"PATH" => ::std::result::Result::Ok(SupportedType::PATH),
_ => ::anyhow::bail!("Unable to parse {} as SupportedType", string),
}
}
}
impl ::fbthrift::GetTType for SupportedType {
const TTYPE: ::fbthrift::TType = ::fbthrift::TType::I32;
}
impl<P> ::fbthrift::Serialize<P> for SupportedType
where
P: ::fbthrift::ProtocolWriter,
{
#[inline]
fn write(&self, p: &mut P) {
p.write_i32(self.into())
}
}
impl<P> ::fbthrift::Deserialize<P> for SupportedType
where
P: ::fbthrift::ProtocolReader,
{
#[inline]
fn read(p: &mut P) -> ::anyhow::Result<Self> {
::std::result::Result::Ok(SupportedType::from(p.read_i32()?))
}
}
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct RoleType(pub ::std::primitive::i32);
impl RoleType {
pub const GOD: Self = RoleType(1i32);
pub const ADMIN: Self = RoleType(2i32);
pub const DBA: Self = RoleType(3i32);
pub const USER: Self = RoleType(4i32);
pub const GUEST: Self = RoleType(5i32);
pub fn variants() -> &'static [&'static str] {
&[
"GOD",
"ADMIN",
"DBA",
"USER",
"GUEST",
]
}
}
impl ::std::default::Default for RoleType {
fn default() -> Self {
RoleType(::fbthrift::__UNKNOWN_ID)
}
}
impl<'a> ::std::convert::From<&'a RoleType> for ::std::primitive::i32 {
#[inline]
fn from(x: &'a RoleType) -> Self {
x.0
}
}
impl ::std::convert::From<RoleType> for ::std::primitive::i32 {
#[inline]
fn from(x: RoleType) -> Self {
x.0
}
}
impl ::std::convert::From<::std::primitive::i32> for RoleType {
#[inline]
fn from(x: ::std::primitive::i32) -> Self {
Self(x)
}
}
impl ::std::fmt::Display for RoleType {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let s: &::std::primitive::str = match *self {
RoleType::GOD => "GOD",
RoleType::ADMIN => "ADMIN",
RoleType::DBA => "DBA",
RoleType::USER => "USER",
RoleType::GUEST => "GUEST",
RoleType(x) => return write!(fmt, "{}", x),
};
write!(fmt, "{}", s)
}
}
impl ::std::fmt::Debug for RoleType {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(fmt, "RoleType::{}", self)
}
}
impl ::std::str::FromStr for RoleType {
type Err = ::anyhow::Error;
fn from_str(string: &::std::primitive::str) -> ::std::result::Result<Self, Self::Err> {
match string {
"GOD" => ::std::result::Result::Ok(RoleType::GOD),
"ADMIN" => ::std::result::Result::Ok(RoleType::ADMIN),
"DBA" => ::std::result::Result::Ok(RoleType::DBA),
"USER" => ::std::result::Result::Ok(RoleType::USER),
"GUEST" => ::std::result::Result::Ok(RoleType::GUEST),
_ => ::anyhow::bail!("Unable to parse {} as RoleType", string),
}
}
}
impl ::fbthrift::GetTType for RoleType {
const TTYPE: ::fbthrift::TType = ::fbthrift::TType::I32;
}
impl<P> ::fbthrift::Serialize<P> for RoleType
where
P: ::fbthrift::ProtocolWriter,
{
#[inline]
fn write(&self, p: &mut P) {
p.write_i32(self.into())
}
}
impl<P> ::fbthrift::Deserialize<P> for RoleType
where
P: ::fbthrift::ProtocolReader,
{
#[inline]
fn read(p: &mut P) -> ::anyhow::Result<Self> {
::std::result::Result::Ok(RoleType::from(p.read_i32()?))
}
}
impl ::std::default::Default for self::ValueType {
fn default() -> Self {
Self {
type_: ::std::default::Default::default(),
value_type: ::std::option::Option::None,
schema: ::std::option::Option::None,
}
}
}
unsafe impl ::std::marker::Send for self::ValueType {}
unsafe impl ::std::marker::Sync for self::ValueType {}
impl ::fbthrift::GetTType for self::ValueType {
const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}
impl<P> ::fbthrift::Serialize<P> for self::ValueType
where
P: ::fbthrift::ProtocolWriter,
{
fn write(&self, p: &mut P) {
p.write_struct_begin("ValueType");
p.write_field_begin("type", ::fbthrift::TType::I32, 1);
::fbthrift::Serialize::write(&self.type_, p);
p.write_field_end();
if let ::std::option::Option::Some(some) = &self.value_type {
p.write_field_begin("value_type", ::fbthrift::TType::Struct, 2);
::fbthrift::Serialize::write(some, p);
p.write_field_end();
}
if let ::std::option::Option::Some(some) = &self.schema {
p.write_field_begin("schema", ::fbthrift::TType::Struct, 3);
::fbthrift::Serialize::write(some, p);
p.write_field_end();
}
p.write_field_stop();
p.write_struct_end();
}
}
impl<P> ::fbthrift::Deserialize<P> for self::ValueType
where
P: ::fbthrift::ProtocolReader,
{
fn read(p: &mut P) -> ::anyhow::Result<Self> {
let mut field_type = ::std::option::Option::None;
let mut field_value_type = ::std::option::Option::None;
let mut field_schema = ::std::option::Option::None;
let _ = p.read_struct_begin(|_| ())?;
loop {
let (_, fty, fid) = p.read_field_begin(|_| ())?;
match (fty, fid as ::std::primitive::i32) {
(::fbthrift::TType::Stop, _) => break,
(::fbthrift::TType::I32, 1) => field_type = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(::fbthrift::TType::Struct, 2) => field_value_type = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(::fbthrift::TType::Struct, 3) => field_schema = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(fty, _) => p.skip(fty)?,
}
p.read_field_end()?;
}
p.read_struct_end()?;
::std::result::Result::Ok(Self {
type_: field_type.unwrap_or_default(),
value_type: field_value_type,
schema: field_schema,
})
}
}
impl ::std::default::Default for Value {
fn default() -> Self {
Self::UnknownField(-1)
}
}
impl ::fbthrift::GetTType for Value {
const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}
impl<P> ::fbthrift::Serialize<P> for Value
where
P: ::fbthrift::ProtocolWriter,
{
fn write(&self, p: &mut P) {
p.write_struct_begin("Value");
match self {
Value::int_value(inner) => {
p.write_field_begin("int_value", ::fbthrift::TType::I64, 1);
::fbthrift::Serialize::write(inner, p);
p.write_field_end();
}
Value::bool_value(inner) => {
p.write_field_begin("bool_value", ::fbthrift::TType::Bool, 2);
::fbthrift::Serialize::write(inner, p);
p.write_field_end();
}
Value::double_value(inner) => {
p.write_field_begin("double_value", ::fbthrift::TType::Double, 3);
::fbthrift::Serialize::write(inner, p);
p.write_field_end();
}
Value::string_value(inner) => {
p.write_field_begin("string_value", ::fbthrift::TType::String, 4);
::fbthrift::Serialize::write(inner, p);
p.write_field_end();
}
Value::timestamp(inner) => {
p.write_field_begin("timestamp", ::fbthrift::TType::I64, 5);
::fbthrift::Serialize::write(inner, p);
p.write_field_end();
}
Value::UnknownField(x) => {
p.write_field_begin("UnknownField", ::fbthrift::TType::I32, *x as ::std::primitive::i16);
x.write(p);
p.write_field_end();
}
}
p.write_field_stop();
p.write_struct_end();
}
}
impl<P> ::fbthrift::Deserialize<P> for Value
where
P: ::fbthrift::ProtocolReader,
{
fn read(p: &mut P) -> ::anyhow::Result<Self> {
let _ = p.read_struct_begin(|_| ())?;
let mut once = false;
let mut alt = ::std::option::Option::None;
loop {
let (_, fty, fid) = p.read_field_begin(|_| ())?;
match (fty, fid as ::std::primitive::i32, once) {
(::fbthrift::TType::Stop, _, _) => break,
(::fbthrift::TType::I64, 1, false) => {
once = true;
alt = ::std::option::Option::Some(Value::int_value(::fbthrift::Deserialize::read(p)?));
}
(::fbthrift::TType::Bool, 2, false) => {
once = true;
alt = ::std::option::Option::Some(Value::bool_value(::fbthrift::Deserialize::read(p)?));
}
(::fbthrift::TType::Double, 3, false) => {
once = true;
alt = ::std::option::Option::Some(Value::double_value(::fbthrift::Deserialize::read(p)?));
}
(::fbthrift::TType::String, 4, false) => {
once = true;
alt = ::std::option::Option::Some(Value::string_value(::fbthrift::Deserialize::read(p)?));
}
(::fbthrift::TType::I64, 5, false) => {
once = true;
alt = ::std::option::Option::Some(Value::timestamp(::fbthrift::Deserialize::read(p)?));
}
(fty, _, false) => p.skip(fty)?,
(badty, badid, true) => return ::std::result::Result::Err(::std::convert::From::from(::fbthrift::ApplicationException::new(
::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
format!(
"unwanted extra union {} field ty {:?} id {}",
"Value",
badty,
badid,
),
))),
}
p.read_field_end()?;
}
p.read_struct_end()?;
::std::result::Result::Ok(alt.unwrap_or_default())
}
}
impl ::std::default::Default for self::ColumnDef {
fn default() -> Self {
Self {
name: ::std::default::Default::default(),
type_: ::std::default::Default::default(),
default_value: ::std::option::Option::None,
}
}
}
unsafe impl ::std::marker::Send for self::ColumnDef {}
unsafe impl ::std::marker::Sync for self::ColumnDef {}
impl ::fbthrift::GetTType for self::ColumnDef {
const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}
impl<P> ::fbthrift::Serialize<P> for self::ColumnDef
where
P: ::fbthrift::ProtocolWriter,
{
fn write(&self, p: &mut P) {
p.write_struct_begin("ColumnDef");
p.write_field_begin("name", ::fbthrift::TType::String, 1);
::fbthrift::Serialize::write(&self.name, p);
p.write_field_end();
p.write_field_begin("type", ::fbthrift::TType::Struct, 2);
::fbthrift::Serialize::write(&self.type_, p);
p.write_field_end();
if let ::std::option::Option::Some(some) = &self.default_value {
p.write_field_begin("default_value", ::fbthrift::TType::Struct, 3);
::fbthrift::Serialize::write(some, p);
p.write_field_end();
}
p.write_field_stop();
p.write_struct_end();
}
}
impl<P> ::fbthrift::Deserialize<P> for self::ColumnDef
where
P: ::fbthrift::ProtocolReader,
{
fn read(p: &mut P) -> ::anyhow::Result<Self> {
let mut field_name = ::std::option::Option::None;
let mut field_type = ::std::option::Option::None;
let mut field_default_value = ::std::option::Option::None;
let _ = p.read_struct_begin(|_| ())?;
loop {
let (_, fty, fid) = p.read_field_begin(|_| ())?;
match (fty, fid as ::std::primitive::i32) {
(::fbthrift::TType::Stop, _) => break,
(::fbthrift::TType::String, 1) => field_name = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(::fbthrift::TType::Struct, 2) => field_type = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(::fbthrift::TType::Struct, 3) => field_default_value = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(fty, _) => p.skip(fty)?,
}
p.read_field_end()?;
}
p.read_struct_end()?;
::std::result::Result::Ok(Self {
name: field_name.unwrap_or_default(),
type_: field_type.unwrap_or_default(),
default_value: field_default_value,
})
}
}
impl ::std::default::Default for self::SchemaProp {
fn default() -> Self {
Self {
ttl_duration: ::std::option::Option::None,
ttl_col: ::std::option::Option::None,
}
}
}
unsafe impl ::std::marker::Send for self::SchemaProp {}
unsafe impl ::std::marker::Sync for self::SchemaProp {}
impl ::fbthrift::GetTType for self::SchemaProp {
const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}
impl<P> ::fbthrift::Serialize<P> for self::SchemaProp
where
P: ::fbthrift::ProtocolWriter,
{
fn write(&self, p: &mut P) {
p.write_struct_begin("SchemaProp");
if let ::std::option::Option::Some(some) = &self.ttl_duration {
p.write_field_begin("ttl_duration", ::fbthrift::TType::I64, 1);
::fbthrift::Serialize::write(some, p);
p.write_field_end();
}
if let ::std::option::Option::Some(some) = &self.ttl_col {
p.write_field_begin("ttl_col", ::fbthrift::TType::String, 2);
::fbthrift::Serialize::write(some, p);
p.write_field_end();
}
p.write_field_stop();
p.write_struct_end();
}
}
impl<P> ::fbthrift::Deserialize<P> for self::SchemaProp
where
P: ::fbthrift::ProtocolReader,
{
fn read(p: &mut P) -> ::anyhow::Result<Self> {
let mut field_ttl_duration = ::std::option::Option::None;
let mut field_ttl_col = ::std::option::Option::None;
let _ = p.read_struct_begin(|_| ())?;
loop {
let (_, fty, fid) = p.read_field_begin(|_| ())?;
match (fty, fid as ::std::primitive::i32) {
(::fbthrift::TType::Stop, _) => break,
(::fbthrift::TType::I64, 1) => field_ttl_duration = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(::fbthrift::TType::String, 2) => field_ttl_col = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(fty, _) => p.skip(fty)?,
}
p.read_field_end()?;
}
p.read_struct_end()?;
::std::result::Result::Ok(Self {
ttl_duration: field_ttl_duration,
ttl_col: field_ttl_col,
})
}
}
impl ::std::default::Default for self::Schema {
fn default() -> Self {
Self {
columns: ::std::default::Default::default(),
schema_prop: ::std::default::Default::default(),
}
}
}
unsafe impl ::std::marker::Send for self::Schema {}
unsafe impl ::std::marker::Sync for self::Schema {}
impl ::fbthrift::GetTType for self::Schema {
const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}
impl<P> ::fbthrift::Serialize<P> for self::Schema
where
P: ::fbthrift::ProtocolWriter,
{
fn write(&self, p: &mut P) {
p.write_struct_begin("Schema");
p.write_field_begin("columns", ::fbthrift::TType::List, 1);
::fbthrift::Serialize::write(&self.columns, p);
p.write_field_end();
p.write_field_begin("schema_prop", ::fbthrift::TType::Struct, 2);
::fbthrift::Serialize::write(&self.schema_prop, p);
p.write_field_end();
p.write_field_stop();
p.write_struct_end();
}
}
impl<P> ::fbthrift::Deserialize<P> for self::Schema
where
P: ::fbthrift::ProtocolReader,
{
fn read(p: &mut P) -> ::anyhow::Result<Self> {
let mut field_columns = ::std::option::Option::None;
let mut field_schema_prop = ::std::option::Option::None;
let _ = p.read_struct_begin(|_| ())?;
loop {
let (_, fty, fid) = p.read_field_begin(|_| ())?;
match (fty, fid as ::std::primitive::i32) {
(::fbthrift::TType::Stop, _) => break,
(::fbthrift::TType::List, 1) => field_columns = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(::fbthrift::TType::Struct, 2) => field_schema_prop = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(fty, _) => p.skip(fty)?,
}
p.read_field_end()?;
}
p.read_struct_end()?;
::std::result::Result::Ok(Self {
columns: field_columns.unwrap_or_default(),
schema_prop: field_schema_prop.unwrap_or_default(),
})
}
}
impl ::std::default::Default for SchemaID {
fn default() -> Self {
Self::UnknownField(-1)
}
}
impl ::fbthrift::GetTType for SchemaID {
const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}
impl<P> ::fbthrift::Serialize<P> for SchemaID
where
P: ::fbthrift::ProtocolWriter,
{
fn write(&self, p: &mut P) {
p.write_struct_begin("SchemaID");
match self {
SchemaID::tag_id(inner) => {
p.write_field_begin("tag_id", ::fbthrift::TType::I32, 1);
::fbthrift::Serialize::write(inner, p);
p.write_field_end();
}
SchemaID::edge_type(inner) => {
p.write_field_begin("edge_type", ::fbthrift::TType::I32, 2);
::fbthrift::Serialize::write(inner, p);
p.write_field_end();
}
SchemaID::UnknownField(x) => {
p.write_field_begin("UnknownField", ::fbthrift::TType::I32, *x as ::std::primitive::i16);
x.write(p);
p.write_field_end();
}
}
p.write_field_stop();
p.write_struct_end();
}
}
impl<P> ::fbthrift::Deserialize<P> for SchemaID
where
P: ::fbthrift::ProtocolReader,
{
fn read(p: &mut P) -> ::anyhow::Result<Self> {
let _ = p.read_struct_begin(|_| ())?;
let mut once = false;
let mut alt = ::std::option::Option::None;
loop {
let (_, fty, fid) = p.read_field_begin(|_| ())?;
match (fty, fid as ::std::primitive::i32, once) {
(::fbthrift::TType::Stop, _, _) => break,
(::fbthrift::TType::I32, 1, false) => {
once = true;
alt = ::std::option::Option::Some(SchemaID::tag_id(::fbthrift::Deserialize::read(p)?));
}
(::fbthrift::TType::I32, 2, false) => {
once = true;
alt = ::std::option::Option::Some(SchemaID::edge_type(::fbthrift::Deserialize::read(p)?));
}
(fty, _, false) => p.skip(fty)?,
(badty, badid, true) => return ::std::result::Result::Err(::std::convert::From::from(::fbthrift::ApplicationException::new(
::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
format!(
"unwanted extra union {} field ty {:?} id {}",
"SchemaID",
badty,
badid,
),
))),
}
p.read_field_end()?;
}
p.read_struct_end()?;
::std::result::Result::Ok(alt.unwrap_or_default())
}
}
impl ::std::default::Default for self::IndexItem {
fn default() -> Self {
Self {
index_id: ::std::default::Default::default(),
index_name: ::std::default::Default::default(),
schema_id: ::std::default::Default::default(),
schema_name: ::std::default::Default::default(),
fields: ::std::default::Default::default(),
}
}
}
unsafe impl ::std::marker::Send for self::IndexItem {}
unsafe impl ::std::marker::Sync for self::IndexItem {}
impl ::fbthrift::GetTType for self::IndexItem {
const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}
impl<P> ::fbthrift::Serialize<P> for self::IndexItem
where
P: ::fbthrift::ProtocolWriter,
{
fn write(&self, p: &mut P) {
p.write_struct_begin("IndexItem");
p.write_field_begin("index_id", ::fbthrift::TType::I32, 1);
::fbthrift::Serialize::write(&self.index_id, p);
p.write_field_end();
p.write_field_begin("index_name", ::fbthrift::TType::String, 2);
::fbthrift::Serialize::write(&self.index_name, p);
p.write_field_end();
p.write_field_begin("schema_id", ::fbthrift::TType::Struct, 3);
::fbthrift::Serialize::write(&self.schema_id, p);
p.write_field_end();
p.write_field_begin("schema_name", ::fbthrift::TType::String, 4);
::fbthrift::Serialize::write(&self.schema_name, p);
p.write_field_end();
p.write_field_begin("fields", ::fbthrift::TType::List, 5);
::fbthrift::Serialize::write(&self.fields, p);
p.write_field_end();
p.write_field_stop();
p.write_struct_end();
}
}
impl<P> ::fbthrift::Deserialize<P> for self::IndexItem
where
P: ::fbthrift::ProtocolReader,
{
fn read(p: &mut P) -> ::anyhow::Result<Self> {
let mut field_index_id = ::std::option::Option::None;
let mut field_index_name = ::std::option::Option::None;
let mut field_schema_id = ::std::option::Option::None;
let mut field_schema_name = ::std::option::Option::None;
let mut field_fields = ::std::option::Option::None;
let _ = p.read_struct_begin(|_| ())?;
loop {
let (_, fty, fid) = p.read_field_begin(|_| ())?;
match (fty, fid as ::std::primitive::i32) {
(::fbthrift::TType::Stop, _) => break,
(::fbthrift::TType::I32, 1) => field_index_id = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(::fbthrift::TType::String, 2) => field_index_name = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(::fbthrift::TType::Struct, 3) => field_schema_id = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(::fbthrift::TType::String, 4) => field_schema_name = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(::fbthrift::TType::List, 5) => field_fields = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(fty, _) => p.skip(fty)?,
}
p.read_field_end()?;
}
p.read_struct_end()?;
::std::result::Result::Ok(Self {
index_id: field_index_id.unwrap_or_default(),
index_name: field_index_name.unwrap_or_default(),
schema_id: field_schema_id.unwrap_or_default(),
schema_name: field_schema_name.unwrap_or_default(),
fields: field_fields.unwrap_or_default(),
})
}
}
impl ::std::default::Default for self::HostAddr {
fn default() -> Self {
Self {
ip: ::std::default::Default::default(),
port: ::std::default::Default::default(),
}
}
}
unsafe impl ::std::marker::Send for self::HostAddr {}
unsafe impl ::std::marker::Sync for self::HostAddr {}
impl ::fbthrift::GetTType for self::HostAddr {
const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}
impl<P> ::fbthrift::Serialize<P> for self::HostAddr
where
P: ::fbthrift::ProtocolWriter,
{
fn write(&self, p: &mut P) {
p.write_struct_begin("HostAddr");
p.write_field_begin("ip", ::fbthrift::TType::I32, 1);
::fbthrift::Serialize::write(&self.ip, p);
p.write_field_end();
p.write_field_begin("port", ::fbthrift::TType::I32, 2);
::fbthrift::Serialize::write(&self.port, p);
p.write_field_end();
p.write_field_stop();
p.write_struct_end();
}
}
impl<P> ::fbthrift::Deserialize<P> for self::HostAddr
where
P: ::fbthrift::ProtocolReader,
{
fn read(p: &mut P) -> ::anyhow::Result<Self> {
let mut field_ip = ::std::option::Option::None;
let mut field_port = ::std::option::Option::None;
let _ = p.read_struct_begin(|_| ())?;
loop {
let (_, fty, fid) = p.read_field_begin(|_| ())?;
match (fty, fid as ::std::primitive::i32) {
(::fbthrift::TType::Stop, _) => break,
(::fbthrift::TType::I32, 1) => field_ip = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(::fbthrift::TType::I32, 2) => field_port = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(fty, _) => p.skip(fty)?,
}
p.read_field_end()?;
}
p.read_struct_end()?;
::std::result::Result::Ok(Self {
ip: field_ip.unwrap_or_default(),
port: field_port.unwrap_or_default(),
})
}
}
impl ::std::default::Default for self::Pair {
fn default() -> Self {
Self {
key: ::std::default::Default::default(),
value: ::std::default::Default::default(),
}
}
}
unsafe impl ::std::marker::Send for self::Pair {}
unsafe impl ::std::marker::Sync for self::Pair {}
impl ::fbthrift::GetTType for self::Pair {
const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}
impl<P> ::fbthrift::Serialize<P> for self::Pair
where
P: ::fbthrift::ProtocolWriter,
{
fn write(&self, p: &mut P) {
p.write_struct_begin("Pair");
p.write_field_begin("key", ::fbthrift::TType::String, 1);
::fbthrift::Serialize::write(&self.key, p);
p.write_field_end();
p.write_field_begin("value", ::fbthrift::TType::String, 2);
::fbthrift::Serialize::write(&self.value, p);
p.write_field_end();
p.write_field_stop();
p.write_struct_end();
}
}
impl<P> ::fbthrift::Deserialize<P> for self::Pair
where
P: ::fbthrift::ProtocolReader,
{
fn read(p: &mut P) -> ::anyhow::Result<Self> {
let mut field_key = ::std::option::Option::None;
let mut field_value = ::std::option::Option::None;
let _ = p.read_struct_begin(|_| ())?;
loop {
let (_, fty, fid) = p.read_field_begin(|_| ())?;
match (fty, fid as ::std::primitive::i32) {
(::fbthrift::TType::Stop, _) => break,
(::fbthrift::TType::String, 1) => field_key = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(::fbthrift::TType::String, 2) => field_value = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(fty, _) => p.skip(fty)?,
}
p.read_field_end()?;
}
p.read_struct_end()?;
::std::result::Result::Ok(Self {
key: field_key.unwrap_or_default(),
value: field_value.unwrap_or_default(),
})
}
}
impl ::std::default::Default for self::RoleItem {
fn default() -> Self {
Self {
user: ::std::default::Default::default(),
space_id: ::std::default::Default::default(),
role_type: ::std::default::Default::default(),
}
}
}
unsafe impl ::std::marker::Send for self::RoleItem {}
unsafe impl ::std::marker::Sync for self::RoleItem {}
impl ::fbthrift::GetTType for self::RoleItem {
const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}
impl<P> ::fbthrift::Serialize<P> for self::RoleItem
where
P: ::fbthrift::ProtocolWriter,
{
fn write(&self, p: &mut P) {
p.write_struct_begin("RoleItem");
p.write_field_begin("user", ::fbthrift::TType::String, 1);
::fbthrift::Serialize::write(&self.user, p);
p.write_field_end();
p.write_field_begin("space_id", ::fbthrift::TType::I32, 2);
::fbthrift::Serialize::write(&self.space_id, p);
p.write_field_end();
p.write_field_begin("role_type", ::fbthrift::TType::I32, 3);
::fbthrift::Serialize::write(&self.role_type, p);
p.write_field_end();
p.write_field_stop();
p.write_struct_end();
}
}
impl<P> ::fbthrift::Deserialize<P> for self::RoleItem
where
P: ::fbthrift::ProtocolReader,
{
fn read(p: &mut P) -> ::anyhow::Result<Self> {
let mut field_user = ::std::option::Option::None;
let mut field_space_id = ::std::option::Option::None;
let mut field_role_type = ::std::option::Option::None;
let _ = p.read_struct_begin(|_| ())?;
loop {
let (_, fty, fid) = p.read_field_begin(|_| ())?;
match (fty, fid as ::std::primitive::i32) {
(::fbthrift::TType::Stop, _) => break,
(::fbthrift::TType::String, 1) => field_user = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(::fbthrift::TType::I32, 2) => field_space_id = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(::fbthrift::TType::I32, 3) => field_role_type = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
(fty, _) => p.skip(fty)?,
}
p.read_field_end()?;
}
p.read_struct_end()?;
::std::result::Result::Ok(Self {
user: field_user.unwrap_or_default(),
space_id: field_space_id.unwrap_or_default(),
role_type: field_role_type.unwrap_or_default(),
})
}
}
}
pub mod errors {
}