tensorflow-protos-rs 0.2.0

// This file is generated by rust-protobuf 2.17.0. Do not edit
// @generated

// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]

#![allow(unused_attributes)]
#![rustfmt::skip]

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_imports)]
#![allow(unused_results)]
//! Generated file from `tensorflow/core/protobuf/meta_graph.proto`

/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_17_0;

#[derive(PartialEq,Clone,Default)]
pub struct MetaGraphDef {
    // message fields
    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>,
    // special fields
    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()
    }

    // .tensorflow.MetaGraphDef.MetaInfoDef meta_info_def = 1;


    pub fn get_meta_info_def(&self) -> &MetaGraphDef_MetaInfoDef {
        self.meta_info_def.as_ref().unwrap_or_else(|| <MetaGraphDef_MetaInfoDef as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_meta_info_def(&mut self, v: MetaGraphDef_MetaInfoDef) {
        self.meta_info_def = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_meta_info_def(&mut self) -> MetaGraphDef_MetaInfoDef {
        self.meta_info_def.take().unwrap_or_else(|| MetaGraphDef_MetaInfoDef::new())
    }

    // .tensorflow.GraphDef graph_def = 2;


    pub fn get_graph_def(&self) -> &super::graph::GraphDef {
        self.graph_def.as_ref().unwrap_or_else(|| <super::graph::GraphDef as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_graph_def(&mut self, v: super::graph::GraphDef) {
        self.graph_def = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_graph_def(&mut self) -> super::graph::GraphDef {
        self.graph_def.take().unwrap_or_else(|| super::graph::GraphDef::new())
    }

    // .tensorflow.SaverDef saver_def = 3;


    pub fn get_saver_def(&self) -> &super::saver::SaverDef {
        self.saver_def.as_ref().unwrap_or_else(|| <super::saver::SaverDef as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_saver_def(&mut self, v: super::saver::SaverDef) {
        self.saver_def = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_saver_def(&mut self) -> super::saver::SaverDef {
        self.saver_def.take().unwrap_or_else(|| super::saver::SaverDef::new())
    }

    // repeated .tensorflow.MetaGraphDef.CollectionDefEntry collection_def = 4;


    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();
    }

    // Param is passed by value, moved
    pub fn set_collection_def(&mut self, v: ::std::collections::HashMap<::std::string::String, CollectionDef>) {
        self.collection_def = v;
    }

    // Mutable pointer to the field.
    pub fn mut_collection_def(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, CollectionDef> {
        &mut self.collection_def
    }

    // Take field
    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())
    }

    // repeated .tensorflow.MetaGraphDef.SignatureDefEntry signature_def = 5;


    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();
    }

    // Param is passed by value, moved
    pub fn set_signature_def(&mut self, v: ::std::collections::HashMap<::std::string::String, SignatureDef>) {
        self.signature_def = v;
    }

    // Mutable pointer to the field.
    pub fn mut_signature_def(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, SignatureDef> {
        &mut self.signature_def
    }

    // Take field
    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())
    }

    // repeated .tensorflow.AssetFileDef asset_file_def = 6;


    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();
    }

    // Param is passed by value, moved
    pub fn set_asset_file_def(&mut self, v: ::protobuf::RepeatedField<AssetFileDef>) {
        self.asset_file_def = v;
    }

    // Mutable pointer to the field.
    pub fn mut_asset_file_def(&mut self) -> &mut ::protobuf::RepeatedField<AssetFileDef> {
        &mut self.asset_file_def
    }

    // Take field
    pub fn take_asset_file_def(&mut self) -> ::protobuf::RepeatedField<AssetFileDef> {
        ::std::mem::replace(&mut self.asset_file_def, ::protobuf::RepeatedField::new())
    }

    // .tensorflow.SavedObjectGraph object_graph_def = 7;


    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 as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_object_graph_def(&mut self, v: super::saved_object_graph::SavedObjectGraph) {
        self.object_graph_def = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    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(())
    }

    // Compute sizes of nested messages
    #[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: ::std::boxed::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 descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<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 instance: ::protobuf::rt::LazyV2<MetaGraphDef> = ::protobuf::rt::LazyV2::INIT;
        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 {
    // message fields
    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,
    // special fields
    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()
    }

    // string meta_graph_version = 1;


    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();
    }

    // Param is passed by value, moved
    pub fn set_meta_graph_version(&mut self, v: ::std::string::String) {
        self.meta_graph_version = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_meta_graph_version(&mut self) -> &mut ::std::string::String {
        &mut self.meta_graph_version
    }

    // Take field
    pub fn take_meta_graph_version(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.meta_graph_version, ::std::string::String::new())
    }

    // .tensorflow.OpList stripped_op_list = 2;


    pub fn get_stripped_op_list(&self) -> &super::op_def::OpList {
        self.stripped_op_list.as_ref().unwrap_or_else(|| <super::op_def::OpList as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_stripped_op_list(&mut self, v: super::op_def::OpList) {
        self.stripped_op_list = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    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())
    }

    // .google.protobuf.Any any_info = 3;


    pub fn get_any_info(&self) -> &::protobuf::well_known_types::Any {
        self.any_info.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Any as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_any_info(&mut self, v: ::protobuf::well_known_types::Any) {
        self.any_info = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    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())
    }

    // repeated string tags = 4;


    pub fn get_tags(&self) -> &[::std::string::String] {
        &self.tags
    }
    pub fn clear_tags(&mut self) {
        self.tags.clear();
    }

    // Param is passed by value, moved
    pub fn set_tags(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
        self.tags = v;
    }

    // Mutable pointer to the field.
    pub fn mut_tags(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
        &mut self.tags
    }

    // Take field
    pub fn take_tags(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
        ::std::mem::replace(&mut self.tags, ::protobuf::RepeatedField::new())
    }

    // string tensorflow_version = 5;


    pub fn get_tensorflow_version(&self) -> &str {
        &self.tensorflow_version
    }
    pub fn clear_tensorflow_version(&mut self) {
        self.tensorflow_version.clear();
    }

    // Param is passed by value, moved
    pub fn set_tensorflow_version(&mut self, v: ::std::string::String) {
        self.tensorflow_version = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_tensorflow_version(&mut self) -> &mut ::std::string::String {
        &mut self.tensorflow_version
    }

    // Take field
    pub fn take_tensorflow_version(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.tensorflow_version, ::std::string::String::new())
    }

    // string tensorflow_git_version = 6;


    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();
    }

    // Param is passed by value, moved
    pub fn set_tensorflow_git_version(&mut self, v: ::std::string::String) {
        self.tensorflow_git_version = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_tensorflow_git_version(&mut self) -> &mut ::std::string::String {
        &mut self.tensorflow_git_version
    }

    // Take field
    pub fn take_tensorflow_git_version(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.tensorflow_git_version, ::std::string::String::new())
    }

    // bool stripped_default_attrs = 7;


    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;
    }

    // Param is passed by value, moved
    pub fn set_stripped_default_attrs(&mut self, v: bool) {
        self.stripped_default_attrs = v;
    }
}

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;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[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::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)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> MetaGraphDef_MetaInfoDef {
        MetaGraphDef_MetaInfoDef::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "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 },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<MetaGraphDef_MetaInfoDef>(
                "MetaGraphDef.MetaInfoDef",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static MetaGraphDef_MetaInfoDef {
        static instance: ::protobuf::rt::LazyV2<MetaGraphDef_MetaInfoDef> = ::protobuf::rt::LazyV2::INIT;
        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.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 {
    // message oneof groups
    pub kind: ::std::option::Option<CollectionDef_oneof_kind>,
    // special fields
    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()
    }

    // .tensorflow.CollectionDef.NodeList node_list = 1;


    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 as ::protobuf::Message>::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,
        }
    }

    // Param is passed by value, moved
    pub fn set_node_list(&mut self, v: CollectionDef_NodeList) {
        self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::node_list(v))
    }

    // Mutable pointer to the field.
    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!(),
        }
    }

    // Take field
    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()
        }
    }

    // .tensorflow.CollectionDef.BytesList bytes_list = 2;


    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 as ::protobuf::Message>::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,
        }
    }

    // Param is passed by value, moved
    pub fn set_bytes_list(&mut self, v: CollectionDef_BytesList) {
        self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::bytes_list(v))
    }

    // Mutable pointer to the field.
    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!(),
        }
    }

    // Take field
    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()
        }
    }

    // .tensorflow.CollectionDef.Int64List int64_list = 3;


    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 as ::protobuf::Message>::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,
        }
    }

    // Param is passed by value, moved
    pub fn set_int64_list(&mut self, v: CollectionDef_Int64List) {
        self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::int64_list(v))
    }

    // Mutable pointer to the field.
    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!(),
        }
    }

    // Take field
    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()
        }
    }

    // .tensorflow.CollectionDef.FloatList float_list = 4;


    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 as ::protobuf::Message>::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,
        }
    }

    // Param is passed by value, moved
    pub fn set_float_list(&mut self, v: CollectionDef_FloatList) {
        self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::float_list(v))
    }

    // Mutable pointer to the field.
    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!(),
        }
    }

    // Take field
    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()
        }
    }

    // .tensorflow.CollectionDef.AnyList any_list = 5;


    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 as ::protobuf::Message>::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,
        }
    }

    // Param is passed by value, moved
    pub fn set_any_list(&mut self, v: CollectionDef_AnyList) {
        self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::any_list(v))
    }

    // Mutable pointer to the field.
    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!(),
        }
    }

    // Take field
    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(())
    }

    // Compute sizes of nested messages
    #[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: ::std::boxed::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 descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_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 instance: ::protobuf::rt::LazyV2<CollectionDef> = ::protobuf::rt::LazyV2::INIT;
        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 {
    // message fields
    pub value: ::protobuf::RepeatedField<::std::string::String>,
    // special fields
    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()
    }

    // repeated string value = 1;


    pub fn get_value(&self) -> &[::std::string::String] {
        &self.value
    }
    pub fn clear_value(&mut self) {
        self.value.clear();
    }

    // Param is passed by value, moved
    pub fn set_value(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
        self.value = v;
    }

    // Mutable pointer to the field.
    pub fn mut_value(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
        &mut self.value
    }

    // Take field
    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(())
    }

    // Compute sizes of nested messages
    #[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: ::std::boxed::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 descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::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 instance: ::protobuf::rt::LazyV2<CollectionDef_NodeList> = ::protobuf::rt::LazyV2::INIT;
        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 {
    // message fields
    pub value: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
    // special fields
    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()
    }

    // repeated bytes value = 1;


    pub fn get_value(&self) -> &[::std::vec::Vec<u8>] {
        &self.value
    }
    pub fn clear_value(&mut self) {
        self.value.clear();
    }

    // Param is passed by value, moved
    pub fn set_value(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
        self.value = v;
    }

    // Mutable pointer to the field.
    pub fn mut_value(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
        &mut self.value
    }

    // Take field
    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(())
    }

    // Compute sizes of nested messages
    #[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: ::std::boxed::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 descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::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 instance: ::protobuf::rt::LazyV2<CollectionDef_BytesList> = ::protobuf::rt::LazyV2::INIT;
        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 {
    // message fields
    pub value: ::std::vec::Vec<i64>,
    // special fields
    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()
    }

    // repeated int64 value = 1;


    pub fn get_value(&self) -> &[i64] {
        &self.value
    }
    pub fn clear_value(&mut self) {
        self.value.clear();
    }

    // Param is passed by value, moved
    pub fn set_value(&mut self, v: ::std::vec::Vec<i64>) {
        self.value = v;
    }

    // Mutable pointer to the field.
    pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<i64> {
        &mut self.value
    }

    // Take field
    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(())
    }

    // Compute sizes of nested messages
    #[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)?;
            // TODO: Data size is computed again, it should be cached
            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: ::std::boxed::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 descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_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 instance: ::protobuf::rt::LazyV2<CollectionDef_Int64List> = ::protobuf::rt::LazyV2::INIT;
        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 {
    // message fields
    pub value: ::std::vec::Vec<f32>,
    // special fields
    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()
    }

    // repeated float value = 1;


    pub fn get_value(&self) -> &[f32] {
        &self.value
    }
    pub fn clear_value(&mut self) {
        self.value.clear();
    }

    // Param is passed by value, moved
    pub fn set_value(&mut self, v: ::std::vec::Vec<f32>) {
        self.value = v;
    }

    // Mutable pointer to the field.
    pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<f32> {
        &mut self.value
    }

    // Take field
    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(())
    }

    // Compute sizes of nested messages
    #[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)?;
            // TODO: Data size is computed again, it should be cached
            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: ::std::boxed::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 descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_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 instance: ::protobuf::rt::LazyV2<CollectionDef_FloatList> = ::protobuf::rt::LazyV2::INIT;
        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 {
    // message fields
    pub value: ::protobuf::RepeatedField<::protobuf::well_known_types::Any>,
    // special fields
    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()
    }

    // repeated .google.protobuf.Any value = 1;


    pub fn get_value(&self) -> &[::protobuf::well_known_types::Any] {
        &self.value
    }
    pub fn clear_value(&mut self) {
        self.value.clear();
    }

    // Param is passed by value, moved
    pub fn set_value(&mut self, v: ::protobuf::RepeatedField<::protobuf::well_known_types::Any>) {
        self.value = v;
    }

    // Mutable pointer to the field.
    pub fn mut_value(&mut self) -> &mut ::protobuf::RepeatedField<::protobuf::well_known_types::Any> {
        &mut self.value
    }

    // Take field
    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(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.value {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.value {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CollectionDef_AnyList {
        CollectionDef_AnyList::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::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 instance: ::protobuf::rt::LazyV2<CollectionDef_AnyList> = ::protobuf::rt::LazyV2::INIT;
        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 {
    // message fields
    pub dtype: super::types::DataType,
    pub tensor_shape: ::protobuf::SingularPtrField<super::tensor_shape::TensorShapeProto>,
    // message oneof groups
    pub encoding: ::std::option::Option<TensorInfo_oneof_encoding>,
    // special fields
    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()
    }

    // string name = 1;


    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,
        }
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.encoding = ::std::option::Option::Some(TensorInfo_oneof_encoding::name(v))
    }

    // Mutable pointer to the field.
    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!(),
        }
    }

    // Take field
    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()
        }
    }

    // .tensorflow.TensorInfo.CooSparse coo_sparse = 4;


    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 as ::protobuf::Message>::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,
        }
    }

    // Param is passed by value, moved
    pub fn set_coo_sparse(&mut self, v: TensorInfo_CooSparse) {
        self.encoding = ::std::option::Option::Some(TensorInfo_oneof_encoding::coo_sparse(v))
    }

    // Mutable pointer to the field.
    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!(),
        }
    }

    // Take field
    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()
        }
    }

    // .tensorflow.TensorInfo.CompositeTensor composite_tensor = 5;


    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 as ::protobuf::Message>::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,
        }
    }

    // Param is passed by value, moved
    pub fn set_composite_tensor(&mut self, v: TensorInfo_CompositeTensor) {
        self.encoding = ::std::option::Option::Some(TensorInfo_oneof_encoding::composite_tensor(v))
    }

    // Mutable pointer to the field.
    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!(),
        }
    }

    // Take field
    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()
        }
    }

    // .tensorflow.DataType dtype = 2;


    pub fn get_dtype(&self) -> super::types::DataType {
        self.dtype
    }
    pub fn clear_dtype(&mut self) {
        self.dtype = super::types::DataType::DT_INVALID;
    }

    // Param is passed by value, moved
    pub fn set_dtype(&mut self, v: super::types::DataType) {
        self.dtype = v;
    }

    // .tensorflow.TensorShapeProto tensor_shape = 3;


    pub fn get_tensor_shape(&self) -> &super::tensor_shape::TensorShapeProto {
        self.tensor_shape.as_ref().unwrap_or_else(|| <super::tensor_shape::TensorShapeProto as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_tensor_shape(&mut self, v: super::tensor_shape::TensorShapeProto) {
        self.tensor_shape = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    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(())
    }

    // Compute sizes of nested messages
    #[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, ::protobuf::ProtobufEnum::value(&self.dtype))?;
        }
        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: ::std::boxed::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 descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_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 instance: ::protobuf::rt::LazyV2<TensorInfo> = ::protobuf::rt::LazyV2::INIT;
        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 {
    // message fields
    pub values_tensor_name: ::std::string::String,
    pub indices_tensor_name: ::std::string::String,
    pub dense_shape_tensor_name: ::std::string::String,
    // special fields
    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()
    }

    // string values_tensor_name = 1;


    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();
    }

    // Param is passed by value, moved
    pub fn set_values_tensor_name(&mut self, v: ::std::string::String) {
        self.values_tensor_name = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_values_tensor_name(&mut self) -> &mut ::std::string::String {
        &mut self.values_tensor_name
    }

    // Take field
    pub fn take_values_tensor_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.values_tensor_name, ::std::string::String::new())
    }

    // string indices_tensor_name = 2;


    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();
    }

    // Param is passed by value, moved
    pub fn set_indices_tensor_name(&mut self, v: ::std::string::String) {
        self.indices_tensor_name = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_indices_tensor_name(&mut self) -> &mut ::std::string::String {
        &mut self.indices_tensor_name
    }

    // Take field
    pub fn take_indices_tensor_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.indices_tensor_name, ::std::string::String::new())
    }

    // string dense_shape_tensor_name = 3;


    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();
    }

    // Param is passed by value, moved
    pub fn set_dense_shape_tensor_name(&mut self, v: ::std::string::String) {
        self.dense_shape_tensor_name = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_dense_shape_tensor_name(&mut self) -> &mut ::std::string::String {
        &mut self.dense_shape_tensor_name
    }

    // Take field
    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(())
    }

    // Compute sizes of nested messages
    #[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: ::std::boxed::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 descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "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 instance: ::protobuf::rt::LazyV2<TensorInfo_CooSparse> = ::protobuf::rt::LazyV2::INIT;
        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 {
    // message fields
    pub type_spec: ::protobuf::SingularPtrField<super::struct_pb::TypeSpecProto>,
    pub components: ::protobuf::RepeatedField<TensorInfo>,
    // special fields
    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()
    }

    // .tensorflow.TypeSpecProto type_spec = 1;


    pub fn get_type_spec(&self) -> &super::struct_pb::TypeSpecProto {
        self.type_spec.as_ref().unwrap_or_else(|| <super::struct_pb::TypeSpecProto as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_type_spec(&mut self, v: super::struct_pb::TypeSpecProto) {
        self.type_spec = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_type_spec(&mut self) -> super::struct_pb::TypeSpecProto {
        self.type_spec.take().unwrap_or_else(|| super::struct_pb::TypeSpecProto::new())
    }

    // repeated .tensorflow.TensorInfo components = 2;


    pub fn get_components(&self) -> &[TensorInfo] {
        &self.components
    }
    pub fn clear_components(&mut self) {
        self.components.clear();
    }

    // Param is passed by value, moved
    pub fn set_components(&mut self, v: ::protobuf::RepeatedField<TensorInfo>) {
        self.components = v;
    }

    // Mutable pointer to the field.
    pub fn mut_components(&mut self) -> &mut ::protobuf::RepeatedField<TensorInfo> {
        &mut self.components
    }

    // Take field
    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(())
    }

    // Compute sizes of nested messages
    #[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: ::std::boxed::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 descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<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 instance: ::protobuf::rt::LazyV2<TensorInfo_CompositeTensor> = ::protobuf::rt::LazyV2::INIT;
        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 {
    // message fields
    pub inputs: ::std::collections::HashMap<::std::string::String, TensorInfo>,
    pub outputs: ::std::collections::HashMap<::std::string::String, TensorInfo>,
    pub method_name: ::std::string::String,
    // special fields
    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()
    }

    // repeated .tensorflow.SignatureDef.InputsEntry inputs = 1;


    pub fn get_inputs(&self) -> &::std::collections::HashMap<::std::string::String, TensorInfo> {
        &self.inputs
    }
    pub fn clear_inputs(&mut self) {
        self.inputs.clear();
    }

    // Param is passed by value, moved
    pub fn set_inputs(&mut self, v: ::std::collections::HashMap<::std::string::String, TensorInfo>) {
        self.inputs = v;
    }

    // Mutable pointer to the field.
    pub fn mut_inputs(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, TensorInfo> {
        &mut self.inputs
    }

    // Take field
    pub fn take_inputs(&mut self) -> ::std::collections::HashMap<::std::string::String, TensorInfo> {
        ::std::mem::replace(&mut self.inputs, ::std::collections::HashMap::new())
    }

    // repeated .tensorflow.SignatureDef.OutputsEntry outputs = 2;


    pub fn get_outputs(&self) -> &::std::collections::HashMap<::std::string::String, TensorInfo> {
        &self.outputs
    }
    pub fn clear_outputs(&mut self) {
        self.outputs.clear();
    }

    // Param is passed by value, moved
    pub fn set_outputs(&mut self, v: ::std::collections::HashMap<::std::string::String, TensorInfo>) {
        self.outputs = v;
    }

    // Mutable pointer to the field.
    pub fn mut_outputs(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, TensorInfo> {
        &mut self.outputs
    }

    // Take field
    pub fn take_outputs(&mut self) -> ::std::collections::HashMap<::std::string::String, TensorInfo> {
        ::std::mem::replace(&mut self.outputs, ::std::collections::HashMap::new())
    }

    // string method_name = 3;


    pub fn get_method_name(&self) -> &str {
        &self.method_name
    }
    pub fn clear_method_name(&mut self) {
        self.method_name.clear();
    }

    // Param is passed by value, moved
    pub fn set_method_name(&mut self, v: ::std::string::String) {
        self.method_name = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_method_name(&mut self) -> &mut ::std::string::String {
        &mut self.method_name
    }

    // Take field
    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(())
    }

    // Compute sizes of nested messages
    #[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: ::std::boxed::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 descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_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 instance: ::protobuf::rt::LazyV2<SignatureDef> = ::protobuf::rt::LazyV2::INIT;
        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 {
    // message fields
    pub tensor_info: ::protobuf::SingularPtrField<TensorInfo>,
    pub filename: ::std::string::String,
    // special fields
    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()
    }

    // .tensorflow.TensorInfo tensor_info = 1;


    pub fn get_tensor_info(&self) -> &TensorInfo {
        self.tensor_info.as_ref().unwrap_or_else(|| <TensorInfo as ::protobuf::Message>::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()
    }

    // Param is passed by value, moved
    pub fn set_tensor_info(&mut self, v: TensorInfo) {
        self.tensor_info = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    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()
    }

    // Take field
    pub fn take_tensor_info(&mut self) -> TensorInfo {
        self.tensor_info.take().unwrap_or_else(|| TensorInfo::new())
    }

    // string filename = 2;


    pub fn get_filename(&self) -> &str {
        &self.filename
    }
    pub fn clear_filename(&mut self) {
        self.filename.clear();
    }

    // Param is passed by value, moved
    pub fn set_filename(&mut self, v: ::std::string::String) {
        self.filename = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_filename(&mut self) -> &mut ::std::string::String {
        &mut self.filename
    }

    // Take field
    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(())
    }

    // Compute sizes of nested messages
    #[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: ::std::boxed::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 descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<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 instance: ::protobuf::rt::LazyV2<AssetFileDef> = ::protobuf::rt::LazyV2::INIT;
        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\"\xff\x07\n\x0cMetaGraphD\
    ef\x12H\n\rmeta_info_def\x18\x01\x20\x01(\x0b2$.tensorflow.MetaGraphDef.\
    MetaInfoDefR\x0bmetaInfoDef\x121\n\tgraph_def\x18\x02\x20\x01(\x0b2\x14.\
    tensorflow.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\xd9\x02\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\x1a[\n\x12Collection\
    DefEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12/\n\x05value\x18\
    \x02\x20\x01(\x0b2\x19.tensorflow.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\rCollectionDef\x12A\n\tnode_list\x18\x01\x20\x01(\
    \x0b2\".tensorflow.CollectionDef.NodeListH\0R\x08nodeList\x12D\n\nbytes_\
    list\x18\x02\x20\x01(\x0b2#.tensorflow.CollectionDef.BytesListH\0R\tbyte\
    sList\x12D\n\nint64_list\x18\x03\x20\x01(\x0b2#.tensorflow.CollectionDef\
    .Int64ListH\0R\tint64List\x12D\n\nfloat_list\x18\x04\x20\x01(\x0b2#.tens\
    orflow.CollectionDef.FloatListH\0R\tfloatList\x12>\n\x08any_list\x18\x05\
    \x20\x01(\x0b2!.tensorflow.CollectionDef.AnyListH\0R\x07anyList\x1a\x20\
    \n\x08NodeList\x12\x14\n\x05value\x18\x01\x20\x03(\tR\x05value\x1a!\n\tB\
    ytesList\x12\x14\n\x05value\x18\x01\x20\x03(\x0cR\x05value\x1a%\n\tInt64\
    List\x12\x18\n\x05value\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\x07AnyList\x12*\n\x05value\x18\x01\x20\x03(\x0b2\x14.google.\
    protobuf.AnyR\x05valueB\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.tensorflow.TensorInfo.CooSparseH\0R\tcooSparse\x12S\n\x10\
    composite_tensor\x18\x05\x20\x01(\x0b2&.tensorflow.TensorInfo.CompositeT\
    ensorH\0R\x0fcompositeTensor\x12*\n\x05dtype\x18\x02\x20\x01(\x0e2\x14.t\
    ensorflow.DataTypeR\x05dtype\x12?\n\x0ctensor_shape\x18\x03\x20\x01(\x0b\
    2\x1c.tensorflow.TensorShapeProtoR\x0btensorShape\x1a\xa0\x01\n\tCooSpar\
    se\x12,\n\x12values_tensor_name\x18\x01\x20\x01(\tR\x10valuesTensorName\
    \x12.\n\x13indices_tensor_name\x18\x02\x20\x01(\tR\x11indicesTensorName\
    \x125\n\x17dense_shape_tensor_name\x18\x03\x20\x01(\tR\x14denseShapeTens\
    orName\x1a\x81\x01\n\x0fCompositeTensor\x126\n\ttype_spec\x18\x01\x20\
    \x01(\x0b2\x19.tensorflow.TypeSpecProtoR\x08typeSpec\x126\n\ncomponents\
    \x18\x02\x20\x03(\x0b2\x16.tensorflow.TensorInfoR\ncomponentsB\n\n\x08en\
    coding\"\xd5\x02\n\x0cSignatureDef\x12<\n\x06inputs\x18\x01\x20\x03(\x0b\
    2$.tensorflow.SignatureDef.InputsEntryR\x06inputs\x12?\n\x07outputs\x18\
    \x02\x20\x03(\x0b2%.tensorflow.SignatureDef.OutputsEntryR\x07outputs\x12\
    \x1f\n\x0bmethod_name\x18\x03\x20\x01(\tR\nmethodName\x1aQ\n\x0bInputsEn\
    try\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12,\n\x05value\x18\x02\
    \x20\x01(\x0b2\x16.tensorflow.TensorInfoR\x05value:\x028\x01\x1aR\n\x0cO\
    utputsEntry\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.tenso\
    rflow.TensorInfoR\ntensorInfo\x12\x1a\n\x08filename\x18\x02\x20\x01(\tR\
    \x08filenameBn\n\x18org.tensorflow.frameworkB\x0fMetaGraphProtosP\x01Z<g\
    ithub.com/tensorflow/tensorflow/tensorflow/go/core/protobuf\xf8\x01\x01b\
    \x06proto3\
";

static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::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 {
    file_descriptor_proto_lazy.get(|| {
        parse_descriptor_proto()
    })
}