#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![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(unused_imports)]
#![allow(unused_results)]
#[derive(PartialEq,Clone,Default)]
pub struct SummaryDescription {
pub type_hint: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SummaryDescription {
fn default() -> &'a SummaryDescription {
<SummaryDescription as ::protobuf::Message>::default_instance()
}
}
impl SummaryDescription {
pub fn new() -> SummaryDescription {
::std::default::Default::default()
}
pub fn get_type_hint(&self) -> &str {
&self.type_hint
}
pub fn clear_type_hint(&mut self) {
self.type_hint.clear();
}
pub fn set_type_hint(&mut self, v: ::std::string::String) {
self.type_hint = v;
}
pub fn mut_type_hint(&mut self) -> &mut ::std::string::String {
&mut self.type_hint
}
pub fn take_type_hint(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.type_hint, ::std::string::String::new())
}
}
impl ::protobuf::Message for SummaryDescription {
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.type_hint)?;
},
_ => {
::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.type_hint.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.type_hint);
}
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.type_hint.is_empty() {
os.write_string(1, &self.type_hint)?;
}
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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> SummaryDescription {
SummaryDescription::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"type_hint",
|m: &SummaryDescription| { &m.type_hint },
|m: &mut SummaryDescription| { &mut m.type_hint },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<SummaryDescription>(
"SummaryDescription",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SummaryDescription {
static instance: ::protobuf::rt::LazyV2<SummaryDescription> = ::protobuf::rt::LazyV2::INIT;
instance.get(SummaryDescription::new)
}
}
impl ::protobuf::Clear for SummaryDescription {
fn clear(&mut self) {
self.type_hint.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SummaryDescription {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SummaryDescription {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct HistogramProto {
pub min: f64,
pub max: f64,
pub num: f64,
pub sum: f64,
pub sum_squares: f64,
pub bucket_limit: ::std::vec::Vec<f64>,
pub bucket: ::std::vec::Vec<f64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a HistogramProto {
fn default() -> &'a HistogramProto {
<HistogramProto as ::protobuf::Message>::default_instance()
}
}
impl HistogramProto {
pub fn new() -> HistogramProto {
::std::default::Default::default()
}
pub fn get_min(&self) -> f64 {
self.min
}
pub fn clear_min(&mut self) {
self.min = 0.;
}
pub fn set_min(&mut self, v: f64) {
self.min = v;
}
pub fn get_max(&self) -> f64 {
self.max
}
pub fn clear_max(&mut self) {
self.max = 0.;
}
pub fn set_max(&mut self, v: f64) {
self.max = v;
}
pub fn get_num(&self) -> f64 {
self.num
}
pub fn clear_num(&mut self) {
self.num = 0.;
}
pub fn set_num(&mut self, v: f64) {
self.num = v;
}
pub fn get_sum(&self) -> f64 {
self.sum
}
pub fn clear_sum(&mut self) {
self.sum = 0.;
}
pub fn set_sum(&mut self, v: f64) {
self.sum = v;
}
pub fn get_sum_squares(&self) -> f64 {
self.sum_squares
}
pub fn clear_sum_squares(&mut self) {
self.sum_squares = 0.;
}
pub fn set_sum_squares(&mut self, v: f64) {
self.sum_squares = v;
}
pub fn get_bucket_limit(&self) -> &[f64] {
&self.bucket_limit
}
pub fn clear_bucket_limit(&mut self) {
self.bucket_limit.clear();
}
pub fn set_bucket_limit(&mut self, v: ::std::vec::Vec<f64>) {
self.bucket_limit = v;
}
pub fn mut_bucket_limit(&mut self) -> &mut ::std::vec::Vec<f64> {
&mut self.bucket_limit
}
pub fn take_bucket_limit(&mut self) -> ::std::vec::Vec<f64> {
::std::mem::replace(&mut self.bucket_limit, ::std::vec::Vec::new())
}
pub fn get_bucket(&self) -> &[f64] {
&self.bucket
}
pub fn clear_bucket(&mut self) {
self.bucket.clear();
}
pub fn set_bucket(&mut self, v: ::std::vec::Vec<f64>) {
self.bucket = v;
}
pub fn mut_bucket(&mut self) -> &mut ::std::vec::Vec<f64> {
&mut self.bucket
}
pub fn take_bucket(&mut self) -> ::std::vec::Vec<f64> {
::std::mem::replace(&mut self.bucket, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for HistogramProto {
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::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.min = tmp;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.max = tmp;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.num = tmp;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.sum = tmp;
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.sum_squares = tmp;
},
6 => {
::protobuf::rt::read_repeated_double_into(wire_type, is, &mut self.bucket_limit)?;
},
7 => {
::protobuf::rt::read_repeated_double_into(wire_type, is, &mut self.bucket)?;
},
_ => {
::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.min != 0. {
my_size += 9;
}
if self.max != 0. {
my_size += 9;
}
if self.num != 0. {
my_size += 9;
}
if self.sum != 0. {
my_size += 9;
}
if self.sum_squares != 0. {
my_size += 9;
}
if !self.bucket_limit.is_empty() {
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size((self.bucket_limit.len() * 8) as u32) + (self.bucket_limit.len() * 8) as u32;
}
if !self.bucket.is_empty() {
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size((self.bucket.len() * 8) as u32) + (self.bucket.len() * 8) as u32;
}
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.min != 0. {
os.write_double(1, self.min)?;
}
if self.max != 0. {
os.write_double(2, self.max)?;
}
if self.num != 0. {
os.write_double(3, self.num)?;
}
if self.sum != 0. {
os.write_double(4, self.sum)?;
}
if self.sum_squares != 0. {
os.write_double(5, self.sum_squares)?;
}
if !self.bucket_limit.is_empty() {
os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32((self.bucket_limit.len() * 8) as u32)?;
for v in &self.bucket_limit {
os.write_double_no_tag(*v)?;
};
}
if !self.bucket.is_empty() {
os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32((self.bucket.len() * 8) as u32)?;
for v in &self.bucket {
os.write_double_no_tag(*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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> HistogramProto {
HistogramProto::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"min",
|m: &HistogramProto| { &m.min },
|m: &mut HistogramProto| { &mut m.min },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"max",
|m: &HistogramProto| { &m.max },
|m: &mut HistogramProto| { &mut m.max },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"num",
|m: &HistogramProto| { &m.num },
|m: &mut HistogramProto| { &mut m.num },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"sum",
|m: &HistogramProto| { &m.sum },
|m: &mut HistogramProto| { &mut m.sum },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"sum_squares",
|m: &HistogramProto| { &m.sum_squares },
|m: &mut HistogramProto| { &mut m.sum_squares },
));
fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"bucket_limit",
|m: &HistogramProto| { &m.bucket_limit },
|m: &mut HistogramProto| { &mut m.bucket_limit },
));
fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"bucket",
|m: &HistogramProto| { &m.bucket },
|m: &mut HistogramProto| { &mut m.bucket },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<HistogramProto>(
"HistogramProto",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static HistogramProto {
static instance: ::protobuf::rt::LazyV2<HistogramProto> = ::protobuf::rt::LazyV2::INIT;
instance.get(HistogramProto::new)
}
}
impl ::protobuf::Clear for HistogramProto {
fn clear(&mut self) {
self.min = 0.;
self.max = 0.;
self.num = 0.;
self.sum = 0.;
self.sum_squares = 0.;
self.bucket_limit.clear();
self.bucket.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for HistogramProto {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for HistogramProto {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SummaryMetadata {
pub plugin_data: ::protobuf::SingularPtrField<SummaryMetadata_PluginData>,
pub display_name: ::std::string::String,
pub summary_description: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SummaryMetadata {
fn default() -> &'a SummaryMetadata {
<SummaryMetadata as ::protobuf::Message>::default_instance()
}
}
impl SummaryMetadata {
pub fn new() -> SummaryMetadata {
::std::default::Default::default()
}
pub fn get_plugin_data(&self) -> &SummaryMetadata_PluginData {
self.plugin_data.as_ref().unwrap_or_else(|| <SummaryMetadata_PluginData as ::protobuf::Message>::default_instance())
}
pub fn clear_plugin_data(&mut self) {
self.plugin_data.clear();
}
pub fn has_plugin_data(&self) -> bool {
self.plugin_data.is_some()
}
pub fn set_plugin_data(&mut self, v: SummaryMetadata_PluginData) {
self.plugin_data = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_plugin_data(&mut self) -> &mut SummaryMetadata_PluginData {
if self.plugin_data.is_none() {
self.plugin_data.set_default();
}
self.plugin_data.as_mut().unwrap()
}
pub fn take_plugin_data(&mut self) -> SummaryMetadata_PluginData {
self.plugin_data.take().unwrap_or_else(|| SummaryMetadata_PluginData::new())
}
pub fn get_display_name(&self) -> &str {
&self.display_name
}
pub fn clear_display_name(&mut self) {
self.display_name.clear();
}
pub fn set_display_name(&mut self, v: ::std::string::String) {
self.display_name = v;
}
pub fn mut_display_name(&mut self) -> &mut ::std::string::String {
&mut self.display_name
}
pub fn take_display_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.display_name, ::std::string::String::new())
}
pub fn get_summary_description(&self) -> &str {
&self.summary_description
}
pub fn clear_summary_description(&mut self) {
self.summary_description.clear();
}
pub fn set_summary_description(&mut self, v: ::std::string::String) {
self.summary_description = v;
}
pub fn mut_summary_description(&mut self) -> &mut ::std::string::String {
&mut self.summary_description
}
pub fn take_summary_description(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.summary_description, ::std::string::String::new())
}
}
impl ::protobuf::Message for SummaryMetadata {
fn is_initialized(&self) -> bool {
for v in &self.plugin_data {
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_message_into(wire_type, is, &mut self.plugin_data)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.display_name)?;
},
3 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.summary_description)?;
},
_ => {
::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 Some(ref v) = self.plugin_data.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.display_name.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.display_name);
}
if !self.summary_description.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.summary_description);
}
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 Some(ref v) = self.plugin_data.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.display_name.is_empty() {
os.write_string(2, &self.display_name)?;
}
if !self.summary_description.is_empty() {
os.write_string(3, &self.summary_description)?;
}
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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> SummaryMetadata {
SummaryMetadata::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<SummaryMetadata_PluginData>>(
"plugin_data",
|m: &SummaryMetadata| { &m.plugin_data },
|m: &mut SummaryMetadata| { &mut m.plugin_data },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"display_name",
|m: &SummaryMetadata| { &m.display_name },
|m: &mut SummaryMetadata| { &mut m.display_name },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"summary_description",
|m: &SummaryMetadata| { &m.summary_description },
|m: &mut SummaryMetadata| { &mut m.summary_description },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<SummaryMetadata>(
"SummaryMetadata",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SummaryMetadata {
static instance: ::protobuf::rt::LazyV2<SummaryMetadata> = ::protobuf::rt::LazyV2::INIT;
instance.get(SummaryMetadata::new)
}
}
impl ::protobuf::Clear for SummaryMetadata {
fn clear(&mut self) {
self.plugin_data.clear();
self.display_name.clear();
self.summary_description.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SummaryMetadata {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SummaryMetadata {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SummaryMetadata_PluginData {
pub plugin_name: ::std::string::String,
pub content: ::std::vec::Vec<u8>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SummaryMetadata_PluginData {
fn default() -> &'a SummaryMetadata_PluginData {
<SummaryMetadata_PluginData as ::protobuf::Message>::default_instance()
}
}
impl SummaryMetadata_PluginData {
pub fn new() -> SummaryMetadata_PluginData {
::std::default::Default::default()
}
pub fn get_plugin_name(&self) -> &str {
&self.plugin_name
}
pub fn clear_plugin_name(&mut self) {
self.plugin_name.clear();
}
pub fn set_plugin_name(&mut self, v: ::std::string::String) {
self.plugin_name = v;
}
pub fn mut_plugin_name(&mut self) -> &mut ::std::string::String {
&mut self.plugin_name
}
pub fn take_plugin_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.plugin_name, ::std::string::String::new())
}
pub fn get_content(&self) -> &[u8] {
&self.content
}
pub fn clear_content(&mut self) {
self.content.clear();
}
pub fn set_content(&mut self, v: ::std::vec::Vec<u8>) {
self.content = v;
}
pub fn mut_content(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.content
}
pub fn take_content(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.content, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for SummaryMetadata_PluginData {
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.plugin_name)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.content)?;
},
_ => {
::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.plugin_name.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.plugin_name);
}
if !self.content.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.content);
}
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.plugin_name.is_empty() {
os.write_string(1, &self.plugin_name)?;
}
if !self.content.is_empty() {
os.write_bytes(2, &self.content)?;
}
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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> SummaryMetadata_PluginData {
SummaryMetadata_PluginData::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"plugin_name",
|m: &SummaryMetadata_PluginData| { &m.plugin_name },
|m: &mut SummaryMetadata_PluginData| { &mut m.plugin_name },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"content",
|m: &SummaryMetadata_PluginData| { &m.content },
|m: &mut SummaryMetadata_PluginData| { &mut m.content },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<SummaryMetadata_PluginData>(
"SummaryMetadata.PluginData",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SummaryMetadata_PluginData {
static instance: ::protobuf::rt::LazyV2<SummaryMetadata_PluginData> = ::protobuf::rt::LazyV2::INIT;
instance.get(SummaryMetadata_PluginData::new)
}
}
impl ::protobuf::Clear for SummaryMetadata_PluginData {
fn clear(&mut self) {
self.plugin_name.clear();
self.content.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SummaryMetadata_PluginData {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SummaryMetadata_PluginData {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Summary {
pub value: ::protobuf::RepeatedField<Summary_Value>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Summary {
fn default() -> &'a Summary {
<Summary as ::protobuf::Message>::default_instance()
}
}
impl Summary {
pub fn new() -> Summary {
::std::default::Default::default()
}
pub fn get_value(&self) -> &[Summary_Value] {
&self.value
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn set_value(&mut self, v: ::protobuf::RepeatedField<Summary_Value>) {
self.value = v;
}
pub fn mut_value(&mut self) -> &mut ::protobuf::RepeatedField<Summary_Value> {
&mut self.value
}
pub fn take_value(&mut self) -> ::protobuf::RepeatedField<Summary_Value> {
::std::mem::replace(&mut self.value, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for Summary {
fn is_initialized(&self) -> bool {
for v in &self.value {
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_repeated_message_into(wire_type, is, &mut self.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;
for value in &self.value {
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<()> {
for v in &self.value {
os.write_tag(1, ::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Summary {
Summary::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Summary_Value>>(
"value",
|m: &Summary| { &m.value },
|m: &mut Summary| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<Summary>(
"Summary",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static Summary {
static instance: ::protobuf::rt::LazyV2<Summary> = ::protobuf::rt::LazyV2::INIT;
instance.get(Summary::new)
}
}
impl ::protobuf::Clear for Summary {
fn clear(&mut self) {
self.value.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Summary {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Summary {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Summary_Image {
pub height: i32,
pub width: i32,
pub colorspace: i32,
pub encoded_image_string: ::std::vec::Vec<u8>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Summary_Image {
fn default() -> &'a Summary_Image {
<Summary_Image as ::protobuf::Message>::default_instance()
}
}
impl Summary_Image {
pub fn new() -> Summary_Image {
::std::default::Default::default()
}
pub fn get_height(&self) -> i32 {
self.height
}
pub fn clear_height(&mut self) {
self.height = 0;
}
pub fn set_height(&mut self, v: i32) {
self.height = v;
}
pub fn get_width(&self) -> i32 {
self.width
}
pub fn clear_width(&mut self) {
self.width = 0;
}
pub fn set_width(&mut self, v: i32) {
self.width = v;
}
pub fn get_colorspace(&self) -> i32 {
self.colorspace
}
pub fn clear_colorspace(&mut self) {
self.colorspace = 0;
}
pub fn set_colorspace(&mut self, v: i32) {
self.colorspace = v;
}
pub fn get_encoded_image_string(&self) -> &[u8] {
&self.encoded_image_string
}
pub fn clear_encoded_image_string(&mut self) {
self.encoded_image_string.clear();
}
pub fn set_encoded_image_string(&mut self, v: ::std::vec::Vec<u8>) {
self.encoded_image_string = v;
}
pub fn mut_encoded_image_string(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.encoded_image_string
}
pub fn take_encoded_image_string(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.encoded_image_string, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for Summary_Image {
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_int32()?;
self.height = 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_int32()?;
self.width = 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_int32()?;
self.colorspace = tmp;
},
4 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.encoded_image_string)?;
},
_ => {
::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.height != 0 {
my_size += ::protobuf::rt::value_size(1, self.height, ::protobuf::wire_format::WireTypeVarint);
}
if self.width != 0 {
my_size += ::protobuf::rt::value_size(2, self.width, ::protobuf::wire_format::WireTypeVarint);
}
if self.colorspace != 0 {
my_size += ::protobuf::rt::value_size(3, self.colorspace, ::protobuf::wire_format::WireTypeVarint);
}
if !self.encoded_image_string.is_empty() {
my_size += ::protobuf::rt::bytes_size(4, &self.encoded_image_string);
}
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.height != 0 {
os.write_int32(1, self.height)?;
}
if self.width != 0 {
os.write_int32(2, self.width)?;
}
if self.colorspace != 0 {
os.write_int32(3, self.colorspace)?;
}
if !self.encoded_image_string.is_empty() {
os.write_bytes(4, &self.encoded_image_string)?;
}
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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Summary_Image {
Summary_Image::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"height",
|m: &Summary_Image| { &m.height },
|m: &mut Summary_Image| { &mut m.height },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"width",
|m: &Summary_Image| { &m.width },
|m: &mut Summary_Image| { &mut m.width },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"colorspace",
|m: &Summary_Image| { &m.colorspace },
|m: &mut Summary_Image| { &mut m.colorspace },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"encoded_image_string",
|m: &Summary_Image| { &m.encoded_image_string },
|m: &mut Summary_Image| { &mut m.encoded_image_string },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<Summary_Image>(
"Summary.Image",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static Summary_Image {
static instance: ::protobuf::rt::LazyV2<Summary_Image> = ::protobuf::rt::LazyV2::INIT;
instance.get(Summary_Image::new)
}
}
impl ::protobuf::Clear for Summary_Image {
fn clear(&mut self) {
self.height = 0;
self.width = 0;
self.colorspace = 0;
self.encoded_image_string.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Summary_Image {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Summary_Image {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Summary_Audio {
pub sample_rate: f32,
pub num_channels: i64,
pub length_frames: i64,
pub encoded_audio_string: ::std::vec::Vec<u8>,
pub content_type: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Summary_Audio {
fn default() -> &'a Summary_Audio {
<Summary_Audio as ::protobuf::Message>::default_instance()
}
}
impl Summary_Audio {
pub fn new() -> Summary_Audio {
::std::default::Default::default()
}
pub fn get_sample_rate(&self) -> f32 {
self.sample_rate
}
pub fn clear_sample_rate(&mut self) {
self.sample_rate = 0.;
}
pub fn set_sample_rate(&mut self, v: f32) {
self.sample_rate = v;
}
pub fn get_num_channels(&self) -> i64 {
self.num_channels
}
pub fn clear_num_channels(&mut self) {
self.num_channels = 0;
}
pub fn set_num_channels(&mut self, v: i64) {
self.num_channels = v;
}
pub fn get_length_frames(&self) -> i64 {
self.length_frames
}
pub fn clear_length_frames(&mut self) {
self.length_frames = 0;
}
pub fn set_length_frames(&mut self, v: i64) {
self.length_frames = v;
}
pub fn get_encoded_audio_string(&self) -> &[u8] {
&self.encoded_audio_string
}
pub fn clear_encoded_audio_string(&mut self) {
self.encoded_audio_string.clear();
}
pub fn set_encoded_audio_string(&mut self, v: ::std::vec::Vec<u8>) {
self.encoded_audio_string = v;
}
pub fn mut_encoded_audio_string(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.encoded_audio_string
}
pub fn take_encoded_audio_string(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.encoded_audio_string, ::std::vec::Vec::new())
}
pub fn get_content_type(&self) -> &str {
&self.content_type
}
pub fn clear_content_type(&mut self) {
self.content_type.clear();
}
pub fn set_content_type(&mut self, v: ::std::string::String) {
self.content_type = v;
}
pub fn mut_content_type(&mut self) -> &mut ::std::string::String {
&mut self.content_type
}
pub fn take_content_type(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.content_type, ::std::string::String::new())
}
}
impl ::protobuf::Message for Summary_Audio {
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::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.sample_rate = 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_int64()?;
self.num_channels = 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_int64()?;
self.length_frames = tmp;
},
4 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.encoded_audio_string)?;
},
5 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.content_type)?;
},
_ => {
::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.sample_rate != 0. {
my_size += 5;
}
if self.num_channels != 0 {
my_size += ::protobuf::rt::value_size(2, self.num_channels, ::protobuf::wire_format::WireTypeVarint);
}
if self.length_frames != 0 {
my_size += ::protobuf::rt::value_size(3, self.length_frames, ::protobuf::wire_format::WireTypeVarint);
}
if !self.encoded_audio_string.is_empty() {
my_size += ::protobuf::rt::bytes_size(4, &self.encoded_audio_string);
}
if !self.content_type.is_empty() {
my_size += ::protobuf::rt::string_size(5, &self.content_type);
}
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.sample_rate != 0. {
os.write_float(1, self.sample_rate)?;
}
if self.num_channels != 0 {
os.write_int64(2, self.num_channels)?;
}
if self.length_frames != 0 {
os.write_int64(3, self.length_frames)?;
}
if !self.encoded_audio_string.is_empty() {
os.write_bytes(4, &self.encoded_audio_string)?;
}
if !self.content_type.is_empty() {
os.write_string(5, &self.content_type)?;
}
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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Summary_Audio {
Summary_Audio::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"sample_rate",
|m: &Summary_Audio| { &m.sample_rate },
|m: &mut Summary_Audio| { &mut m.sample_rate },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
"num_channels",
|m: &Summary_Audio| { &m.num_channels },
|m: &mut Summary_Audio| { &mut m.num_channels },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
"length_frames",
|m: &Summary_Audio| { &m.length_frames },
|m: &mut Summary_Audio| { &mut m.length_frames },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"encoded_audio_string",
|m: &Summary_Audio| { &m.encoded_audio_string },
|m: &mut Summary_Audio| { &mut m.encoded_audio_string },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"content_type",
|m: &Summary_Audio| { &m.content_type },
|m: &mut Summary_Audio| { &mut m.content_type },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<Summary_Audio>(
"Summary.Audio",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static Summary_Audio {
static instance: ::protobuf::rt::LazyV2<Summary_Audio> = ::protobuf::rt::LazyV2::INIT;
instance.get(Summary_Audio::new)
}
}
impl ::protobuf::Clear for Summary_Audio {
fn clear(&mut self) {
self.sample_rate = 0.;
self.num_channels = 0;
self.length_frames = 0;
self.encoded_audio_string.clear();
self.content_type.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Summary_Audio {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Summary_Audio {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Summary_Value {
pub node_name: ::std::string::String,
pub tag: ::std::string::String,
pub metadata: ::protobuf::SingularPtrField<SummaryMetadata>,
pub value: ::std::option::Option<Summary_Value_oneof_value>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Summary_Value {
fn default() -> &'a Summary_Value {
<Summary_Value as ::protobuf::Message>::default_instance()
}
}
#[derive(Clone,PartialEq,Debug)]
pub enum Summary_Value_oneof_value {
simple_value(f32),
obsolete_old_style_histogram(::std::vec::Vec<u8>),
image(Summary_Image),
histo(HistogramProto),
audio(Summary_Audio),
tensor(super::tensor::TensorProto),
}
impl Summary_Value {
pub fn new() -> Summary_Value {
::std::default::Default::default()
}
pub fn get_node_name(&self) -> &str {
&self.node_name
}
pub fn clear_node_name(&mut self) {
self.node_name.clear();
}
pub fn set_node_name(&mut self, v: ::std::string::String) {
self.node_name = v;
}
pub fn mut_node_name(&mut self) -> &mut ::std::string::String {
&mut self.node_name
}
pub fn take_node_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.node_name, ::std::string::String::new())
}
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())
}
pub fn get_metadata(&self) -> &SummaryMetadata {
self.metadata.as_ref().unwrap_or_else(|| <SummaryMetadata as ::protobuf::Message>::default_instance())
}
pub fn clear_metadata(&mut self) {
self.metadata.clear();
}
pub fn has_metadata(&self) -> bool {
self.metadata.is_some()
}
pub fn set_metadata(&mut self, v: SummaryMetadata) {
self.metadata = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_metadata(&mut self) -> &mut SummaryMetadata {
if self.metadata.is_none() {
self.metadata.set_default();
}
self.metadata.as_mut().unwrap()
}
pub fn take_metadata(&mut self) -> SummaryMetadata {
self.metadata.take().unwrap_or_else(|| SummaryMetadata::new())
}
pub fn get_simple_value(&self) -> f32 {
match self.value {
::std::option::Option::Some(Summary_Value_oneof_value::simple_value(v)) => v,
_ => 0.,
}
}
pub fn clear_simple_value(&mut self) {
self.value = ::std::option::Option::None;
}
pub fn has_simple_value(&self) -> bool {
match self.value {
::std::option::Option::Some(Summary_Value_oneof_value::simple_value(..)) => true,
_ => false,
}
}
pub fn set_simple_value(&mut self, v: f32) {
self.value = ::std::option::Option::Some(Summary_Value_oneof_value::simple_value(v))
}
pub fn get_obsolete_old_style_histogram(&self) -> &[u8] {
match self.value {
::std::option::Option::Some(Summary_Value_oneof_value::obsolete_old_style_histogram(ref v)) => v,
_ => &[],
}
}
pub fn clear_obsolete_old_style_histogram(&mut self) {
self.value = ::std::option::Option::None;
}
pub fn has_obsolete_old_style_histogram(&self) -> bool {
match self.value {
::std::option::Option::Some(Summary_Value_oneof_value::obsolete_old_style_histogram(..)) => true,
_ => false,
}
}
pub fn set_obsolete_old_style_histogram(&mut self, v: ::std::vec::Vec<u8>) {
self.value = ::std::option::Option::Some(Summary_Value_oneof_value::obsolete_old_style_histogram(v))
}
pub fn mut_obsolete_old_style_histogram(&mut self) -> &mut ::std::vec::Vec<u8> {
if let ::std::option::Option::Some(Summary_Value_oneof_value::obsolete_old_style_histogram(_)) = self.value {
} else {
self.value = ::std::option::Option::Some(Summary_Value_oneof_value::obsolete_old_style_histogram(::std::vec::Vec::new()));
}
match self.value {
::std::option::Option::Some(Summary_Value_oneof_value::obsolete_old_style_histogram(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_obsolete_old_style_histogram(&mut self) -> ::std::vec::Vec<u8> {
if self.has_obsolete_old_style_histogram() {
match self.value.take() {
::std::option::Option::Some(Summary_Value_oneof_value::obsolete_old_style_histogram(v)) => v,
_ => panic!(),
}
} else {
::std::vec::Vec::new()
}
}
pub fn get_image(&self) -> &Summary_Image {
match self.value {
::std::option::Option::Some(Summary_Value_oneof_value::image(ref v)) => v,
_ => <Summary_Image as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_image(&mut self) {
self.value = ::std::option::Option::None;
}
pub fn has_image(&self) -> bool {
match self.value {
::std::option::Option::Some(Summary_Value_oneof_value::image(..)) => true,
_ => false,
}
}
pub fn set_image(&mut self, v: Summary_Image) {
self.value = ::std::option::Option::Some(Summary_Value_oneof_value::image(v))
}
pub fn mut_image(&mut self) -> &mut Summary_Image {
if let ::std::option::Option::Some(Summary_Value_oneof_value::image(_)) = self.value {
} else {
self.value = ::std::option::Option::Some(Summary_Value_oneof_value::image(Summary_Image::new()));
}
match self.value {
::std::option::Option::Some(Summary_Value_oneof_value::image(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_image(&mut self) -> Summary_Image {
if self.has_image() {
match self.value.take() {
::std::option::Option::Some(Summary_Value_oneof_value::image(v)) => v,
_ => panic!(),
}
} else {
Summary_Image::new()
}
}
pub fn get_histo(&self) -> &HistogramProto {
match self.value {
::std::option::Option::Some(Summary_Value_oneof_value::histo(ref v)) => v,
_ => <HistogramProto as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_histo(&mut self) {
self.value = ::std::option::Option::None;
}
pub fn has_histo(&self) -> bool {
match self.value {
::std::option::Option::Some(Summary_Value_oneof_value::histo(..)) => true,
_ => false,
}
}
pub fn set_histo(&mut self, v: HistogramProto) {
self.value = ::std::option::Option::Some(Summary_Value_oneof_value::histo(v))
}
pub fn mut_histo(&mut self) -> &mut HistogramProto {
if let ::std::option::Option::Some(Summary_Value_oneof_value::histo(_)) = self.value {
} else {
self.value = ::std::option::Option::Some(Summary_Value_oneof_value::histo(HistogramProto::new()));
}
match self.value {
::std::option::Option::Some(Summary_Value_oneof_value::histo(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_histo(&mut self) -> HistogramProto {
if self.has_histo() {
match self.value.take() {
::std::option::Option::Some(Summary_Value_oneof_value::histo(v)) => v,
_ => panic!(),
}
} else {
HistogramProto::new()
}
}
pub fn get_audio(&self) -> &Summary_Audio {
match self.value {
::std::option::Option::Some(Summary_Value_oneof_value::audio(ref v)) => v,
_ => <Summary_Audio as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_audio(&mut self) {
self.value = ::std::option::Option::None;
}
pub fn has_audio(&self) -> bool {
match self.value {
::std::option::Option::Some(Summary_Value_oneof_value::audio(..)) => true,
_ => false,
}
}
pub fn set_audio(&mut self, v: Summary_Audio) {
self.value = ::std::option::Option::Some(Summary_Value_oneof_value::audio(v))
}
pub fn mut_audio(&mut self) -> &mut Summary_Audio {
if let ::std::option::Option::Some(Summary_Value_oneof_value::audio(_)) = self.value {
} else {
self.value = ::std::option::Option::Some(Summary_Value_oneof_value::audio(Summary_Audio::new()));
}
match self.value {
::std::option::Option::Some(Summary_Value_oneof_value::audio(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_audio(&mut self) -> Summary_Audio {
if self.has_audio() {
match self.value.take() {
::std::option::Option::Some(Summary_Value_oneof_value::audio(v)) => v,
_ => panic!(),
}
} else {
Summary_Audio::new()
}
}
pub fn get_tensor(&self) -> &super::tensor::TensorProto {
match self.value {
::std::option::Option::Some(Summary_Value_oneof_value::tensor(ref v)) => v,
_ => <super::tensor::TensorProto as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_tensor(&mut self) {
self.value = ::std::option::Option::None;
}
pub fn has_tensor(&self) -> bool {
match self.value {
::std::option::Option::Some(Summary_Value_oneof_value::tensor(..)) => true,
_ => false,
}
}
pub fn set_tensor(&mut self, v: super::tensor::TensorProto) {
self.value = ::std::option::Option::Some(Summary_Value_oneof_value::tensor(v))
}
pub fn mut_tensor(&mut self) -> &mut super::tensor::TensorProto {
if let ::std::option::Option::Some(Summary_Value_oneof_value::tensor(_)) = self.value {
} else {
self.value = ::std::option::Option::Some(Summary_Value_oneof_value::tensor(super::tensor::TensorProto::new()));
}
match self.value {
::std::option::Option::Some(Summary_Value_oneof_value::tensor(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_tensor(&mut self) -> super::tensor::TensorProto {
if self.has_tensor() {
match self.value.take() {
::std::option::Option::Some(Summary_Value_oneof_value::tensor(v)) => v,
_ => panic!(),
}
} else {
super::tensor::TensorProto::new()
}
}
}
impl ::protobuf::Message for Summary_Value {
fn is_initialized(&self) -> bool {
for v in &self.metadata {
if !v.is_initialized() {
return false;
}
};
if let Some(Summary_Value_oneof_value::image(ref v)) = self.value {
if !v.is_initialized() {
return false;
}
}
if let Some(Summary_Value_oneof_value::histo(ref v)) = self.value {
if !v.is_initialized() {
return false;
}
}
if let Some(Summary_Value_oneof_value::audio(ref v)) = self.value {
if !v.is_initialized() {
return false;
}
}
if let Some(Summary_Value_oneof_value::tensor(ref v)) = self.value {
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 {
7 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.node_name)?;
},
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.tag)?;
},
9 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.metadata)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.value = ::std::option::Option::Some(Summary_Value_oneof_value::simple_value(is.read_float()?));
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.value = ::std::option::Option::Some(Summary_Value_oneof_value::obsolete_old_style_histogram(is.read_bytes()?));
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.value = ::std::option::Option::Some(Summary_Value_oneof_value::image(is.read_message()?));
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.value = ::std::option::Option::Some(Summary_Value_oneof_value::histo(is.read_message()?));
},
6 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.value = ::std::option::Option::Some(Summary_Value_oneof_value::audio(is.read_message()?));
},
8 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.value = ::std::option::Option::Some(Summary_Value_oneof_value::tensor(is.read_message()?));
},
_ => {
::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.node_name.is_empty() {
my_size += ::protobuf::rt::string_size(7, &self.node_name);
}
if !self.tag.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.tag);
}
if let Some(ref v) = self.metadata.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let ::std::option::Option::Some(ref v) = self.value {
match v {
&Summary_Value_oneof_value::simple_value(v) => {
my_size += 5;
},
&Summary_Value_oneof_value::obsolete_old_style_histogram(ref v) => {
my_size += ::protobuf::rt::bytes_size(3, &v);
},
&Summary_Value_oneof_value::image(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&Summary_Value_oneof_value::histo(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&Summary_Value_oneof_value::audio(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&Summary_Value_oneof_value::tensor(ref v) => {
let len = v.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.node_name.is_empty() {
os.write_string(7, &self.node_name)?;
}
if !self.tag.is_empty() {
os.write_string(1, &self.tag)?;
}
if let Some(ref v) = self.metadata.as_ref() {
os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let ::std::option::Option::Some(ref v) = self.value {
match v {
&Summary_Value_oneof_value::simple_value(v) => {
os.write_float(2, v)?;
},
&Summary_Value_oneof_value::obsolete_old_style_histogram(ref v) => {
os.write_bytes(3, v)?;
},
&Summary_Value_oneof_value::image(ref v) => {
os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
&Summary_Value_oneof_value::histo(ref v) => {
os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
&Summary_Value_oneof_value::audio(ref v) => {
os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
&Summary_Value_oneof_value::tensor(ref v) => {
os.write_tag(8, ::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Summary_Value {
Summary_Value::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"node_name",
|m: &Summary_Value| { &m.node_name },
|m: &mut Summary_Value| { &mut m.node_name },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"tag",
|m: &Summary_Value| { &m.tag },
|m: &mut Summary_Value| { &mut m.tag },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<SummaryMetadata>>(
"metadata",
|m: &Summary_Value| { &m.metadata },
|m: &mut Summary_Value| { &mut m.metadata },
));
fields.push(::protobuf::reflect::accessor::make_singular_f32_accessor::<_>(
"simple_value",
Summary_Value::has_simple_value,
Summary_Value::get_simple_value,
));
fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>(
"obsolete_old_style_histogram",
Summary_Value::has_obsolete_old_style_histogram,
Summary_Value::get_obsolete_old_style_histogram,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Summary_Image>(
"image",
Summary_Value::has_image,
Summary_Value::get_image,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, HistogramProto>(
"histo",
Summary_Value::has_histo,
Summary_Value::get_histo,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Summary_Audio>(
"audio",
Summary_Value::has_audio,
Summary_Value::get_audio,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, super::tensor::TensorProto>(
"tensor",
Summary_Value::has_tensor,
Summary_Value::get_tensor,
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<Summary_Value>(
"Summary.Value",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static Summary_Value {
static instance: ::protobuf::rt::LazyV2<Summary_Value> = ::protobuf::rt::LazyV2::INIT;
instance.get(Summary_Value::new)
}
}
impl ::protobuf::Clear for Summary_Value {
fn clear(&mut self) {
self.node_name.clear();
self.tag.clear();
self.metadata.clear();
self.value = ::std::option::Option::None;
self.value = ::std::option::Option::None;
self.value = ::std::option::Option::None;
self.value = ::std::option::Option::None;
self.value = ::std::option::Option::None;
self.value = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Summary_Value {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Summary_Value {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x11src/summary.proto\x12\rtensorboardrs\x1a\x10src/tensor.proto\"1\n\
\x12SummaryDescription\x12\x1b\n\ttype_hint\x18\x01\x20\x01(\tR\x08typeH\
int\"\xbc\x01\n\x0eHistogramProto\x12\x10\n\x03min\x18\x01\x20\x01(\x01R\
\x03min\x12\x10\n\x03max\x18\x02\x20\x01(\x01R\x03max\x12\x10\n\x03num\
\x18\x03\x20\x01(\x01R\x03num\x12\x10\n\x03sum\x18\x04\x20\x01(\x01R\x03\
sum\x12\x1f\n\x0bsum_squares\x18\x05\x20\x01(\x01R\nsumSquares\x12%\n\
\x0cbucket_limit\x18\x06\x20\x03(\x01R\x0bbucketLimitB\x02\x10\x01\x12\
\x1a\n\x06bucket\x18\x07\x20\x03(\x01R\x06bucketB\x02\x10\x01\"\xfa\x01\
\n\x0fSummaryMetadata\x12J\n\x0bplugin_data\x18\x01\x20\x01(\x0b2).tenso\
rboardrs.SummaryMetadata.PluginDataR\npluginData\x12!\n\x0cdisplay_name\
\x18\x02\x20\x01(\tR\x0bdisplayName\x12/\n\x13summary_description\x18\
\x03\x20\x01(\tR\x12summaryDescription\x1aG\n\nPluginData\x12\x1f\n\x0bp\
lugin_name\x18\x01\x20\x01(\tR\npluginName\x12\x18\n\x07content\x18\x02\
\x20\x01(\x0cR\x07content\"\xce\x06\n\x07Summary\x122\n\x05value\x18\x01\
\x20\x03(\x0b2\x1c.tensorboardrs.Summary.ValueR\x05value\x1a\x87\x01\n\
\x05Image\x12\x16\n\x06height\x18\x01\x20\x01(\x05R\x06height\x12\x14\n\
\x05width\x18\x02\x20\x01(\x05R\x05width\x12\x1e\n\ncolorspace\x18\x03\
\x20\x01(\x05R\ncolorspace\x120\n\x14encoded_image_string\x18\x04\x20\
\x01(\x0cR\x12encodedImageString\x1a\xc5\x01\n\x05Audio\x12\x1f\n\x0bsam\
ple_rate\x18\x01\x20\x01(\x02R\nsampleRate\x12!\n\x0cnum_channels\x18\
\x02\x20\x01(\x03R\x0bnumChannels\x12#\n\rlength_frames\x18\x03\x20\x01(\
\x03R\x0clengthFrames\x120\n\x14encoded_audio_string\x18\x04\x20\x01(\
\x0cR\x12encodedAudioString\x12!\n\x0ccontent_type\x18\x05\x20\x01(\tR\
\x0bcontentType\x1a\xbc\x03\n\x05Value\x12\x1b\n\tnode_name\x18\x07\x20\
\x01(\tR\x08nodeName\x12\x10\n\x03tag\x18\x01\x20\x01(\tR\x03tag\x12:\n\
\x08metadata\x18\t\x20\x01(\x0b2\x1e.tensorboardrs.SummaryMetadataR\x08m\
etadata\x12#\n\x0csimple_value\x18\x02\x20\x01(\x02H\0R\x0bsimpleValue\
\x12A\n\x1cobsolete_old_style_histogram\x18\x03\x20\x01(\x0cH\0R\x19obso\
leteOldStyleHistogram\x124\n\x05image\x18\x04\x20\x01(\x0b2\x1c.tensorbo\
ardrs.Summary.ImageH\0R\x05image\x125\n\x05histo\x18\x05\x20\x01(\x0b2\
\x1d.tensorboardrs.HistogramProtoH\0R\x05histo\x124\n\x05audio\x18\x06\
\x20\x01(\x0b2\x1c.tensorboardrs.Summary.AudioH\0R\x05audio\x124\n\x06te\
nsor\x18\x08\x20\x01(\x0b2\x1a.tensorboardrs.TensorProtoH\0R\x06tensorB\
\x07\n\x05valueB.\n\x18org.tensorflow.frameworkB\rSummaryProtosP\x01\xf8\
\x01\x01J\xf8$\n\x06\x12\x04\0\0{\x01\n\x08\n\x01\x0c\x12\x03\0\0\x12\n\
\x08\n\x01\x02\x12\x03\x02\0\x16\n\x08\n\x01\x08\x12\x03\x03\0\x1f\n\t\n\
\x02\x08\x1f\x12\x03\x03\0\x1f\n\x08\n\x01\x08\x12\x03\x04\0.\n\t\n\x02\
\x08\x08\x12\x03\x04\0.\n\x08\n\x01\x08\x12\x03\x05\0\"\n\t\n\x02\x08\n\
\x12\x03\x05\0\"\n\x08\n\x01\x08\x12\x03\x06\01\n\t\n\x02\x08\x01\x12\
\x03\x06\01\n\t\n\x02\x03\0\x12\x03\x08\0\x1a\n?\n\x02\x04\0\x12\x04\x0b\
\0\x0f\x01\x1a3\x20Metadata\x20associated\x20with\x20a\x20series\x20of\
\x20Summary\x20data\n\n\n\n\x03\x04\0\x01\x12\x03\x0b\x08\x1a\n\x8c\x01\
\n\x04\x04\0\x02\0\x12\x03\x0e\x02\x17\x1a\x7f\x20Hint\x20on\x20how\x20p\
lugins\x20should\x20process\x20the\x20data\x20in\x20this\x20series.\n\
\x20Supported\x20values\x20include\x20\"scalar\",\x20\"histogram\",\x20\
\"image\",\x20\"audio\"\n\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x0e\x02\
\x08\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x0e\t\x12\n\x0c\n\x05\x04\0\x02\
\0\x03\x12\x03\x0e\x15\x16\nZ\n\x02\x04\x01\x12\x04\x13\0!\x01\x1aN\x20S\
erialization\x20format\x20for\x20histogram\x20module\x20in\n\x20core/lib\
/histogram/histogram.h\n\n\n\n\x03\x04\x01\x01\x12\x03\x13\x08\x16\n\x0b\
\n\x04\x04\x01\x02\0\x12\x03\x14\x02\x11\n\x0c\n\x05\x04\x01\x02\0\x05\
\x12\x03\x14\x02\x08\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03\x14\t\x0c\n\
\x0c\n\x05\x04\x01\x02\0\x03\x12\x03\x14\x0f\x10\n\x0b\n\x04\x04\x01\x02\
\x01\x12\x03\x15\x02\x11\n\x0c\n\x05\x04\x01\x02\x01\x05\x12\x03\x15\x02\
\x08\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x03\x15\t\x0c\n\x0c\n\x05\x04\
\x01\x02\x01\x03\x12\x03\x15\x0f\x10\n\x0b\n\x04\x04\x01\x02\x02\x12\x03\
\x16\x02\x11\n\x0c\n\x05\x04\x01\x02\x02\x05\x12\x03\x16\x02\x08\n\x0c\n\
\x05\x04\x01\x02\x02\x01\x12\x03\x16\t\x0c\n\x0c\n\x05\x04\x01\x02\x02\
\x03\x12\x03\x16\x0f\x10\n\x0b\n\x04\x04\x01\x02\x03\x12\x03\x17\x02\x11\
\n\x0c\n\x05\x04\x01\x02\x03\x05\x12\x03\x17\x02\x08\n\x0c\n\x05\x04\x01\
\x02\x03\x01\x12\x03\x17\t\x0c\n\x0c\n\x05\x04\x01\x02\x03\x03\x12\x03\
\x17\x0f\x10\n\x0b\n\x04\x04\x01\x02\x04\x12\x03\x18\x02\x19\n\x0c\n\x05\
\x04\x01\x02\x04\x05\x12\x03\x18\x02\x08\n\x0c\n\x05\x04\x01\x02\x04\x01\
\x12\x03\x18\t\x14\n\x0c\n\x05\x04\x01\x02\x04\x03\x12\x03\x18\x17\x18\n\
\xf5\x01\n\x04\x04\x01\x02\x05\x12\x03\x1f\x023\x1a\xe7\x01\x20Parallel\
\x20arrays\x20encoding\x20the\x20bucket\x20boundaries\x20and\x20the\x20b\
ucket\x20values.\n\x20bucket(i)\x20is\x20the\x20count\x20for\x20the\x20b\
ucket\x20i.\x20\x20The\x20range\x20for\n\x20a\x20bucket\x20is:\n\x20\x20\
\x20i\x20==\x200:\x20\x20-DBL_MAX\x20..\x20bucket_limit(0)\n\x20\x20\x20\
i\x20!=\x200:\x20\x20bucket_limit(i-1)\x20..\x20bucket_limit(i)\n\n\x0c\
\n\x05\x04\x01\x02\x05\x04\x12\x03\x1f\x02\n\n\x0c\n\x05\x04\x01\x02\x05\
\x05\x12\x03\x1f\x0b\x11\n\x0c\n\x05\x04\x01\x02\x05\x01\x12\x03\x1f\x12\
\x1e\n\x0c\n\x05\x04\x01\x02\x05\x03\x12\x03\x1f!\"\n\x0c\n\x05\x04\x01\
\x02\x05\x08\x12\x03\x1f#2\n\r\n\x06\x04\x01\x02\x05\x08\x02\x12\x03\x1f\
$1\n\x0b\n\x04\x04\x01\x02\x06\x12\x03\x20\x02-\n\x0c\n\x05\x04\x01\x02\
\x06\x04\x12\x03\x20\x02\n\n\x0c\n\x05\x04\x01\x02\x06\x05\x12\x03\x20\
\x0b\x11\n\x0c\n\x05\x04\x01\x02\x06\x01\x12\x03\x20\x12\x18\n\x0c\n\x05\
\x04\x01\x02\x06\x03\x12\x03\x20\x1b\x1c\n\x0c\n\x05\x04\x01\x02\x06\x08\
\x12\x03\x20\x1d,\n\r\n\x06\x04\x01\x02\x06\x08\x02\x12\x03\x20\x1e+\n{\
\n\x02\x04\x02\x12\x04%\07\x01\x1ao\x20A\x20SummaryMetadata\x20encapsula\
tes\x20information\x20on\x20which\x20plugins\x20are\x20able\x20to\x20mak\
e\n\x20use\x20of\x20a\x20certain\x20summary\x20value.\n\n\n\n\x03\x04\
\x02\x01\x12\x03%\x08\x17\n\x0c\n\x04\x04\x02\x03\0\x12\x04&\x02-\x03\n\
\x0c\n\x05\x04\x02\x03\0\x01\x12\x03&\n\x14\n>\n\x06\x04\x02\x03\0\x02\0\
\x12\x03(\x04\x1b\x1a/\x20The\x20name\x20of\x20the\x20plugin\x20this\x20\
data\x20pertains\x20to.\n\n\x0e\n\x07\x04\x02\x03\0\x02\0\x05\x12\x03(\
\x04\n\n\x0e\n\x07\x04\x02\x03\0\x02\0\x01\x12\x03(\x0b\x16\n\x0e\n\x07\
\x04\x02\x03\0\x02\0\x03\x12\x03(\x19\x1a\n\x7f\n\x06\x04\x02\x03\0\x02\
\x01\x12\x03,\x04\x16\x1ap\x20The\x20content\x20to\x20store\x20for\x20th\
e\x20plugin.\x20The\x20best\x20practice\x20is\x20for\x20this\x20to\x20be\
\n\x20a\x20binary\x20serialized\x20protocol\x20buffer.\n\n\x0e\n\x07\x04\
\x02\x03\0\x02\x01\x05\x12\x03,\x04\t\n\x0e\n\x07\x04\x02\x03\0\x02\x01\
\x01\x12\x03,\n\x11\n\x0e\n\x07\x04\x02\x03\0\x02\x01\x03\x12\x03,\x14\
\x15\nD\n\x04\x04\x02\x02\0\x12\x030\x02\x1d\x1a7\x20Data\x20that\x20ass\
ociates\x20a\x20summary\x20with\x20a\x20certain\x20plugin.\n\n\x0c\n\x05\
\x04\x02\x02\0\x06\x12\x030\x02\x0c\n\x0c\n\x05\x04\x02\x02\0\x01\x12\
\x030\r\x18\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x030\x1b\x1c\n7\n\x04\x04\
\x02\x02\x01\x12\x033\x02\x1a\x1a*\x20Display\x20name\x20for\x20viewing\
\x20in\x20TensorBoard.\n\n\x0c\n\x05\x04\x02\x02\x01\x05\x12\x033\x02\
\x08\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x033\t\x15\n\x0c\n\x05\x04\x02\
\x02\x01\x03\x12\x033\x18\x19\nY\n\x04\x04\x02\x02\x02\x12\x036\x02!\x1a\
L\x20Longform\x20readable\x20description\x20of\x20the\x20summary\x20sequ\
ence.\x20Markdown\x20supported.\n\n\x0c\n\x05\x04\x02\x02\x02\x05\x12\
\x036\x02\x08\n\x0c\n\x05\x04\x02\x02\x02\x01\x12\x036\t\x1c\n\x0c\n\x05\
\x04\x02\x02\x02\x03\x12\x036\x1f\x20\n\x96\x02\n\x02\x04\x03\x12\x04?\0\
{\x01\x1a\x89\x02\x20A\x20Summary\x20is\x20a\x20set\x20of\x20named\x20va\
lues\x20to\x20be\x20displayed\x20by\x20the\n\x20visualizer.\n\n\x20Summa\
ries\x20are\x20produced\x20regularly\x20during\x20training,\x20as\x20con\
trolled\x20by\n\x20the\x20\"summary_interval_secs\"\x20attribute\x20of\
\x20the\x20training\x20operation.\n\x20Summaries\x20are\x20also\x20produ\
ced\x20at\x20the\x20end\x20of\x20an\x20evaluation.\n\n\n\n\x03\x04\x03\
\x01\x12\x03?\x08\x0f\n\x0c\n\x04\x04\x03\x03\0\x12\x04@\x02O\x03\n\x0c\
\n\x05\x04\x03\x03\0\x01\x12\x03@\n\x0f\n)\n\x06\x04\x03\x03\0\x02\0\x12\
\x03B\x04\x15\x1a\x1a\x20Dimensions\x20of\x20the\x20image.\n\n\x0e\n\x07\
\x04\x03\x03\0\x02\0\x05\x12\x03B\x04\t\n\x0e\n\x07\x04\x03\x03\0\x02\0\
\x01\x12\x03B\n\x10\n\x0e\n\x07\x04\x03\x03\0\x02\0\x03\x12\x03B\x13\x14\
\n\r\n\x06\x04\x03\x03\0\x02\x01\x12\x03C\x04\x14\n\x0e\n\x07\x04\x03\
\x03\0\x02\x01\x05\x12\x03C\x04\t\n\x0e\n\x07\x04\x03\x03\0\x02\x01\x01\
\x12\x03C\n\x0f\n\x0e\n\x07\x04\x03\x03\0\x02\x01\x03\x12\x03C\x12\x13\n\
\x8c\x01\n\x06\x04\x03\x03\0\x02\x02\x12\x03K\x04\x19\x1a}\x20Valid\x20c\
olorspace\x20values\x20are\n\x20\x20\x201\x20-\x20grayscale\n\x20\x20\
\x202\x20-\x20grayscale\x20+\x20alpha\n\x20\x20\x203\x20-\x20RGB\n\x20\
\x20\x204\x20-\x20RGBA\n\x20\x20\x205\x20-\x20DIGITAL_YUV\n\x20\x20\x206\
\x20-\x20BGRA\n\n\x0e\n\x07\x04\x03\x03\0\x02\x02\x05\x12\x03K\x04\t\n\
\x0e\n\x07\x04\x03\x03\0\x02\x02\x01\x12\x03K\n\x14\n\x0e\n\x07\x04\x03\
\x03\0\x02\x02\x03\x12\x03K\x17\x18\nz\n\x06\x04\x03\x03\0\x02\x03\x12\
\x03N\x04#\x1ak\x20Image\x20data\x20in\x20encoded\x20format.\x20\x20All\
\x20image\x20formats\x20supported\x20by\n\x20image_codec::CoderUtil\x20c\
an\x20be\x20stored\x20here.\n\n\x0e\n\x07\x04\x03\x03\0\x02\x03\x05\x12\
\x03N\x04\t\n\x0e\n\x07\x04\x03\x03\0\x02\x03\x01\x12\x03N\n\x1e\n\x0e\n\
\x07\x04\x03\x03\0\x02\x03\x03\x12\x03N!\"\n\x0c\n\x04\x04\x03\x03\x01\
\x12\x04Q\x02\\\x03\n\x0c\n\x05\x04\x03\x03\x01\x01\x12\x03Q\n\x0f\n0\n\
\x06\x04\x03\x03\x01\x02\0\x12\x03S\x04\x1a\x1a!\x20Sample\x20rate\x20of\
\x20the\x20audio\x20in\x20Hz.\n\n\x0e\n\x07\x04\x03\x03\x01\x02\0\x05\
\x12\x03S\x04\t\n\x0e\n\x07\x04\x03\x03\x01\x02\0\x01\x12\x03S\n\x15\n\
\x0e\n\x07\x04\x03\x03\x01\x02\0\x03\x12\x03S\x18\x19\n-\n\x06\x04\x03\
\x03\x01\x02\x01\x12\x03U\x04\x1b\x1a\x1e\x20Number\x20of\x20channels\
\x20of\x20audio.\n\n\x0e\n\x07\x04\x03\x03\x01\x02\x01\x05\x12\x03U\x04\
\t\n\x0e\n\x07\x04\x03\x03\x01\x02\x01\x01\x12\x03U\n\x16\n\x0e\n\x07\
\x04\x03\x03\x01\x02\x01\x03\x12\x03U\x19\x1a\nE\n\x06\x04\x03\x03\x01\
\x02\x02\x12\x03W\x04\x1c\x1a6\x20Length\x20of\x20the\x20audio\x20in\x20\
frames\x20(samples\x20per\x20channel).\n\n\x0e\n\x07\x04\x03\x03\x01\x02\
\x02\x05\x12\x03W\x04\t\n\x0e\n\x07\x04\x03\x03\x01\x02\x02\x01\x12\x03W\
\n\x17\n\x0e\n\x07\x04\x03\x03\x01\x02\x02\x03\x12\x03W\x1a\x1b\na\n\x06\
\x04\x03\x03\x01\x02\x03\x12\x03Z\x04#\x1aR\x20Encoded\x20audio\x20data\
\x20and\x20its\x20associated\x20RFC\x202045\x20content\x20type\x20(e.g.\
\n\x20\"audio/wav\").\n\n\x0e\n\x07\x04\x03\x03\x01\x02\x03\x05\x12\x03Z\
\x04\t\n\x0e\n\x07\x04\x03\x03\x01\x02\x03\x01\x12\x03Z\n\x1e\n\x0e\n\
\x07\x04\x03\x03\x01\x02\x03\x03\x12\x03Z!\"\n\r\n\x06\x04\x03\x03\x01\
\x02\x04\x12\x03[\x04\x1c\n\x0e\n\x07\x04\x03\x03\x01\x02\x04\x05\x12\
\x03[\x04\n\n\x0e\n\x07\x04\x03\x03\x01\x02\x04\x01\x12\x03[\x0b\x17\n\
\x0e\n\x07\x04\x03\x03\x01\x02\x04\x03\x12\x03[\x1a\x1b\n\x0c\n\x04\x04\
\x03\x03\x02\x12\x04^\x02w\x03\n\x0c\n\x05\x04\x03\x03\x02\x01\x12\x03^\
\n\x0f\n>\n\x06\x04\x03\x03\x02\x02\0\x12\x03`\x04\x19\x1a/\x20This\x20f\
ield\x20is\x20deprecated\x20and\x20will\x20not\x20be\x20set.\n\n\x0e\n\
\x07\x04\x03\x03\x02\x02\0\x05\x12\x03`\x04\n\n\x0e\n\x07\x04\x03\x03\
\x02\x02\0\x01\x12\x03`\x0b\x14\n\x0e\n\x07\x04\x03\x03\x02\x02\0\x03\
\x12\x03`\x17\x18\n\xbf\x01\n\x06\x04\x03\x03\x02\x02\x01\x12\x03e\x04\
\x13\x1a\xaf\x01\x20Tag\x20name\x20for\x20the\x20data.\x20Used\x20by\x20\
TensorBoard\x20plugins\x20to\x20organize\x20data.\x20Tags\n\x20are\x20of\
ten\x20organized\x20by\x20scope\x20(which\x20contains\x20slashes\x20to\
\x20convey\n\x20hierarchy).\x20For\x20example:\x20foo/bar/0\n\n\x0e\n\
\x07\x04\x03\x03\x02\x02\x01\x05\x12\x03e\x04\n\n\x0e\n\x07\x04\x03\x03\
\x02\x02\x01\x01\x12\x03e\x0b\x0e\n\x0e\n\x07\x04\x03\x03\x02\x02\x01\
\x03\x12\x03e\x11\x12\n\xef\x02\n\x06\x04\x03\x03\x02\x02\x02\x12\x03l\
\x04!\x1a\xdf\x02\x20Contains\x20metadata\x20on\x20the\x20summary\x20val\
ue\x20such\x20as\x20which\x20plugins\x20may\x20use\x20it.\n\x20Take\x20n\
ote\x20that\x20many\x20summary\x20values\x20may\x20lack\x20a\x20metadata\
\x20field.\x20This\x20is\n\x20because\x20the\x20FileWriter\x20only\x20ke\
eps\x20a\x20metadata\x20object\x20on\x20the\x20first\x20summary\n\x20val\
ue\x20with\x20a\x20certain\x20tag\x20for\x20each\x20tag.\x20TensorBoard\
\x20then\x20remembers\x20which\n\x20tags\x20are\x20associated\x20with\
\x20which\x20plugins.\x20This\x20saves\x20space.\n\n\x0e\n\x07\x04\x03\
\x03\x02\x02\x02\x06\x12\x03l\x04\x13\n\x0e\n\x07\x04\x03\x03\x02\x02\
\x02\x01\x12\x03l\x14\x1c\n\x0e\n\x07\x04\x03\x03\x02\x02\x02\x03\x12\
\x03l\x1f\x20\n0\n\x06\x04\x03\x03\x02\x08\0\x12\x04o\x04v\x05\x1a\x20\
\x20Value\x20associated\x20with\x20the\x20tag.\n\n\x0e\n\x07\x04\x03\x03\
\x02\x08\0\x01\x12\x03o\n\x0f\n\r\n\x06\x04\x03\x03\x02\x02\x03\x12\x03p\
\x06\x1d\n\x0e\n\x07\x04\x03\x03\x02\x02\x03\x05\x12\x03p\x06\x0b\n\x0e\
\n\x07\x04\x03\x03\x02\x02\x03\x01\x12\x03p\x0c\x18\n\x0e\n\x07\x04\x03\
\x03\x02\x02\x03\x03\x12\x03p\x1b\x1c\n\r\n\x06\x04\x03\x03\x02\x02\x04\
\x12\x03q\x06-\n\x0e\n\x07\x04\x03\x03\x02\x02\x04\x05\x12\x03q\x06\x0b\
\n\x0e\n\x07\x04\x03\x03\x02\x02\x04\x01\x12\x03q\x0c(\n\x0e\n\x07\x04\
\x03\x03\x02\x02\x04\x03\x12\x03q+,\n\r\n\x06\x04\x03\x03\x02\x02\x05\
\x12\x03r\x06\x16\n\x0e\n\x07\x04\x03\x03\x02\x02\x05\x06\x12\x03r\x06\
\x0b\n\x0e\n\x07\x04\x03\x03\x02\x02\x05\x01\x12\x03r\x0c\x11\n\x0e\n\
\x07\x04\x03\x03\x02\x02\x05\x03\x12\x03r\x14\x15\n\r\n\x06\x04\x03\x03\
\x02\x02\x06\x12\x03s\x06\x1f\n\x0e\n\x07\x04\x03\x03\x02\x02\x06\x06\
\x12\x03s\x06\x14\n\x0e\n\x07\x04\x03\x03\x02\x02\x06\x01\x12\x03s\x15\
\x1a\n\x0e\n\x07\x04\x03\x03\x02\x02\x06\x03\x12\x03s\x1d\x1e\n\r\n\x06\
\x04\x03\x03\x02\x02\x07\x12\x03t\x06\x16\n\x0e\n\x07\x04\x03\x03\x02\
\x02\x07\x06\x12\x03t\x06\x0b\n\x0e\n\x07\x04\x03\x03\x02\x02\x07\x01\
\x12\x03t\x0c\x11\n\x0e\n\x07\x04\x03\x03\x02\x02\x07\x03\x12\x03t\x14\
\x15\n\r\n\x06\x04\x03\x03\x02\x02\x08\x12\x03u\x06\x1d\n\x0e\n\x07\x04\
\x03\x03\x02\x02\x08\x06\x12\x03u\x06\x11\n\x0e\n\x07\x04\x03\x03\x02\
\x02\x08\x01\x12\x03u\x12\x18\n\x0e\n\x07\x04\x03\x03\x02\x02\x08\x03\
\x12\x03u\x1b\x1c\n-\n\x04\x04\x03\x02\0\x12\x03z\x02\x1b\x1a\x20\x20Set\
\x20of\x20values\x20for\x20the\x20summary.\n\n\x0c\n\x05\x04\x03\x02\0\
\x04\x12\x03z\x02\n\n\x0c\n\x05\x04\x03\x02\0\x06\x12\x03z\x0b\x10\n\x0c\
\n\x05\x04\x03\x02\0\x01\x12\x03z\x11\x16\n\x0c\n\x05\x04\x03\x02\0\x03\
\x12\x03z\x19\x1ab\x06proto3\
";
static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}