#![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;
#[derive(PartialEq,Clone,Default)]
pub struct MetaGraphDef {
pub meta_info_def: ::protobuf::SingularPtrField<MetaGraphDef_MetaInfoDef>,
pub graph_def: ::protobuf::SingularPtrField<super::graph::GraphDef>,
pub saver_def: ::protobuf::SingularPtrField<super::saver::SaverDef>,
pub collection_def: ::std::collections::HashMap<::std::string::String, CollectionDef>,
pub signature_def: ::std::collections::HashMap<::std::string::String, SignatureDef>,
pub asset_file_def: ::protobuf::RepeatedField<AssetFileDef>,
pub object_graph_def: ::protobuf::SingularPtrField<super::saved_object_graph::SavedObjectGraph>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a MetaGraphDef {
fn default() -> &'a MetaGraphDef {
<MetaGraphDef as ::protobuf::Message>::default_instance()
}
}
impl MetaGraphDef {
pub fn new() -> MetaGraphDef {
::std::default::Default::default()
}
pub fn get_meta_info_def(&self) -> &MetaGraphDef_MetaInfoDef {
self.meta_info_def.as_ref().unwrap_or_else(|| MetaGraphDef_MetaInfoDef::default_instance())
}
pub fn clear_meta_info_def(&mut self) {
self.meta_info_def.clear();
}
pub fn has_meta_info_def(&self) -> bool {
self.meta_info_def.is_some()
}
pub fn set_meta_info_def(&mut self, v: MetaGraphDef_MetaInfoDef) {
self.meta_info_def = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_meta_info_def(&mut self) -> &mut MetaGraphDef_MetaInfoDef {
if self.meta_info_def.is_none() {
self.meta_info_def.set_default();
}
self.meta_info_def.as_mut().unwrap()
}
pub fn take_meta_info_def(&mut self) -> MetaGraphDef_MetaInfoDef {
self.meta_info_def.take().unwrap_or_else(|| MetaGraphDef_MetaInfoDef::new())
}
pub fn get_graph_def(&self) -> &super::graph::GraphDef {
self.graph_def.as_ref().unwrap_or_else(|| super::graph::GraphDef::default_instance())
}
pub fn clear_graph_def(&mut self) {
self.graph_def.clear();
}
pub fn has_graph_def(&self) -> bool {
self.graph_def.is_some()
}
pub fn set_graph_def(&mut self, v: super::graph::GraphDef) {
self.graph_def = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_graph_def(&mut self) -> &mut super::graph::GraphDef {
if self.graph_def.is_none() {
self.graph_def.set_default();
}
self.graph_def.as_mut().unwrap()
}
pub fn take_graph_def(&mut self) -> super::graph::GraphDef {
self.graph_def.take().unwrap_or_else(|| super::graph::GraphDef::new())
}
pub fn get_saver_def(&self) -> &super::saver::SaverDef {
self.saver_def.as_ref().unwrap_or_else(|| super::saver::SaverDef::default_instance())
}
pub fn clear_saver_def(&mut self) {
self.saver_def.clear();
}
pub fn has_saver_def(&self) -> bool {
self.saver_def.is_some()
}
pub fn set_saver_def(&mut self, v: super::saver::SaverDef) {
self.saver_def = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_saver_def(&mut self) -> &mut super::saver::SaverDef {
if self.saver_def.is_none() {
self.saver_def.set_default();
}
self.saver_def.as_mut().unwrap()
}
pub fn take_saver_def(&mut self) -> super::saver::SaverDef {
self.saver_def.take().unwrap_or_else(|| super::saver::SaverDef::new())
}
pub fn get_collection_def(&self) -> &::std::collections::HashMap<::std::string::String, CollectionDef> {
&self.collection_def
}
pub fn clear_collection_def(&mut self) {
self.collection_def.clear();
}
pub fn set_collection_def(&mut self, v: ::std::collections::HashMap<::std::string::String, CollectionDef>) {
self.collection_def = v;
}
pub fn mut_collection_def(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, CollectionDef> {
&mut self.collection_def
}
pub fn take_collection_def(&mut self) -> ::std::collections::HashMap<::std::string::String, CollectionDef> {
::std::mem::replace(&mut self.collection_def, ::std::collections::HashMap::new())
}
pub fn get_signature_def(&self) -> &::std::collections::HashMap<::std::string::String, SignatureDef> {
&self.signature_def
}
pub fn clear_signature_def(&mut self) {
self.signature_def.clear();
}
pub fn set_signature_def(&mut self, v: ::std::collections::HashMap<::std::string::String, SignatureDef>) {
self.signature_def = v;
}
pub fn mut_signature_def(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, SignatureDef> {
&mut self.signature_def
}
pub fn take_signature_def(&mut self) -> ::std::collections::HashMap<::std::string::String, SignatureDef> {
::std::mem::replace(&mut self.signature_def, ::std::collections::HashMap::new())
}
pub fn get_asset_file_def(&self) -> &[AssetFileDef] {
&self.asset_file_def
}
pub fn clear_asset_file_def(&mut self) {
self.asset_file_def.clear();
}
pub fn set_asset_file_def(&mut self, v: ::protobuf::RepeatedField<AssetFileDef>) {
self.asset_file_def = v;
}
pub fn mut_asset_file_def(&mut self) -> &mut ::protobuf::RepeatedField<AssetFileDef> {
&mut self.asset_file_def
}
pub fn take_asset_file_def(&mut self) -> ::protobuf::RepeatedField<AssetFileDef> {
::std::mem::replace(&mut self.asset_file_def, ::protobuf::RepeatedField::new())
}
pub fn get_object_graph_def(&self) -> &super::saved_object_graph::SavedObjectGraph {
self.object_graph_def.as_ref().unwrap_or_else(|| super::saved_object_graph::SavedObjectGraph::default_instance())
}
pub fn clear_object_graph_def(&mut self) {
self.object_graph_def.clear();
}
pub fn has_object_graph_def(&self) -> bool {
self.object_graph_def.is_some()
}
pub fn set_object_graph_def(&mut self, v: super::saved_object_graph::SavedObjectGraph) {
self.object_graph_def = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_object_graph_def(&mut self) -> &mut super::saved_object_graph::SavedObjectGraph {
if self.object_graph_def.is_none() {
self.object_graph_def.set_default();
}
self.object_graph_def.as_mut().unwrap()
}
pub fn take_object_graph_def(&mut self) -> super::saved_object_graph::SavedObjectGraph {
self.object_graph_def.take().unwrap_or_else(|| super::saved_object_graph::SavedObjectGraph::new())
}
}
impl ::protobuf::Message for MetaGraphDef {
fn is_initialized(&self) -> bool {
for v in &self.meta_info_def {
if !v.is_initialized() {
return false;
}
};
for v in &self.graph_def {
if !v.is_initialized() {
return false;
}
};
for v in &self.saver_def {
if !v.is_initialized() {
return false;
}
};
for v in &self.asset_file_def {
if !v.is_initialized() {
return false;
}
};
for v in &self.object_graph_def {
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.meta_info_def)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.graph_def)?;
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.saver_def)?;
},
4 => {
::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<CollectionDef>>(wire_type, is, &mut self.collection_def)?;
},
5 => {
::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<SignatureDef>>(wire_type, is, &mut self.signature_def)?;
},
6 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.asset_file_def)?;
},
7 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.object_graph_def)?;
},
_ => {
::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.meta_info_def.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.graph_def.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.saver_def.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::ProtobufTypeMessage<CollectionDef>>(4, &self.collection_def);
my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<SignatureDef>>(5, &self.signature_def);
for value in &self.asset_file_def {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
if let Some(ref v) = self.object_graph_def.as_ref() {
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 let Some(ref v) = self.meta_info_def.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 let Some(ref v) = self.graph_def.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.saver_def.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)?;
}
::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<CollectionDef>>(4, &self.collection_def, os)?;
::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<SignatureDef>>(5, &self.signature_def, os)?;
for v in &self.asset_file_def {
os.write_tag(6, ::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.object_graph_def.as_ref() {
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() -> MetaGraphDef {
MetaGraphDef::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MetaGraphDef_MetaInfoDef>>(
"meta_info_def",
|m: &MetaGraphDef| { &m.meta_info_def },
|m: &mut MetaGraphDef| { &mut m.meta_info_def },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::graph::GraphDef>>(
"graph_def",
|m: &MetaGraphDef| { &m.graph_def },
|m: &mut MetaGraphDef| { &mut m.graph_def },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::saver::SaverDef>>(
"saver_def",
|m: &MetaGraphDef| { &m.saver_def },
|m: &mut MetaGraphDef| { &mut m.saver_def },
));
fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<CollectionDef>>(
"collection_def",
|m: &MetaGraphDef| { &m.collection_def },
|m: &mut MetaGraphDef| { &mut m.collection_def },
));
fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<SignatureDef>>(
"signature_def",
|m: &MetaGraphDef| { &m.signature_def },
|m: &mut MetaGraphDef| { &mut m.signature_def },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<AssetFileDef>>(
"asset_file_def",
|m: &MetaGraphDef| { &m.asset_file_def },
|m: &mut MetaGraphDef| { &mut m.asset_file_def },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::saved_object_graph::SavedObjectGraph>>(
"object_graph_def",
|m: &MetaGraphDef| { &m.object_graph_def },
|m: &mut MetaGraphDef| { &mut m.object_graph_def },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<MetaGraphDef>(
"MetaGraphDef",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static MetaGraphDef {
static mut instance: ::protobuf::lazy::Lazy<MetaGraphDef> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(MetaGraphDef::new)
}
}
}
impl ::protobuf::Clear for MetaGraphDef {
fn clear(&mut self) {
self.meta_info_def.clear();
self.graph_def.clear();
self.saver_def.clear();
self.collection_def.clear();
self.signature_def.clear();
self.asset_file_def.clear();
self.object_graph_def.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for MetaGraphDef {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for MetaGraphDef {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct MetaGraphDef_MetaInfoDef {
pub meta_graph_version: ::std::string::String,
pub stripped_op_list: ::protobuf::SingularPtrField<super::op_def::OpList>,
pub any_info: ::protobuf::SingularPtrField<::protobuf::well_known_types::Any>,
pub tags: ::protobuf::RepeatedField<::std::string::String>,
pub tensorflow_version: ::std::string::String,
pub tensorflow_git_version: ::std::string::String,
pub stripped_default_attrs: bool,
pub function_aliases: ::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 MetaGraphDef_MetaInfoDef {
fn default() -> &'a MetaGraphDef_MetaInfoDef {
<MetaGraphDef_MetaInfoDef as ::protobuf::Message>::default_instance()
}
}
impl MetaGraphDef_MetaInfoDef {
pub fn new() -> MetaGraphDef_MetaInfoDef {
::std::default::Default::default()
}
pub fn get_meta_graph_version(&self) -> &str {
&self.meta_graph_version
}
pub fn clear_meta_graph_version(&mut self) {
self.meta_graph_version.clear();
}
pub fn set_meta_graph_version(&mut self, v: ::std::string::String) {
self.meta_graph_version = v;
}
pub fn mut_meta_graph_version(&mut self) -> &mut ::std::string::String {
&mut self.meta_graph_version
}
pub fn take_meta_graph_version(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.meta_graph_version, ::std::string::String::new())
}
pub fn get_stripped_op_list(&self) -> &super::op_def::OpList {
self.stripped_op_list.as_ref().unwrap_or_else(|| super::op_def::OpList::default_instance())
}
pub fn clear_stripped_op_list(&mut self) {
self.stripped_op_list.clear();
}
pub fn has_stripped_op_list(&self) -> bool {
self.stripped_op_list.is_some()
}
pub fn set_stripped_op_list(&mut self, v: super::op_def::OpList) {
self.stripped_op_list = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_stripped_op_list(&mut self) -> &mut super::op_def::OpList {
if self.stripped_op_list.is_none() {
self.stripped_op_list.set_default();
}
self.stripped_op_list.as_mut().unwrap()
}
pub fn take_stripped_op_list(&mut self) -> super::op_def::OpList {
self.stripped_op_list.take().unwrap_or_else(|| super::op_def::OpList::new())
}
pub fn get_any_info(&self) -> &::protobuf::well_known_types::Any {
self.any_info.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Any::default_instance())
}
pub fn clear_any_info(&mut self) {
self.any_info.clear();
}
pub fn has_any_info(&self) -> bool {
self.any_info.is_some()
}
pub fn set_any_info(&mut self, v: ::protobuf::well_known_types::Any) {
self.any_info = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_any_info(&mut self) -> &mut ::protobuf::well_known_types::Any {
if self.any_info.is_none() {
self.any_info.set_default();
}
self.any_info.as_mut().unwrap()
}
pub fn take_any_info(&mut self) -> ::protobuf::well_known_types::Any {
self.any_info.take().unwrap_or_else(|| ::protobuf::well_known_types::Any::new())
}
pub fn get_tags(&self) -> &[::std::string::String] {
&self.tags
}
pub fn clear_tags(&mut self) {
self.tags.clear();
}
pub fn set_tags(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
self.tags = v;
}
pub fn mut_tags(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
&mut self.tags
}
pub fn take_tags(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
::std::mem::replace(&mut self.tags, ::protobuf::RepeatedField::new())
}
pub fn get_tensorflow_version(&self) -> &str {
&self.tensorflow_version
}
pub fn clear_tensorflow_version(&mut self) {
self.tensorflow_version.clear();
}
pub fn set_tensorflow_version(&mut self, v: ::std::string::String) {
self.tensorflow_version = v;
}
pub fn mut_tensorflow_version(&mut self) -> &mut ::std::string::String {
&mut self.tensorflow_version
}
pub fn take_tensorflow_version(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.tensorflow_version, ::std::string::String::new())
}
pub fn get_tensorflow_git_version(&self) -> &str {
&self.tensorflow_git_version
}
pub fn clear_tensorflow_git_version(&mut self) {
self.tensorflow_git_version.clear();
}
pub fn set_tensorflow_git_version(&mut self, v: ::std::string::String) {
self.tensorflow_git_version = v;
}
pub fn mut_tensorflow_git_version(&mut self) -> &mut ::std::string::String {
&mut self.tensorflow_git_version
}
pub fn take_tensorflow_git_version(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.tensorflow_git_version, ::std::string::String::new())
}
pub fn get_stripped_default_attrs(&self) -> bool {
self.stripped_default_attrs
}
pub fn clear_stripped_default_attrs(&mut self) {
self.stripped_default_attrs = false;
}
pub fn set_stripped_default_attrs(&mut self, v: bool) {
self.stripped_default_attrs = v;
}
pub fn get_function_aliases(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> {
&self.function_aliases
}
pub fn clear_function_aliases(&mut self) {
self.function_aliases.clear();
}
pub fn set_function_aliases(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::string::String>) {
self.function_aliases = v;
}
pub fn mut_function_aliases(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> {
&mut self.function_aliases
}
pub fn take_function_aliases(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> {
::std::mem::replace(&mut self.function_aliases, ::std::collections::HashMap::new())
}
}
impl ::protobuf::Message for MetaGraphDef_MetaInfoDef {
fn is_initialized(&self) -> bool {
for v in &self.stripped_op_list {
if !v.is_initialized() {
return false;
}
};
for v in &self.any_info {
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.meta_graph_version)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.stripped_op_list)?;
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.any_info)?;
},
4 => {
::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.tags)?;
},
5 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.tensorflow_version)?;
},
6 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.tensorflow_git_version)?;
},
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.stripped_default_attrs = tmp;
},
8 => {
::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.function_aliases)?;
},
_ => {
::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.meta_graph_version.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.meta_graph_version);
}
if let Some(ref v) = self.stripped_op_list.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.any_info.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.tags {
my_size += ::protobuf::rt::string_size(4, &value);
};
if !self.tensorflow_version.is_empty() {
my_size += ::protobuf::rt::string_size(5, &self.tensorflow_version);
}
if !self.tensorflow_git_version.is_empty() {
my_size += ::protobuf::rt::string_size(6, &self.tensorflow_git_version);
}
if self.stripped_default_attrs != false {
my_size += 2;
}
my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(8, &self.function_aliases);
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.meta_graph_version.is_empty() {
os.write_string(1, &self.meta_graph_version)?;
}
if let Some(ref v) = self.stripped_op_list.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.any_info.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)?;
}
for v in &self.tags {
os.write_string(4, &v)?;
};
if !self.tensorflow_version.is_empty() {
os.write_string(5, &self.tensorflow_version)?;
}
if !self.tensorflow_git_version.is_empty() {
os.write_string(6, &self.tensorflow_git_version)?;
}
if self.stripped_default_attrs != false {
os.write_bool(7, self.stripped_default_attrs)?;
}
::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(8, &self.function_aliases, 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() -> MetaGraphDef_MetaInfoDef {
MetaGraphDef_MetaInfoDef::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"meta_graph_version",
|m: &MetaGraphDef_MetaInfoDef| { &m.meta_graph_version },
|m: &mut MetaGraphDef_MetaInfoDef| { &mut m.meta_graph_version },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::op_def::OpList>>(
"stripped_op_list",
|m: &MetaGraphDef_MetaInfoDef| { &m.stripped_op_list },
|m: &mut MetaGraphDef_MetaInfoDef| { &mut m.stripped_op_list },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Any>>(
"any_info",
|m: &MetaGraphDef_MetaInfoDef| { &m.any_info },
|m: &mut MetaGraphDef_MetaInfoDef| { &mut m.any_info },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"tags",
|m: &MetaGraphDef_MetaInfoDef| { &m.tags },
|m: &mut MetaGraphDef_MetaInfoDef| { &mut m.tags },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"tensorflow_version",
|m: &MetaGraphDef_MetaInfoDef| { &m.tensorflow_version },
|m: &mut MetaGraphDef_MetaInfoDef| { &mut m.tensorflow_version },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"tensorflow_git_version",
|m: &MetaGraphDef_MetaInfoDef| { &m.tensorflow_git_version },
|m: &mut MetaGraphDef_MetaInfoDef| { &mut m.tensorflow_git_version },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"stripped_default_attrs",
|m: &MetaGraphDef_MetaInfoDef| { &m.stripped_default_attrs },
|m: &mut MetaGraphDef_MetaInfoDef| { &mut m.stripped_default_attrs },
));
fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(
"function_aliases",
|m: &MetaGraphDef_MetaInfoDef| { &m.function_aliases },
|m: &mut MetaGraphDef_MetaInfoDef| { &mut m.function_aliases },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<MetaGraphDef_MetaInfoDef>(
"MetaGraphDef.MetaInfoDef",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static MetaGraphDef_MetaInfoDef {
static mut instance: ::protobuf::lazy::Lazy<MetaGraphDef_MetaInfoDef> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(MetaGraphDef_MetaInfoDef::new)
}
}
}
impl ::protobuf::Clear for MetaGraphDef_MetaInfoDef {
fn clear(&mut self) {
self.meta_graph_version.clear();
self.stripped_op_list.clear();
self.any_info.clear();
self.tags.clear();
self.tensorflow_version.clear();
self.tensorflow_git_version.clear();
self.stripped_default_attrs = false;
self.function_aliases.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for MetaGraphDef_MetaInfoDef {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for MetaGraphDef_MetaInfoDef {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CollectionDef {
pub kind: ::std::option::Option<CollectionDef_oneof_kind>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CollectionDef {
fn default() -> &'a CollectionDef {
<CollectionDef as ::protobuf::Message>::default_instance()
}
}
#[derive(Clone,PartialEq,Debug)]
pub enum CollectionDef_oneof_kind {
node_list(CollectionDef_NodeList),
bytes_list(CollectionDef_BytesList),
int64_list(CollectionDef_Int64List),
float_list(CollectionDef_FloatList),
any_list(CollectionDef_AnyList),
}
impl CollectionDef {
pub fn new() -> CollectionDef {
::std::default::Default::default()
}
pub fn get_node_list(&self) -> &CollectionDef_NodeList {
match self.kind {
::std::option::Option::Some(CollectionDef_oneof_kind::node_list(ref v)) => v,
_ => CollectionDef_NodeList::default_instance(),
}
}
pub fn clear_node_list(&mut self) {
self.kind = ::std::option::Option::None;
}
pub fn has_node_list(&self) -> bool {
match self.kind {
::std::option::Option::Some(CollectionDef_oneof_kind::node_list(..)) => true,
_ => false,
}
}
pub fn set_node_list(&mut self, v: CollectionDef_NodeList) {
self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::node_list(v))
}
pub fn mut_node_list(&mut self) -> &mut CollectionDef_NodeList {
if let ::std::option::Option::Some(CollectionDef_oneof_kind::node_list(_)) = self.kind {
} else {
self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::node_list(CollectionDef_NodeList::new()));
}
match self.kind {
::std::option::Option::Some(CollectionDef_oneof_kind::node_list(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_node_list(&mut self) -> CollectionDef_NodeList {
if self.has_node_list() {
match self.kind.take() {
::std::option::Option::Some(CollectionDef_oneof_kind::node_list(v)) => v,
_ => panic!(),
}
} else {
CollectionDef_NodeList::new()
}
}
pub fn get_bytes_list(&self) -> &CollectionDef_BytesList {
match self.kind {
::std::option::Option::Some(CollectionDef_oneof_kind::bytes_list(ref v)) => v,
_ => CollectionDef_BytesList::default_instance(),
}
}
pub fn clear_bytes_list(&mut self) {
self.kind = ::std::option::Option::None;
}
pub fn has_bytes_list(&self) -> bool {
match self.kind {
::std::option::Option::Some(CollectionDef_oneof_kind::bytes_list(..)) => true,
_ => false,
}
}
pub fn set_bytes_list(&mut self, v: CollectionDef_BytesList) {
self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::bytes_list(v))
}
pub fn mut_bytes_list(&mut self) -> &mut CollectionDef_BytesList {
if let ::std::option::Option::Some(CollectionDef_oneof_kind::bytes_list(_)) = self.kind {
} else {
self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::bytes_list(CollectionDef_BytesList::new()));
}
match self.kind {
::std::option::Option::Some(CollectionDef_oneof_kind::bytes_list(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_bytes_list(&mut self) -> CollectionDef_BytesList {
if self.has_bytes_list() {
match self.kind.take() {
::std::option::Option::Some(CollectionDef_oneof_kind::bytes_list(v)) => v,
_ => panic!(),
}
} else {
CollectionDef_BytesList::new()
}
}
pub fn get_int64_list(&self) -> &CollectionDef_Int64List {
match self.kind {
::std::option::Option::Some(CollectionDef_oneof_kind::int64_list(ref v)) => v,
_ => CollectionDef_Int64List::default_instance(),
}
}
pub fn clear_int64_list(&mut self) {
self.kind = ::std::option::Option::None;
}
pub fn has_int64_list(&self) -> bool {
match self.kind {
::std::option::Option::Some(CollectionDef_oneof_kind::int64_list(..)) => true,
_ => false,
}
}
pub fn set_int64_list(&mut self, v: CollectionDef_Int64List) {
self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::int64_list(v))
}
pub fn mut_int64_list(&mut self) -> &mut CollectionDef_Int64List {
if let ::std::option::Option::Some(CollectionDef_oneof_kind::int64_list(_)) = self.kind {
} else {
self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::int64_list(CollectionDef_Int64List::new()));
}
match self.kind {
::std::option::Option::Some(CollectionDef_oneof_kind::int64_list(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_int64_list(&mut self) -> CollectionDef_Int64List {
if self.has_int64_list() {
match self.kind.take() {
::std::option::Option::Some(CollectionDef_oneof_kind::int64_list(v)) => v,
_ => panic!(),
}
} else {
CollectionDef_Int64List::new()
}
}
pub fn get_float_list(&self) -> &CollectionDef_FloatList {
match self.kind {
::std::option::Option::Some(CollectionDef_oneof_kind::float_list(ref v)) => v,
_ => CollectionDef_FloatList::default_instance(),
}
}
pub fn clear_float_list(&mut self) {
self.kind = ::std::option::Option::None;
}
pub fn has_float_list(&self) -> bool {
match self.kind {
::std::option::Option::Some(CollectionDef_oneof_kind::float_list(..)) => true,
_ => false,
}
}
pub fn set_float_list(&mut self, v: CollectionDef_FloatList) {
self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::float_list(v))
}
pub fn mut_float_list(&mut self) -> &mut CollectionDef_FloatList {
if let ::std::option::Option::Some(CollectionDef_oneof_kind::float_list(_)) = self.kind {
} else {
self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::float_list(CollectionDef_FloatList::new()));
}
match self.kind {
::std::option::Option::Some(CollectionDef_oneof_kind::float_list(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_float_list(&mut self) -> CollectionDef_FloatList {
if self.has_float_list() {
match self.kind.take() {
::std::option::Option::Some(CollectionDef_oneof_kind::float_list(v)) => v,
_ => panic!(),
}
} else {
CollectionDef_FloatList::new()
}
}
pub fn get_any_list(&self) -> &CollectionDef_AnyList {
match self.kind {
::std::option::Option::Some(CollectionDef_oneof_kind::any_list(ref v)) => v,
_ => CollectionDef_AnyList::default_instance(),
}
}
pub fn clear_any_list(&mut self) {
self.kind = ::std::option::Option::None;
}
pub fn has_any_list(&self) -> bool {
match self.kind {
::std::option::Option::Some(CollectionDef_oneof_kind::any_list(..)) => true,
_ => false,
}
}
pub fn set_any_list(&mut self, v: CollectionDef_AnyList) {
self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::any_list(v))
}
pub fn mut_any_list(&mut self) -> &mut CollectionDef_AnyList {
if let ::std::option::Option::Some(CollectionDef_oneof_kind::any_list(_)) = self.kind {
} else {
self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::any_list(CollectionDef_AnyList::new()));
}
match self.kind {
::std::option::Option::Some(CollectionDef_oneof_kind::any_list(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_any_list(&mut self) -> CollectionDef_AnyList {
if self.has_any_list() {
match self.kind.take() {
::std::option::Option::Some(CollectionDef_oneof_kind::any_list(v)) => v,
_ => panic!(),
}
} else {
CollectionDef_AnyList::new()
}
}
}
impl ::protobuf::Message for CollectionDef {
fn is_initialized(&self) -> bool {
if let Some(CollectionDef_oneof_kind::node_list(ref v)) = self.kind {
if !v.is_initialized() {
return false;
}
}
if let Some(CollectionDef_oneof_kind::bytes_list(ref v)) = self.kind {
if !v.is_initialized() {
return false;
}
}
if let Some(CollectionDef_oneof_kind::int64_list(ref v)) = self.kind {
if !v.is_initialized() {
return false;
}
}
if let Some(CollectionDef_oneof_kind::float_list(ref v)) = self.kind {
if !v.is_initialized() {
return false;
}
}
if let Some(CollectionDef_oneof_kind::any_list(ref v)) = self.kind {
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::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::node_list(is.read_message()?));
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::bytes_list(is.read_message()?));
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::int64_list(is.read_message()?));
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::float_list(is.read_message()?));
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::any_list(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 let ::std::option::Option::Some(ref v) = self.kind {
match v {
&CollectionDef_oneof_kind::node_list(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&CollectionDef_oneof_kind::bytes_list(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&CollectionDef_oneof_kind::int64_list(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&CollectionDef_oneof_kind::float_list(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&CollectionDef_oneof_kind::any_list(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 let ::std::option::Option::Some(ref v) = self.kind {
match v {
&CollectionDef_oneof_kind::node_list(ref v) => {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
&CollectionDef_oneof_kind::bytes_list(ref v) => {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
&CollectionDef_oneof_kind::int64_list(ref v) => {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
&CollectionDef_oneof_kind::float_list(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)?;
},
&CollectionDef_oneof_kind::any_list(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)?;
},
};
}
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() -> CollectionDef {
CollectionDef::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CollectionDef_NodeList>(
"node_list",
CollectionDef::has_node_list,
CollectionDef::get_node_list,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CollectionDef_BytesList>(
"bytes_list",
CollectionDef::has_bytes_list,
CollectionDef::get_bytes_list,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CollectionDef_Int64List>(
"int64_list",
CollectionDef::has_int64_list,
CollectionDef::get_int64_list,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CollectionDef_FloatList>(
"float_list",
CollectionDef::has_float_list,
CollectionDef::get_float_list,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CollectionDef_AnyList>(
"any_list",
CollectionDef::has_any_list,
CollectionDef::get_any_list,
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CollectionDef>(
"CollectionDef",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static CollectionDef {
static mut instance: ::protobuf::lazy::Lazy<CollectionDef> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(CollectionDef::new)
}
}
}
impl ::protobuf::Clear for CollectionDef {
fn clear(&mut self) {
self.kind = ::std::option::Option::None;
self.kind = ::std::option::Option::None;
self.kind = ::std::option::Option::None;
self.kind = ::std::option::Option::None;
self.kind = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CollectionDef {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CollectionDef {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CollectionDef_NodeList {
pub value: ::protobuf::RepeatedField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CollectionDef_NodeList {
fn default() -> &'a CollectionDef_NodeList {
<CollectionDef_NodeList as ::protobuf::Message>::default_instance()
}
}
impl CollectionDef_NodeList {
pub fn new() -> CollectionDef_NodeList {
::std::default::Default::default()
}
pub fn get_value(&self) -> &[::std::string::String] {
&self.value
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn set_value(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
self.value = v;
}
pub fn mut_value(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
&mut self.value
}
pub fn take_value(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
::std::mem::replace(&mut self.value, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for CollectionDef_NodeList {
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.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 {
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.value {
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() -> CollectionDef_NodeList {
CollectionDef_NodeList::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"value",
|m: &CollectionDef_NodeList| { &m.value },
|m: &mut CollectionDef_NodeList| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CollectionDef_NodeList>(
"CollectionDef.NodeList",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static CollectionDef_NodeList {
static mut instance: ::protobuf::lazy::Lazy<CollectionDef_NodeList> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(CollectionDef_NodeList::new)
}
}
}
impl ::protobuf::Clear for CollectionDef_NodeList {
fn clear(&mut self) {
self.value.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CollectionDef_NodeList {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CollectionDef_NodeList {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CollectionDef_BytesList {
pub value: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CollectionDef_BytesList {
fn default() -> &'a CollectionDef_BytesList {
<CollectionDef_BytesList as ::protobuf::Message>::default_instance()
}
}
impl CollectionDef_BytesList {
pub fn new() -> CollectionDef_BytesList {
::std::default::Default::default()
}
pub fn get_value(&self) -> &[::std::vec::Vec<u8>] {
&self.value
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn set_value(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
self.value = v;
}
pub fn mut_value(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
&mut self.value
}
pub fn take_value(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
::std::mem::replace(&mut self.value, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for CollectionDef_BytesList {
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_bytes_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 {
my_size += ::protobuf::rt::bytes_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.value {
os.write_bytes(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() -> CollectionDef_BytesList {
CollectionDef_BytesList::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"value",
|m: &CollectionDef_BytesList| { &m.value },
|m: &mut CollectionDef_BytesList| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CollectionDef_BytesList>(
"CollectionDef.BytesList",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static CollectionDef_BytesList {
static mut instance: ::protobuf::lazy::Lazy<CollectionDef_BytesList> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(CollectionDef_BytesList::new)
}
}
}
impl ::protobuf::Clear for CollectionDef_BytesList {
fn clear(&mut self) {
self.value.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CollectionDef_BytesList {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CollectionDef_BytesList {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CollectionDef_Int64List {
pub value: ::std::vec::Vec<i64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CollectionDef_Int64List {
fn default() -> &'a CollectionDef_Int64List {
<CollectionDef_Int64List as ::protobuf::Message>::default_instance()
}
}
impl CollectionDef_Int64List {
pub fn new() -> CollectionDef_Int64List {
::std::default::Default::default()
}
pub fn get_value(&self) -> &[i64] {
&self.value
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn set_value(&mut self, v: ::std::vec::Vec<i64>) {
self.value = v;
}
pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<i64> {
&mut self.value
}
pub fn take_value(&mut self) -> ::std::vec::Vec<i64> {
::std::mem::replace(&mut self.value, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for CollectionDef_Int64List {
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_int64_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;
if !self.value.is_empty() {
my_size += ::protobuf::rt::vec_packed_varint_size(1, &self.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.value.is_empty() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(::protobuf::rt::vec_packed_varint_data_size(&self.value))?;
for v in &self.value {
os.write_int64_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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CollectionDef_Int64List {
CollectionDef_Int64List::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
"value",
|m: &CollectionDef_Int64List| { &m.value },
|m: &mut CollectionDef_Int64List| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CollectionDef_Int64List>(
"CollectionDef.Int64List",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static CollectionDef_Int64List {
static mut instance: ::protobuf::lazy::Lazy<CollectionDef_Int64List> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(CollectionDef_Int64List::new)
}
}
}
impl ::protobuf::Clear for CollectionDef_Int64List {
fn clear(&mut self) {
self.value.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CollectionDef_Int64List {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CollectionDef_Int64List {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CollectionDef_FloatList {
pub value: ::std::vec::Vec<f32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CollectionDef_FloatList {
fn default() -> &'a CollectionDef_FloatList {
<CollectionDef_FloatList as ::protobuf::Message>::default_instance()
}
}
impl CollectionDef_FloatList {
pub fn new() -> CollectionDef_FloatList {
::std::default::Default::default()
}
pub fn get_value(&self) -> &[f32] {
&self.value
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn set_value(&mut self, v: ::std::vec::Vec<f32>) {
self.value = v;
}
pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<f32> {
&mut self.value
}
pub fn take_value(&mut self) -> ::std::vec::Vec<f32> {
::std::mem::replace(&mut self.value, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for CollectionDef_FloatList {
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_float_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;
if !self.value.is_empty() {
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size((self.value.len() * 4) as u32) + (self.value.len() * 4) 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.value.is_empty() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32((self.value.len() * 4) as u32)?;
for v in &self.value {
os.write_float_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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CollectionDef_FloatList {
CollectionDef_FloatList::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"value",
|m: &CollectionDef_FloatList| { &m.value },
|m: &mut CollectionDef_FloatList| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CollectionDef_FloatList>(
"CollectionDef.FloatList",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static CollectionDef_FloatList {
static mut instance: ::protobuf::lazy::Lazy<CollectionDef_FloatList> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(CollectionDef_FloatList::new)
}
}
}
impl ::protobuf::Clear for CollectionDef_FloatList {
fn clear(&mut self) {
self.value.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CollectionDef_FloatList {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CollectionDef_FloatList {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CollectionDef_AnyList {
pub value: ::protobuf::RepeatedField<::protobuf::well_known_types::Any>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CollectionDef_AnyList {
fn default() -> &'a CollectionDef_AnyList {
<CollectionDef_AnyList as ::protobuf::Message>::default_instance()
}
}
impl CollectionDef_AnyList {
pub fn new() -> CollectionDef_AnyList {
::std::default::Default::default()
}
pub fn get_value(&self) -> &[::protobuf::well_known_types::Any] {
&self.value
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn set_value(&mut self, v: ::protobuf::RepeatedField<::protobuf::well_known_types::Any>) {
self.value = v;
}
pub fn mut_value(&mut self) -> &mut ::protobuf::RepeatedField<::protobuf::well_known_types::Any> {
&mut self.value
}
pub fn take_value(&mut self) -> ::protobuf::RepeatedField<::protobuf::well_known_types::Any> {
::std::mem::replace(&mut self.value, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for CollectionDef_AnyList {
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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CollectionDef_AnyList {
CollectionDef_AnyList::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Any>>(
"value",
|m: &CollectionDef_AnyList| { &m.value },
|m: &mut CollectionDef_AnyList| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CollectionDef_AnyList>(
"CollectionDef.AnyList",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static CollectionDef_AnyList {
static mut instance: ::protobuf::lazy::Lazy<CollectionDef_AnyList> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(CollectionDef_AnyList::new)
}
}
}
impl ::protobuf::Clear for CollectionDef_AnyList {
fn clear(&mut self) {
self.value.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CollectionDef_AnyList {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CollectionDef_AnyList {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TensorInfo {
pub dtype: super::types::DataType,
pub tensor_shape: ::protobuf::SingularPtrField<super::tensor_shape::TensorShapeProto>,
pub encoding: ::std::option::Option<TensorInfo_oneof_encoding>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TensorInfo {
fn default() -> &'a TensorInfo {
<TensorInfo as ::protobuf::Message>::default_instance()
}
}
#[derive(Clone,PartialEq,Debug)]
pub enum TensorInfo_oneof_encoding {
name(::std::string::String),
coo_sparse(TensorInfo_CooSparse),
composite_tensor(TensorInfo_CompositeTensor),
}
impl TensorInfo {
pub fn new() -> TensorInfo {
::std::default::Default::default()
}
pub fn get_name(&self) -> &str {
match self.encoding {
::std::option::Option::Some(TensorInfo_oneof_encoding::name(ref v)) => v,
_ => "",
}
}
pub fn clear_name(&mut self) {
self.encoding = ::std::option::Option::None;
}
pub fn has_name(&self) -> bool {
match self.encoding {
::std::option::Option::Some(TensorInfo_oneof_encoding::name(..)) => true,
_ => false,
}
}
pub fn set_name(&mut self, v: ::std::string::String) {
self.encoding = ::std::option::Option::Some(TensorInfo_oneof_encoding::name(v))
}
pub fn mut_name(&mut self) -> &mut ::std::string::String {
if let ::std::option::Option::Some(TensorInfo_oneof_encoding::name(_)) = self.encoding {
} else {
self.encoding = ::std::option::Option::Some(TensorInfo_oneof_encoding::name(::std::string::String::new()));
}
match self.encoding {
::std::option::Option::Some(TensorInfo_oneof_encoding::name(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_name(&mut self) -> ::std::string::String {
if self.has_name() {
match self.encoding.take() {
::std::option::Option::Some(TensorInfo_oneof_encoding::name(v)) => v,
_ => panic!(),
}
} else {
::std::string::String::new()
}
}
pub fn get_coo_sparse(&self) -> &TensorInfo_CooSparse {
match self.encoding {
::std::option::Option::Some(TensorInfo_oneof_encoding::coo_sparse(ref v)) => v,
_ => TensorInfo_CooSparse::default_instance(),
}
}
pub fn clear_coo_sparse(&mut self) {
self.encoding = ::std::option::Option::None;
}
pub fn has_coo_sparse(&self) -> bool {
match self.encoding {
::std::option::Option::Some(TensorInfo_oneof_encoding::coo_sparse(..)) => true,
_ => false,
}
}
pub fn set_coo_sparse(&mut self, v: TensorInfo_CooSparse) {
self.encoding = ::std::option::Option::Some(TensorInfo_oneof_encoding::coo_sparse(v))
}
pub fn mut_coo_sparse(&mut self) -> &mut TensorInfo_CooSparse {
if let ::std::option::Option::Some(TensorInfo_oneof_encoding::coo_sparse(_)) = self.encoding {
} else {
self.encoding = ::std::option::Option::Some(TensorInfo_oneof_encoding::coo_sparse(TensorInfo_CooSparse::new()));
}
match self.encoding {
::std::option::Option::Some(TensorInfo_oneof_encoding::coo_sparse(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_coo_sparse(&mut self) -> TensorInfo_CooSparse {
if self.has_coo_sparse() {
match self.encoding.take() {
::std::option::Option::Some(TensorInfo_oneof_encoding::coo_sparse(v)) => v,
_ => panic!(),
}
} else {
TensorInfo_CooSparse::new()
}
}
pub fn get_composite_tensor(&self) -> &TensorInfo_CompositeTensor {
match self.encoding {
::std::option::Option::Some(TensorInfo_oneof_encoding::composite_tensor(ref v)) => v,
_ => TensorInfo_CompositeTensor::default_instance(),
}
}
pub fn clear_composite_tensor(&mut self) {
self.encoding = ::std::option::Option::None;
}
pub fn has_composite_tensor(&self) -> bool {
match self.encoding {
::std::option::Option::Some(TensorInfo_oneof_encoding::composite_tensor(..)) => true,
_ => false,
}
}
pub fn set_composite_tensor(&mut self, v: TensorInfo_CompositeTensor) {
self.encoding = ::std::option::Option::Some(TensorInfo_oneof_encoding::composite_tensor(v))
}
pub fn mut_composite_tensor(&mut self) -> &mut TensorInfo_CompositeTensor {
if let ::std::option::Option::Some(TensorInfo_oneof_encoding::composite_tensor(_)) = self.encoding {
} else {
self.encoding = ::std::option::Option::Some(TensorInfo_oneof_encoding::composite_tensor(TensorInfo_CompositeTensor::new()));
}
match self.encoding {
::std::option::Option::Some(TensorInfo_oneof_encoding::composite_tensor(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_composite_tensor(&mut self) -> TensorInfo_CompositeTensor {
if self.has_composite_tensor() {
match self.encoding.take() {
::std::option::Option::Some(TensorInfo_oneof_encoding::composite_tensor(v)) => v,
_ => panic!(),
}
} else {
TensorInfo_CompositeTensor::new()
}
}
pub fn get_dtype(&self) -> super::types::DataType {
self.dtype
}
pub fn clear_dtype(&mut self) {
self.dtype = super::types::DataType::DT_INVALID;
}
pub fn set_dtype(&mut self, v: super::types::DataType) {
self.dtype = v;
}
pub fn get_tensor_shape(&self) -> &super::tensor_shape::TensorShapeProto {
self.tensor_shape.as_ref().unwrap_or_else(|| super::tensor_shape::TensorShapeProto::default_instance())
}
pub fn clear_tensor_shape(&mut self) {
self.tensor_shape.clear();
}
pub fn has_tensor_shape(&self) -> bool {
self.tensor_shape.is_some()
}
pub fn set_tensor_shape(&mut self, v: super::tensor_shape::TensorShapeProto) {
self.tensor_shape = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_tensor_shape(&mut self) -> &mut super::tensor_shape::TensorShapeProto {
if self.tensor_shape.is_none() {
self.tensor_shape.set_default();
}
self.tensor_shape.as_mut().unwrap()
}
pub fn take_tensor_shape(&mut self) -> super::tensor_shape::TensorShapeProto {
self.tensor_shape.take().unwrap_or_else(|| super::tensor_shape::TensorShapeProto::new())
}
}
impl ::protobuf::Message for TensorInfo {
fn is_initialized(&self) -> bool {
if let Some(TensorInfo_oneof_encoding::coo_sparse(ref v)) = self.encoding {
if !v.is_initialized() {
return false;
}
}
if let Some(TensorInfo_oneof_encoding::composite_tensor(ref v)) = self.encoding {
if !v.is_initialized() {
return false;
}
}
for v in &self.tensor_shape {
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::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.encoding = ::std::option::Option::Some(TensorInfo_oneof_encoding::name(is.read_string()?));
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.encoding = ::std::option::Option::Some(TensorInfo_oneof_encoding::coo_sparse(is.read_message()?));
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.encoding = ::std::option::Option::Some(TensorInfo_oneof_encoding::composite_tensor(is.read_message()?));
},
2 => {
::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.dtype, 2, &mut self.unknown_fields)?
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.tensor_shape)?;
},
_ => {
::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.dtype != super::types::DataType::DT_INVALID {
my_size += ::protobuf::rt::enum_size(2, self.dtype);
}
if let Some(ref v) = self.tensor_shape.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.encoding {
match v {
&TensorInfo_oneof_encoding::name(ref v) => {
my_size += ::protobuf::rt::string_size(1, &v);
},
&TensorInfo_oneof_encoding::coo_sparse(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&TensorInfo_oneof_encoding::composite_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.dtype != super::types::DataType::DT_INVALID {
os.write_enum(2, self.dtype.value())?;
}
if let Some(ref v) = self.tensor_shape.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 ::std::option::Option::Some(ref v) = self.encoding {
match v {
&TensorInfo_oneof_encoding::name(ref v) => {
os.write_string(1, v)?;
},
&TensorInfo_oneof_encoding::coo_sparse(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)?;
},
&TensorInfo_oneof_encoding::composite_tensor(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)?;
},
};
}
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() -> TensorInfo {
TensorInfo::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
"name",
TensorInfo::has_name,
TensorInfo::get_name,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TensorInfo_CooSparse>(
"coo_sparse",
TensorInfo::has_coo_sparse,
TensorInfo::get_coo_sparse,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TensorInfo_CompositeTensor>(
"composite_tensor",
TensorInfo::has_composite_tensor,
TensorInfo::get_composite_tensor,
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::types::DataType>>(
"dtype",
|m: &TensorInfo| { &m.dtype },
|m: &mut TensorInfo| { &mut m.dtype },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::tensor_shape::TensorShapeProto>>(
"tensor_shape",
|m: &TensorInfo| { &m.tensor_shape },
|m: &mut TensorInfo| { &mut m.tensor_shape },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TensorInfo>(
"TensorInfo",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static TensorInfo {
static mut instance: ::protobuf::lazy::Lazy<TensorInfo> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(TensorInfo::new)
}
}
}
impl ::protobuf::Clear for TensorInfo {
fn clear(&mut self) {
self.encoding = ::std::option::Option::None;
self.encoding = ::std::option::Option::None;
self.encoding = ::std::option::Option::None;
self.dtype = super::types::DataType::DT_INVALID;
self.tensor_shape.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TensorInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TensorInfo {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TensorInfo_CooSparse {
pub values_tensor_name: ::std::string::String,
pub indices_tensor_name: ::std::string::String,
pub dense_shape_tensor_name: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TensorInfo_CooSparse {
fn default() -> &'a TensorInfo_CooSparse {
<TensorInfo_CooSparse as ::protobuf::Message>::default_instance()
}
}
impl TensorInfo_CooSparse {
pub fn new() -> TensorInfo_CooSparse {
::std::default::Default::default()
}
pub fn get_values_tensor_name(&self) -> &str {
&self.values_tensor_name
}
pub fn clear_values_tensor_name(&mut self) {
self.values_tensor_name.clear();
}
pub fn set_values_tensor_name(&mut self, v: ::std::string::String) {
self.values_tensor_name = v;
}
pub fn mut_values_tensor_name(&mut self) -> &mut ::std::string::String {
&mut self.values_tensor_name
}
pub fn take_values_tensor_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.values_tensor_name, ::std::string::String::new())
}
pub fn get_indices_tensor_name(&self) -> &str {
&self.indices_tensor_name
}
pub fn clear_indices_tensor_name(&mut self) {
self.indices_tensor_name.clear();
}
pub fn set_indices_tensor_name(&mut self, v: ::std::string::String) {
self.indices_tensor_name = v;
}
pub fn mut_indices_tensor_name(&mut self) -> &mut ::std::string::String {
&mut self.indices_tensor_name
}
pub fn take_indices_tensor_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.indices_tensor_name, ::std::string::String::new())
}
pub fn get_dense_shape_tensor_name(&self) -> &str {
&self.dense_shape_tensor_name
}
pub fn clear_dense_shape_tensor_name(&mut self) {
self.dense_shape_tensor_name.clear();
}
pub fn set_dense_shape_tensor_name(&mut self, v: ::std::string::String) {
self.dense_shape_tensor_name = v;
}
pub fn mut_dense_shape_tensor_name(&mut self) -> &mut ::std::string::String {
&mut self.dense_shape_tensor_name
}
pub fn take_dense_shape_tensor_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.dense_shape_tensor_name, ::std::string::String::new())
}
}
impl ::protobuf::Message for TensorInfo_CooSparse {
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.values_tensor_name)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.indices_tensor_name)?;
},
3 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.dense_shape_tensor_name)?;
},
_ => {
::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.values_tensor_name.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.values_tensor_name);
}
if !self.indices_tensor_name.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.indices_tensor_name);
}
if !self.dense_shape_tensor_name.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.dense_shape_tensor_name);
}
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.values_tensor_name.is_empty() {
os.write_string(1, &self.values_tensor_name)?;
}
if !self.indices_tensor_name.is_empty() {
os.write_string(2, &self.indices_tensor_name)?;
}
if !self.dense_shape_tensor_name.is_empty() {
os.write_string(3, &self.dense_shape_tensor_name)?;
}
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() -> TensorInfo_CooSparse {
TensorInfo_CooSparse::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"values_tensor_name",
|m: &TensorInfo_CooSparse| { &m.values_tensor_name },
|m: &mut TensorInfo_CooSparse| { &mut m.values_tensor_name },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"indices_tensor_name",
|m: &TensorInfo_CooSparse| { &m.indices_tensor_name },
|m: &mut TensorInfo_CooSparse| { &mut m.indices_tensor_name },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"dense_shape_tensor_name",
|m: &TensorInfo_CooSparse| { &m.dense_shape_tensor_name },
|m: &mut TensorInfo_CooSparse| { &mut m.dense_shape_tensor_name },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TensorInfo_CooSparse>(
"TensorInfo.CooSparse",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static TensorInfo_CooSparse {
static mut instance: ::protobuf::lazy::Lazy<TensorInfo_CooSparse> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(TensorInfo_CooSparse::new)
}
}
}
impl ::protobuf::Clear for TensorInfo_CooSparse {
fn clear(&mut self) {
self.values_tensor_name.clear();
self.indices_tensor_name.clear();
self.dense_shape_tensor_name.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TensorInfo_CooSparse {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TensorInfo_CooSparse {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TensorInfo_CompositeTensor {
pub type_spec: ::protobuf::SingularPtrField<super::struct_pb::TypeSpecProto>,
pub components: ::protobuf::RepeatedField<TensorInfo>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TensorInfo_CompositeTensor {
fn default() -> &'a TensorInfo_CompositeTensor {
<TensorInfo_CompositeTensor as ::protobuf::Message>::default_instance()
}
}
impl TensorInfo_CompositeTensor {
pub fn new() -> TensorInfo_CompositeTensor {
::std::default::Default::default()
}
pub fn get_type_spec(&self) -> &super::struct_pb::TypeSpecProto {
self.type_spec.as_ref().unwrap_or_else(|| super::struct_pb::TypeSpecProto::default_instance())
}
pub fn clear_type_spec(&mut self) {
self.type_spec.clear();
}
pub fn has_type_spec(&self) -> bool {
self.type_spec.is_some()
}
pub fn set_type_spec(&mut self, v: super::struct_pb::TypeSpecProto) {
self.type_spec = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_type_spec(&mut self) -> &mut super::struct_pb::TypeSpecProto {
if self.type_spec.is_none() {
self.type_spec.set_default();
}
self.type_spec.as_mut().unwrap()
}
pub fn take_type_spec(&mut self) -> super::struct_pb::TypeSpecProto {
self.type_spec.take().unwrap_or_else(|| super::struct_pb::TypeSpecProto::new())
}
pub fn get_components(&self) -> &[TensorInfo] {
&self.components
}
pub fn clear_components(&mut self) {
self.components.clear();
}
pub fn set_components(&mut self, v: ::protobuf::RepeatedField<TensorInfo>) {
self.components = v;
}
pub fn mut_components(&mut self) -> &mut ::protobuf::RepeatedField<TensorInfo> {
&mut self.components
}
pub fn take_components(&mut self) -> ::protobuf::RepeatedField<TensorInfo> {
::std::mem::replace(&mut self.components, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for TensorInfo_CompositeTensor {
fn is_initialized(&self) -> bool {
for v in &self.type_spec {
if !v.is_initialized() {
return false;
}
};
for v in &self.components {
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.type_spec)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.components)?;
},
_ => {
::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.type_spec.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.components {
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 let Some(ref v) = self.type_spec.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)?;
}
for v in &self.components {
os.write_tag(2, ::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() -> TensorInfo_CompositeTensor {
TensorInfo_CompositeTensor::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::struct_pb::TypeSpecProto>>(
"type_spec",
|m: &TensorInfo_CompositeTensor| { &m.type_spec },
|m: &mut TensorInfo_CompositeTensor| { &mut m.type_spec },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TensorInfo>>(
"components",
|m: &TensorInfo_CompositeTensor| { &m.components },
|m: &mut TensorInfo_CompositeTensor| { &mut m.components },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<TensorInfo_CompositeTensor>(
"TensorInfo.CompositeTensor",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static TensorInfo_CompositeTensor {
static mut instance: ::protobuf::lazy::Lazy<TensorInfo_CompositeTensor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(TensorInfo_CompositeTensor::new)
}
}
}
impl ::protobuf::Clear for TensorInfo_CompositeTensor {
fn clear(&mut self) {
self.type_spec.clear();
self.components.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TensorInfo_CompositeTensor {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TensorInfo_CompositeTensor {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SignatureDef {
pub inputs: ::std::collections::HashMap<::std::string::String, TensorInfo>,
pub outputs: ::std::collections::HashMap<::std::string::String, TensorInfo>,
pub method_name: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SignatureDef {
fn default() -> &'a SignatureDef {
<SignatureDef as ::protobuf::Message>::default_instance()
}
}
impl SignatureDef {
pub fn new() -> SignatureDef {
::std::default::Default::default()
}
pub fn get_inputs(&self) -> &::std::collections::HashMap<::std::string::String, TensorInfo> {
&self.inputs
}
pub fn clear_inputs(&mut self) {
self.inputs.clear();
}
pub fn set_inputs(&mut self, v: ::std::collections::HashMap<::std::string::String, TensorInfo>) {
self.inputs = v;
}
pub fn mut_inputs(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, TensorInfo> {
&mut self.inputs
}
pub fn take_inputs(&mut self) -> ::std::collections::HashMap<::std::string::String, TensorInfo> {
::std::mem::replace(&mut self.inputs, ::std::collections::HashMap::new())
}
pub fn get_outputs(&self) -> &::std::collections::HashMap<::std::string::String, TensorInfo> {
&self.outputs
}
pub fn clear_outputs(&mut self) {
self.outputs.clear();
}
pub fn set_outputs(&mut self, v: ::std::collections::HashMap<::std::string::String, TensorInfo>) {
self.outputs = v;
}
pub fn mut_outputs(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, TensorInfo> {
&mut self.outputs
}
pub fn take_outputs(&mut self) -> ::std::collections::HashMap<::std::string::String, TensorInfo> {
::std::mem::replace(&mut self.outputs, ::std::collections::HashMap::new())
}
pub fn get_method_name(&self) -> &str {
&self.method_name
}
pub fn clear_method_name(&mut self) {
self.method_name.clear();
}
pub fn set_method_name(&mut self, v: ::std::string::String) {
self.method_name = v;
}
pub fn mut_method_name(&mut self) -> &mut ::std::string::String {
&mut self.method_name
}
pub fn take_method_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.method_name, ::std::string::String::new())
}
}
impl ::protobuf::Message for SignatureDef {
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::ProtobufTypeMessage<TensorInfo>>(wire_type, is, &mut self.inputs)?;
},
2 => {
::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<TensorInfo>>(wire_type, is, &mut self.outputs)?;
},
3 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.method_name)?;
},
_ => {
::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::ProtobufTypeMessage<TensorInfo>>(1, &self.inputs);
my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<TensorInfo>>(2, &self.outputs);
if !self.method_name.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.method_name);
}
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::ProtobufTypeMessage<TensorInfo>>(1, &self.inputs, os)?;
::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<TensorInfo>>(2, &self.outputs, os)?;
if !self.method_name.is_empty() {
os.write_string(3, &self.method_name)?;
}
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() -> SignatureDef {
SignatureDef::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<TensorInfo>>(
"inputs",
|m: &SignatureDef| { &m.inputs },
|m: &mut SignatureDef| { &mut m.inputs },
));
fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<TensorInfo>>(
"outputs",
|m: &SignatureDef| { &m.outputs },
|m: &mut SignatureDef| { &mut m.outputs },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"method_name",
|m: &SignatureDef| { &m.method_name },
|m: &mut SignatureDef| { &mut m.method_name },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<SignatureDef>(
"SignatureDef",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static SignatureDef {
static mut instance: ::protobuf::lazy::Lazy<SignatureDef> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(SignatureDef::new)
}
}
}
impl ::protobuf::Clear for SignatureDef {
fn clear(&mut self) {
self.inputs.clear();
self.outputs.clear();
self.method_name.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SignatureDef {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SignatureDef {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct AssetFileDef {
pub tensor_info: ::protobuf::SingularPtrField<TensorInfo>,
pub filename: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a AssetFileDef {
fn default() -> &'a AssetFileDef {
<AssetFileDef as ::protobuf::Message>::default_instance()
}
}
impl AssetFileDef {
pub fn new() -> AssetFileDef {
::std::default::Default::default()
}
pub fn get_tensor_info(&self) -> &TensorInfo {
self.tensor_info.as_ref().unwrap_or_else(|| TensorInfo::default_instance())
}
pub fn clear_tensor_info(&mut self) {
self.tensor_info.clear();
}
pub fn has_tensor_info(&self) -> bool {
self.tensor_info.is_some()
}
pub fn set_tensor_info(&mut self, v: TensorInfo) {
self.tensor_info = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_tensor_info(&mut self) -> &mut TensorInfo {
if self.tensor_info.is_none() {
self.tensor_info.set_default();
}
self.tensor_info.as_mut().unwrap()
}
pub fn take_tensor_info(&mut self) -> TensorInfo {
self.tensor_info.take().unwrap_or_else(|| TensorInfo::new())
}
pub fn get_filename(&self) -> &str {
&self.filename
}
pub fn clear_filename(&mut self) {
self.filename.clear();
}
pub fn set_filename(&mut self, v: ::std::string::String) {
self.filename = v;
}
pub fn mut_filename(&mut self) -> &mut ::std::string::String {
&mut self.filename
}
pub fn take_filename(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.filename, ::std::string::String::new())
}
}
impl ::protobuf::Message for AssetFileDef {
fn is_initialized(&self) -> bool {
for v in &self.tensor_info {
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.tensor_info)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.filename)?;
},
_ => {
::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.tensor_info.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.filename.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.filename);
}
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.tensor_info.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.filename.is_empty() {
os.write_string(2, &self.filename)?;
}
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() -> AssetFileDef {
AssetFileDef::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TensorInfo>>(
"tensor_info",
|m: &AssetFileDef| { &m.tensor_info },
|m: &mut AssetFileDef| { &mut m.tensor_info },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"filename",
|m: &AssetFileDef| { &m.filename },
|m: &mut AssetFileDef| { &mut m.filename },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<AssetFileDef>(
"AssetFileDef",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static AssetFileDef {
static mut instance: ::protobuf::lazy::Lazy<AssetFileDef> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(AssetFileDef::new)
}
}
}
impl ::protobuf::Clear for AssetFileDef {
fn clear(&mut self) {
self.tensor_info.clear();
self.filename.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for AssetFileDef {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for AssetFileDef {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n)tensorflow/core/protobuf/meta_graph.proto\x12\ntensorflow\x1a\x19goog\
le/protobuf/any.proto\x1a%tensorflow/core/framework/graph.proto\x1a&tens\
orflow/core/framework/op_def.proto\x1a,tensorflow/core/framework/tensor_\
shape.proto\x1a%tensorflow/core/framework/types.proto\x1a1tensorflow/cor\
e/protobuf/saved_object_graph.proto\x1a$tensorflow/core/protobuf/saver.p\
roto\x1a%tensorflow/core/protobuf/struct.proto\"\xa9\t\n\x0cMetaGraphDef\
\x12H\n\rmeta_info_def\x18\x01\x20\x01(\x0b2$.tensorflow.MetaGraphDef.Me\
taInfoDefR\x0bmetaInfoDef\x121\n\tgraph_def\x18\x02\x20\x01(\x0b2\x14.te\
nsorflow.GraphDefR\x08graphDef\x121\n\tsaver_def\x18\x03\x20\x01(\x0b2\
\x14.tensorflow.SaverDefR\x08saverDef\x12R\n\x0ecollection_def\x18\x04\
\x20\x03(\x0b2+.tensorflow.MetaGraphDef.CollectionDefEntryR\rcollectionD\
ef\x12O\n\rsignature_def\x18\x05\x20\x03(\x0b2*.tensorflow.MetaGraphDef.\
SignatureDefEntryR\x0csignatureDef\x12>\n\x0easset_file_def\x18\x06\x20\
\x03(\x0b2\x18.tensorflow.AssetFileDefR\x0cassetFileDef\x12F\n\x10object\
_graph_def\x18\x07\x20\x01(\x0b2\x1c.tensorflow.SavedObjectGraphR\x0eobj\
ectGraphDef\x1a\x83\x04\n\x0bMetaInfoDef\x12,\n\x12meta_graph_version\
\x18\x01\x20\x01(\tR\x10metaGraphVersion\x12<\n\x10stripped_op_list\x18\
\x02\x20\x01(\x0b2\x12.tensorflow.OpListR\x0estrippedOpList\x12/\n\x08an\
y_info\x18\x03\x20\x01(\x0b2\x14.google.protobuf.AnyR\x07anyInfo\x12\x12\
\n\x04tags\x18\x04\x20\x03(\tR\x04tags\x12-\n\x12tensorflow_version\x18\
\x05\x20\x01(\tR\x11tensorflowVersion\x124\n\x16tensorflow_git_version\
\x18\x06\x20\x01(\tR\x14tensorflowGitVersion\x124\n\x16stripped_default_\
attrs\x18\x07\x20\x01(\x08R\x14strippedDefaultAttrs\x12d\n\x10function_a\
liases\x18\x08\x20\x03(\x0b29.tensorflow.MetaGraphDef.MetaInfoDef.Functi\
onAliasesEntryR\x0ffunctionAliases\x1aB\n\x14FunctionAliasesEntry\x12\
\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\
\x01(\tR\x05value:\x028\x01\x1a[\n\x12CollectionDefEntry\x12\x10\n\x03ke\
y\x18\x01\x20\x01(\tR\x03key\x12/\n\x05value\x18\x02\x20\x01(\x0b2\x19.t\
ensorflow.CollectionDefR\x05value:\x028\x01\x1aY\n\x11SignatureDefEntry\
\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12.\n\x05value\x18\x02\x20\
\x01(\x0b2\x18.tensorflow.SignatureDefR\x05value:\x028\x01\"\xb6\x04\n\r\
CollectionDef\x12A\n\tnode_list\x18\x01\x20\x01(\x0b2\".tensorflow.Colle\
ctionDef.NodeListH\0R\x08nodeList\x12D\n\nbytes_list\x18\x02\x20\x01(\
\x0b2#.tensorflow.CollectionDef.BytesListH\0R\tbytesList\x12D\n\nint64_l\
ist\x18\x03\x20\x01(\x0b2#.tensorflow.CollectionDef.Int64ListH\0R\tint64\
List\x12D\n\nfloat_list\x18\x04\x20\x01(\x0b2#.tensorflow.CollectionDef.\
FloatListH\0R\tfloatList\x12>\n\x08any_list\x18\x05\x20\x01(\x0b2!.tenso\
rflow.CollectionDef.AnyListH\0R\x07anyList\x1a\x20\n\x08NodeList\x12\x14\
\n\x05value\x18\x01\x20\x03(\tR\x05value\x1a!\n\tBytesList\x12\x14\n\x05\
value\x18\x01\x20\x03(\x0cR\x05value\x1a%\n\tInt64List\x12\x18\n\x05valu\
e\x18\x01\x20\x03(\x03R\x05valueB\x02\x10\x01\x1a%\n\tFloatList\x12\x18\
\n\x05value\x18\x01\x20\x03(\x02R\x05valueB\x02\x10\x01\x1a5\n\x07AnyLis\
t\x12*\n\x05value\x18\x01\x20\x03(\x0b2\x14.google.protobuf.AnyR\x05valu\
eB\x06\n\x04kind\"\xda\x04\n\nTensorInfo\x12\x14\n\x04name\x18\x01\x20\
\x01(\tH\0R\x04name\x12A\n\ncoo_sparse\x18\x04\x20\x01(\x0b2\x20.tensorf\
low.TensorInfo.CooSparseH\0R\tcooSparse\x12S\n\x10composite_tensor\x18\
\x05\x20\x01(\x0b2&.tensorflow.TensorInfo.CompositeTensorH\0R\x0fcomposi\
teTensor\x12*\n\x05dtype\x18\x02\x20\x01(\x0e2\x14.tensorflow.DataTypeR\
\x05dtype\x12?\n\x0ctensor_shape\x18\x03\x20\x01(\x0b2\x1c.tensorflow.Te\
nsorShapeProtoR\x0btensorShape\x1a\xa0\x01\n\tCooSparse\x12,\n\x12values\
_tensor_name\x18\x01\x20\x01(\tR\x10valuesTensorName\x12.\n\x13indices_t\
ensor_name\x18\x02\x20\x01(\tR\x11indicesTensorName\x125\n\x17dense_shap\
e_tensor_name\x18\x03\x20\x01(\tR\x14denseShapeTensorName\x1a\x81\x01\n\
\x0fCompositeTensor\x126\n\ttype_spec\x18\x01\x20\x01(\x0b2\x19.tensorfl\
ow.TypeSpecProtoR\x08typeSpec\x126\n\ncomponents\x18\x02\x20\x03(\x0b2\
\x16.tensorflow.TensorInfoR\ncomponentsB\n\n\x08encoding\"\xd5\x02\n\x0c\
SignatureDef\x12<\n\x06inputs\x18\x01\x20\x03(\x0b2$.tensorflow.Signatur\
eDef.InputsEntryR\x06inputs\x12?\n\x07outputs\x18\x02\x20\x03(\x0b2%.ten\
sorflow.SignatureDef.OutputsEntryR\x07outputs\x12\x1f\n\x0bmethod_name\
\x18\x03\x20\x01(\tR\nmethodName\x1aQ\n\x0bInputsEntry\x12\x10\n\x03key\
\x18\x01\x20\x01(\tR\x03key\x12,\n\x05value\x18\x02\x20\x01(\x0b2\x16.te\
nsorflow.TensorInfoR\x05value:\x028\x01\x1aR\n\x0cOutputsEntry\x12\x10\n\
\x03key\x18\x01\x20\x01(\tR\x03key\x12,\n\x05value\x18\x02\x20\x01(\x0b2\
\x16.tensorflow.TensorInfoR\x05value:\x028\x01\"c\n\x0cAssetFileDef\x127\
\n\x0btensor_info\x18\x01\x20\x01(\x0b2\x16.tensorflow.TensorInfoR\ntens\
orInfo\x12\x1a\n\x08filename\x18\x02\x20\x01(\tR\x08filenameBz\n\x18org.\
tensorflow.frameworkB\x0fMetaGraphProtosP\x01ZHgithub.com/tensorflow/ten\
sorflow/tensorflow/go/core/core_protos_go_proto\xf8\x01\x01J\xa8[\n\x07\
\x12\x05\0\0\xd5\x02\x01\n\x08\n\x01\x0c\x12\x03\0\0\x12\n\x08\n\x01\x02\
\x12\x03\x02\0\x13\n\t\n\x02\x03\0\x12\x03\x04\0#\n\t\n\x02\x03\x01\x12\
\x03\x05\0/\n\t\n\x02\x03\x02\x12\x03\x06\00\n\t\n\x02\x03\x03\x12\x03\
\x07\06\n\t\n\x02\x03\x04\x12\x03\x08\0/\n\t\n\x02\x03\x05\x12\x03\t\0;\
\n\t\n\x02\x03\x06\x12\x03\n\0.\n\t\n\x02\x03\x07\x12\x03\x0b\0/\n\x08\n\
\x01\x08\x12\x03\r\0\x1f\n\t\n\x02\x08\x1f\x12\x03\r\0\x1f\n\x08\n\x01\
\x08\x12\x03\x0e\00\n\t\n\x02\x08\x08\x12\x03\x0e\00\n\x08\n\x01\x08\x12\
\x03\x0f\0\"\n\t\n\x02\x08\n\x12\x03\x0f\0\"\n\x08\n\x01\x08\x12\x03\x10\
\01\n\t\n\x02\x08\x01\x12\x03\x10\01\n\x08\n\x01\x08\x12\x03\x11\0_\n\t\
\n\x02\x08\x0b\x12\x03\x11\0_\n\x8a\x04\n\x02\x04\0\x12\x04!\0_\x01\x1a\
\xfd\x03\x20NOTE:\x20This\x20protocol\x20buffer\x20is\x20evolving,\x20an\
d\x20will\x20go\x20through\x20revisions\x20in\x20the\n\x20coming\x20mont\
hs.\n\n\x20Protocol\x20buffer\x20containing\x20the\x20following\x20which\
\x20are\x20necessary\x20to\x20restart\n\x20training,\x20run\x20inference\
.\x20It\x20can\x20be\x20used\x20to\x20serialize/de-serialize\x20memory\n\
\x20objects\x20necessary\x20for\x20running\x20computation\x20in\x20a\x20\
graph\x20when\x20crossing\x20the\n\x20process\x20boundary.\x20It\x20can\
\x20be\x20used\x20for\x20long\x20term\x20storage\x20of\x20graphs,\n\x20c\
ross-language\x20execution\x20of\x20graphs,\x20etc.\n\x20\x20\x20MetaInf\
oDef\n\x20\x20\x20GraphDef\n\x20\x20\x20SaverDef\n\x20\x20\x20Collection\
Def\n\x20\x20\x20TensorInfo\n\x20\x20\x20SignatureDef\n\n\n\n\x03\x04\0\
\x01\x12\x03!\x08\x14\n\xa5\x01\n\x04\x04\0\x03\0\x12\x04$\x02I\x03\x1a\
\x96\x01\x20Meta\x20information\x20regarding\x20the\x20graph\x20to\x20be\
\x20exported.\x20\x20To\x20be\x20used\x20by\x20users\n\x20of\x20this\x20\
protocol\x20buffer\x20to\x20encode\x20information\x20regarding\x20their\
\x20meta\x20graph.\n\n\x0c\n\x05\x04\0\x03\0\x01\x12\x03$\n\x15\n\x86\
\x01\n\x06\x04\0\x03\0\x02\0\x12\x03'\x04\"\x1aw\x20User\x20specified\
\x20Version\x20string.\x20Can\x20be\x20the\x20name\x20of\x20the\x20model\
\x20and\x20revision,\n\x20steps\x20this\x20model\x20has\x20been\x20train\
ed\x20to,\x20etc.\n\n\x0e\n\x07\x04\0\x03\0\x02\0\x05\x12\x03'\x04\n\n\
\x0e\n\x07\x04\0\x03\0\x02\0\x01\x12\x03'\x0b\x1d\n\x0e\n\x07\x04\0\x03\
\0\x02\0\x03\x12\x03'\x20!\n\x8b\x01\n\x06\x04\0\x03\0\x02\x01\x12\x03+\
\x04\x20\x1a|\x20A\x20copy\x20of\x20the\x20OpDefs\x20used\x20by\x20the\
\x20producer\x20of\x20this\x20graph_def.\n\x20Descriptions\x20and\x20Ops\
\x20not\x20used\x20in\x20graph_def\x20are\x20stripped\x20out.\n\n\x0e\n\
\x07\x04\0\x03\0\x02\x01\x06\x12\x03+\x04\n\n\x0e\n\x07\x04\0\x03\0\x02\
\x01\x01\x12\x03+\x0b\x1b\n\x0e\n\x07\x04\0\x03\0\x02\x01\x03\x12\x03+\
\x1e\x1f\nw\n\x06\x04\0\x03\0\x02\x02\x12\x03/\x04%\x1ah\x20A\x20seriali\
zed\x20protobuf.\x20Can\x20be\x20the\x20time\x20this\x20meta\x20graph\
\x20is\x20created,\x20or\n\x20modified,\x20or\x20name\x20of\x20the\x20mo\
del.\n\n\x0e\n\x07\x04\0\x03\0\x02\x02\x06\x12\x03/\x04\x17\n\x0e\n\x07\
\x04\0\x03\0\x02\x02\x01\x12\x03/\x18\x20\n\x0e\n\x07\x04\0\x03\0\x02\
\x02\x03\x12\x03/#$\n\xba\x02\n\x06\x04\0\x03\0\x02\x03\x12\x037\x04\x1d\
\x1a\xaa\x02\x20User\x20supplied\x20tag(s)\x20on\x20the\x20meta_graph\
\x20and\x20included\x20graph_def.\n\n\x20MetaGraphDefs\x20should\x20be\
\x20tagged\x20with\x20their\x20capabilities\x20or\x20use-cases.\n\x20Exa\
mples:\x20\"train\",\x20\"serve\",\x20\"gpu\",\x20\"tpu\",\x20etc.\n\x20\
These\x20tags\x20enable\x20loaders\x20to\x20access\x20the\x20MetaGraph(s\
)\x20appropriate\x20for\x20a\n\x20specific\x20use-case\x20or\x20runtime\
\x20environment.\n\n\x0e\n\x07\x04\0\x03\0\x02\x03\x04\x12\x037\x04\x0c\
\n\x0e\n\x07\x04\0\x03\0\x02\x03\x05\x12\x037\r\x13\n\x0e\n\x07\x04\0\
\x03\0\x02\x03\x01\x12\x037\x14\x18\n\x0e\n\x07\x04\0\x03\0\x02\x03\x03\
\x12\x037\x1b\x1c\n\xb3\x01\n\x06\x04\0\x03\0\x02\x04\x12\x03<\x04\"\x1a\
\xa3\x01\x20The\x20__version__\x20string\x20of\x20the\x20tensorflow\x20b\
uild\x20used\x20to\x20write\x20this\x20graph.\n\x20This\x20will\x20be\
\x20populated\x20by\x20the\x20framework,\x20which\x20will\x20overwrite\
\x20any\x20user\n\x20supplied\x20value.\n\n\x0e\n\x07\x04\0\x03\0\x02\
\x04\x05\x12\x03<\x04\n\n\x0e\n\x07\x04\0\x03\0\x02\x04\x01\x12\x03<\x0b\
\x1d\n\x0e\n\x07\x04\0\x03\0\x02\x04\x03\x12\x03<\x20!\n\xb7\x01\n\x06\
\x04\0\x03\0\x02\x05\x12\x03A\x04&\x1a\xa7\x01\x20The\x20__git_version__\
\x20string\x20of\x20the\x20tensorflow\x20build\x20used\x20to\x20write\
\x20this\n\x20graph.\x20This\x20will\x20be\x20populated\x20by\x20the\x20\
framework,\x20which\x20will\x20overwrite\x20any\n\x20user\x20supplied\
\x20value.\n\n\x0e\n\x07\x04\0\x03\0\x02\x05\x05\x12\x03A\x04\n\n\x0e\n\
\x07\x04\0\x03\0\x02\x05\x01\x12\x03A\x0b!\n\x0e\n\x07\x04\0\x03\0\x02\
\x05\x03\x12\x03A$%\nt\n\x06\x04\0\x03\0\x02\x06\x12\x03E\x04$\x1ae\x20A\
\x20flag\x20to\x20denote\x20whether\x20default-valued\x20attrs\x20have\
\x20been\x20stripped\x20from\n\x20the\x20nodes\x20in\x20this\x20graph_de\
f.\n\n\x0e\n\x07\x04\0\x03\0\x02\x06\x05\x12\x03E\x04\x08\n\x0e\n\x07\
\x04\0\x03\0\x02\x06\x01\x12\x03E\t\x1f\n\x0e\n\x07\x04\0\x03\0\x02\x06\
\x03\x12\x03E\"#\n5\n\x06\x04\0\x03\0\x02\x07\x12\x03H\x04-\x1a&\x20Func\
tionDef\x20name\x20to\x20aliases\x20mapping.\n\n\x0e\n\x07\x04\0\x03\0\
\x02\x07\x06\x12\x03H\x04\x17\n\x0e\n\x07\x04\0\x03\0\x02\x07\x01\x12\
\x03H\x18(\n\x0e\n\x07\x04\0\x03\0\x02\x07\x03\x12\x03H+,\n\x0b\n\x04\
\x04\0\x02\0\x12\x03J\x02\x20\n\x0c\n\x05\x04\0\x02\0\x06\x12\x03J\x02\r\
\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03J\x0e\x1b\n\x0c\n\x05\x04\0\x02\0\
\x03\x12\x03J\x1e\x1f\n\x18\n\x04\x04\0\x02\x01\x12\x03M\x02\x19\x1a\x0b\
\x20GraphDef.\n\n\x0c\n\x05\x04\0\x02\x01\x06\x12\x03M\x02\n\n\x0c\n\x05\
\x04\0\x02\x01\x01\x12\x03M\x0b\x14\n\x0c\n\x05\x04\0\x02\x01\x03\x12\
\x03M\x17\x18\n\x18\n\x04\x04\0\x02\x02\x12\x03P\x02\x19\x1a\x0b\x20Save\
rDef.\n\n\x0c\n\x05\x04\0\x02\x02\x06\x12\x03P\x02\n\n\x0c\n\x05\x04\0\
\x02\x02\x01\x12\x03P\x0b\x14\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x03P\x17\
\x18\no\n\x04\x04\0\x02\x03\x12\x03T\x020\x1ab\x20collection_def:\x20Map\
\x20from\x20collection\x20name\x20to\x20collections.\n\x20See\x20Collect\
ionDef\x20section\x20for\x20details.\n\n\x0c\n\x05\x04\0\x02\x03\x06\x12\
\x03T\x02\x1c\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x03T\x1d+\n\x0c\n\x05\
\x04\0\x02\x03\x03\x12\x03T./\nc\n\x04\x04\0\x02\x04\x12\x03X\x02.\x1aV\
\x20signature_def:\x20Map\x20from\x20user\x20supplied\x20key\x20for\x20a\
\x20signature\x20to\x20a\x20single\n\x20SignatureDef.\n\n\x0c\n\x05\x04\
\0\x02\x04\x06\x12\x03X\x02\x1b\n\x0c\n\x05\x04\0\x02\x04\x01\x12\x03X\
\x1c)\n\x0c\n\x05\x04\0\x02\x04\x03\x12\x03X,-\n@\n\x04\x04\0\x02\x05\
\x12\x03[\x02+\x1a3\x20Asset\x20file\x20def\x20to\x20be\x20used\x20with\
\x20the\x20defined\x20graph.\n\n\x0c\n\x05\x04\0\x02\x05\x04\x12\x03[\
\x02\n\n\x0c\n\x05\x04\0\x02\x05\x06\x12\x03[\x0b\x17\n\x0c\n\x05\x04\0\
\x02\x05\x01\x12\x03[\x18&\n\x0c\n\x05\x04\0\x02\x05\x03\x12\x03[)*\nW\n\
\x04\x04\0\x02\x06\x12\x03^\x02(\x1aJ\x20Extra\x20information\x20about\
\x20the\x20structure\x20of\x20functions\x20and\x20stateful\x20objects.\n\
\n\x0c\n\x05\x04\0\x02\x06\x06\x12\x03^\x02\x12\n\x0c\n\x05\x04\0\x02\
\x06\x01\x12\x03^\x13#\n\x0c\n\x05\x04\0\x02\x06\x03\x12\x03^&'\n\xdf\
\x0f\n\x02\x04\x01\x12\x06\x9f\x01\0\xd5\x01\x01\x1a\xd0\x0f\x20Collecti\
onDef\x20should\x20cover\x20most\x20collections.\n\x20To\x20add\x20a\x20\
user-defined\x20collection,\x20do\x20one\x20of\x20the\x20following:\n\
\x201.\x20For\x20simple\x20data\x20types,\x20such\x20as\x20string,\x20in\
t,\x20float:\n\x20\x20\x20\x20\x20\x20tf.add_to_collection(\"your_collec\
tion_name\",\x20your_simple_value)\n\x20\x20\x20\x20strings\x20will\x20b\
e\x20stored\x20as\x20bytes_list.\n\n\x202.\x20For\x20Protobuf\x20types,\
\x20there\x20are\x20three\x20ways\x20to\x20add\x20them:\n\x20\x20\x20\
\x201)\x20tf.add_to_collection(\"your_collection_name\",\n\x20\x20\x20\
\x20\x20\x20\x20\x20\x20your_proto.SerializeToString())\n\n\x20\x20\x20\
\x20\x20\x20\x20collection_def\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\
\x20key:\x20\"user_defined_bytes_collection\"\n\x20\x20\x20\x20\x20\x20\
\x20\x20\x20value\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20byte\
s_list\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20value:\
\x20\"queue_name:\x20\\\"test_queue\\\"\\n\"\n\x20\x20\x20\x20\x20\x20\
\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20\x20\x20\x20\x20}\n\x20\x20\
\x20\x20\x20\x20\x20}\n\n\x20\x20or\n\n\x20\x20\x20\x202)\x20tf.add_to_c\
ollection(\"your_collection_name\",\x20str(your_proto))\n\n\x20\x20\x20\
\x20\x20\x20\x20collection_def\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\
\x20key:\x20\"user_defined_string_collection\"\n\x20\x20\x20\x20\x20\x20\
\x20\x20\x20value\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20bytes_li\
st\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20value:\x20\
\"\\n\\ntest_queue\"\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20}\n\
\x20\x20\x20\x20\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20\x20\x20}\n\n\
\x20\x20or\n\n\x20\x20\x20\x203)\x20any_buf\x20=\x20any_pb2.Any()\n\x20\
\x20\x20\x20\x20\x20\x20tf.add_to_collection(\"your_collection_name\",\n\
\x20\x20\x20\x20\x20\x20\x20\x20\x20any_buf.Pack(your_proto))\n\n\x20\
\x20\x20\x20\x20\x20\x20collection_def\x20{\n\x20\x20\x20\x20\x20\x20\
\x20\x20\x20key:\x20\"user_defined_any_collection\"\n\x20\x20\x20\x20\
\x20\x20\x20\x20\x20value\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20any_list\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20v\
alue\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20t\
ype_url:\x20\"type.googleapis.com/tensorflow.QueueRunnerDef\"\n\x20\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20value:\x20\"\\n\\nte\
st_queue\"\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20}\n\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20\x20\x20\
\x20\x20}\n\x20\x20\x20\x20\x20\x20\x20}\n\n\x203.\x20For\x20Python\x20o\
bjects,\x20implement\x20to_proto()\x20and\x20from_proto(),\x20and\x20reg\
ister\n\x20\x20\x20\x20them\x20in\x20the\x20following\x20manner:\n\x20\
\x20\x20\x20ops.register_proto_function(\"your_collection_name\",\n\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20proto_type,\n\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20to_proto=YourPythonO\
bject.to_proto,\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20from_proto=YourPythonObject.from_proto)\n\x20\x20\x20\x20These\x20fu\
nctions\x20will\x20be\x20invoked\x20to\x20serialize\x20and\x20de-seriali\
ze\x20the\n\x20\x20\x20\x20collection.\x20For\x20example,\n\x20\x20\x20\
\x20ops.register_proto_function(ops.GraphKeys.GLOBAL_VARIABLES,\n\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20proto_type=variable_\
pb2.VariableDef,\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20to_proto=Variable.to_proto,\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20\x20\x20\x20\x20from_proto=Variable.from_proto)\n\n\x0b\n\x03\x04\
\x01\x01\x12\x04\x9f\x01\x08\x15\n\x98\x02\n\x04\x04\x01\x03\0\x12\x06\
\xaa\x01\x02\xac\x01\x03\x1a\x87\x02\x20NodeList\x20is\x20used\x20for\
\x20collecting\x20nodes\x20in\x20graph.\x20For\x20example\n\x20collectio\
n_def\x20{\n\x20\x20\x20key:\x20\"summaries\"\n\x20\x20\x20value\x20{\n\
\x20\x20\x20\x20\x20node_list\x20{\n\x20\x20\x20\x20\x20\x20\x20value:\
\x20\"input_producer/ScalarSummary:0\"\n\x20\x20\x20\x20\x20\x20\x20valu\
e:\x20\"shuffle_batch/ScalarSummary:0\"\n\x20\x20\x20\x20\x20\x20\x20val\
ue:\x20\"ImageSummary:0\"\n\x20\x20\x20\x20\x20}\n\x20\x20\x20}\n\n\r\n\
\x05\x04\x01\x03\0\x01\x12\x04\xaa\x01\n\x12\n\x0e\n\x06\x04\x01\x03\0\
\x02\0\x12\x04\xab\x01\x04\x1e\n\x0f\n\x07\x04\x01\x03\0\x02\0\x04\x12\
\x04\xab\x01\x04\x0c\n\x0f\n\x07\x04\x01\x03\0\x02\0\x05\x12\x04\xab\x01\
\r\x13\n\x0f\n\x07\x04\x01\x03\0\x02\0\x01\x12\x04\xab\x01\x14\x19\n\x0f\
\n\x07\x04\x01\x03\0\x02\0\x03\x12\x04\xab\x01\x1c\x1d\n\x96\x03\n\x04\
\x04\x01\x03\x01\x12\x06\xbb\x01\x02\xbd\x01\x03\x1a\x85\x03\x20BytesLis\
t\x20is\x20used\x20for\x20collecting\x20strings\x20and\x20serialized\x20\
protobufs.\x20For\n\x20example:\n\x20collection_def\x20{\n\x20\x20\x20ke\
y:\x20\"trainable_variables\"\n\x20\x20\x20value\x20{\n\x20\x20\x20\x20\
\x20bytes_list\x20{\n\x20\x20\x20\x20\x20\x20\x20value:\x20\"\\n\\017con\
v1/weights:0\\022\\024conv1/weights/Assign\n\x20\x20\x20\x20\x20\x20\x20\
\x20\x20\x20\x20\x20\x20\x20\\032\\024conv1/weights/read:0\"\n\x20\x20\
\x20\x20\x20\x20\x20value:\x20\"\\n\\016conv1/biases:0\\022\\023conv1/bi\
ases/Assign\\032\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
\x20\\023conv1/biases/read:0\"\n\x20\x20\x20\x20\x20}\n\x20\x20\x20}\n\
\x20}\n\n\r\n\x05\x04\x01\x03\x01\x01\x12\x04\xbb\x01\n\x13\n\x0e\n\x06\
\x04\x01\x03\x01\x02\0\x12\x04\xbc\x01\x04\x1d\n\x0f\n\x07\x04\x01\x03\
\x01\x02\0\x04\x12\x04\xbc\x01\x04\x0c\n\x0f\n\x07\x04\x01\x03\x01\x02\0\
\x05\x12\x04\xbc\x01\r\x12\n\x0f\n\x07\x04\x01\x03\x01\x02\0\x01\x12\x04\
\xbc\x01\x13\x18\n\x0f\n\x07\x04\x01\x03\x01\x02\0\x03\x12\x04\xbc\x01\
\x1b\x1c\nN\n\x04\x04\x01\x03\x02\x12\x06\xc0\x01\x02\xc2\x01\x03\x1a>\
\x20Int64List\x20is\x20used\x20for\x20collecting\x20int,\x20int64\x20and\
\x20long\x20values.\n\n\r\n\x05\x04\x01\x03\x02\x01\x12\x04\xc0\x01\n\
\x13\n\x0e\n\x06\x04\x01\x03\x02\x02\0\x12\x04\xc1\x01\x04-\n\x0f\n\x07\
\x04\x01\x03\x02\x02\0\x04\x12\x04\xc1\x01\x04\x0c\n\x0f\n\x07\x04\x01\
\x03\x02\x02\0\x05\x12\x04\xc1\x01\r\x12\n\x0f\n\x07\x04\x01\x03\x02\x02\
\0\x01\x12\x04\xc1\x01\x13\x18\n\x0f\n\x07\x04\x01\x03\x02\x02\0\x03\x12\
\x04\xc1\x01\x1b\x1c\n\x0f\n\x07\x04\x01\x03\x02\x02\0\x08\x12\x04\xc1\
\x01\x1d,\n\x10\n\x08\x04\x01\x03\x02\x02\0\x08\x02\x12\x04\xc1\x01\x1e+\
\n@\n\x04\x04\x01\x03\x03\x12\x06\xc5\x01\x02\xc7\x01\x03\x1a0\x20FloatL\
ist\x20is\x20used\x20for\x20collecting\x20float\x20values.\n\n\r\n\x05\
\x04\x01\x03\x03\x01\x12\x04\xc5\x01\n\x13\n\x0e\n\x06\x04\x01\x03\x03\
\x02\0\x12\x04\xc6\x01\x04-\n\x0f\n\x07\x04\x01\x03\x03\x02\0\x04\x12\
\x04\xc6\x01\x04\x0c\n\x0f\n\x07\x04\x01\x03\x03\x02\0\x05\x12\x04\xc6\
\x01\r\x12\n\x0f\n\x07\x04\x01\x03\x03\x02\0\x01\x12\x04\xc6\x01\x13\x18\
\n\x0f\n\x07\x04\x01\x03\x03\x02\0\x03\x12\x04\xc6\x01\x1b\x1c\n\x0f\n\
\x07\x04\x01\x03\x03\x02\0\x08\x12\x04\xc6\x01\x1d,\n\x10\n\x08\x04\x01\
\x03\x03\x02\0\x08\x02\x12\x04\xc6\x01\x1e+\n<\n\x04\x04\x01\x03\x04\x12\
\x06\xca\x01\x02\xcc\x01\x03\x1a,\x20AnyList\x20is\x20used\x20for\x20col\
lecting\x20Any\x20protos.\n\n\r\n\x05\x04\x01\x03\x04\x01\x12\x04\xca\
\x01\n\x11\n\x0e\n\x06\x04\x01\x03\x04\x02\0\x12\x04\xcb\x01\x04+\n\x0f\
\n\x07\x04\x01\x03\x04\x02\0\x04\x12\x04\xcb\x01\x04\x0c\n\x0f\n\x07\x04\
\x01\x03\x04\x02\0\x06\x12\x04\xcb\x01\r\x20\n\x0f\n\x07\x04\x01\x03\x04\
\x02\0\x01\x12\x04\xcb\x01!&\n\x0f\n\x07\x04\x01\x03\x04\x02\0\x03\x12\
\x04\xcb\x01)*\n\x0e\n\x04\x04\x01\x08\0\x12\x06\xce\x01\x02\xd4\x01\x03\
\n\r\n\x05\x04\x01\x08\0\x01\x12\x04\xce\x01\x08\x0c\n\x0c\n\x04\x04\x01\
\x02\0\x12\x04\xcf\x01\x04\x1b\n\r\n\x05\x04\x01\x02\0\x06\x12\x04\xcf\
\x01\x04\x0c\n\r\n\x05\x04\x01\x02\0\x01\x12\x04\xcf\x01\r\x16\n\r\n\x05\
\x04\x01\x02\0\x03\x12\x04\xcf\x01\x19\x1a\n\x0c\n\x04\x04\x01\x02\x01\
\x12\x04\xd0\x01\x04\x1d\n\r\n\x05\x04\x01\x02\x01\x06\x12\x04\xd0\x01\
\x04\r\n\r\n\x05\x04\x01\x02\x01\x01\x12\x04\xd0\x01\x0e\x18\n\r\n\x05\
\x04\x01\x02\x01\x03\x12\x04\xd0\x01\x1b\x1c\n\x0c\n\x04\x04\x01\x02\x02\
\x12\x04\xd1\x01\x04\x1d\n\r\n\x05\x04\x01\x02\x02\x06\x12\x04\xd1\x01\
\x04\r\n\r\n\x05\x04\x01\x02\x02\x01\x12\x04\xd1\x01\x0e\x18\n\r\n\x05\
\x04\x01\x02\x02\x03\x12\x04\xd1\x01\x1b\x1c\n\x0c\n\x04\x04\x01\x02\x03\
\x12\x04\xd2\x01\x04\x1d\n\r\n\x05\x04\x01\x02\x03\x06\x12\x04\xd2\x01\
\x04\r\n\r\n\x05\x04\x01\x02\x03\x01\x12\x04\xd2\x01\x0e\x18\n\r\n\x05\
\x04\x01\x02\x03\x03\x12\x04\xd2\x01\x1b\x1c\n\x0c\n\x04\x04\x01\x02\x04\
\x12\x04\xd3\x01\x04\x19\n\r\n\x05\x04\x01\x02\x04\x06\x12\x04\xd3\x01\
\x04\x0b\n\r\n\x05\x04\x01\x02\x04\x01\x12\x04\xd3\x01\x0c\x14\n\r\n\x05\
\x04\x01\x02\x04\x03\x12\x04\xd3\x01\x17\x18\nN\n\x02\x04\x02\x12\x06\
\xd8\x01\0\x81\x02\x01\x1a@\x20Information\x20about\x20a\x20Tensor\x20ne\
cessary\x20for\x20feeding\x20or\x20retrieval.\n\n\x0b\n\x03\x04\x02\x01\
\x12\x04\xd8\x01\x08\x12\nf\n\x04\x04\x02\x03\0\x12\x06\xdb\x01\x02\xe6\
\x01\x03\x1aV\x20For\x20sparse\x20tensors,\x20The\x20COO\x20encoding\x20\
stores\x20a\x20triple\x20of\x20values,\x20indices,\n\x20and\x20shape.\n\
\n\r\n\x05\x04\x02\x03\0\x01\x12\x04\xdb\x01\n\x13\n\x9a\x01\n\x06\x04\
\x02\x03\0\x02\0\x12\x04\xde\x01\x04\"\x1a\x89\x01\x20The\x20shape\x20of\
\x20the\x20values\x20Tensor\x20is\x20[?].\x20\x20Its\x20dtype\x20must\
\x20be\x20the\x20dtype\x20of\n\x20the\x20SparseTensor\x20as\x20a\x20whol\
e,\x20given\x20in\x20the\x20enclosing\x20TensorInfo.\n\n\x0f\n\x07\x04\
\x02\x03\0\x02\0\x05\x12\x04\xde\x01\x04\n\n\x0f\n\x07\x04\x02\x03\0\x02\
\0\x01\x12\x04\xde\x01\x0b\x1d\n\x0f\n\x07\x04\x02\x03\0\x02\0\x03\x12\
\x04\xde\x01\x20!\nL\n\x06\x04\x02\x03\0\x02\x01\x12\x04\xe1\x01\x04#\
\x1a<\x20The\x20indices\x20Tensor\x20must\x20have\x20dtype\x20int64\x20a\
nd\x20shape\x20[?,\x20?].\n\n\x0f\n\x07\x04\x02\x03\0\x02\x01\x05\x12\
\x04\xe1\x01\x04\n\n\x0f\n\x07\x04\x02\x03\0\x02\x01\x01\x12\x04\xe1\x01\
\x0b\x1e\n\x0f\n\x07\x04\x02\x03\0\x02\x01\x03\x12\x04\xe1\x01!\"\n\xa1\
\x01\n\x06\x04\x02\x03\0\x02\x02\x12\x04\xe5\x01\x04'\x1a\x90\x01\x20The\
\x20dynamic\x20logical\x20shape\x20represented\x20by\x20the\x20SparseTen\
sor\x20is\x20recorded\x20in\n\x20the\x20Tensor\x20referenced\x20here.\
\x20\x20It\x20must\x20have\x20dtype\x20int64\x20and\x20shape\x20[?].\n\n\
\x0f\n\x07\x04\x02\x03\0\x02\x02\x05\x12\x04\xe5\x01\x04\n\n\x0f\n\x07\
\x04\x02\x03\0\x02\x02\x01\x12\x04\xe5\x01\x0b\"\n\x0f\n\x07\x04\x02\x03\
\0\x02\x02\x03\x12\x04\xe5\x01%&\n9\n\x04\x04\x02\x03\x01\x12\x06\xe9\
\x01\x02\xef\x01\x03\x1a)\x20Generic\x20encoding\x20for\x20composite\x20\
tensors.\n\n\r\n\x05\x04\x02\x03\x01\x01\x12\x04\xe9\x01\n\x19\nC\n\x06\
\x04\x02\x03\x01\x02\0\x12\x04\xeb\x01\x04\x20\x1a3\x20The\x20serialized\
\x20TypeSpec\x20for\x20the\x20composite\x20tensor.\n\n\x0f\n\x07\x04\x02\
\x03\x01\x02\0\x06\x12\x04\xeb\x01\x04\x11\n\x0f\n\x07\x04\x02\x03\x01\
\x02\0\x01\x12\x04\xeb\x01\x12\x1b\n\x0f\n\x07\x04\x02\x03\x01\x02\0\x03\
\x12\x04\xeb\x01\x1e\x1f\nC\n\x06\x04\x02\x03\x01\x02\x01\x12\x04\xee\
\x01\x04'\x1a3\x20A\x20TensorInfo\x20for\x20each\x20flattened\x20compone\
nt\x20tensor.\n\n\x0f\n\x07\x04\x02\x03\x01\x02\x01\x04\x12\x04\xee\x01\
\x04\x0c\n\x0f\n\x07\x04\x02\x03\x01\x02\x01\x06\x12\x04\xee\x01\r\x17\n\
\x0f\n\x07\x04\x02\x03\x01\x02\x01\x01\x12\x04\xee\x01\x18\"\n\x0f\n\x07\
\x04\x02\x03\x01\x02\x01\x03\x12\x04\xee\x01%&\n\x0e\n\x04\x04\x02\x08\0\
\x12\x06\xf1\x01\x02\xfb\x01\x03\n\r\n\x05\x04\x02\x08\0\x01\x12\x04\xf1\
\x01\x08\x10\nI\n\x04\x04\x02\x02\0\x12\x04\xf3\x01\x04\x14\x1a;\x20For\
\x20dense\x20`Tensor`s,\x20the\x20name\x20of\x20the\x20tensor\x20in\x20t\
he\x20graph.\n\n\r\n\x05\x04\x02\x02\0\x05\x12\x04\xf3\x01\x04\n\n\r\n\
\x05\x04\x02\x02\0\x01\x12\x04\xf3\x01\x0b\x0f\n\r\n\x05\x04\x02\x02\0\
\x03\x12\x04\xf3\x01\x12\x13\n\xee\x01\n\x04\x04\x02\x02\x01\x12\x04\xf8\
\x01\x04\x1d\x1a\xdf\x01\x20There\x20are\x20many\x20possible\x20encoding\
s\x20of\x20sparse\x20matrices\n\x20(https://en.wikipedia.org/wiki/Sparse\
_matrix).\x20\x20Currently,\x20TensorFlow\n\x20uses\x20only\x20the\x20CO\
O\x20encoding.\x20\x20This\x20is\x20supported\x20and\x20documented\x20in\
\x20the\n\x20SparseTensor\x20Python\x20class.\n\n\r\n\x05\x04\x02\x02\
\x01\x06\x12\x04\xf8\x01\x04\r\n\r\n\x05\x04\x02\x02\x01\x01\x12\x04\xf8\
\x01\x0e\x18\n\r\n\x05\x04\x02\x02\x01\x03\x12\x04\xf8\x01\x1b\x1c\n6\n\
\x04\x04\x02\x02\x02\x12\x04\xfa\x01\x04)\x1a(\x20Generic\x20encoding\
\x20for\x20CompositeTensors.\n\n\r\n\x05\x04\x02\x02\x02\x06\x12\x04\xfa\
\x01\x04\x13\n\r\n\x05\x04\x02\x02\x02\x01\x12\x04\xfa\x01\x14$\n\r\n\
\x05\x04\x02\x02\x02\x03\x12\x04\xfa\x01'(\n\x0c\n\x04\x04\x02\x02\x03\
\x12\x04\xfc\x01\x02\x15\n\r\n\x05\x04\x02\x02\x03\x06\x12\x04\xfc\x01\
\x02\n\n\r\n\x05\x04\x02\x02\x03\x01\x12\x04\xfc\x01\x0b\x10\n\r\n\x05\
\x04\x02\x02\x03\x03\x12\x04\xfc\x01\x13\x14\n\xdf\x01\n\x04\x04\x02\x02\
\x04\x12\x04\x80\x02\x02$\x1a\xd0\x01\x20The\x20static\x20shape\x20shoul\
d\x20be\x20recorded\x20here,\x20to\x20the\x20extent\x20that\x20it\x20can\
\n\x20be\x20known\x20in\x20advance.\x20\x20In\x20the\x20case\x20of\x20a\
\x20SparseTensor,\x20this\x20field\x20describes\n\x20the\x20logical\x20s\
hape\x20of\x20the\x20represented\x20tensor\x20(aka\x20dense_shape).\n\n\
\r\n\x05\x04\x02\x02\x04\x06\x12\x04\x80\x02\x02\x12\n\r\n\x05\x04\x02\
\x02\x04\x01\x12\x04\x80\x02\x13\x1f\n\r\n\x05\x04\x02\x02\x04\x03\x12\
\x04\x80\x02\"#\n\xbe\n\n\x02\x04\x03\x12\x06\xbc\x02\0\xca\x02\x01\x1a\
\xaf\n\x20SignatureDef\x20defines\x20the\x20signature\x20of\x20a\x20comp\
utation\x20supported\x20by\x20a\x20TensorFlow\n\x20graph.\n\n\x20For\x20\
example,\x20a\x20model\x20with\x20two\x20loss\x20computations,\x20sharin\
g\x20a\x20single\x20input,\n\x20might\x20have\x20the\x20following\x20sig\
nature_def\x20map.\n\n\x20Note\x20that\x20across\x20the\x20two\x20Signat\
ureDefs\x20\"loss_A\"\x20and\x20\"loss_B\",\x20the\x20input\x20key,\n\
\x20output\x20key,\x20and\x20method_name\x20are\x20identical,\x20and\x20\
will\x20be\x20used\x20by\x20system(s)\x20that\n\x20implement\x20or\x20re\
ly\x20upon\x20this\x20particular\x20loss\x20method.\x20The\x20output\x20\
tensor\x20names\n\x20differ,\x20demonstrating\x20how\x20different\x20out\
puts\x20can\x20exist\x20for\x20the\x20same\x20method.\n\n\x20signature_d\
ef\x20{\n\x20\x20\x20key:\x20\"loss_A\"\n\x20\x20\x20value\x20{\n\x20\
\x20\x20\x20\x20inputs\x20{\n\x20\x20\x20\x20\x20\x20\x20key:\x20\"input\
\"\n\x20\x20\x20\x20\x20\x20\x20value\x20{\n\x20\x20\x20\x20\x20\x20\x20\
\x20\x20name:\x20\"input:0\"\n\x20\x20\x20\x20\x20\x20\x20\x20\x20dtype:\
\x20DT_STRING\n\x20\x20\x20\x20\x20\x20\x20\x20\x20tensor_shape:\x20...\
\n\x20\x20\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\
\x20outputs\x20{\n\x20\x20\x20\x20\x20\x20\x20key:\x20\"loss_output\"\n\
\x20\x20\x20\x20\x20\x20\x20value\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\
\x20name:\x20\"loss_output_A:0\"\n\x20\x20\x20\x20\x20\x20\x20\x20\x20dt\
ype:\x20DT_FLOAT\n\x20\x20\x20\x20\x20\x20\x20\x20\x20tensor_shape:\x20.\
..\n\x20\x20\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20}\n\x20\x20\x20}\
\n\x20\x20\x20...\n\x20\x20\x20method_name:\x20\"some/package/compute_lo\
ss\"\n\x20}\n\x20signature_def\x20{\n\x20\x20\x20key:\x20\"loss_B\"\n\
\x20\x20\x20value\x20{\n\x20\x20\x20\x20\x20inputs\x20{\n\x20\x20\x20\
\x20\x20\x20\x20key:\x20\"input\"\n\x20\x20\x20\x20\x20\x20\x20value\x20\
{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20name:\x20\"input:0\"\n\x20\x20\
\x20\x20\x20\x20\x20\x20\x20dtype:\x20DT_STRING\n\x20\x20\x20\x20\x20\
\x20\x20\x20\x20tensor_shape:\x20...\n\x20\x20\x20\x20\x20\x20\x20}\n\
\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20outputs\x20{\n\x20\x20\x20\
\x20\x20\x20\x20key:\x20\"loss_output\"\n\x20\x20\x20\x20\x20\x20\x20val\
ue\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20name:\x20\"loss_output_B:0\
\"\n\x20\x20\x20\x20\x20\x20\x20\x20\x20dtype:\x20DT_FLOAT\n\x20\x20\x20\
\x20\x20\x20\x20\x20\x20tensor_shape:\x20...\n\x20\x20\x20\x20\x20\x20\
\x20}\n\x20\x20\x20\x20\x20}\n\x20\x20\x20}\n\x20\x20\x20...\n\x20\x20\
\x20method_name:\x20\"some/package/compute_loss\"\n\x20}\n\n\x0b\n\x03\
\x04\x03\x01\x12\x04\xbc\x02\x08\x14\n'\n\x04\x04\x03\x02\0\x12\x04\xbe\
\x02\x02%\x1a\x19\x20Named\x20input\x20parameters.\n\n\r\n\x05\x04\x03\
\x02\0\x06\x12\x04\xbe\x02\x02\x19\n\r\n\x05\x04\x03\x02\0\x01\x12\x04\
\xbe\x02\x1a\x20\n\r\n\x05\x04\x03\x02\0\x03\x12\x04\xbe\x02#$\n(\n\x04\
\x04\x03\x02\x01\x12\x04\xc0\x02\x02&\x1a\x1a\x20Named\x20output\x20para\
meters.\n\n\r\n\x05\x04\x03\x02\x01\x06\x12\x04\xc0\x02\x02\x19\n\r\n\
\x05\x04\x03\x02\x01\x01\x12\x04\xc0\x02\x1a!\n\r\n\x05\x04\x03\x02\x01\
\x03\x12\x04\xc0\x02$%\n\x91\x04\n\x04\x04\x03\x02\x02\x12\x04\xc9\x02\
\x02\x19\x1a\x82\x04\x20Extensible\x20method_name\x20information\x20enab\
ling\x20third-party\x20users\x20to\x20mark\x20a\n\x20SignatureDef\x20as\
\x20supporting\x20a\x20particular\x20method.\x20This\x20enables\x20produ\
cers\x20and\n\x20consumers\x20of\x20SignatureDefs,\x20e.g.\x20a\x20model\
\x20definition\x20library\x20and\x20a\x20serving\n\x20library\x20to\x20h\
ave\x20a\x20clear\x20hand-off\x20regarding\x20the\x20semantics\x20of\x20\
a\x20computation.\n\n\x20Note\x20that\x20multiple\x20SignatureDefs\x20in\
\x20a\x20single\x20MetaGraphDef\x20may\x20have\x20the\x20same\n\x20metho\
d_name.\x20This\x20is\x20commonly\x20used\x20to\x20support\x20multi-head\
ed\x20computation,\n\x20where\x20a\x20single\x20graph\x20computation\x20\
may\x20return\x20multiple\x20results.\n\n\r\n\x05\x04\x03\x02\x02\x05\
\x12\x04\xc9\x02\x02\x08\n\r\n\x05\x04\x03\x02\x02\x01\x12\x04\xc9\x02\t\
\x14\n\r\n\x05\x04\x03\x02\x02\x03\x12\x04\xc9\x02\x17\x18\nb\n\x02\x04\
\x04\x12\x06\xce\x02\0\xd5\x02\x01\x1aT\x20An\x20asset\x20file\x20def\
\x20for\x20a\x20single\x20file\x20or\x20a\x20set\x20of\x20sharded\x20fil\
es\x20with\x20the\x20same\n\x20name.\n\n\x0b\n\x03\x04\x04\x01\x12\x04\
\xce\x02\x08\x14\n9\n\x04\x04\x04\x02\0\x12\x04\xd0\x02\x02\x1d\x1a+\x20\
The\x20tensor\x20to\x20bind\x20the\x20asset\x20filename\x20to.\n\n\r\n\
\x05\x04\x04\x02\0\x06\x12\x04\xd0\x02\x02\x0c\n\r\n\x05\x04\x04\x02\0\
\x01\x12\x04\xd0\x02\r\x18\n\r\n\x05\x04\x04\x02\0\x03\x12\x04\xd0\x02\
\x1b\x1c\n\xbd\x01\n\x04\x04\x04\x02\x01\x12\x04\xd4\x02\x02\x16\x1a\xae\
\x01\x20The\x20filename\x20within\x20an\x20assets\x20directory.\x20Note:\
\x20does\x20not\x20include\x20the\x20path\n\x20prefix,\x20i.e.\x20direct\
ories.\x20For\x20an\x20asset\x20at\x20/tmp/path/vocab.txt,\x20the\x20fil\
ename\n\x20would\x20be\x20\"vocab.txt\".\n\n\r\n\x05\x04\x04\x02\x01\x05\
\x12\x04\xd4\x02\x02\x08\n\r\n\x05\x04\x04\x02\x01\x01\x12\x04\xd4\x02\t\
\x11\n\r\n\x05\x04\x04\x02\x01\x03\x12\x04\xd4\x02\x14\x15b\x06proto3\
";
static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT;
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()
})
}
}