#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_results)]
#![allow(unused_mut)]
const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_2_0;
#[derive(PartialEq,Clone,Default,Debug)]
pub struct TensorProto {
pub dtype: ::protobuf::EnumOrUnknown<super::types::DataType>,
pub tensor_shape: ::protobuf::MessageField<super::tensor_shape::TensorShapeProto>,
pub version_number: i32,
pub tensor_content: ::std::vec::Vec<u8>,
pub half_val: ::std::vec::Vec<i32>,
pub float_val: ::std::vec::Vec<f32>,
pub double_val: ::std::vec::Vec<f64>,
pub int_val: ::std::vec::Vec<i32>,
pub string_val: ::std::vec::Vec<::std::vec::Vec<u8>>,
pub scomplex_val: ::std::vec::Vec<f32>,
pub int64_val: ::std::vec::Vec<i64>,
pub bool_val: ::std::vec::Vec<bool>,
pub dcomplex_val: ::std::vec::Vec<f64>,
pub resource_handle_val: ::std::vec::Vec<super::resource_handle::ResourceHandleProto>,
pub variant_val: ::std::vec::Vec<VariantTensorDataProto>,
pub uint32_val: ::std::vec::Vec<u32>,
pub uint64_val: ::std::vec::Vec<u64>,
pub float8_val: ::std::vec::Vec<u8>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a TensorProto {
fn default() -> &'a TensorProto {
<TensorProto as ::protobuf::Message>::default_instance()
}
}
impl TensorProto {
pub fn new() -> TensorProto {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(18);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"dtype",
|m: &TensorProto| { &m.dtype },
|m: &mut TensorProto| { &mut m.dtype },
));
fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, super::tensor_shape::TensorShapeProto>(
"tensor_shape",
|m: &TensorProto| { &m.tensor_shape },
|m: &mut TensorProto| { &mut m.tensor_shape },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"version_number",
|m: &TensorProto| { &m.version_number },
|m: &mut TensorProto| { &mut m.version_number },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"tensor_content",
|m: &TensorProto| { &m.tensor_content },
|m: &mut TensorProto| { &mut m.tensor_content },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"half_val",
|m: &TensorProto| { &m.half_val },
|m: &mut TensorProto| { &mut m.half_val },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"float_val",
|m: &TensorProto| { &m.float_val },
|m: &mut TensorProto| { &mut m.float_val },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"double_val",
|m: &TensorProto| { &m.double_val },
|m: &mut TensorProto| { &mut m.double_val },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"int_val",
|m: &TensorProto| { &m.int_val },
|m: &mut TensorProto| { &mut m.int_val },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"string_val",
|m: &TensorProto| { &m.string_val },
|m: &mut TensorProto| { &mut m.string_val },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"scomplex_val",
|m: &TensorProto| { &m.scomplex_val },
|m: &mut TensorProto| { &mut m.scomplex_val },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"int64_val",
|m: &TensorProto| { &m.int64_val },
|m: &mut TensorProto| { &mut m.int64_val },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"bool_val",
|m: &TensorProto| { &m.bool_val },
|m: &mut TensorProto| { &mut m.bool_val },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"dcomplex_val",
|m: &TensorProto| { &m.dcomplex_val },
|m: &mut TensorProto| { &mut m.dcomplex_val },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"resource_handle_val",
|m: &TensorProto| { &m.resource_handle_val },
|m: &mut TensorProto| { &mut m.resource_handle_val },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"variant_val",
|m: &TensorProto| { &m.variant_val },
|m: &mut TensorProto| { &mut m.variant_val },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"uint32_val",
|m: &TensorProto| { &m.uint32_val },
|m: &mut TensorProto| { &mut m.uint32_val },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"uint64_val",
|m: &TensorProto| { &m.uint64_val },
|m: &mut TensorProto| { &mut m.uint64_val },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"float8_val",
|m: &TensorProto| { &m.float8_val },
|m: &mut TensorProto| { &mut m.float8_val },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<TensorProto>(
"TensorProto",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for TensorProto {
const NAME: &'static str = "TensorProto";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.dtype = is.read_enum_or_unknown()?;
},
18 => {
::protobuf::rt::read_singular_message_into_field(is, &mut self.tensor_shape)?;
},
24 => {
self.version_number = is.read_int32()?;
},
34 => {
self.tensor_content = is.read_bytes()?;
},
106 => {
is.read_repeated_packed_int32_into(&mut self.half_val)?;
},
104 => {
self.half_val.push(is.read_int32()?);
},
42 => {
is.read_repeated_packed_float_into(&mut self.float_val)?;
},
45 => {
self.float_val.push(is.read_float()?);
},
50 => {
is.read_repeated_packed_double_into(&mut self.double_val)?;
},
49 => {
self.double_val.push(is.read_double()?);
},
58 => {
is.read_repeated_packed_int32_into(&mut self.int_val)?;
},
56 => {
self.int_val.push(is.read_int32()?);
},
66 => {
self.string_val.push(is.read_bytes()?);
},
74 => {
is.read_repeated_packed_float_into(&mut self.scomplex_val)?;
},
77 => {
self.scomplex_val.push(is.read_float()?);
},
82 => {
is.read_repeated_packed_int64_into(&mut self.int64_val)?;
},
80 => {
self.int64_val.push(is.read_int64()?);
},
90 => {
is.read_repeated_packed_bool_into(&mut self.bool_val)?;
},
88 => {
self.bool_val.push(is.read_bool()?);
},
98 => {
is.read_repeated_packed_double_into(&mut self.dcomplex_val)?;
},
97 => {
self.dcomplex_val.push(is.read_double()?);
},
114 => {
self.resource_handle_val.push(is.read_message()?);
},
122 => {
self.variant_val.push(is.read_message()?);
},
130 => {
is.read_repeated_packed_uint32_into(&mut self.uint32_val)?;
},
128 => {
self.uint32_val.push(is.read_uint32()?);
},
138 => {
is.read_repeated_packed_uint64_into(&mut self.uint64_val)?;
},
136 => {
self.uint64_val.push(is.read_uint64()?);
},
146 => {
self.float8_val = is.read_bytes()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if self.dtype != ::protobuf::EnumOrUnknown::new(super::types::DataType::DT_INVALID) {
my_size += ::protobuf::rt::int32_size(1, self.dtype.value());
}
if let Some(v) = self.tensor_shape.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
}
if self.version_number != 0 {
my_size += ::protobuf::rt::int32_size(3, self.version_number);
}
if !self.tensor_content.is_empty() {
my_size += ::protobuf::rt::bytes_size(4, &self.tensor_content);
}
my_size += ::protobuf::rt::vec_packed_int32_size(13, &self.half_val);
my_size += ::protobuf::rt::vec_packed_float_size(5, &self.float_val);
my_size += ::protobuf::rt::vec_packed_double_size(6, &self.double_val);
my_size += ::protobuf::rt::vec_packed_int32_size(7, &self.int_val);
for value in &self.string_val {
my_size += ::protobuf::rt::bytes_size(8, &value);
};
my_size += ::protobuf::rt::vec_packed_float_size(9, &self.scomplex_val);
my_size += ::protobuf::rt::vec_packed_int64_size(10, &self.int64_val);
my_size += ::protobuf::rt::vec_packed_bool_size(11, &self.bool_val);
my_size += ::protobuf::rt::vec_packed_double_size(12, &self.dcomplex_val);
for value in &self.resource_handle_val {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
for value in &self.variant_val {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
my_size += ::protobuf::rt::vec_packed_uint32_size(16, &self.uint32_val);
my_size += ::protobuf::rt::vec_packed_uint64_size(17, &self.uint64_val);
if !self.float8_val.is_empty() {
my_size += ::protobuf::rt::bytes_size(18, &self.float8_val);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if self.dtype != ::protobuf::EnumOrUnknown::new(super::types::DataType::DT_INVALID) {
os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.dtype))?;
}
if let Some(v) = self.tensor_shape.as_ref() {
::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
}
if self.version_number != 0 {
os.write_int32(3, self.version_number)?;
}
if !self.tensor_content.is_empty() {
os.write_bytes(4, &self.tensor_content)?;
}
os.write_repeated_packed_int32(13, &self.half_val)?;
os.write_repeated_packed_float(5, &self.float_val)?;
os.write_repeated_packed_double(6, &self.double_val)?;
os.write_repeated_packed_int32(7, &self.int_val)?;
for v in &self.string_val {
os.write_bytes(8, &v)?;
};
os.write_repeated_packed_float(9, &self.scomplex_val)?;
os.write_repeated_packed_int64(10, &self.int64_val)?;
os.write_repeated_packed_bool(11, &self.bool_val)?;
os.write_repeated_packed_double(12, &self.dcomplex_val)?;
for v in &self.resource_handle_val {
::protobuf::rt::write_message_field_with_cached_size(14, v, os)?;
};
for v in &self.variant_val {
::protobuf::rt::write_message_field_with_cached_size(15, v, os)?;
};
os.write_repeated_packed_uint32(16, &self.uint32_val)?;
os.write_repeated_packed_uint64(17, &self.uint64_val)?;
if !self.float8_val.is_empty() {
os.write_bytes(18, &self.float8_val)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> TensorProto {
TensorProto::new()
}
fn clear(&mut self) {
self.dtype = ::protobuf::EnumOrUnknown::new(super::types::DataType::DT_INVALID);
self.tensor_shape.clear();
self.version_number = 0;
self.tensor_content.clear();
self.half_val.clear();
self.float_val.clear();
self.double_val.clear();
self.int_val.clear();
self.string_val.clear();
self.scomplex_val.clear();
self.int64_val.clear();
self.bool_val.clear();
self.dcomplex_val.clear();
self.resource_handle_val.clear();
self.variant_val.clear();
self.uint32_val.clear();
self.uint64_val.clear();
self.float8_val.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static TensorProto {
static instance: TensorProto = TensorProto {
dtype: ::protobuf::EnumOrUnknown::from_i32(0),
tensor_shape: ::protobuf::MessageField::none(),
version_number: 0,
tensor_content: ::std::vec::Vec::new(),
half_val: ::std::vec::Vec::new(),
float_val: ::std::vec::Vec::new(),
double_val: ::std::vec::Vec::new(),
int_val: ::std::vec::Vec::new(),
string_val: ::std::vec::Vec::new(),
scomplex_val: ::std::vec::Vec::new(),
int64_val: ::std::vec::Vec::new(),
bool_val: ::std::vec::Vec::new(),
dcomplex_val: ::std::vec::Vec::new(),
resource_handle_val: ::std::vec::Vec::new(),
variant_val: ::std::vec::Vec::new(),
uint32_val: ::std::vec::Vec::new(),
uint64_val: ::std::vec::Vec::new(),
float8_val: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for TensorProto {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("TensorProto").unwrap()).clone()
}
}
impl ::std::fmt::Display for TensorProto {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TensorProto {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct VariantTensorDataProto {
pub type_name: ::std::string::String,
pub metadata: ::std::vec::Vec<u8>,
pub tensors: ::std::vec::Vec<TensorProto>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a VariantTensorDataProto {
fn default() -> &'a VariantTensorDataProto {
<VariantTensorDataProto as ::protobuf::Message>::default_instance()
}
}
impl VariantTensorDataProto {
pub fn new() -> VariantTensorDataProto {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(3);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"type_name",
|m: &VariantTensorDataProto| { &m.type_name },
|m: &mut VariantTensorDataProto| { &mut m.type_name },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"metadata",
|m: &VariantTensorDataProto| { &m.metadata },
|m: &mut VariantTensorDataProto| { &mut m.metadata },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"tensors",
|m: &VariantTensorDataProto| { &m.tensors },
|m: &mut VariantTensorDataProto| { &mut m.tensors },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<VariantTensorDataProto>(
"VariantTensorDataProto",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for VariantTensorDataProto {
const NAME: &'static str = "VariantTensorDataProto";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.type_name = is.read_string()?;
},
18 => {
self.metadata = is.read_bytes()?;
},
26 => {
self.tensors.push(is.read_message()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.type_name.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.type_name);
}
if !self.metadata.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.metadata);
}
for value in &self.tensors {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.type_name.is_empty() {
os.write_string(1, &self.type_name)?;
}
if !self.metadata.is_empty() {
os.write_bytes(2, &self.metadata)?;
}
for v in &self.tensors {
::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
};
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> VariantTensorDataProto {
VariantTensorDataProto::new()
}
fn clear(&mut self) {
self.type_name.clear();
self.metadata.clear();
self.tensors.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static VariantTensorDataProto {
static instance: VariantTensorDataProto = VariantTensorDataProto {
type_name: ::std::string::String::new(),
metadata: ::std::vec::Vec::new(),
tensors: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for VariantTensorDataProto {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("VariantTensorDataProto").unwrap()).clone()
}
}
impl ::std::fmt::Display for VariantTensorDataProto {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for VariantTensorDataProto {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n&tensorflow/core/framework/tensor.proto\x12\ntensorflow\x1a/tensorflow\
/core/framework/resource_handle.proto\x1a,tensorflow/core/framework/tens\
or_shape.proto\x1a%tensorflow/core/framework/types.proto\"\xf0\x05\n\x0b\
TensorProto\x12*\n\x05dtype\x18\x01\x20\x01(\x0e2\x14.tensorflow.DataTyp\
eR\x05dtype\x12?\n\x0ctensor_shape\x18\x02\x20\x01(\x0b2\x1c.tensorflow.\
TensorShapeProtoR\x0btensorShape\x12%\n\x0eversion_number\x18\x03\x20\
\x01(\x05R\rversionNumber\x12%\n\x0etensor_content\x18\x04\x20\x01(\x0cR\
\rtensorContent\x12\x1d\n\x08half_val\x18\r\x20\x03(\x05R\x07halfValB\
\x02\x10\x01\x12\x1f\n\tfloat_val\x18\x05\x20\x03(\x02R\x08floatValB\x02\
\x10\x01\x12!\n\ndouble_val\x18\x06\x20\x03(\x01R\tdoubleValB\x02\x10\
\x01\x12\x1b\n\x07int_val\x18\x07\x20\x03(\x05R\x06intValB\x02\x10\x01\
\x12\x1d\n\nstring_val\x18\x08\x20\x03(\x0cR\tstringVal\x12%\n\x0cscompl\
ex_val\x18\t\x20\x03(\x02R\x0bscomplexValB\x02\x10\x01\x12\x1f\n\tint64_\
val\x18\n\x20\x03(\x03R\x08int64ValB\x02\x10\x01\x12\x1d\n\x08bool_val\
\x18\x0b\x20\x03(\x08R\x07boolValB\x02\x10\x01\x12%\n\x0cdcomplex_val\
\x18\x0c\x20\x03(\x01R\x0bdcomplexValB\x02\x10\x01\x12O\n\x13resource_ha\
ndle_val\x18\x0e\x20\x03(\x0b2\x1f.tensorflow.ResourceHandleProtoR\x11re\
sourceHandleVal\x12C\n\x0bvariant_val\x18\x0f\x20\x03(\x0b2\".tensorflow\
.VariantTensorDataProtoR\nvariantVal\x12!\n\nuint32_val\x18\x10\x20\x03(\
\rR\tuint32ValB\x02\x10\x01\x12!\n\nuint64_val\x18\x11\x20\x03(\x04R\tui\
nt64ValB\x02\x10\x01\x12\x1d\n\nfloat8_val\x18\x12\x20\x01(\x0cR\tfloat8\
Val\"\x84\x01\n\x16VariantTensorDataProto\x12\x1b\n\ttype_name\x18\x01\
\x20\x01(\tR\x08typeName\x12\x1a\n\x08metadata\x18\x02\x20\x01(\x0cR\x08\
metadata\x121\n\x07tensors\x18\x03\x20\x03(\x0b2\x17.tensorflow.TensorPr\
otoR\x07tensorsB|\n\x18org.tensorflow.frameworkB\x0cTensorProtosP\x01ZMg\
ithub.com/tensorflow/tensorflow/tensorflow/go/core/framework/tensor_go_p\
roto\xf8\x01\x01b\x06proto3\
";
fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
file_descriptor_proto_lazy.get(|| {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
})
}
pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
file_descriptor.get(|| {
let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
let mut deps = ::std::vec::Vec::with_capacity(3);
deps.push(super::resource_handle::file_descriptor().clone());
deps.push(super::tensor_shape::file_descriptor().clone());
deps.push(super::types::file_descriptor().clone());
let mut messages = ::std::vec::Vec::with_capacity(2);
messages.push(TensorProto::generated_message_descriptor_data());
messages.push(VariantTensorDataProto::generated_message_descriptor_data());
let mut enums = ::std::vec::Vec::with_capacity(0);
::protobuf::reflect::GeneratedFileDescriptor::new_generated(
file_descriptor_proto(),
deps,
messages,
enums,
)
});
::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
})
}