tensorflow_serving_client/

debug.rs

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

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

#![cfg_attr(rustfmt, rustfmt_skip)]

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

use protobuf::Message as Message_imported_for_functions;
use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;

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

#[derive(PartialEq,Clone,Default)]
pub struct DebugTensorWatch {
    // message fields
    pub node_name: ::std::string::String,
    pub output_slot: i32,
    pub debug_ops: ::protobuf::RepeatedField<::std::string::String>,
    pub debug_urls: ::protobuf::RepeatedField<::std::string::String>,
    pub tolerate_debug_op_creation_failures: bool,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a DebugTensorWatch {
    fn default() -> &'a DebugTensorWatch {
        <DebugTensorWatch as ::protobuf::Message>::default_instance()
    }
}

impl DebugTensorWatch {
    pub fn new() -> DebugTensorWatch {
        ::std::default::Default::default()
    }

    // string node_name = 1;


    pub fn get_node_name(&self) -> &str {
        &self.node_name
    }
    pub fn clear_node_name(&mut self) {
        self.node_name.clear();
    }

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

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

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

    // int32 output_slot = 2;


    pub fn get_output_slot(&self) -> i32 {
        self.output_slot
    }
    pub fn clear_output_slot(&mut self) {
        self.output_slot = 0;
    }

    // Param is passed by value, moved
    pub fn set_output_slot(&mut self, v: i32) {
        self.output_slot = v;
    }

    // repeated string debug_ops = 3;


    pub fn get_debug_ops(&self) -> &[::std::string::String] {
        &self.debug_ops
    }
    pub fn clear_debug_ops(&mut self) {
        self.debug_ops.clear();
    }

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

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

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

    // repeated string debug_urls = 4;


    pub fn get_debug_urls(&self) -> &[::std::string::String] {
        &self.debug_urls
    }
    pub fn clear_debug_urls(&mut self) {
        self.debug_urls.clear();
    }

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

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

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

    // bool tolerate_debug_op_creation_failures = 5;


    pub fn get_tolerate_debug_op_creation_failures(&self) -> bool {
        self.tolerate_debug_op_creation_failures
    }
    pub fn clear_tolerate_debug_op_creation_failures(&mut self) {
        self.tolerate_debug_op_creation_failures = false;
    }

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

impl ::protobuf::Message for DebugTensorWatch {
    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.node_name)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.output_slot = tmp;
                },
                3 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.debug_ops)?;
                },
                4 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.debug_urls)?;
                },
                5 => {
                    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.tolerate_debug_op_creation_failures = 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.node_name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.node_name);
        }
        if self.output_slot != 0 {
            my_size += ::protobuf::rt::value_size(2, self.output_slot, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.debug_ops {
            my_size += ::protobuf::rt::string_size(3, &value);
        };
        for value in &self.debug_urls {
            my_size += ::protobuf::rt::string_size(4, &value);
        };
        if self.tolerate_debug_op_creation_failures != 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.node_name.is_empty() {
            os.write_string(1, &self.node_name)?;
        }
        if self.output_slot != 0 {
            os.write_int32(2, self.output_slot)?;
        }
        for v in &self.debug_ops {
            os.write_string(3, &v)?;
        };
        for v in &self.debug_urls {
            os.write_string(4, &v)?;
        };
        if self.tolerate_debug_op_creation_failures != false {
            os.write_bool(5, self.tolerate_debug_op_creation_failures)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "node_name",
                    |m: &DebugTensorWatch| { &m.node_name },
                    |m: &mut DebugTensorWatch| { &mut m.node_name },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                    "output_slot",
                    |m: &DebugTensorWatch| { &m.output_slot },
                    |m: &mut DebugTensorWatch| { &mut m.output_slot },
                ));
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "debug_ops",
                    |m: &DebugTensorWatch| { &m.debug_ops },
                    |m: &mut DebugTensorWatch| { &mut m.debug_ops },
                ));
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "debug_urls",
                    |m: &DebugTensorWatch| { &m.debug_urls },
                    |m: &mut DebugTensorWatch| { &mut m.debug_urls },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "tolerate_debug_op_creation_failures",
                    |m: &DebugTensorWatch| { &m.tolerate_debug_op_creation_failures },
                    |m: &mut DebugTensorWatch| { &mut m.tolerate_debug_op_creation_failures },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<DebugTensorWatch>(
                    "DebugTensorWatch",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static DebugTensorWatch {
        static mut instance: ::protobuf::lazy::Lazy<DebugTensorWatch> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(DebugTensorWatch::new)
        }
    }
}

impl ::protobuf::Clear for DebugTensorWatch {
    fn clear(&mut self) {
        self.node_name.clear();
        self.output_slot = 0;
        self.debug_ops.clear();
        self.debug_urls.clear();
        self.tolerate_debug_op_creation_failures = false;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for DebugTensorWatch {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for DebugTensorWatch {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct DebugOptions {
    // message fields
    pub debug_tensor_watch_opts: ::protobuf::RepeatedField<DebugTensorWatch>,
    pub global_step: i64,
    pub reset_disk_byte_usage: bool,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a DebugOptions {
    fn default() -> &'a DebugOptions {
        <DebugOptions as ::protobuf::Message>::default_instance()
    }
}

impl DebugOptions {
    pub fn new() -> DebugOptions {
        ::std::default::Default::default()
    }

    // repeated .tensorflow.DebugTensorWatch debug_tensor_watch_opts = 4;


    pub fn get_debug_tensor_watch_opts(&self) -> &[DebugTensorWatch] {
        &self.debug_tensor_watch_opts
    }
    pub fn clear_debug_tensor_watch_opts(&mut self) {
        self.debug_tensor_watch_opts.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_debug_tensor_watch_opts(&mut self) -> &mut ::protobuf::RepeatedField<DebugTensorWatch> {
        &mut self.debug_tensor_watch_opts
    }

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

    // int64 global_step = 10;


    pub fn get_global_step(&self) -> i64 {
        self.global_step
    }
    pub fn clear_global_step(&mut self) {
        self.global_step = 0;
    }

    // Param is passed by value, moved
    pub fn set_global_step(&mut self, v: i64) {
        self.global_step = v;
    }

    // bool reset_disk_byte_usage = 11;


    pub fn get_reset_disk_byte_usage(&self) -> bool {
        self.reset_disk_byte_usage
    }
    pub fn clear_reset_disk_byte_usage(&mut self) {
        self.reset_disk_byte_usage = false;
    }

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

impl ::protobuf::Message for DebugOptions {
    fn is_initialized(&self) -> bool {
        for v in &self.debug_tensor_watch_opts {
            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 {
                4 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.debug_tensor_watch_opts)?;
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.global_step = tmp;
                },
                11 => {
                    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.reset_disk_byte_usage = 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;
        for value in &self.debug_tensor_watch_opts {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if self.global_step != 0 {
            my_size += ::protobuf::rt::value_size(10, self.global_step, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.reset_disk_byte_usage != 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<()> {
        for v in &self.debug_tensor_watch_opts {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if self.global_step != 0 {
            os.write_int64(10, self.global_step)?;
        }
        if self.reset_disk_byte_usage != false {
            os.write_bool(11, self.reset_disk_byte_usage)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<DebugTensorWatch>>(
                    "debug_tensor_watch_opts",
                    |m: &DebugOptions| { &m.debug_tensor_watch_opts },
                    |m: &mut DebugOptions| { &mut m.debug_tensor_watch_opts },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "global_step",
                    |m: &DebugOptions| { &m.global_step },
                    |m: &mut DebugOptions| { &mut m.global_step },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "reset_disk_byte_usage",
                    |m: &DebugOptions| { &m.reset_disk_byte_usage },
                    |m: &mut DebugOptions| { &mut m.reset_disk_byte_usage },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<DebugOptions>(
                    "DebugOptions",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static DebugOptions {
        static mut instance: ::protobuf::lazy::Lazy<DebugOptions> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(DebugOptions::new)
        }
    }
}

impl ::protobuf::Clear for DebugOptions {
    fn clear(&mut self) {
        self.debug_tensor_watch_opts.clear();
        self.global_step = 0;
        self.reset_disk_byte_usage = false;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for DebugOptions {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for DebugOptions {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct DebuggedSourceFile {
    // message fields
    pub host: ::std::string::String,
    pub file_path: ::std::string::String,
    pub last_modified: i64,
    pub bytes: i64,
    pub lines: ::protobuf::RepeatedField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a DebuggedSourceFile {
    fn default() -> &'a DebuggedSourceFile {
        <DebuggedSourceFile as ::protobuf::Message>::default_instance()
    }
}

impl DebuggedSourceFile {
    pub fn new() -> DebuggedSourceFile {
        ::std::default::Default::default()
    }

    // string host = 1;


    pub fn get_host(&self) -> &str {
        &self.host
    }
    pub fn clear_host(&mut self) {
        self.host.clear();
    }

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

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

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

    // string file_path = 2;


    pub fn get_file_path(&self) -> &str {
        &self.file_path
    }
    pub fn clear_file_path(&mut self) {
        self.file_path.clear();
    }

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

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

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

    // int64 last_modified = 3;


    pub fn get_last_modified(&self) -> i64 {
        self.last_modified
    }
    pub fn clear_last_modified(&mut self) {
        self.last_modified = 0;
    }

    // Param is passed by value, moved
    pub fn set_last_modified(&mut self, v: i64) {
        self.last_modified = v;
    }

    // int64 bytes = 4;


    pub fn get_bytes(&self) -> i64 {
        self.bytes
    }
    pub fn clear_bytes(&mut self) {
        self.bytes = 0;
    }

    // Param is passed by value, moved
    pub fn set_bytes(&mut self, v: i64) {
        self.bytes = v;
    }

    // repeated string lines = 5;


    pub fn get_lines(&self) -> &[::std::string::String] {
        &self.lines
    }
    pub fn clear_lines(&mut self) {
        self.lines.clear();
    }

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

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

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

impl ::protobuf::Message for DebuggedSourceFile {
    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.host)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.file_path)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.last_modified = tmp;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.bytes = tmp;
                },
                5 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.lines)?;
                },
                _ => {
                    ::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.host.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.host);
        }
        if !self.file_path.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.file_path);
        }
        if self.last_modified != 0 {
            my_size += ::protobuf::rt::value_size(3, self.last_modified, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.bytes != 0 {
            my_size += ::protobuf::rt::value_size(4, self.bytes, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.lines {
            my_size += ::protobuf::rt::string_size(5, &value);
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.host.is_empty() {
            os.write_string(1, &self.host)?;
        }
        if !self.file_path.is_empty() {
            os.write_string(2, &self.file_path)?;
        }
        if self.last_modified != 0 {
            os.write_int64(3, self.last_modified)?;
        }
        if self.bytes != 0 {
            os.write_int64(4, self.bytes)?;
        }
        for v in &self.lines {
            os.write_string(5, &v)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "host",
                    |m: &DebuggedSourceFile| { &m.host },
                    |m: &mut DebuggedSourceFile| { &mut m.host },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "file_path",
                    |m: &DebuggedSourceFile| { &m.file_path },
                    |m: &mut DebuggedSourceFile| { &mut m.file_path },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "last_modified",
                    |m: &DebuggedSourceFile| { &m.last_modified },
                    |m: &mut DebuggedSourceFile| { &mut m.last_modified },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "bytes",
                    |m: &DebuggedSourceFile| { &m.bytes },
                    |m: &mut DebuggedSourceFile| { &mut m.bytes },
                ));
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "lines",
                    |m: &DebuggedSourceFile| { &m.lines },
                    |m: &mut DebuggedSourceFile| { &mut m.lines },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<DebuggedSourceFile>(
                    "DebuggedSourceFile",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static DebuggedSourceFile {
        static mut instance: ::protobuf::lazy::Lazy<DebuggedSourceFile> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(DebuggedSourceFile::new)
        }
    }
}

impl ::protobuf::Clear for DebuggedSourceFile {
    fn clear(&mut self) {
        self.host.clear();
        self.file_path.clear();
        self.last_modified = 0;
        self.bytes = 0;
        self.lines.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for DebuggedSourceFile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for DebuggedSourceFile {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct DebuggedSourceFiles {
    // message fields
    pub source_files: ::protobuf::RepeatedField<DebuggedSourceFile>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a DebuggedSourceFiles {
    fn default() -> &'a DebuggedSourceFiles {
        <DebuggedSourceFiles as ::protobuf::Message>::default_instance()
    }
}

impl DebuggedSourceFiles {
    pub fn new() -> DebuggedSourceFiles {
        ::std::default::Default::default()
    }

    // repeated .tensorflow.DebuggedSourceFile source_files = 1;


    pub fn get_source_files(&self) -> &[DebuggedSourceFile] {
        &self.source_files
    }
    pub fn clear_source_files(&mut self) {
        self.source_files.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_source_files(&mut self) -> &mut ::protobuf::RepeatedField<DebuggedSourceFile> {
        &mut self.source_files
    }

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

impl ::protobuf::Message for DebuggedSourceFiles {
    fn is_initialized(&self) -> bool {
        for v in &self.source_files {
            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.source_files)?;
                },
                _ => {
                    ::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.source_files {
            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.source_files {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<DebuggedSourceFile>>(
                    "source_files",
                    |m: &DebuggedSourceFiles| { &m.source_files },
                    |m: &mut DebuggedSourceFiles| { &mut m.source_files },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<DebuggedSourceFiles>(
                    "DebuggedSourceFiles",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static DebuggedSourceFiles {
        static mut instance: ::protobuf::lazy::Lazy<DebuggedSourceFiles> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(DebuggedSourceFiles::new)
        }
    }
}

impl ::protobuf::Clear for DebuggedSourceFiles {
    fn clear(&mut self) {
        self.source_files.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for DebuggedSourceFiles {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for DebuggedSourceFiles {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n$tensorflow/core/protobuf/debug.proto\x12\ntensorflow\"\xda\x01\n\x10D\
    ebugTensorWatch\x12\x1b\n\tnode_name\x18\x01\x20\x01(\tR\x08nodeName\x12\
    \x1f\n\x0boutput_slot\x18\x02\x20\x01(\x05R\noutputSlot\x12\x1b\n\tdebug\
    _ops\x18\x03\x20\x03(\tR\x08debugOps\x12\x1d\n\ndebug_urls\x18\x04\x20\
    \x03(\tR\tdebugUrls\x12L\n#tolerate_debug_op_creation_failures\x18\x05\
    \x20\x01(\x08R\x1ftolerateDebugOpCreationFailures\"\xb7\x01\n\x0cDebugOp\
    tions\x12S\n\x17debug_tensor_watch_opts\x18\x04\x20\x03(\x0b2\x1c.tensor\
    flow.DebugTensorWatchR\x14debugTensorWatchOpts\x12\x1f\n\x0bglobal_step\
    \x18\n\x20\x01(\x03R\nglobalStep\x121\n\x15reset_disk_byte_usage\x18\x0b\
    \x20\x01(\x08R\x12resetDiskByteUsage\"\x96\x01\n\x12DebuggedSourceFile\
    \x12\x12\n\x04host\x18\x01\x20\x01(\tR\x04host\x12\x1b\n\tfile_path\x18\
    \x02\x20\x01(\tR\x08filePath\x12#\n\rlast_modified\x18\x03\x20\x01(\x03R\
    \x0clastModified\x12\x14\n\x05bytes\x18\x04\x20\x01(\x03R\x05bytes\x12\
    \x14\n\x05lines\x18\x05\x20\x03(\tR\x05lines\"X\n\x13DebuggedSourceFiles\
    \x12A\n\x0csource_files\x18\x01\x20\x03(\x0b2\x1e.tensorflow.DebuggedSou\
    rceFileR\x0bsourceFilesBv\n\x18org.tensorflow.frameworkB\x0bDebugProtosP\
    \x01ZHgithub.com/tensorflow/tensorflow/tensorflow/go/core/core_protos_go\
    _proto\xf8\x01\x01J\xc0\x1a\n\x06\x12\x04\0\0]\x01\n\x08\n\x01\x0c\x12\
    \x03\0\0\x12\n\x08\n\x01\x02\x12\x03\x02\0\x13\n\x08\n\x01\x08\x12\x03\
    \x04\0\x1f\n\t\n\x02\x08\x1f\x12\x03\x04\0\x1f\n\x08\n\x01\x08\x12\x03\
    \x05\0,\n\t\n\x02\x08\x08\x12\x03\x05\0,\n\x08\n\x01\x08\x12\x03\x06\0\"\
    \n\t\n\x02\x08\n\x12\x03\x06\0\"\n\x08\n\x01\x08\x12\x03\x07\01\n\t\n\
    \x02\x08\x01\x12\x03\x07\01\n\x08\n\x01\x08\x12\x03\x08\0_\n\t\n\x02\x08\
    \x0b\x12\x03\x08\0_\nH\n\x02\x04\0\x12\x04\x0b\06\x01\x1a<\x20Option\x20\
    for\x20watching\x20a\x20node\x20in\x20TensorFlow\x20Debugger\x20(tfdbg).\
    \n\n\n\n\x03\x04\0\x01\x12\x03\x0b\x08\x18\ny\n\x04\x04\0\x02\0\x12\x03\
    \x0f\x02\x17\x1al\x20Name\x20of\x20the\x20node\x20to\x20watch.\n\x20Use\
    \x20\"*\"\x20for\x20wildcard.\x20But\x20note:\x20currently,\x20regex\x20\
    is\x20not\x20supported\x20in\n\x20general.\n\n\x0c\n\x05\x04\0\x02\0\x05\
    \x12\x03\x0f\x02\x08\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x0f\t\x12\n\x0c\
    \n\x05\x04\0\x02\0\x03\x12\x03\x0f\x15\x16\n\xe4\x01\n\x04\x04\0\x02\x01\
    \x12\x03\x16\x02\x18\x1a\xd6\x01\x20Output\x20slot\x20to\x20watch.\n\x20\
    The\x20semantics\x20of\x20output_slot\x20==\x20-1\x20is\x20that\x20all\
    \x20outputs\x20of\x20the\x20node\n\x20will\x20be\x20watched\x20(i.e.,\
    \x20a\x20wildcard).\n\x20Other\x20negative\x20values\x20of\x20output_slo\
    t\x20are\x20invalid\x20and\x20will\x20lead\x20to\n\x20errors\x20currentl\
    y.\n\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x03\x16\x02\x07\n\x0c\n\x05\x04\0\
    \x02\x01\x01\x12\x03\x16\x08\x13\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03\
    \x16\x16\x17\n\x82\x01\n\x04\x04\0\x02\x02\x12\x03\x1b\x02\x20\x1au\x20N\
    ame(s)\x20of\x20the\x20debugging\x20op(s).\n\x20One\x20or\x20more\x20tha\
    n\x20one\x20probes\x20on\x20a\x20tensor.\n\x20e.g.,\x20{\"DebugIdentity\
    \",\x20\"DebugNanCount\"}\n\n\x0c\n\x05\x04\0\x02\x02\x04\x12\x03\x1b\
    \x02\n\n\x0c\n\x05\x04\0\x02\x02\x05\x12\x03\x1b\x0b\x11\n\x0c\n\x05\x04\
    \0\x02\x02\x01\x12\x03\x1b\x12\x1b\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x03\
    \x1b\x1e\x1f\n\xcb\x07\n\x04\x04\0\x02\x03\x12\x031\x02!\x1a\xbd\x07\x20\
    URL(s)\x20for\x20debug\x20targets(s).\n\n\x20Supported\x20URL\x20formats\
    \x20are:\n\x20\x20\x20-\x20file:///foo/tfdbg_dump:\x20Writes\x20out\x20E\
    vent\x20content\x20to\x20file\n\x20\x20\x20\x20\x20/foo/tfdbg_dump.\x20\
    \x20Assumes\x20all\x20directories\x20can\x20be\x20created\x20if\x20they\
    \x20don't\n\x20\x20\x20\x20\x20already\x20exist.\n\x20\x20\x20-\x20grpc:\
    //localhost:11011:\x20Sends\x20an\x20RPC\x20request\x20to\x20an\x20Event\
    Listener\n\x20\x20\x20\x20\x20service\x20running\x20at\x20localhost:1101\
    1\x20with\x20the\x20event.\n\x20\x20\x20-\x20memcbk:///event_key:\x20Rou\
    tes\x20tensors\x20to\x20clients\x20using\x20the\n\x20\x20\x20\x20\x20cal\
    lback\x20registered\x20with\x20the\x20DebugCallbackRegistry\x20for\x20ev\
    ent_key.\n\n\x20Each\x20debug\x20op\x20listed\x20in\x20debug_ops\x20will\
    \x20publish\x20its\x20output\x20tensor\x20(debug\n\x20signal)\x20to\x20a\
    ll\x20URLs\x20in\x20debug_urls.\n\n\x20N.B.\x20Session::Run()\x20support\
    s\x20concurrent\x20invocations\x20of\x20the\x20same\x20inputs\n\x20(feed\
    \x20keys),\x20outputs\x20and\x20target\x20nodes.\x20If\x20such\x20concur\
    rent\x20invocations\n\x20are\x20to\x20be\x20debugged,\x20the\x20callers\
    \x20of\x20Session::Run()\x20must\x20use\x20distinct\n\x20debug_urls\x20t\
    o\x20make\x20sure\x20that\x20the\x20streamed\x20or\x20dumped\x20events\
    \x20do\x20not\x20overlap\n\x20among\x20the\x20invocations.\n\x20TODO(cai\
    s):\x20More\x20visible\x20documentation\x20of\x20this\x20in\x20g3docs.\n\
    \n\x0c\n\x05\x04\0\x02\x03\x04\x12\x031\x02\n\n\x0c\n\x05\x04\0\x02\x03\
    \x05\x12\x031\x0b\x11\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x031\x12\x1c\n\
    \x0c\n\x05\x04\0\x02\x03\x03\x12\x031\x1f\x20\n\x80\x01\n\x04\x04\0\x02\
    \x04\x12\x035\x02/\x1as\x20Do\x20not\x20error\x20out\x20if\x20debug\x20o\
    p\x20creation\x20fails\x20(e.g.,\x20due\x20to\x20dtype\n\x20incompatibil\
    ity).\x20Instead,\x20just\x20log\x20the\x20failure.\n\n\x0c\n\x05\x04\0\
    \x02\x04\x05\x12\x035\x02\x06\n\x0c\n\x05\x04\0\x02\x04\x01\x12\x035\x07\
    *\n\x0c\n\x05\x04\0\x02\x04\x03\x12\x035-.\nT\n\x02\x04\x01\x12\x049\0G\
    \x01\x1aH\x20Options\x20for\x20initializing\x20DebuggerState\x20in\x20Te\
    nsorFlow\x20Debugger\x20(tfdbg).\n\n\n\n\x03\x04\x01\x01\x12\x039\x08\
    \x14\n\x20\n\x04\x04\x01\x02\0\x12\x03;\x028\x1a\x13\x20Debugging\x20opt\
    ions\n\n\x0c\n\x05\x04\x01\x02\0\x04\x12\x03;\x02\n\n\x0c\n\x05\x04\x01\
    \x02\0\x06\x12\x03;\x0b\x1b\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03;\x1c3\
    \n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03;67\n\x87\x01\n\x04\x04\x01\x02\
    \x01\x12\x03@\x02\x19\x1az\x20Caller-specified\x20global\x20step\x20coun\
    t.\n\x20Note\x20that\x20this\x20is\x20distinct\x20from\x20the\x20session\
    \x20run\x20count\x20and\x20the\x20executor\n\x20step\x20count.\n\n\x0c\n\
    \x05\x04\x01\x02\x01\x05\x12\x03@\x02\x07\n\x0c\n\x05\x04\x01\x02\x01\
    \x01\x12\x03@\x08\x13\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03@\x16\x18\n\
    \x80\x02\n\x04\x04\x01\x02\x02\x12\x03F\x02\"\x1a\xf2\x01\x20Whether\x20\
    the\x20total\x20disk\x20usage\x20of\x20tfdbg\x20is\x20to\x20be\x20reset\
    \x20to\x20zero\n\x20in\x20this\x20Session.run\x20call.\x20This\x20is\x20\
    used\x20by\x20wrappers\x20and\x20hooks\n\x20such\x20as\x20the\x20local\
    \x20CLI\x20ones\x20to\x20indicate\x20that\x20the\x20dumped\x20tensors\n\
    \x20are\x20cleaned\x20up\x20from\x20the\x20disk\x20after\x20each\x20Sess\
    ion.run.\n\n\x0c\n\x05\x04\x01\x02\x02\x05\x12\x03F\x02\x06\n\x0c\n\x05\
    \x04\x01\x02\x02\x01\x12\x03F\x07\x1c\n\x0c\n\x05\x04\x01\x02\x02\x03\
    \x12\x03F\x1f!\n\n\n\x02\x04\x02\x12\x04I\0X\x01\n\n\n\x03\x04\x02\x01\
    \x12\x03I\x08\x1a\nD\n\x04\x04\x02\x02\0\x12\x03K\x02\x12\x1a7\x20The\
    \x20host\x20name\x20on\x20which\x20a\x20source\x20code\x20file\x20is\x20\
    located.\n\n\x0c\n\x05\x04\x02\x02\0\x05\x12\x03K\x02\x08\n\x0c\n\x05\
    \x04\x02\x02\0\x01\x12\x03K\t\r\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03K\
    \x10\x11\n,\n\x04\x04\x02\x02\x01\x12\x03N\x02\x17\x1a\x1f\x20Path\x20to\
    \x20the\x20source\x20code\x20file.\n\n\x0c\n\x05\x04\x02\x02\x01\x05\x12\
    \x03N\x02\x08\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x03N\t\x12\n\x0c\n\x05\
    \x04\x02\x02\x01\x03\x12\x03N\x15\x16\nL\n\x04\x04\x02\x02\x02\x12\x03Q\
    \x02\x1a\x1a?\x20The\x20timestamp\x20at\x20which\x20the\x20source\x20cod\
    e\x20file\x20is\x20last\x20modified.\n\n\x0c\n\x05\x04\x02\x02\x02\x05\
    \x12\x03Q\x02\x07\n\x0c\n\x05\x04\x02\x02\x02\x01\x12\x03Q\x08\x15\n\x0c\
    \n\x05\x04\x02\x02\x02\x03\x12\x03Q\x18\x19\n%\n\x04\x04\x02\x02\x03\x12\
    \x03T\x02\x12\x1a\x18\x20Byte\x20size\x20of\x20the\x20file.\n\n\x0c\n\
    \x05\x04\x02\x02\x03\x05\x12\x03T\x02\x07\n\x0c\n\x05\x04\x02\x02\x03\
    \x01\x12\x03T\x08\r\n\x0c\n\x05\x04\x02\x02\x03\x03\x12\x03T\x10\x11\n<\
    \n\x04\x04\x02\x02\x04\x12\x03W\x02\x1c\x1a/\x20Line-by-line\x20content\
    \x20of\x20the\x20source\x20code\x20file.\n\n\x0c\n\x05\x04\x02\x02\x04\
    \x04\x12\x03W\x02\n\n\x0c\n\x05\x04\x02\x02\x04\x05\x12\x03W\x0b\x11\n\
    \x0c\n\x05\x04\x02\x02\x04\x01\x12\x03W\x12\x17\n\x0c\n\x05\x04\x02\x02\
    \x04\x03\x12\x03W\x1a\x1b\n\n\n\x02\x04\x03\x12\x04Z\0]\x01\n\n\n\x03\
    \x04\x03\x01\x12\x03Z\x08\x1b\n1\n\x04\x04\x03\x02\0\x12\x03\\\x02/\x1a$\
    \x20A\x20collection\x20of\x20source\x20code\x20files.\n\n\x0c\n\x05\x04\
    \x03\x02\0\x04\x12\x03\\\x02\n\n\x0c\n\x05\x04\x03\x02\0\x06\x12\x03\\\
    \x0b\x1d\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03\\\x1e*\n\x0c\n\x05\x04\
    \x03\x02\0\x03\x12\x03\\-.b\x06proto3\
";

static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT;

fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
    ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
}

pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    unsafe {
        file_descriptor_proto_lazy.get(|| {
            parse_descriptor_proto()
        })
    }
}