#![allow(unknown_lints)]
#![allow(clippy::all)]
#![cfg_attr(rustfmt, rustfmt_skip)]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unsafe_code)]
#![allow(unused_imports)]
#![allow(unused_results)]
use protobuf::Message as Message_imported_for_functions;
use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;
const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_8_2;
#[derive(PartialEq,Clone,Default)]
pub struct Request {
pub start_ts: u64,
pub query: ::std::string::String,
pub vars: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
pub read_only: bool,
pub best_effort: bool,
pub mutations: ::protobuf::RepeatedField<Mutation>,
pub commit_now: bool,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Request {
fn default() -> &'a Request {
<Request as ::protobuf::Message>::default_instance()
}
}
impl Request {
pub fn new() -> Request {
::std::default::Default::default()
}
pub fn get_start_ts(&self) -> u64 {
self.start_ts
}
pub fn clear_start_ts(&mut self) {
self.start_ts = 0;
}
pub fn set_start_ts(&mut self, v: u64) {
self.start_ts = v;
}
pub fn get_query(&self) -> &str {
&self.query
}
pub fn clear_query(&mut self) {
self.query.clear();
}
pub fn set_query(&mut self, v: ::std::string::String) {
self.query = v;
}
pub fn mut_query(&mut self) -> &mut ::std::string::String {
&mut self.query
}
pub fn take_query(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.query, ::std::string::String::new())
}
pub fn get_vars(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> {
&self.vars
}
pub fn clear_vars(&mut self) {
self.vars.clear();
}
pub fn set_vars(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::string::String>) {
self.vars = v;
}
pub fn mut_vars(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> {
&mut self.vars
}
pub fn take_vars(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> {
::std::mem::replace(&mut self.vars, ::std::collections::HashMap::new())
}
pub fn get_read_only(&self) -> bool {
self.read_only
}
pub fn clear_read_only(&mut self) {
self.read_only = false;
}
pub fn set_read_only(&mut self, v: bool) {
self.read_only = v;
}
pub fn get_best_effort(&self) -> bool {
self.best_effort
}
pub fn clear_best_effort(&mut self) {
self.best_effort = false;
}
pub fn set_best_effort(&mut self, v: bool) {
self.best_effort = v;
}
pub fn get_mutations(&self) -> &[Mutation] {
&self.mutations
}
pub fn clear_mutations(&mut self) {
self.mutations.clear();
}
pub fn set_mutations(&mut self, v: ::protobuf::RepeatedField<Mutation>) {
self.mutations = v;
}
pub fn mut_mutations(&mut self) -> &mut ::protobuf::RepeatedField<Mutation> {
&mut self.mutations
}
pub fn take_mutations(&mut self) -> ::protobuf::RepeatedField<Mutation> {
::std::mem::replace(&mut self.mutations, ::protobuf::RepeatedField::new())
}
pub fn get_commit_now(&self) -> bool {
self.commit_now
}
pub fn clear_commit_now(&mut self) {
self.commit_now = false;
}
pub fn set_commit_now(&mut self, v: bool) {
self.commit_now = v;
}
}
impl ::protobuf::Message for Request {
fn is_initialized(&self) -> bool {
for v in &self.mutations {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_ts = tmp;
},
4 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.query)?;
},
5 => {
::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.vars)?;
},
6 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.read_only = tmp;
},
7 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.best_effort = tmp;
},
12 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.mutations)?;
},
13 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.commit_now = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.start_ts != 0 {
my_size += ::protobuf::rt::value_size(1, self.start_ts, ::protobuf::wire_format::WireTypeVarint);
}
if !self.query.is_empty() {
my_size += ::protobuf::rt::string_size(4, &self.query);
}
my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(5, &self.vars);
if self.read_only != false {
my_size += 2;
}
if self.best_effort != false {
my_size += 2;
}
for value in &self.mutations {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
if self.commit_now != false {
my_size += 2;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if self.start_ts != 0 {
os.write_uint64(1, self.start_ts)?;
}
if !self.query.is_empty() {
os.write_string(4, &self.query)?;
}
::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(5, &self.vars, os)?;
if self.read_only != false {
os.write_bool(6, self.read_only)?;
}
if self.best_effort != false {
os.write_bool(7, self.best_effort)?;
}
for v in &self.mutations {
os.write_tag(12, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
if self.commit_now != false {
os.write_bool(13, self.commit_now)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Request {
Request::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"start_ts",
|m: &Request| { &m.start_ts },
|m: &mut Request| { &mut m.start_ts },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"query",
|m: &Request| { &m.query },
|m: &mut Request| { &mut m.query },
));
fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(
"vars",
|m: &Request| { &m.vars },
|m: &mut Request| { &mut m.vars },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"read_only",
|m: &Request| { &m.read_only },
|m: &mut Request| { &mut m.read_only },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"best_effort",
|m: &Request| { &m.best_effort },
|m: &mut Request| { &mut m.best_effort },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Mutation>>(
"mutations",
|m: &Request| { &m.mutations },
|m: &mut Request| { &mut m.mutations },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"commit_now",
|m: &Request| { &m.commit_now },
|m: &mut Request| { &mut m.commit_now },
));
::protobuf::reflect::MessageDescriptor::new::<Request>(
"Request",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Request {
static mut instance: ::protobuf::lazy::Lazy<Request> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Request,
};
unsafe {
instance.get(Request::new)
}
}
}
impl ::protobuf::Clear for Request {
fn clear(&mut self) {
self.start_ts = 0;
self.query.clear();
self.vars.clear();
self.read_only = false;
self.best_effort = false;
self.mutations.clear();
self.commit_now = false;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Request {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Uids {
pub uids: ::protobuf::RepeatedField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Uids {
fn default() -> &'a Uids {
<Uids as ::protobuf::Message>::default_instance()
}
}
impl Uids {
pub fn new() -> Uids {
::std::default::Default::default()
}
pub fn get_uids(&self) -> &[::std::string::String] {
&self.uids
}
pub fn clear_uids(&mut self) {
self.uids.clear();
}
pub fn set_uids(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
self.uids = v;
}
pub fn mut_uids(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
&mut self.uids
}
pub fn take_uids(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
::std::mem::replace(&mut self.uids, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for Uids {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.uids)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
for value in &self.uids {
my_size += ::protobuf::rt::string_size(1, &value);
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
for v in &self.uids {
os.write_string(1, &v)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Uids {
Uids::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"uids",
|m: &Uids| { &m.uids },
|m: &mut Uids| { &mut m.uids },
));
::protobuf::reflect::MessageDescriptor::new::<Uids>(
"Uids",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Uids {
static mut instance: ::protobuf::lazy::Lazy<Uids> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Uids,
};
unsafe {
instance.get(Uids::new)
}
}
}
impl ::protobuf::Clear for Uids {
fn clear(&mut self) {
self.uids.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Uids {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Uids {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Response {
pub json: ::std::vec::Vec<u8>,
pub txn: ::protobuf::SingularPtrField<TxnContext>,
pub latency: ::protobuf::SingularPtrField<Latency>,
pub metrics: ::protobuf::SingularPtrField<Metrics>,
pub uids: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Response {
fn default() -> &'a Response {
<Response as ::protobuf::Message>::default_instance()
}
}
impl Response {
pub fn new() -> Response {
::std::default::Default::default()
}
pub fn get_json(&self) -> &[u8] {
&self.json
}
pub fn clear_json(&mut self) {
self.json.clear();
}
pub fn set_json(&mut self, v: ::std::vec::Vec<u8>) {
self.json = v;
}
pub fn mut_json(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.json
}
pub fn take_json(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.json, ::std::vec::Vec::new())
}
pub fn get_txn(&self) -> &TxnContext {
self.txn.as_ref().unwrap_or_else(|| TxnContext::default_instance())
}
pub fn clear_txn(&mut self) {
self.txn.clear();
}
pub fn has_txn(&self) -> bool {
self.txn.is_some()
}
pub fn set_txn(&mut self, v: TxnContext) {
self.txn = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_txn(&mut self) -> &mut TxnContext {
if self.txn.is_none() {
self.txn.set_default();
}
self.txn.as_mut().unwrap()
}
pub fn take_txn(&mut self) -> TxnContext {
self.txn.take().unwrap_or_else(|| TxnContext::new())
}
pub fn get_latency(&self) -> &Latency {
self.latency.as_ref().unwrap_or_else(|| Latency::default_instance())
}
pub fn clear_latency(&mut self) {
self.latency.clear();
}
pub fn has_latency(&self) -> bool {
self.latency.is_some()
}
pub fn set_latency(&mut self, v: Latency) {
self.latency = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_latency(&mut self) -> &mut Latency {
if self.latency.is_none() {
self.latency.set_default();
}
self.latency.as_mut().unwrap()
}
pub fn take_latency(&mut self) -> Latency {
self.latency.take().unwrap_or_else(|| Latency::new())
}
pub fn get_metrics(&self) -> &Metrics {
self.metrics.as_ref().unwrap_or_else(|| Metrics::default_instance())
}
pub fn clear_metrics(&mut self) {
self.metrics.clear();
}
pub fn has_metrics(&self) -> bool {
self.metrics.is_some()
}
pub fn set_metrics(&mut self, v: Metrics) {
self.metrics = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_metrics(&mut self) -> &mut Metrics {
if self.metrics.is_none() {
self.metrics.set_default();
}
self.metrics.as_mut().unwrap()
}
pub fn take_metrics(&mut self) -> Metrics {
self.metrics.take().unwrap_or_else(|| Metrics::new())
}
pub fn get_uids(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> {
&self.uids
}
pub fn clear_uids(&mut self) {
self.uids.clear();
}
pub fn set_uids(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::string::String>) {
self.uids = v;
}
pub fn mut_uids(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> {
&mut self.uids
}
pub fn take_uids(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> {
::std::mem::replace(&mut self.uids, ::std::collections::HashMap::new())
}
}
impl ::protobuf::Message for Response {
fn is_initialized(&self) -> bool {
for v in &self.txn {
if !v.is_initialized() {
return false;
}
};
for v in &self.latency {
if !v.is_initialized() {
return false;
}
};
for v in &self.metrics {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.json)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.txn)?;
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.latency)?;
},
4 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.metrics)?;
},
12 => {
::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.uids)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.json.is_empty() {
my_size += ::protobuf::rt::bytes_size(1, &self.json);
}
if let Some(ref v) = self.txn.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.latency.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.metrics.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(12, &self.uids);
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if !self.json.is_empty() {
os.write_bytes(1, &self.json)?;
}
if let Some(ref v) = self.txn.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.latency.as_ref() {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.metrics.as_ref() {
os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(12, &self.uids, os)?;
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Response {
Response::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"json",
|m: &Response| { &m.json },
|m: &mut Response| { &mut m.json },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TxnContext>>(
"txn",
|m: &Response| { &m.txn },
|m: &mut Response| { &mut m.txn },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Latency>>(
"latency",
|m: &Response| { &m.latency },
|m: &mut Response| { &mut m.latency },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Metrics>>(
"metrics",
|m: &Response| { &m.metrics },
|m: &mut Response| { &mut m.metrics },
));
fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(
"uids",
|m: &Response| { &m.uids },
|m: &mut Response| { &mut m.uids },
));
::protobuf::reflect::MessageDescriptor::new::<Response>(
"Response",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Response {
static mut instance: ::protobuf::lazy::Lazy<Response> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Response,
};
unsafe {
instance.get(Response::new)
}
}
}
impl ::protobuf::Clear for Response {
fn clear(&mut self) {
self.json.clear();
self.txn.clear();
self.latency.clear();
self.metrics.clear();
self.uids.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Response {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Mutation {
pub set_json: ::std::vec::Vec<u8>,
pub delete_json: ::std::vec::Vec<u8>,
pub set_nquads: ::std::vec::Vec<u8>,
pub del_nquads: ::std::vec::Vec<u8>,
pub set: ::protobuf::RepeatedField<NQuad>,
pub del: ::protobuf::RepeatedField<NQuad>,
pub cond: ::std::string::String,
pub commit_now: bool,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Mutation {
fn default() -> &'a Mutation {
<Mutation as ::protobuf::Message>::default_instance()
}
}
impl Mutation {
pub fn new() -> Mutation {
::std::default::Default::default()
}
pub fn get_set_json(&self) -> &[u8] {
&self.set_json
}
pub fn clear_set_json(&mut self) {
self.set_json.clear();
}
pub fn set_set_json(&mut self, v: ::std::vec::Vec<u8>) {
self.set_json = v;
}
pub fn mut_set_json(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.set_json
}
pub fn take_set_json(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.set_json, ::std::vec::Vec::new())
}
pub fn get_delete_json(&self) -> &[u8] {
&self.delete_json
}
pub fn clear_delete_json(&mut self) {
self.delete_json.clear();
}
pub fn set_delete_json(&mut self, v: ::std::vec::Vec<u8>) {
self.delete_json = v;
}
pub fn mut_delete_json(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.delete_json
}
pub fn take_delete_json(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.delete_json, ::std::vec::Vec::new())
}
pub fn get_set_nquads(&self) -> &[u8] {
&self.set_nquads
}
pub fn clear_set_nquads(&mut self) {
self.set_nquads.clear();
}
pub fn set_set_nquads(&mut self, v: ::std::vec::Vec<u8>) {
self.set_nquads = v;
}
pub fn mut_set_nquads(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.set_nquads
}
pub fn take_set_nquads(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.set_nquads, ::std::vec::Vec::new())
}
pub fn get_del_nquads(&self) -> &[u8] {
&self.del_nquads
}
pub fn clear_del_nquads(&mut self) {
self.del_nquads.clear();
}
pub fn set_del_nquads(&mut self, v: ::std::vec::Vec<u8>) {
self.del_nquads = v;
}
pub fn mut_del_nquads(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.del_nquads
}
pub fn take_del_nquads(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.del_nquads, ::std::vec::Vec::new())
}
pub fn get_set(&self) -> &[NQuad] {
&self.set
}
pub fn clear_set(&mut self) {
self.set.clear();
}
pub fn set_set(&mut self, v: ::protobuf::RepeatedField<NQuad>) {
self.set = v;
}
pub fn mut_set(&mut self) -> &mut ::protobuf::RepeatedField<NQuad> {
&mut self.set
}
pub fn take_set(&mut self) -> ::protobuf::RepeatedField<NQuad> {
::std::mem::replace(&mut self.set, ::protobuf::RepeatedField::new())
}
pub fn get_del(&self) -> &[NQuad] {
&self.del
}
pub fn clear_del(&mut self) {
self.del.clear();
}
pub fn set_del(&mut self, v: ::protobuf::RepeatedField<NQuad>) {
self.del = v;
}
pub fn mut_del(&mut self) -> &mut ::protobuf::RepeatedField<NQuad> {
&mut self.del
}
pub fn take_del(&mut self) -> ::protobuf::RepeatedField<NQuad> {
::std::mem::replace(&mut self.del, ::protobuf::RepeatedField::new())
}
pub fn get_cond(&self) -> &str {
&self.cond
}
pub fn clear_cond(&mut self) {
self.cond.clear();
}
pub fn set_cond(&mut self, v: ::std::string::String) {
self.cond = v;
}
pub fn mut_cond(&mut self) -> &mut ::std::string::String {
&mut self.cond
}
pub fn take_cond(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.cond, ::std::string::String::new())
}
pub fn get_commit_now(&self) -> bool {
self.commit_now
}
pub fn clear_commit_now(&mut self) {
self.commit_now = false;
}
pub fn set_commit_now(&mut self, v: bool) {
self.commit_now = v;
}
}
impl ::protobuf::Message for Mutation {
fn is_initialized(&self) -> bool {
for v in &self.set {
if !v.is_initialized() {
return false;
}
};
for v in &self.del {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.set_json)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.delete_json)?;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.set_nquads)?;
},
4 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.del_nquads)?;
},
5 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.set)?;
},
6 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.del)?;
},
9 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.cond)?;
},
14 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.commit_now = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.set_json.is_empty() {
my_size += ::protobuf::rt::bytes_size(1, &self.set_json);
}
if !self.delete_json.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.delete_json);
}
if !self.set_nquads.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.set_nquads);
}
if !self.del_nquads.is_empty() {
my_size += ::protobuf::rt::bytes_size(4, &self.del_nquads);
}
for value in &self.set {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
for value in &self.del {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
if !self.cond.is_empty() {
my_size += ::protobuf::rt::string_size(9, &self.cond);
}
if self.commit_now != false {
my_size += 2;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if !self.set_json.is_empty() {
os.write_bytes(1, &self.set_json)?;
}
if !self.delete_json.is_empty() {
os.write_bytes(2, &self.delete_json)?;
}
if !self.set_nquads.is_empty() {
os.write_bytes(3, &self.set_nquads)?;
}
if !self.del_nquads.is_empty() {
os.write_bytes(4, &self.del_nquads)?;
}
for v in &self.set {
os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
for v in &self.del {
os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
if !self.cond.is_empty() {
os.write_string(9, &self.cond)?;
}
if self.commit_now != false {
os.write_bool(14, self.commit_now)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Mutation {
Mutation::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"set_json",
|m: &Mutation| { &m.set_json },
|m: &mut Mutation| { &mut m.set_json },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"delete_json",
|m: &Mutation| { &m.delete_json },
|m: &mut Mutation| { &mut m.delete_json },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"set_nquads",
|m: &Mutation| { &m.set_nquads },
|m: &mut Mutation| { &mut m.set_nquads },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"del_nquads",
|m: &Mutation| { &m.del_nquads },
|m: &mut Mutation| { &mut m.del_nquads },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<NQuad>>(
"set",
|m: &Mutation| { &m.set },
|m: &mut Mutation| { &mut m.set },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<NQuad>>(
"del",
|m: &Mutation| { &m.del },
|m: &mut Mutation| { &mut m.del },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"cond",
|m: &Mutation| { &m.cond },
|m: &mut Mutation| { &mut m.cond },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"commit_now",
|m: &Mutation| { &m.commit_now },
|m: &mut Mutation| { &mut m.commit_now },
));
::protobuf::reflect::MessageDescriptor::new::<Mutation>(
"Mutation",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Mutation {
static mut instance: ::protobuf::lazy::Lazy<Mutation> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Mutation,
};
unsafe {
instance.get(Mutation::new)
}
}
}
impl ::protobuf::Clear for Mutation {
fn clear(&mut self) {
self.set_json.clear();
self.delete_json.clear();
self.set_nquads.clear();
self.del_nquads.clear();
self.set.clear();
self.del.clear();
self.cond.clear();
self.commit_now = false;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Mutation {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Mutation {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Operation {
pub schema: ::std::string::String,
pub drop_attr: ::std::string::String,
pub drop_all: bool,
pub drop_op: Operation_DropOp,
pub drop_value: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Operation {
fn default() -> &'a Operation {
<Operation as ::protobuf::Message>::default_instance()
}
}
impl Operation {
pub fn new() -> Operation {
::std::default::Default::default()
}
pub fn get_schema(&self) -> &str {
&self.schema
}
pub fn clear_schema(&mut self) {
self.schema.clear();
}
pub fn set_schema(&mut self, v: ::std::string::String) {
self.schema = v;
}
pub fn mut_schema(&mut self) -> &mut ::std::string::String {
&mut self.schema
}
pub fn take_schema(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.schema, ::std::string::String::new())
}
pub fn get_drop_attr(&self) -> &str {
&self.drop_attr
}
pub fn clear_drop_attr(&mut self) {
self.drop_attr.clear();
}
pub fn set_drop_attr(&mut self, v: ::std::string::String) {
self.drop_attr = v;
}
pub fn mut_drop_attr(&mut self) -> &mut ::std::string::String {
&mut self.drop_attr
}
pub fn take_drop_attr(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.drop_attr, ::std::string::String::new())
}
pub fn get_drop_all(&self) -> bool {
self.drop_all
}
pub fn clear_drop_all(&mut self) {
self.drop_all = false;
}
pub fn set_drop_all(&mut self, v: bool) {
self.drop_all = v;
}
pub fn get_drop_op(&self) -> Operation_DropOp {
self.drop_op
}
pub fn clear_drop_op(&mut self) {
self.drop_op = Operation_DropOp::NONE;
}
pub fn set_drop_op(&mut self, v: Operation_DropOp) {
self.drop_op = v;
}
pub fn get_drop_value(&self) -> &str {
&self.drop_value
}
pub fn clear_drop_value(&mut self) {
self.drop_value.clear();
}
pub fn set_drop_value(&mut self, v: ::std::string::String) {
self.drop_value = v;
}
pub fn mut_drop_value(&mut self) -> &mut ::std::string::String {
&mut self.drop_value
}
pub fn take_drop_value(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.drop_value, ::std::string::String::new())
}
}
impl ::protobuf::Message for Operation {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.schema)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.drop_attr)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.drop_all = tmp;
},
4 => {
::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.drop_op, 4, &mut self.unknown_fields)?
},
5 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.drop_value)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.schema.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.schema);
}
if !self.drop_attr.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.drop_attr);
}
if self.drop_all != false {
my_size += 2;
}
if self.drop_op != Operation_DropOp::NONE {
my_size += ::protobuf::rt::enum_size(4, self.drop_op);
}
if !self.drop_value.is_empty() {
my_size += ::protobuf::rt::string_size(5, &self.drop_value);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if !self.schema.is_empty() {
os.write_string(1, &self.schema)?;
}
if !self.drop_attr.is_empty() {
os.write_string(2, &self.drop_attr)?;
}
if self.drop_all != false {
os.write_bool(3, self.drop_all)?;
}
if self.drop_op != Operation_DropOp::NONE {
os.write_enum(4, self.drop_op.value())?;
}
if !self.drop_value.is_empty() {
os.write_string(5, &self.drop_value)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Operation {
Operation::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"schema",
|m: &Operation| { &m.schema },
|m: &mut Operation| { &mut m.schema },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"drop_attr",
|m: &Operation| { &m.drop_attr },
|m: &mut Operation| { &mut m.drop_attr },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"drop_all",
|m: &Operation| { &m.drop_all },
|m: &mut Operation| { &mut m.drop_all },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Operation_DropOp>>(
"drop_op",
|m: &Operation| { &m.drop_op },
|m: &mut Operation| { &mut m.drop_op },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"drop_value",
|m: &Operation| { &m.drop_value },
|m: &mut Operation| { &mut m.drop_value },
));
::protobuf::reflect::MessageDescriptor::new::<Operation>(
"Operation",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Operation {
static mut instance: ::protobuf::lazy::Lazy<Operation> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Operation,
};
unsafe {
instance.get(Operation::new)
}
}
}
impl ::protobuf::Clear for Operation {
fn clear(&mut self) {
self.schema.clear();
self.drop_attr.clear();
self.drop_all = false;
self.drop_op = Operation_DropOp::NONE;
self.drop_value.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Operation {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Operation {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum Operation_DropOp {
NONE = 0,
ALL = 1,
DATA = 2,
ATTR = 3,
TYPE = 4,
}
impl ::protobuf::ProtobufEnum for Operation_DropOp {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<Operation_DropOp> {
match value {
0 => ::std::option::Option::Some(Operation_DropOp::NONE),
1 => ::std::option::Option::Some(Operation_DropOp::ALL),
2 => ::std::option::Option::Some(Operation_DropOp::DATA),
3 => ::std::option::Option::Some(Operation_DropOp::ATTR),
4 => ::std::option::Option::Some(Operation_DropOp::TYPE),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [Operation_DropOp] = &[
Operation_DropOp::NONE,
Operation_DropOp::ALL,
Operation_DropOp::DATA,
Operation_DropOp::ATTR,
Operation_DropOp::TYPE,
];
values
}
fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::EnumDescriptor,
};
unsafe {
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new("Operation_DropOp", file_descriptor_proto())
})
}
}
}
impl ::std::marker::Copy for Operation_DropOp {
}
impl ::std::default::Default for Operation_DropOp {
fn default() -> Self {
Operation_DropOp::NONE
}
}
impl ::protobuf::reflect::ProtobufValue for Operation_DropOp {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Payload {
pub Data: ::std::vec::Vec<u8>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Payload {
fn default() -> &'a Payload {
<Payload as ::protobuf::Message>::default_instance()
}
}
impl Payload {
pub fn new() -> Payload {
::std::default::Default::default()
}
pub fn get_Data(&self) -> &[u8] {
&self.Data
}
pub fn clear_Data(&mut self) {
self.Data.clear();
}
pub fn set_Data(&mut self, v: ::std::vec::Vec<u8>) {
self.Data = v;
}
pub fn mut_Data(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.Data
}
pub fn take_Data(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.Data, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for Payload {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.Data)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.Data.is_empty() {
my_size += ::protobuf::rt::bytes_size(1, &self.Data);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if !self.Data.is_empty() {
os.write_bytes(1, &self.Data)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Payload {
Payload::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"Data",
|m: &Payload| { &m.Data },
|m: &mut Payload| { &mut m.Data },
));
::protobuf::reflect::MessageDescriptor::new::<Payload>(
"Payload",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Payload {
static mut instance: ::protobuf::lazy::Lazy<Payload> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Payload,
};
unsafe {
instance.get(Payload::new)
}
}
}
impl ::protobuf::Clear for Payload {
fn clear(&mut self) {
self.Data.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Payload {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Payload {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TxnContext {
pub start_ts: u64,
pub commit_ts: u64,
pub aborted: bool,
pub keys: ::protobuf::RepeatedField<::std::string::String>,
pub preds: ::protobuf::RepeatedField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TxnContext {
fn default() -> &'a TxnContext {
<TxnContext as ::protobuf::Message>::default_instance()
}
}
impl TxnContext {
pub fn new() -> TxnContext {
::std::default::Default::default()
}
pub fn get_start_ts(&self) -> u64 {
self.start_ts
}
pub fn clear_start_ts(&mut self) {
self.start_ts = 0;
}
pub fn set_start_ts(&mut self, v: u64) {
self.start_ts = v;
}
pub fn get_commit_ts(&self) -> u64 {
self.commit_ts
}
pub fn clear_commit_ts(&mut self) {
self.commit_ts = 0;
}
pub fn set_commit_ts(&mut self, v: u64) {
self.commit_ts = v;
}
pub fn get_aborted(&self) -> bool {
self.aborted
}
pub fn clear_aborted(&mut self) {
self.aborted = false;
}
pub fn set_aborted(&mut self, v: bool) {
self.aborted = v;
}
pub fn get_keys(&self) -> &[::std::string::String] {
&self.keys
}
pub fn clear_keys(&mut self) {
self.keys.clear();
}
pub fn set_keys(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
self.keys = v;
}
pub fn mut_keys(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
&mut self.keys
}
pub fn take_keys(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
::std::mem::replace(&mut self.keys, ::protobuf::RepeatedField::new())
}
pub fn get_preds(&self) -> &[::std::string::String] {
&self.preds
}
pub fn clear_preds(&mut self) {
self.preds.clear();
}
pub fn set_preds(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
self.preds = v;
}
pub fn mut_preds(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
&mut self.preds
}
pub fn take_preds(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
::std::mem::replace(&mut self.preds, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for TxnContext {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.start_ts = tmp;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.commit_ts = tmp;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.aborted = tmp;
},
4 => {
::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.keys)?;
},
5 => {
::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.preds)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.start_ts != 0 {
my_size += ::protobuf::rt::value_size(1, self.start_ts, ::protobuf::wire_format::WireTypeVarint);
}
if self.commit_ts != 0 {
my_size += ::protobuf::rt::value_size(2, self.commit_ts, ::protobuf::wire_format::WireTypeVarint);
}
if self.aborted != false {
my_size += 2;
}
for value in &self.keys {
my_size += ::protobuf::rt::string_size(4, &value);
};
for value in &self.preds {
my_size += ::protobuf::rt::string_size(5, &value);
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if self.start_ts != 0 {
os.write_uint64(1, self.start_ts)?;
}
if self.commit_ts != 0 {
os.write_uint64(2, self.commit_ts)?;
}
if self.aborted != false {
os.write_bool(3, self.aborted)?;
}
for v in &self.keys {
os.write_string(4, &v)?;
};
for v in &self.preds {
os.write_string(5, &v)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> TxnContext {
TxnContext::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"start_ts",
|m: &TxnContext| { &m.start_ts },
|m: &mut TxnContext| { &mut m.start_ts },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"commit_ts",
|m: &TxnContext| { &m.commit_ts },
|m: &mut TxnContext| { &mut m.commit_ts },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"aborted",
|m: &TxnContext| { &m.aborted },
|m: &mut TxnContext| { &mut m.aborted },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"keys",
|m: &TxnContext| { &m.keys },
|m: &mut TxnContext| { &mut m.keys },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"preds",
|m: &TxnContext| { &m.preds },
|m: &mut TxnContext| { &mut m.preds },
));
::protobuf::reflect::MessageDescriptor::new::<TxnContext>(
"TxnContext",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static TxnContext {
static mut instance: ::protobuf::lazy::Lazy<TxnContext> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const TxnContext,
};
unsafe {
instance.get(TxnContext::new)
}
}
}
impl ::protobuf::Clear for TxnContext {
fn clear(&mut self) {
self.start_ts = 0;
self.commit_ts = 0;
self.aborted = false;
self.keys.clear();
self.preds.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TxnContext {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TxnContext {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Check {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Check {
fn default() -> &'a Check {
<Check as ::protobuf::Message>::default_instance()
}
}
impl Check {
pub fn new() -> Check {
::std::default::Default::default()
}
}
impl ::protobuf::Message for Check {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Check {
Check::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let fields = ::std::vec::Vec::new();
::protobuf::reflect::MessageDescriptor::new::<Check>(
"Check",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Check {
static mut instance: ::protobuf::lazy::Lazy<Check> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Check,
};
unsafe {
instance.get(Check::new)
}
}
}
impl ::protobuf::Clear for Check {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Check {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Check {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Version {
pub tag: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Version {
fn default() -> &'a Version {
<Version as ::protobuf::Message>::default_instance()
}
}
impl Version {
pub fn new() -> Version {
::std::default::Default::default()
}
pub fn get_tag(&self) -> &str {
&self.tag
}
pub fn clear_tag(&mut self) {
self.tag.clear();
}
pub fn set_tag(&mut self, v: ::std::string::String) {
self.tag = v;
}
pub fn mut_tag(&mut self) -> &mut ::std::string::String {
&mut self.tag
}
pub fn take_tag(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.tag, ::std::string::String::new())
}
}
impl ::protobuf::Message for Version {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.tag)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.tag.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.tag);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if !self.tag.is_empty() {
os.write_string(1, &self.tag)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Version {
Version::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"tag",
|m: &Version| { &m.tag },
|m: &mut Version| { &mut m.tag },
));
::protobuf::reflect::MessageDescriptor::new::<Version>(
"Version",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Version {
static mut instance: ::protobuf::lazy::Lazy<Version> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Version,
};
unsafe {
instance.get(Version::new)
}
}
}
impl ::protobuf::Clear for Version {
fn clear(&mut self) {
self.tag.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Version {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Version {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Latency {
pub parsing_ns: u64,
pub processing_ns: u64,
pub encoding_ns: u64,
pub assign_timestamp_ns: u64,
pub total_ns: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Latency {
fn default() -> &'a Latency {
<Latency as ::protobuf::Message>::default_instance()
}
}
impl Latency {
pub fn new() -> Latency {
::std::default::Default::default()
}
pub fn get_parsing_ns(&self) -> u64 {
self.parsing_ns
}
pub fn clear_parsing_ns(&mut self) {
self.parsing_ns = 0;
}
pub fn set_parsing_ns(&mut self, v: u64) {
self.parsing_ns = v;
}
pub fn get_processing_ns(&self) -> u64 {
self.processing_ns
}
pub fn clear_processing_ns(&mut self) {
self.processing_ns = 0;
}
pub fn set_processing_ns(&mut self, v: u64) {
self.processing_ns = v;
}
pub fn get_encoding_ns(&self) -> u64 {
self.encoding_ns
}
pub fn clear_encoding_ns(&mut self) {
self.encoding_ns = 0;
}
pub fn set_encoding_ns(&mut self, v: u64) {
self.encoding_ns = v;
}
pub fn get_assign_timestamp_ns(&self) -> u64 {
self.assign_timestamp_ns
}
pub fn clear_assign_timestamp_ns(&mut self) {
self.assign_timestamp_ns = 0;
}
pub fn set_assign_timestamp_ns(&mut self, v: u64) {
self.assign_timestamp_ns = v;
}
pub fn get_total_ns(&self) -> u64 {
self.total_ns
}
pub fn clear_total_ns(&mut self) {
self.total_ns = 0;
}
pub fn set_total_ns(&mut self, v: u64) {
self.total_ns = v;
}
}
impl ::protobuf::Message for Latency {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.parsing_ns = tmp;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.processing_ns = tmp;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.encoding_ns = tmp;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.assign_timestamp_ns = tmp;
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.total_ns = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.parsing_ns != 0 {
my_size += ::protobuf::rt::value_size(1, self.parsing_ns, ::protobuf::wire_format::WireTypeVarint);
}
if self.processing_ns != 0 {
my_size += ::protobuf::rt::value_size(2, self.processing_ns, ::protobuf::wire_format::WireTypeVarint);
}
if self.encoding_ns != 0 {
my_size += ::protobuf::rt::value_size(3, self.encoding_ns, ::protobuf::wire_format::WireTypeVarint);
}
if self.assign_timestamp_ns != 0 {
my_size += ::protobuf::rt::value_size(4, self.assign_timestamp_ns, ::protobuf::wire_format::WireTypeVarint);
}
if self.total_ns != 0 {
my_size += ::protobuf::rt::value_size(5, self.total_ns, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if self.parsing_ns != 0 {
os.write_uint64(1, self.parsing_ns)?;
}
if self.processing_ns != 0 {
os.write_uint64(2, self.processing_ns)?;
}
if self.encoding_ns != 0 {
os.write_uint64(3, self.encoding_ns)?;
}
if self.assign_timestamp_ns != 0 {
os.write_uint64(4, self.assign_timestamp_ns)?;
}
if self.total_ns != 0 {
os.write_uint64(5, self.total_ns)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Latency {
Latency::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"parsing_ns",
|m: &Latency| { &m.parsing_ns },
|m: &mut Latency| { &mut m.parsing_ns },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"processing_ns",
|m: &Latency| { &m.processing_ns },
|m: &mut Latency| { &mut m.processing_ns },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"encoding_ns",
|m: &Latency| { &m.encoding_ns },
|m: &mut Latency| { &mut m.encoding_ns },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"assign_timestamp_ns",
|m: &Latency| { &m.assign_timestamp_ns },
|m: &mut Latency| { &mut m.assign_timestamp_ns },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"total_ns",
|m: &Latency| { &m.total_ns },
|m: &mut Latency| { &mut m.total_ns },
));
::protobuf::reflect::MessageDescriptor::new::<Latency>(
"Latency",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Latency {
static mut instance: ::protobuf::lazy::Lazy<Latency> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Latency,
};
unsafe {
instance.get(Latency::new)
}
}
}
impl ::protobuf::Clear for Latency {
fn clear(&mut self) {
self.parsing_ns = 0;
self.processing_ns = 0;
self.encoding_ns = 0;
self.assign_timestamp_ns = 0;
self.total_ns = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Latency {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Latency {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Metrics {
pub num_uids: ::std::collections::HashMap<::std::string::String, u64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Metrics {
fn default() -> &'a Metrics {
<Metrics as ::protobuf::Message>::default_instance()
}
}
impl Metrics {
pub fn new() -> Metrics {
::std::default::Default::default()
}
pub fn get_num_uids(&self) -> &::std::collections::HashMap<::std::string::String, u64> {
&self.num_uids
}
pub fn clear_num_uids(&mut self) {
self.num_uids.clear();
}
pub fn set_num_uids(&mut self, v: ::std::collections::HashMap<::std::string::String, u64>) {
self.num_uids = v;
}
pub fn mut_num_uids(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, u64> {
&mut self.num_uids
}
pub fn take_num_uids(&mut self) -> ::std::collections::HashMap<::std::string::String, u64> {
::std::mem::replace(&mut self.num_uids, ::std::collections::HashMap::new())
}
}
impl ::protobuf::Message for Metrics {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeUint64>(wire_type, is, &mut self.num_uids)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeUint64>(1, &self.num_uids);
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeUint64>(1, &self.num_uids, os)?;
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Metrics {
Metrics::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeUint64>(
"num_uids",
|m: &Metrics| { &m.num_uids },
|m: &mut Metrics| { &mut m.num_uids },
));
::protobuf::reflect::MessageDescriptor::new::<Metrics>(
"Metrics",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Metrics {
static mut instance: ::protobuf::lazy::Lazy<Metrics> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Metrics,
};
unsafe {
instance.get(Metrics::new)
}
}
}
impl ::protobuf::Clear for Metrics {
fn clear(&mut self) {
self.num_uids.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Metrics {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Metrics {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct NQuad {
pub subject: ::std::string::String,
pub predicate: ::std::string::String,
pub object_id: ::std::string::String,
pub object_value: ::protobuf::SingularPtrField<Value>,
pub label: ::std::string::String,
pub lang: ::std::string::String,
pub facets: ::protobuf::RepeatedField<Facet>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a NQuad {
fn default() -> &'a NQuad {
<NQuad as ::protobuf::Message>::default_instance()
}
}
impl NQuad {
pub fn new() -> NQuad {
::std::default::Default::default()
}
pub fn get_subject(&self) -> &str {
&self.subject
}
pub fn clear_subject(&mut self) {
self.subject.clear();
}
pub fn set_subject(&mut self, v: ::std::string::String) {
self.subject = v;
}
pub fn mut_subject(&mut self) -> &mut ::std::string::String {
&mut self.subject
}
pub fn take_subject(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.subject, ::std::string::String::new())
}
pub fn get_predicate(&self) -> &str {
&self.predicate
}
pub fn clear_predicate(&mut self) {
self.predicate.clear();
}
pub fn set_predicate(&mut self, v: ::std::string::String) {
self.predicate = v;
}
pub fn mut_predicate(&mut self) -> &mut ::std::string::String {
&mut self.predicate
}
pub fn take_predicate(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.predicate, ::std::string::String::new())
}
pub fn get_object_id(&self) -> &str {
&self.object_id
}
pub fn clear_object_id(&mut self) {
self.object_id.clear();
}
pub fn set_object_id(&mut self, v: ::std::string::String) {
self.object_id = v;
}
pub fn mut_object_id(&mut self) -> &mut ::std::string::String {
&mut self.object_id
}
pub fn take_object_id(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.object_id, ::std::string::String::new())
}
pub fn get_object_value(&self) -> &Value {
self.object_value.as_ref().unwrap_or_else(|| Value::default_instance())
}
pub fn clear_object_value(&mut self) {
self.object_value.clear();
}
pub fn has_object_value(&self) -> bool {
self.object_value.is_some()
}
pub fn set_object_value(&mut self, v: Value) {
self.object_value = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_object_value(&mut self) -> &mut Value {
if self.object_value.is_none() {
self.object_value.set_default();
}
self.object_value.as_mut().unwrap()
}
pub fn take_object_value(&mut self) -> Value {
self.object_value.take().unwrap_or_else(|| Value::new())
}
pub fn get_label(&self) -> &str {
&self.label
}
pub fn clear_label(&mut self) {
self.label.clear();
}
pub fn set_label(&mut self, v: ::std::string::String) {
self.label = v;
}
pub fn mut_label(&mut self) -> &mut ::std::string::String {
&mut self.label
}
pub fn take_label(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.label, ::std::string::String::new())
}
pub fn get_lang(&self) -> &str {
&self.lang
}
pub fn clear_lang(&mut self) {
self.lang.clear();
}
pub fn set_lang(&mut self, v: ::std::string::String) {
self.lang = v;
}
pub fn mut_lang(&mut self) -> &mut ::std::string::String {
&mut self.lang
}
pub fn take_lang(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.lang, ::std::string::String::new())
}
pub fn get_facets(&self) -> &[Facet] {
&self.facets
}
pub fn clear_facets(&mut self) {
self.facets.clear();
}
pub fn set_facets(&mut self, v: ::protobuf::RepeatedField<Facet>) {
self.facets = v;
}
pub fn mut_facets(&mut self) -> &mut ::protobuf::RepeatedField<Facet> {
&mut self.facets
}
pub fn take_facets(&mut self) -> ::protobuf::RepeatedField<Facet> {
::std::mem::replace(&mut self.facets, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for NQuad {
fn is_initialized(&self) -> bool {
for v in &self.object_value {
if !v.is_initialized() {
return false;
}
};
for v in &self.facets {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.subject)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.predicate)?;
},
3 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.object_id)?;
},
4 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.object_value)?;
},
5 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.label)?;
},
6 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.lang)?;
},
7 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.facets)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.subject.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.subject);
}
if !self.predicate.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.predicate);
}
if !self.object_id.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.object_id);
}
if let Some(ref v) = self.object_value.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.label.is_empty() {
my_size += ::protobuf::rt::string_size(5, &self.label);
}
if !self.lang.is_empty() {
my_size += ::protobuf::rt::string_size(6, &self.lang);
}
for value in &self.facets {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if !self.subject.is_empty() {
os.write_string(1, &self.subject)?;
}
if !self.predicate.is_empty() {
os.write_string(2, &self.predicate)?;
}
if !self.object_id.is_empty() {
os.write_string(3, &self.object_id)?;
}
if let Some(ref v) = self.object_value.as_ref() {
os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.label.is_empty() {
os.write_string(5, &self.label)?;
}
if !self.lang.is_empty() {
os.write_string(6, &self.lang)?;
}
for v in &self.facets {
os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> NQuad {
NQuad::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"subject",
|m: &NQuad| { &m.subject },
|m: &mut NQuad| { &mut m.subject },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"predicate",
|m: &NQuad| { &m.predicate },
|m: &mut NQuad| { &mut m.predicate },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"object_id",
|m: &NQuad| { &m.object_id },
|m: &mut NQuad| { &mut m.object_id },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Value>>(
"object_value",
|m: &NQuad| { &m.object_value },
|m: &mut NQuad| { &mut m.object_value },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"label",
|m: &NQuad| { &m.label },
|m: &mut NQuad| { &mut m.label },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"lang",
|m: &NQuad| { &m.lang },
|m: &mut NQuad| { &mut m.lang },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Facet>>(
"facets",
|m: &NQuad| { &m.facets },
|m: &mut NQuad| { &mut m.facets },
));
::protobuf::reflect::MessageDescriptor::new::<NQuad>(
"NQuad",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static NQuad {
static mut instance: ::protobuf::lazy::Lazy<NQuad> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const NQuad,
};
unsafe {
instance.get(NQuad::new)
}
}
}
impl ::protobuf::Clear for NQuad {
fn clear(&mut self) {
self.subject.clear();
self.predicate.clear();
self.object_id.clear();
self.object_value.clear();
self.label.clear();
self.lang.clear();
self.facets.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for NQuad {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for NQuad {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Value {
pub val: ::std::option::Option<Value_oneof_val>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Value {
fn default() -> &'a Value {
<Value as ::protobuf::Message>::default_instance()
}
}
#[derive(Clone,PartialEq,Debug)]
pub enum Value_oneof_val {
default_val(::std::string::String),
bytes_val(::std::vec::Vec<u8>),
int_val(i64),
bool_val(bool),
str_val(::std::string::String),
double_val(f64),
geo_val(::std::vec::Vec<u8>),
date_val(::std::vec::Vec<u8>),
datetime_val(::std::vec::Vec<u8>),
password_val(::std::string::String),
uid_val(u64),
}
impl Value {
pub fn new() -> Value {
::std::default::Default::default()
}
pub fn get_default_val(&self) -> &str {
match self.val {
::std::option::Option::Some(Value_oneof_val::default_val(ref v)) => v,
_ => "",
}
}
pub fn clear_default_val(&mut self) {
self.val = ::std::option::Option::None;
}
pub fn has_default_val(&self) -> bool {
match self.val {
::std::option::Option::Some(Value_oneof_val::default_val(..)) => true,
_ => false,
}
}
pub fn set_default_val(&mut self, v: ::std::string::String) {
self.val = ::std::option::Option::Some(Value_oneof_val::default_val(v))
}
pub fn mut_default_val(&mut self) -> &mut ::std::string::String {
if let ::std::option::Option::Some(Value_oneof_val::default_val(_)) = self.val {
} else {
self.val = ::std::option::Option::Some(Value_oneof_val::default_val(::std::string::String::new()));
}
match self.val {
::std::option::Option::Some(Value_oneof_val::default_val(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_default_val(&mut self) -> ::std::string::String {
if self.has_default_val() {
match self.val.take() {
::std::option::Option::Some(Value_oneof_val::default_val(v)) => v,
_ => panic!(),
}
} else {
::std::string::String::new()
}
}
pub fn get_bytes_val(&self) -> &[u8] {
match self.val {
::std::option::Option::Some(Value_oneof_val::bytes_val(ref v)) => v,
_ => &[],
}
}
pub fn clear_bytes_val(&mut self) {
self.val = ::std::option::Option::None;
}
pub fn has_bytes_val(&self) -> bool {
match self.val {
::std::option::Option::Some(Value_oneof_val::bytes_val(..)) => true,
_ => false,
}
}
pub fn set_bytes_val(&mut self, v: ::std::vec::Vec<u8>) {
self.val = ::std::option::Option::Some(Value_oneof_val::bytes_val(v))
}
pub fn mut_bytes_val(&mut self) -> &mut ::std::vec::Vec<u8> {
if let ::std::option::Option::Some(Value_oneof_val::bytes_val(_)) = self.val {
} else {
self.val = ::std::option::Option::Some(Value_oneof_val::bytes_val(::std::vec::Vec::new()));
}
match self.val {
::std::option::Option::Some(Value_oneof_val::bytes_val(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_bytes_val(&mut self) -> ::std::vec::Vec<u8> {
if self.has_bytes_val() {
match self.val.take() {
::std::option::Option::Some(Value_oneof_val::bytes_val(v)) => v,
_ => panic!(),
}
} else {
::std::vec::Vec::new()
}
}
pub fn get_int_val(&self) -> i64 {
match self.val {
::std::option::Option::Some(Value_oneof_val::int_val(v)) => v,
_ => 0,
}
}
pub fn clear_int_val(&mut self) {
self.val = ::std::option::Option::None;
}
pub fn has_int_val(&self) -> bool {
match self.val {
::std::option::Option::Some(Value_oneof_val::int_val(..)) => true,
_ => false,
}
}
pub fn set_int_val(&mut self, v: i64) {
self.val = ::std::option::Option::Some(Value_oneof_val::int_val(v))
}
pub fn get_bool_val(&self) -> bool {
match self.val {
::std::option::Option::Some(Value_oneof_val::bool_val(v)) => v,
_ => false,
}
}
pub fn clear_bool_val(&mut self) {
self.val = ::std::option::Option::None;
}
pub fn has_bool_val(&self) -> bool {
match self.val {
::std::option::Option::Some(Value_oneof_val::bool_val(..)) => true,
_ => false,
}
}
pub fn set_bool_val(&mut self, v: bool) {
self.val = ::std::option::Option::Some(Value_oneof_val::bool_val(v))
}
pub fn get_str_val(&self) -> &str {
match self.val {
::std::option::Option::Some(Value_oneof_val::str_val(ref v)) => v,
_ => "",
}
}
pub fn clear_str_val(&mut self) {
self.val = ::std::option::Option::None;
}
pub fn has_str_val(&self) -> bool {
match self.val {
::std::option::Option::Some(Value_oneof_val::str_val(..)) => true,
_ => false,
}
}
pub fn set_str_val(&mut self, v: ::std::string::String) {
self.val = ::std::option::Option::Some(Value_oneof_val::str_val(v))
}
pub fn mut_str_val(&mut self) -> &mut ::std::string::String {
if let ::std::option::Option::Some(Value_oneof_val::str_val(_)) = self.val {
} else {
self.val = ::std::option::Option::Some(Value_oneof_val::str_val(::std::string::String::new()));
}
match self.val {
::std::option::Option::Some(Value_oneof_val::str_val(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_str_val(&mut self) -> ::std::string::String {
if self.has_str_val() {
match self.val.take() {
::std::option::Option::Some(Value_oneof_val::str_val(v)) => v,
_ => panic!(),
}
} else {
::std::string::String::new()
}
}
pub fn get_double_val(&self) -> f64 {
match self.val {
::std::option::Option::Some(Value_oneof_val::double_val(v)) => v,
_ => 0.,
}
}
pub fn clear_double_val(&mut self) {
self.val = ::std::option::Option::None;
}
pub fn has_double_val(&self) -> bool {
match self.val {
::std::option::Option::Some(Value_oneof_val::double_val(..)) => true,
_ => false,
}
}
pub fn set_double_val(&mut self, v: f64) {
self.val = ::std::option::Option::Some(Value_oneof_val::double_val(v))
}
pub fn get_geo_val(&self) -> &[u8] {
match self.val {
::std::option::Option::Some(Value_oneof_val::geo_val(ref v)) => v,
_ => &[],
}
}
pub fn clear_geo_val(&mut self) {
self.val = ::std::option::Option::None;
}
pub fn has_geo_val(&self) -> bool {
match self.val {
::std::option::Option::Some(Value_oneof_val::geo_val(..)) => true,
_ => false,
}
}
pub fn set_geo_val(&mut self, v: ::std::vec::Vec<u8>) {
self.val = ::std::option::Option::Some(Value_oneof_val::geo_val(v))
}
pub fn mut_geo_val(&mut self) -> &mut ::std::vec::Vec<u8> {
if let ::std::option::Option::Some(Value_oneof_val::geo_val(_)) = self.val {
} else {
self.val = ::std::option::Option::Some(Value_oneof_val::geo_val(::std::vec::Vec::new()));
}
match self.val {
::std::option::Option::Some(Value_oneof_val::geo_val(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_geo_val(&mut self) -> ::std::vec::Vec<u8> {
if self.has_geo_val() {
match self.val.take() {
::std::option::Option::Some(Value_oneof_val::geo_val(v)) => v,
_ => panic!(),
}
} else {
::std::vec::Vec::new()
}
}
pub fn get_date_val(&self) -> &[u8] {
match self.val {
::std::option::Option::Some(Value_oneof_val::date_val(ref v)) => v,
_ => &[],
}
}
pub fn clear_date_val(&mut self) {
self.val = ::std::option::Option::None;
}
pub fn has_date_val(&self) -> bool {
match self.val {
::std::option::Option::Some(Value_oneof_val::date_val(..)) => true,
_ => false,
}
}
pub fn set_date_val(&mut self, v: ::std::vec::Vec<u8>) {
self.val = ::std::option::Option::Some(Value_oneof_val::date_val(v))
}
pub fn mut_date_val(&mut self) -> &mut ::std::vec::Vec<u8> {
if let ::std::option::Option::Some(Value_oneof_val::date_val(_)) = self.val {
} else {
self.val = ::std::option::Option::Some(Value_oneof_val::date_val(::std::vec::Vec::new()));
}
match self.val {
::std::option::Option::Some(Value_oneof_val::date_val(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_date_val(&mut self) -> ::std::vec::Vec<u8> {
if self.has_date_val() {
match self.val.take() {
::std::option::Option::Some(Value_oneof_val::date_val(v)) => v,
_ => panic!(),
}
} else {
::std::vec::Vec::new()
}
}
pub fn get_datetime_val(&self) -> &[u8] {
match self.val {
::std::option::Option::Some(Value_oneof_val::datetime_val(ref v)) => v,
_ => &[],
}
}
pub fn clear_datetime_val(&mut self) {
self.val = ::std::option::Option::None;
}
pub fn has_datetime_val(&self) -> bool {
match self.val {
::std::option::Option::Some(Value_oneof_val::datetime_val(..)) => true,
_ => false,
}
}
pub fn set_datetime_val(&mut self, v: ::std::vec::Vec<u8>) {
self.val = ::std::option::Option::Some(Value_oneof_val::datetime_val(v))
}
pub fn mut_datetime_val(&mut self) -> &mut ::std::vec::Vec<u8> {
if let ::std::option::Option::Some(Value_oneof_val::datetime_val(_)) = self.val {
} else {
self.val = ::std::option::Option::Some(Value_oneof_val::datetime_val(::std::vec::Vec::new()));
}
match self.val {
::std::option::Option::Some(Value_oneof_val::datetime_val(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_datetime_val(&mut self) -> ::std::vec::Vec<u8> {
if self.has_datetime_val() {
match self.val.take() {
::std::option::Option::Some(Value_oneof_val::datetime_val(v)) => v,
_ => panic!(),
}
} else {
::std::vec::Vec::new()
}
}
pub fn get_password_val(&self) -> &str {
match self.val {
::std::option::Option::Some(Value_oneof_val::password_val(ref v)) => v,
_ => "",
}
}
pub fn clear_password_val(&mut self) {
self.val = ::std::option::Option::None;
}
pub fn has_password_val(&self) -> bool {
match self.val {
::std::option::Option::Some(Value_oneof_val::password_val(..)) => true,
_ => false,
}
}
pub fn set_password_val(&mut self, v: ::std::string::String) {
self.val = ::std::option::Option::Some(Value_oneof_val::password_val(v))
}
pub fn mut_password_val(&mut self) -> &mut ::std::string::String {
if let ::std::option::Option::Some(Value_oneof_val::password_val(_)) = self.val {
} else {
self.val = ::std::option::Option::Some(Value_oneof_val::password_val(::std::string::String::new()));
}
match self.val {
::std::option::Option::Some(Value_oneof_val::password_val(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_password_val(&mut self) -> ::std::string::String {
if self.has_password_val() {
match self.val.take() {
::std::option::Option::Some(Value_oneof_val::password_val(v)) => v,
_ => panic!(),
}
} else {
::std::string::String::new()
}
}
pub fn get_uid_val(&self) -> u64 {
match self.val {
::std::option::Option::Some(Value_oneof_val::uid_val(v)) => v,
_ => 0,
}
}
pub fn clear_uid_val(&mut self) {
self.val = ::std::option::Option::None;
}
pub fn has_uid_val(&self) -> bool {
match self.val {
::std::option::Option::Some(Value_oneof_val::uid_val(..)) => true,
_ => false,
}
}
pub fn set_uid_val(&mut self, v: u64) {
self.val = ::std::option::Option::Some(Value_oneof_val::uid_val(v))
}
}
impl ::protobuf::Message for Value {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.val = ::std::option::Option::Some(Value_oneof_val::default_val(is.read_string()?));
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.val = ::std::option::Option::Some(Value_oneof_val::bytes_val(is.read_bytes()?));
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.val = ::std::option::Option::Some(Value_oneof_val::int_val(is.read_int64()?));
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.val = ::std::option::Option::Some(Value_oneof_val::bool_val(is.read_bool()?));
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.val = ::std::option::Option::Some(Value_oneof_val::str_val(is.read_string()?));
},
6 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.val = ::std::option::Option::Some(Value_oneof_val::double_val(is.read_double()?));
},
7 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.val = ::std::option::Option::Some(Value_oneof_val::geo_val(is.read_bytes()?));
},
8 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.val = ::std::option::Option::Some(Value_oneof_val::date_val(is.read_bytes()?));
},
9 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.val = ::std::option::Option::Some(Value_oneof_val::datetime_val(is.read_bytes()?));
},
10 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.val = ::std::option::Option::Some(Value_oneof_val::password_val(is.read_string()?));
},
11 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.val = ::std::option::Option::Some(Value_oneof_val::uid_val(is.read_uint64()?));
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let ::std::option::Option::Some(ref v) = self.val {
match v {
&Value_oneof_val::default_val(ref v) => {
my_size += ::protobuf::rt::string_size(1, &v);
},
&Value_oneof_val::bytes_val(ref v) => {
my_size += ::protobuf::rt::bytes_size(2, &v);
},
&Value_oneof_val::int_val(v) => {
my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
},
&Value_oneof_val::bool_val(v) => {
my_size += 2;
},
&Value_oneof_val::str_val(ref v) => {
my_size += ::protobuf::rt::string_size(5, &v);
},
&Value_oneof_val::double_val(v) => {
my_size += 9;
},
&Value_oneof_val::geo_val(ref v) => {
my_size += ::protobuf::rt::bytes_size(7, &v);
},
&Value_oneof_val::date_val(ref v) => {
my_size += ::protobuf::rt::bytes_size(8, &v);
},
&Value_oneof_val::datetime_val(ref v) => {
my_size += ::protobuf::rt::bytes_size(9, &v);
},
&Value_oneof_val::password_val(ref v) => {
my_size += ::protobuf::rt::string_size(10, &v);
},
&Value_oneof_val::uid_val(v) => {
my_size += ::protobuf::rt::value_size(11, v, ::protobuf::wire_format::WireTypeVarint);
},
};
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let ::std::option::Option::Some(ref v) = self.val {
match v {
&Value_oneof_val::default_val(ref v) => {
os.write_string(1, v)?;
},
&Value_oneof_val::bytes_val(ref v) => {
os.write_bytes(2, v)?;
},
&Value_oneof_val::int_val(v) => {
os.write_int64(3, v)?;
},
&Value_oneof_val::bool_val(v) => {
os.write_bool(4, v)?;
},
&Value_oneof_val::str_val(ref v) => {
os.write_string(5, v)?;
},
&Value_oneof_val::double_val(v) => {
os.write_double(6, v)?;
},
&Value_oneof_val::geo_val(ref v) => {
os.write_bytes(7, v)?;
},
&Value_oneof_val::date_val(ref v) => {
os.write_bytes(8, v)?;
},
&Value_oneof_val::datetime_val(ref v) => {
os.write_bytes(9, v)?;
},
&Value_oneof_val::password_val(ref v) => {
os.write_string(10, v)?;
},
&Value_oneof_val::uid_val(v) => {
os.write_uint64(11, v)?;
},
};
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Value {
Value::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
"default_val",
Value::has_default_val,
Value::get_default_val,
));
fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>(
"bytes_val",
Value::has_bytes_val,
Value::get_bytes_val,
));
fields.push(::protobuf::reflect::accessor::make_singular_i64_accessor::<_>(
"int_val",
Value::has_int_val,
Value::get_int_val,
));
fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>(
"bool_val",
Value::has_bool_val,
Value::get_bool_val,
));
fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
"str_val",
Value::has_str_val,
Value::get_str_val,
));
fields.push(::protobuf::reflect::accessor::make_singular_f64_accessor::<_>(
"double_val",
Value::has_double_val,
Value::get_double_val,
));
fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>(
"geo_val",
Value::has_geo_val,
Value::get_geo_val,
));
fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>(
"date_val",
Value::has_date_val,
Value::get_date_val,
));
fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>(
"datetime_val",
Value::has_datetime_val,
Value::get_datetime_val,
));
fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
"password_val",
Value::has_password_val,
Value::get_password_val,
));
fields.push(::protobuf::reflect::accessor::make_singular_u64_accessor::<_>(
"uid_val",
Value::has_uid_val,
Value::get_uid_val,
));
::protobuf::reflect::MessageDescriptor::new::<Value>(
"Value",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Value {
static mut instance: ::protobuf::lazy::Lazy<Value> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Value,
};
unsafe {
instance.get(Value::new)
}
}
}
impl ::protobuf::Clear for Value {
fn clear(&mut self) {
self.val = ::std::option::Option::None;
self.val = ::std::option::Option::None;
self.val = ::std::option::Option::None;
self.val = ::std::option::Option::None;
self.val = ::std::option::Option::None;
self.val = ::std::option::Option::None;
self.val = ::std::option::Option::None;
self.val = ::std::option::Option::None;
self.val = ::std::option::Option::None;
self.val = ::std::option::Option::None;
self.val = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Value {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Value {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Facet {
pub key: ::std::string::String,
pub value: ::std::vec::Vec<u8>,
pub val_type: Facet_ValType,
pub tokens: ::protobuf::RepeatedField<::std::string::String>,
pub alias: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Facet {
fn default() -> &'a Facet {
<Facet as ::protobuf::Message>::default_instance()
}
}
impl Facet {
pub fn new() -> Facet {
::std::default::Default::default()
}
pub fn get_key(&self) -> &str {
&self.key
}
pub fn clear_key(&mut self) {
self.key.clear();
}
pub fn set_key(&mut self, v: ::std::string::String) {
self.key = v;
}
pub fn mut_key(&mut self) -> &mut ::std::string::String {
&mut self.key
}
pub fn take_key(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.key, ::std::string::String::new())
}
pub fn get_value(&self) -> &[u8] {
&self.value
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn set_value(&mut self, v: ::std::vec::Vec<u8>) {
self.value = v;
}
pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.value
}
pub fn take_value(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.value, ::std::vec::Vec::new())
}
pub fn get_val_type(&self) -> Facet_ValType {
self.val_type
}
pub fn clear_val_type(&mut self) {
self.val_type = Facet_ValType::STRING;
}
pub fn set_val_type(&mut self, v: Facet_ValType) {
self.val_type = v;
}
pub fn get_tokens(&self) -> &[::std::string::String] {
&self.tokens
}
pub fn clear_tokens(&mut self) {
self.tokens.clear();
}
pub fn set_tokens(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
self.tokens = v;
}
pub fn mut_tokens(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
&mut self.tokens
}
pub fn take_tokens(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
::std::mem::replace(&mut self.tokens, ::protobuf::RepeatedField::new())
}
pub fn get_alias(&self) -> &str {
&self.alias
}
pub fn clear_alias(&mut self) {
self.alias.clear();
}
pub fn set_alias(&mut self, v: ::std::string::String) {
self.alias = v;
}
pub fn mut_alias(&mut self) -> &mut ::std::string::String {
&mut self.alias
}
pub fn take_alias(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.alias, ::std::string::String::new())
}
}
impl ::protobuf::Message for Facet {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.key)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?;
},
3 => {
::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.val_type, 3, &mut self.unknown_fields)?
},
4 => {
::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.tokens)?;
},
5 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.alias)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.key.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.key);
}
if !self.value.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.value);
}
if self.val_type != Facet_ValType::STRING {
my_size += ::protobuf::rt::enum_size(3, self.val_type);
}
for value in &self.tokens {
my_size += ::protobuf::rt::string_size(4, &value);
};
if !self.alias.is_empty() {
my_size += ::protobuf::rt::string_size(5, &self.alias);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if !self.key.is_empty() {
os.write_string(1, &self.key)?;
}
if !self.value.is_empty() {
os.write_bytes(2, &self.value)?;
}
if self.val_type != Facet_ValType::STRING {
os.write_enum(3, self.val_type.value())?;
}
for v in &self.tokens {
os.write_string(4, &v)?;
};
if !self.alias.is_empty() {
os.write_string(5, &self.alias)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Facet {
Facet::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"key",
|m: &Facet| { &m.key },
|m: &mut Facet| { &mut m.key },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"value",
|m: &Facet| { &m.value },
|m: &mut Facet| { &mut m.value },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Facet_ValType>>(
"val_type",
|m: &Facet| { &m.val_type },
|m: &mut Facet| { &mut m.val_type },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"tokens",
|m: &Facet| { &m.tokens },
|m: &mut Facet| { &mut m.tokens },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"alias",
|m: &Facet| { &m.alias },
|m: &mut Facet| { &mut m.alias },
));
::protobuf::reflect::MessageDescriptor::new::<Facet>(
"Facet",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Facet {
static mut instance: ::protobuf::lazy::Lazy<Facet> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Facet,
};
unsafe {
instance.get(Facet::new)
}
}
}
impl ::protobuf::Clear for Facet {
fn clear(&mut self) {
self.key.clear();
self.value.clear();
self.val_type = Facet_ValType::STRING;
self.tokens.clear();
self.alias.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Facet {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Facet {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum Facet_ValType {
STRING = 0,
INT = 1,
FLOAT = 2,
BOOL = 3,
DATETIME = 4,
}
impl ::protobuf::ProtobufEnum for Facet_ValType {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<Facet_ValType> {
match value {
0 => ::std::option::Option::Some(Facet_ValType::STRING),
1 => ::std::option::Option::Some(Facet_ValType::INT),
2 => ::std::option::Option::Some(Facet_ValType::FLOAT),
3 => ::std::option::Option::Some(Facet_ValType::BOOL),
4 => ::std::option::Option::Some(Facet_ValType::DATETIME),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [Facet_ValType] = &[
Facet_ValType::STRING,
Facet_ValType::INT,
Facet_ValType::FLOAT,
Facet_ValType::BOOL,
Facet_ValType::DATETIME,
];
values
}
fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::EnumDescriptor,
};
unsafe {
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new("Facet_ValType", file_descriptor_proto())
})
}
}
}
impl ::std::marker::Copy for Facet_ValType {
}
impl ::std::default::Default for Facet_ValType {
fn default() -> Self {
Facet_ValType::STRING
}
}
impl ::protobuf::reflect::ProtobufValue for Facet_ValType {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
}
}
#[derive(PartialEq,Clone,Default)]
pub struct LoginRequest {
pub userid: ::std::string::String,
pub password: ::std::string::String,
pub refresh_token: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a LoginRequest {
fn default() -> &'a LoginRequest {
<LoginRequest as ::protobuf::Message>::default_instance()
}
}
impl LoginRequest {
pub fn new() -> LoginRequest {
::std::default::Default::default()
}
pub fn get_userid(&self) -> &str {
&self.userid
}
pub fn clear_userid(&mut self) {
self.userid.clear();
}
pub fn set_userid(&mut self, v: ::std::string::String) {
self.userid = v;
}
pub fn mut_userid(&mut self) -> &mut ::std::string::String {
&mut self.userid
}
pub fn take_userid(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.userid, ::std::string::String::new())
}
pub fn get_password(&self) -> &str {
&self.password
}
pub fn clear_password(&mut self) {
self.password.clear();
}
pub fn set_password(&mut self, v: ::std::string::String) {
self.password = v;
}
pub fn mut_password(&mut self) -> &mut ::std::string::String {
&mut self.password
}
pub fn take_password(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.password, ::std::string::String::new())
}
pub fn get_refresh_token(&self) -> &str {
&self.refresh_token
}
pub fn clear_refresh_token(&mut self) {
self.refresh_token.clear();
}
pub fn set_refresh_token(&mut self, v: ::std::string::String) {
self.refresh_token = v;
}
pub fn mut_refresh_token(&mut self) -> &mut ::std::string::String {
&mut self.refresh_token
}
pub fn take_refresh_token(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.refresh_token, ::std::string::String::new())
}
}
impl ::protobuf::Message for LoginRequest {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.userid)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.password)?;
},
3 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.refresh_token)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.userid.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.userid);
}
if !self.password.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.password);
}
if !self.refresh_token.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.refresh_token);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if !self.userid.is_empty() {
os.write_string(1, &self.userid)?;
}
if !self.password.is_empty() {
os.write_string(2, &self.password)?;
}
if !self.refresh_token.is_empty() {
os.write_string(3, &self.refresh_token)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> LoginRequest {
LoginRequest::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"userid",
|m: &LoginRequest| { &m.userid },
|m: &mut LoginRequest| { &mut m.userid },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"password",
|m: &LoginRequest| { &m.password },
|m: &mut LoginRequest| { &mut m.password },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"refresh_token",
|m: &LoginRequest| { &m.refresh_token },
|m: &mut LoginRequest| { &mut m.refresh_token },
));
::protobuf::reflect::MessageDescriptor::new::<LoginRequest>(
"LoginRequest",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static LoginRequest {
static mut instance: ::protobuf::lazy::Lazy<LoginRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const LoginRequest,
};
unsafe {
instance.get(LoginRequest::new)
}
}
}
impl ::protobuf::Clear for LoginRequest {
fn clear(&mut self) {
self.userid.clear();
self.password.clear();
self.refresh_token.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for LoginRequest {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for LoginRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Jwt {
pub access_jwt: ::std::string::String,
pub refresh_jwt: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Jwt {
fn default() -> &'a Jwt {
<Jwt as ::protobuf::Message>::default_instance()
}
}
impl Jwt {
pub fn new() -> Jwt {
::std::default::Default::default()
}
pub fn get_access_jwt(&self) -> &str {
&self.access_jwt
}
pub fn clear_access_jwt(&mut self) {
self.access_jwt.clear();
}
pub fn set_access_jwt(&mut self, v: ::std::string::String) {
self.access_jwt = v;
}
pub fn mut_access_jwt(&mut self) -> &mut ::std::string::String {
&mut self.access_jwt
}
pub fn take_access_jwt(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.access_jwt, ::std::string::String::new())
}
pub fn get_refresh_jwt(&self) -> &str {
&self.refresh_jwt
}
pub fn clear_refresh_jwt(&mut self) {
self.refresh_jwt.clear();
}
pub fn set_refresh_jwt(&mut self, v: ::std::string::String) {
self.refresh_jwt = v;
}
pub fn mut_refresh_jwt(&mut self) -> &mut ::std::string::String {
&mut self.refresh_jwt
}
pub fn take_refresh_jwt(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.refresh_jwt, ::std::string::String::new())
}
}
impl ::protobuf::Message for Jwt {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.access_jwt)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.refresh_jwt)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.access_jwt.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.access_jwt);
}
if !self.refresh_jwt.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.refresh_jwt);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if !self.access_jwt.is_empty() {
os.write_string(1, &self.access_jwt)?;
}
if !self.refresh_jwt.is_empty() {
os.write_string(2, &self.refresh_jwt)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Jwt {
Jwt::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"access_jwt",
|m: &Jwt| { &m.access_jwt },
|m: &mut Jwt| { &mut m.access_jwt },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"refresh_jwt",
|m: &Jwt| { &m.refresh_jwt },
|m: &mut Jwt| { &mut m.refresh_jwt },
));
::protobuf::reflect::MessageDescriptor::new::<Jwt>(
"Jwt",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Jwt {
static mut instance: ::protobuf::lazy::Lazy<Jwt> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Jwt,
};
unsafe {
instance.get(Jwt::new)
}
}
}
impl ::protobuf::Clear for Jwt {
fn clear(&mut self) {
self.access_jwt.clear();
self.refresh_jwt.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Jwt {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Jwt {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\tapi.proto\x12\x03api\"\xa9\x02\n\x07Request\x12\x19\n\x08start_ts\
\x18\x01\x20\x01(\x04R\x07startTs\x12\x14\n\x05query\x18\x04\x20\x01(\tR\
\x05query\x12*\n\x04vars\x18\x05\x20\x03(\x0b2\x16.api.Request.VarsEntry\
R\x04vars\x12\x1b\n\tread_only\x18\x06\x20\x01(\x08R\x08readOnly\x12\x1f\
\n\x0bbest_effort\x18\x07\x20\x01(\x08R\nbestEffort\x12+\n\tmutations\
\x18\x0c\x20\x03(\x0b2\r.api.MutationR\tmutations\x12\x1d\n\ncommit_now\
\x18\r\x20\x01(\x08R\tcommitNow\x1a7\n\tVarsEntry\x12\x10\n\x03key\x18\
\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05value:\
\x028\x01\"\x1a\n\x04Uids\x12\x12\n\x04uids\x18\x01\x20\x03(\tR\x04uids\
\"\xf7\x01\n\x08Response\x12\x12\n\x04json\x18\x01\x20\x01(\x0cR\x04json\
\x12!\n\x03txn\x18\x02\x20\x01(\x0b2\x0f.api.TxnContextR\x03txn\x12&\n\
\x07latency\x18\x03\x20\x01(\x0b2\x0c.api.LatencyR\x07latency\x12&\n\x07\
metrics\x18\x04\x20\x01(\x0b2\x0c.api.MetricsR\x07metrics\x12+\n\x04uids\
\x18\x0c\x20\x03(\x0b2\x17.api.Response.UidsEntryR\x04uids\x1a7\n\tUidsE\
ntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\
\x02\x20\x01(\tR\x05value:\x028\x01\"\xf3\x01\n\x08Mutation\x12\x19\n\
\x08set_json\x18\x01\x20\x01(\x0cR\x07setJson\x12\x1f\n\x0bdelete_json\
\x18\x02\x20\x01(\x0cR\ndeleteJson\x12\x1d\n\nset_nquads\x18\x03\x20\x01\
(\x0cR\tsetNquads\x12\x1d\n\ndel_nquads\x18\x04\x20\x01(\x0cR\tdelNquads\
\x12\x1c\n\x03set\x18\x05\x20\x03(\x0b2\n.api.NQuadR\x03set\x12\x1c\n\
\x03del\x18\x06\x20\x03(\x0b2\n.api.NQuadR\x03del\x12\x12\n\x04cond\x18\
\t\x20\x01(\tR\x04cond\x12\x1d\n\ncommit_now\x18\x0e\x20\x01(\x08R\tcomm\
itNow\"\xe5\x01\n\tOperation\x12\x16\n\x06schema\x18\x01\x20\x01(\tR\x06\
schema\x12\x1b\n\tdrop_attr\x18\x02\x20\x01(\tR\x08dropAttr\x12\x19\n\
\x08drop_all\x18\x03\x20\x01(\x08R\x07dropAll\x12.\n\x07drop_op\x18\x04\
\x20\x01(\x0e2\x15.api.Operation.DropOpR\x06dropOp\x12\x1d\n\ndrop_value\
\x18\x05\x20\x01(\tR\tdropValue\"9\n\x06DropOp\x12\x08\n\x04NONE\x10\0\
\x12\x07\n\x03ALL\x10\x01\x12\x08\n\x04DATA\x10\x02\x12\x08\n\x04ATTR\
\x10\x03\x12\x08\n\x04TYPE\x10\x04\"\x1d\n\x07Payload\x12\x12\n\x04Data\
\x18\x01\x20\x01(\x0cR\x04data\"\x88\x01\n\nTxnContext\x12\x19\n\x08star\
t_ts\x18\x01\x20\x01(\x04R\x07startTs\x12\x1b\n\tcommit_ts\x18\x02\x20\
\x01(\x04R\x08commitTs\x12\x18\n\x07aborted\x18\x03\x20\x01(\x08R\x07abo\
rted\x12\x12\n\x04keys\x18\x04\x20\x03(\tR\x04keys\x12\x14\n\x05preds\
\x18\x05\x20\x03(\tR\x05preds\"\x07\n\x05Check\"\x1b\n\x07Version\x12\
\x10\n\x03tag\x18\x01\x20\x01(\tR\x03tag\"\xb9\x01\n\x07Latency\x12\x1d\
\n\nparsing_ns\x18\x01\x20\x01(\x04R\tparsingNs\x12#\n\rprocessing_ns\
\x18\x02\x20\x01(\x04R\x0cprocessingNs\x12\x1f\n\x0bencoding_ns\x18\x03\
\x20\x01(\x04R\nencodingNs\x12.\n\x13assign_timestamp_ns\x18\x04\x20\x01\
(\x04R\x11assignTimestampNs\x12\x19\n\x08total_ns\x18\x05\x20\x01(\x04R\
\x07totalNs\"{\n\x07Metrics\x124\n\x08num_uids\x18\x01\x20\x03(\x0b2\x19\
.api.Metrics.NumUidsEntryR\x07numUids\x1a:\n\x0cNumUidsEntry\x12\x10\n\
\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\
\x04R\x05value:\x028\x01\"\xd9\x01\n\x05NQuad\x12\x18\n\x07subject\x18\
\x01\x20\x01(\tR\x07subject\x12\x1c\n\tpredicate\x18\x02\x20\x01(\tR\tpr\
edicate\x12\x1b\n\tobject_id\x18\x03\x20\x01(\tR\x08objectId\x12-\n\x0co\
bject_value\x18\x04\x20\x01(\x0b2\n.api.ValueR\x0bobjectValue\x12\x14\n\
\x05label\x18\x05\x20\x01(\tR\x05label\x12\x12\n\x04lang\x18\x06\x20\x01\
(\tR\x04lang\x12\"\n\x06facets\x18\x07\x20\x03(\x0b2\n.api.FacetR\x06fac\
ets\"\xe1\x02\n\x05Value\x12!\n\x0bdefault_val\x18\x01\x20\x01(\tH\0R\nd\
efaultVal\x12\x1d\n\tbytes_val\x18\x02\x20\x01(\x0cH\0R\x08bytesVal\x12\
\x19\n\x07int_val\x18\x03\x20\x01(\x03H\0R\x06intVal\x12\x1b\n\x08bool_v\
al\x18\x04\x20\x01(\x08H\0R\x07boolVal\x12\x19\n\x07str_val\x18\x05\x20\
\x01(\tH\0R\x06strVal\x12\x1f\n\ndouble_val\x18\x06\x20\x01(\x01H\0R\tdo\
ubleVal\x12\x19\n\x07geo_val\x18\x07\x20\x01(\x0cH\0R\x06geoVal\x12\x1b\
\n\x08date_val\x18\x08\x20\x01(\x0cH\0R\x07dateVal\x12#\n\x0cdatetime_va\
l\x18\t\x20\x01(\x0cH\0R\x0bdatetimeVal\x12#\n\x0cpassword_val\x18\n\x20\
\x01(\tH\0R\x0bpasswordVal\x12\x19\n\x07uid_val\x18\x0b\x20\x01(\x04H\0R\
\x06uidValB\x05\n\x03val\"\xcf\x01\n\x05Facet\x12\x10\n\x03key\x18\x01\
\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\x0cR\x05value\
\x12-\n\x08val_type\x18\x03\x20\x01(\x0e2\x12.api.Facet.ValTypeR\x07valT\
ype\x12\x16\n\x06tokens\x18\x04\x20\x03(\tR\x06tokens\x12\x14\n\x05alias\
\x18\x05\x20\x01(\tR\x05alias\"A\n\x07ValType\x12\n\n\x06STRING\x10\0\
\x12\x07\n\x03INT\x10\x01\x12\t\n\x05FLOAT\x10\x02\x12\x08\n\x04BOOL\x10\
\x03\x12\x0c\n\x08DATETIME\x10\x04\"g\n\x0cLoginRequest\x12\x16\n\x06use\
rid\x18\x01\x20\x01(\tR\x06userid\x12\x1a\n\x08password\x18\x02\x20\x01(\
\tR\x08password\x12#\n\rrefresh_token\x18\x03\x20\x01(\tR\x0crefreshToke\
n\"E\n\x03Jwt\x12\x1d\n\naccess_jwt\x18\x01\x20\x01(\tR\taccessJwt\x12\
\x1f\n\x0brefresh_jwt\x18\x02\x20\x01(\tR\nrefreshJwt2\xe7\x01\n\x06Dgra\
ph\x12+\n\x05Login\x12\x11.api.LoginRequest\x1a\r.api.Response\"\0\x12&\
\n\x05Query\x12\x0c.api.Request\x1a\r.api.Response\"\0\x12'\n\x05Alter\
\x12\x0e.api.Operation\x1a\x0c.api.Payload\"\0\x123\n\rCommitOrAbort\x12\
\x0f.api.TxnContext\x1a\x0f.api.TxnContext\"\0\x12*\n\x0cCheckVersion\
\x12\n.api.Check\x1a\x0c.api.Version\"\0B\x18\n\tio.dgraphB\x0bDgraphPro\
tob\x06proto3\
";
static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto,
};
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
unsafe {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}
}