#![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)]
#[derive(PartialEq,Clone,Default)]
pub struct NewProfileSessionRequest {
pub request: ::protobuf::SingularPtrField<super::profiler_service::ProfileRequest>,
pub repository_root: ::std::string::String,
pub hosts: ::protobuf::RepeatedField<::std::string::String>,
pub session_id: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a NewProfileSessionRequest {
fn default() -> &'a NewProfileSessionRequest {
<NewProfileSessionRequest as ::protobuf::Message>::default_instance()
}
}
impl NewProfileSessionRequest {
pub fn new() -> NewProfileSessionRequest {
::std::default::Default::default()
}
pub fn get_request(&self) -> &super::profiler_service::ProfileRequest {
self.request.as_ref().unwrap_or_else(|| <super::profiler_service::ProfileRequest as ::protobuf::Message>::default_instance())
}
pub fn clear_request(&mut self) {
self.request.clear();
}
pub fn has_request(&self) -> bool {
self.request.is_some()
}
pub fn set_request(&mut self, v: super::profiler_service::ProfileRequest) {
self.request = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_request(&mut self) -> &mut super::profiler_service::ProfileRequest {
if self.request.is_none() {
self.request.set_default();
}
self.request.as_mut().unwrap()
}
pub fn take_request(&mut self) -> super::profiler_service::ProfileRequest {
self.request.take().unwrap_or_else(|| super::profiler_service::ProfileRequest::new())
}
pub fn get_repository_root(&self) -> &str {
&self.repository_root
}
pub fn clear_repository_root(&mut self) {
self.repository_root.clear();
}
pub fn set_repository_root(&mut self, v: ::std::string::String) {
self.repository_root = v;
}
pub fn mut_repository_root(&mut self) -> &mut ::std::string::String {
&mut self.repository_root
}
pub fn take_repository_root(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.repository_root, ::std::string::String::new())
}
pub fn get_hosts(&self) -> &[::std::string::String] {
&self.hosts
}
pub fn clear_hosts(&mut self) {
self.hosts.clear();
}
pub fn set_hosts(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
self.hosts = v;
}
pub fn mut_hosts(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
&mut self.hosts
}
pub fn take_hosts(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
::std::mem::replace(&mut self.hosts, ::protobuf::RepeatedField::new())
}
pub fn get_session_id(&self) -> &str {
&self.session_id
}
pub fn clear_session_id(&mut self) {
self.session_id.clear();
}
pub fn set_session_id(&mut self, v: ::std::string::String) {
self.session_id = v;
}
pub fn mut_session_id(&mut self) -> &mut ::std::string::String {
&mut self.session_id
}
pub fn take_session_id(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.session_id, ::std::string::String::new())
}
}
impl ::protobuf::Message for NewProfileSessionRequest {
fn is_initialized(&self) -> bool {
for v in &self.request {
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.request)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.repository_root)?;
},
3 => {
::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.hosts)?;
},
4 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.session_id)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.request.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.repository_root.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.repository_root);
}
for value in &self.hosts {
my_size += ::protobuf::rt::string_size(3, &value);
};
if !self.session_id.is_empty() {
my_size += ::protobuf::rt::string_size(4, &self.session_id);
}
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.request.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.repository_root.is_empty() {
os.write_string(2, &self.repository_root)?;
}
for v in &self.hosts {
os.write_string(3, &v)?;
};
if !self.session_id.is_empty() {
os.write_string(4, &self.session_id)?;
}
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() -> NewProfileSessionRequest {
NewProfileSessionRequest::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::profiler_service::ProfileRequest>>(
"request",
|m: &NewProfileSessionRequest| { &m.request },
|m: &mut NewProfileSessionRequest| { &mut m.request },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"repository_root",
|m: &NewProfileSessionRequest| { &m.repository_root },
|m: &mut NewProfileSessionRequest| { &mut m.repository_root },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"hosts",
|m: &NewProfileSessionRequest| { &m.hosts },
|m: &mut NewProfileSessionRequest| { &mut m.hosts },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"session_id",
|m: &NewProfileSessionRequest| { &m.session_id },
|m: &mut NewProfileSessionRequest| { &mut m.session_id },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<NewProfileSessionRequest>(
"NewProfileSessionRequest",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static NewProfileSessionRequest {
static instance: ::protobuf::rt::LazyV2<NewProfileSessionRequest> = ::protobuf::rt::LazyV2::INIT;
instance.get(NewProfileSessionRequest::new)
}
}
impl ::protobuf::Clear for NewProfileSessionRequest {
fn clear(&mut self) {
self.request.clear();
self.repository_root.clear();
self.hosts.clear();
self.session_id.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for NewProfileSessionRequest {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for NewProfileSessionRequest {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct NewProfileSessionResponse {
pub error_message: ::std::string::String,
pub empty_trace: bool,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a NewProfileSessionResponse {
fn default() -> &'a NewProfileSessionResponse {
<NewProfileSessionResponse as ::protobuf::Message>::default_instance()
}
}
impl NewProfileSessionResponse {
pub fn new() -> NewProfileSessionResponse {
::std::default::Default::default()
}
pub fn get_error_message(&self) -> &str {
&self.error_message
}
pub fn clear_error_message(&mut self) {
self.error_message.clear();
}
pub fn set_error_message(&mut self, v: ::std::string::String) {
self.error_message = v;
}
pub fn mut_error_message(&mut self) -> &mut ::std::string::String {
&mut self.error_message
}
pub fn take_error_message(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.error_message, ::std::string::String::new())
}
pub fn get_empty_trace(&self) -> bool {
self.empty_trace
}
pub fn clear_empty_trace(&mut self) {
self.empty_trace = false;
}
pub fn set_empty_trace(&mut self, v: bool) {
self.empty_trace = v;
}
}
impl ::protobuf::Message for NewProfileSessionResponse {
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.error_message)?;
},
2 => {
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.empty_trace = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.error_message.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.error_message);
}
if self.empty_trace != 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.error_message.is_empty() {
os.write_string(1, &self.error_message)?;
}
if self.empty_trace != false {
os.write_bool(2, self.empty_trace)?;
}
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() -> NewProfileSessionResponse {
NewProfileSessionResponse::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>(
"error_message",
|m: &NewProfileSessionResponse| { &m.error_message },
|m: &mut NewProfileSessionResponse| { &mut m.error_message },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"empty_trace",
|m: &NewProfileSessionResponse| { &m.empty_trace },
|m: &mut NewProfileSessionResponse| { &mut m.empty_trace },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<NewProfileSessionResponse>(
"NewProfileSessionResponse",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static NewProfileSessionResponse {
static instance: ::protobuf::rt::LazyV2<NewProfileSessionResponse> = ::protobuf::rt::LazyV2::INIT;
instance.get(NewProfileSessionResponse::new)
}
}
impl ::protobuf::Clear for NewProfileSessionResponse {
fn clear(&mut self) {
self.error_message.clear();
self.empty_trace = false;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for NewProfileSessionResponse {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for NewProfileSessionResponse {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct EnumProfileSessionsAndToolsRequest {
pub repository_root: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a EnumProfileSessionsAndToolsRequest {
fn default() -> &'a EnumProfileSessionsAndToolsRequest {
<EnumProfileSessionsAndToolsRequest as ::protobuf::Message>::default_instance()
}
}
impl EnumProfileSessionsAndToolsRequest {
pub fn new() -> EnumProfileSessionsAndToolsRequest {
::std::default::Default::default()
}
pub fn get_repository_root(&self) -> &str {
&self.repository_root
}
pub fn clear_repository_root(&mut self) {
self.repository_root.clear();
}
pub fn set_repository_root(&mut self, v: ::std::string::String) {
self.repository_root = v;
}
pub fn mut_repository_root(&mut self) -> &mut ::std::string::String {
&mut self.repository_root
}
pub fn take_repository_root(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.repository_root, ::std::string::String::new())
}
}
impl ::protobuf::Message for EnumProfileSessionsAndToolsRequest {
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.repository_root)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.repository_root.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.repository_root);
}
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.repository_root.is_empty() {
os.write_string(1, &self.repository_root)?;
}
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() -> EnumProfileSessionsAndToolsRequest {
EnumProfileSessionsAndToolsRequest::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>(
"repository_root",
|m: &EnumProfileSessionsAndToolsRequest| { &m.repository_root },
|m: &mut EnumProfileSessionsAndToolsRequest| { &mut m.repository_root },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<EnumProfileSessionsAndToolsRequest>(
"EnumProfileSessionsAndToolsRequest",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static EnumProfileSessionsAndToolsRequest {
static instance: ::protobuf::rt::LazyV2<EnumProfileSessionsAndToolsRequest> = ::protobuf::rt::LazyV2::INIT;
instance.get(EnumProfileSessionsAndToolsRequest::new)
}
}
impl ::protobuf::Clear for EnumProfileSessionsAndToolsRequest {
fn clear(&mut self) {
self.repository_root.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for EnumProfileSessionsAndToolsRequest {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for EnumProfileSessionsAndToolsRequest {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ProfileSessionInfo {
pub session_id: ::std::string::String,
pub available_tools: ::protobuf::RepeatedField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ProfileSessionInfo {
fn default() -> &'a ProfileSessionInfo {
<ProfileSessionInfo as ::protobuf::Message>::default_instance()
}
}
impl ProfileSessionInfo {
pub fn new() -> ProfileSessionInfo {
::std::default::Default::default()
}
pub fn get_session_id(&self) -> &str {
&self.session_id
}
pub fn clear_session_id(&mut self) {
self.session_id.clear();
}
pub fn set_session_id(&mut self, v: ::std::string::String) {
self.session_id = v;
}
pub fn mut_session_id(&mut self) -> &mut ::std::string::String {
&mut self.session_id
}
pub fn take_session_id(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.session_id, ::std::string::String::new())
}
pub fn get_available_tools(&self) -> &[::std::string::String] {
&self.available_tools
}
pub fn clear_available_tools(&mut self) {
self.available_tools.clear();
}
pub fn set_available_tools(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
self.available_tools = v;
}
pub fn mut_available_tools(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
&mut self.available_tools
}
pub fn take_available_tools(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
::std::mem::replace(&mut self.available_tools, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for ProfileSessionInfo {
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.session_id)?;
},
2 => {
::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.available_tools)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.session_id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.session_id);
}
for value in &self.available_tools {
my_size += ::protobuf::rt::string_size(2, &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.session_id.is_empty() {
os.write_string(1, &self.session_id)?;
}
for v in &self.available_tools {
os.write_string(2, &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() -> ProfileSessionInfo {
ProfileSessionInfo::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>(
"session_id",
|m: &ProfileSessionInfo| { &m.session_id },
|m: &mut ProfileSessionInfo| { &mut m.session_id },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"available_tools",
|m: &ProfileSessionInfo| { &m.available_tools },
|m: &mut ProfileSessionInfo| { &mut m.available_tools },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<ProfileSessionInfo>(
"ProfileSessionInfo",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static ProfileSessionInfo {
static instance: ::protobuf::rt::LazyV2<ProfileSessionInfo> = ::protobuf::rt::LazyV2::INIT;
instance.get(ProfileSessionInfo::new)
}
}
impl ::protobuf::Clear for ProfileSessionInfo {
fn clear(&mut self) {
self.session_id.clear();
self.available_tools.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for ProfileSessionInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ProfileSessionInfo {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct EnumProfileSessionsAndToolsResponse {
pub error_message: ::std::string::String,
pub sessions: ::protobuf::RepeatedField<ProfileSessionInfo>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a EnumProfileSessionsAndToolsResponse {
fn default() -> &'a EnumProfileSessionsAndToolsResponse {
<EnumProfileSessionsAndToolsResponse as ::protobuf::Message>::default_instance()
}
}
impl EnumProfileSessionsAndToolsResponse {
pub fn new() -> EnumProfileSessionsAndToolsResponse {
::std::default::Default::default()
}
pub fn get_error_message(&self) -> &str {
&self.error_message
}
pub fn clear_error_message(&mut self) {
self.error_message.clear();
}
pub fn set_error_message(&mut self, v: ::std::string::String) {
self.error_message = v;
}
pub fn mut_error_message(&mut self) -> &mut ::std::string::String {
&mut self.error_message
}
pub fn take_error_message(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.error_message, ::std::string::String::new())
}
pub fn get_sessions(&self) -> &[ProfileSessionInfo] {
&self.sessions
}
pub fn clear_sessions(&mut self) {
self.sessions.clear();
}
pub fn set_sessions(&mut self, v: ::protobuf::RepeatedField<ProfileSessionInfo>) {
self.sessions = v;
}
pub fn mut_sessions(&mut self) -> &mut ::protobuf::RepeatedField<ProfileSessionInfo> {
&mut self.sessions
}
pub fn take_sessions(&mut self) -> ::protobuf::RepeatedField<ProfileSessionInfo> {
::std::mem::replace(&mut self.sessions, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for EnumProfileSessionsAndToolsResponse {
fn is_initialized(&self) -> bool {
for v in &self.sessions {
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.error_message)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.sessions)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.error_message.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.error_message);
}
for value in &self.sessions {
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 !self.error_message.is_empty() {
os.write_string(1, &self.error_message)?;
}
for v in &self.sessions {
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() -> EnumProfileSessionsAndToolsResponse {
EnumProfileSessionsAndToolsResponse::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>(
"error_message",
|m: &EnumProfileSessionsAndToolsResponse| { &m.error_message },
|m: &mut EnumProfileSessionsAndToolsResponse| { &mut m.error_message },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ProfileSessionInfo>>(
"sessions",
|m: &EnumProfileSessionsAndToolsResponse| { &m.sessions },
|m: &mut EnumProfileSessionsAndToolsResponse| { &mut m.sessions },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<EnumProfileSessionsAndToolsResponse>(
"EnumProfileSessionsAndToolsResponse",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static EnumProfileSessionsAndToolsResponse {
static instance: ::protobuf::rt::LazyV2<EnumProfileSessionsAndToolsResponse> = ::protobuf::rt::LazyV2::INIT;
instance.get(EnumProfileSessionsAndToolsResponse::new)
}
}
impl ::protobuf::Clear for EnumProfileSessionsAndToolsResponse {
fn clear(&mut self) {
self.error_message.clear();
self.sessions.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for EnumProfileSessionsAndToolsResponse {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for EnumProfileSessionsAndToolsResponse {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ProfileSessionDataRequest {
pub repository_root: ::std::string::String,
pub session_id: ::std::string::String,
pub host_name: ::std::string::String,
pub tool_name: ::std::string::String,
pub parameters: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ProfileSessionDataRequest {
fn default() -> &'a ProfileSessionDataRequest {
<ProfileSessionDataRequest as ::protobuf::Message>::default_instance()
}
}
impl ProfileSessionDataRequest {
pub fn new() -> ProfileSessionDataRequest {
::std::default::Default::default()
}
pub fn get_repository_root(&self) -> &str {
&self.repository_root
}
pub fn clear_repository_root(&mut self) {
self.repository_root.clear();
}
pub fn set_repository_root(&mut self, v: ::std::string::String) {
self.repository_root = v;
}
pub fn mut_repository_root(&mut self) -> &mut ::std::string::String {
&mut self.repository_root
}
pub fn take_repository_root(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.repository_root, ::std::string::String::new())
}
pub fn get_session_id(&self) -> &str {
&self.session_id
}
pub fn clear_session_id(&mut self) {
self.session_id.clear();
}
pub fn set_session_id(&mut self, v: ::std::string::String) {
self.session_id = v;
}
pub fn mut_session_id(&mut self) -> &mut ::std::string::String {
&mut self.session_id
}
pub fn take_session_id(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.session_id, ::std::string::String::new())
}
pub fn get_host_name(&self) -> &str {
&self.host_name
}
pub fn clear_host_name(&mut self) {
self.host_name.clear();
}
pub fn set_host_name(&mut self, v: ::std::string::String) {
self.host_name = v;
}
pub fn mut_host_name(&mut self) -> &mut ::std::string::String {
&mut self.host_name
}
pub fn take_host_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.host_name, ::std::string::String::new())
}
pub fn get_tool_name(&self) -> &str {
&self.tool_name
}
pub fn clear_tool_name(&mut self) {
self.tool_name.clear();
}
pub fn set_tool_name(&mut self, v: ::std::string::String) {
self.tool_name = v;
}
pub fn mut_tool_name(&mut self) -> &mut ::std::string::String {
&mut self.tool_name
}
pub fn take_tool_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.tool_name, ::std::string::String::new())
}
pub fn get_parameters(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> {
&self.parameters
}
pub fn clear_parameters(&mut self) {
self.parameters.clear();
}
pub fn set_parameters(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::string::String>) {
self.parameters = v;
}
pub fn mut_parameters(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> {
&mut self.parameters
}
pub fn take_parameters(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> {
::std::mem::replace(&mut self.parameters, ::std::collections::HashMap::new())
}
}
impl ::protobuf::Message for ProfileSessionDataRequest {
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.repository_root)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.session_id)?;
},
5 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.host_name)?;
},
3 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.tool_name)?;
},
4 => {
::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.parameters)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.repository_root.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.repository_root);
}
if !self.session_id.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.session_id);
}
if !self.host_name.is_empty() {
my_size += ::protobuf::rt::string_size(5, &self.host_name);
}
if !self.tool_name.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.tool_name);
}
my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(4, &self.parameters);
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.repository_root.is_empty() {
os.write_string(1, &self.repository_root)?;
}
if !self.session_id.is_empty() {
os.write_string(2, &self.session_id)?;
}
if !self.host_name.is_empty() {
os.write_string(5, &self.host_name)?;
}
if !self.tool_name.is_empty() {
os.write_string(3, &self.tool_name)?;
}
::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(4, &self.parameters, 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() -> ProfileSessionDataRequest {
ProfileSessionDataRequest::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>(
"repository_root",
|m: &ProfileSessionDataRequest| { &m.repository_root },
|m: &mut ProfileSessionDataRequest| { &mut m.repository_root },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"session_id",
|m: &ProfileSessionDataRequest| { &m.session_id },
|m: &mut ProfileSessionDataRequest| { &mut m.session_id },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"host_name",
|m: &ProfileSessionDataRequest| { &m.host_name },
|m: &mut ProfileSessionDataRequest| { &mut m.host_name },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"tool_name",
|m: &ProfileSessionDataRequest| { &m.tool_name },
|m: &mut ProfileSessionDataRequest| { &mut m.tool_name },
));
fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(
"parameters",
|m: &ProfileSessionDataRequest| { &m.parameters },
|m: &mut ProfileSessionDataRequest| { &mut m.parameters },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<ProfileSessionDataRequest>(
"ProfileSessionDataRequest",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static ProfileSessionDataRequest {
static instance: ::protobuf::rt::LazyV2<ProfileSessionDataRequest> = ::protobuf::rt::LazyV2::INIT;
instance.get(ProfileSessionDataRequest::new)
}
}
impl ::protobuf::Clear for ProfileSessionDataRequest {
fn clear(&mut self) {
self.repository_root.clear();
self.session_id.clear();
self.host_name.clear();
self.tool_name.clear();
self.parameters.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for ProfileSessionDataRequest {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ProfileSessionDataRequest {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ProfileSessionDataResponse {
pub error_message: ::std::string::String,
pub output_format: ::std::string::String,
pub output: ::std::vec::Vec<u8>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ProfileSessionDataResponse {
fn default() -> &'a ProfileSessionDataResponse {
<ProfileSessionDataResponse as ::protobuf::Message>::default_instance()
}
}
impl ProfileSessionDataResponse {
pub fn new() -> ProfileSessionDataResponse {
::std::default::Default::default()
}
pub fn get_error_message(&self) -> &str {
&self.error_message
}
pub fn clear_error_message(&mut self) {
self.error_message.clear();
}
pub fn set_error_message(&mut self, v: ::std::string::String) {
self.error_message = v;
}
pub fn mut_error_message(&mut self) -> &mut ::std::string::String {
&mut self.error_message
}
pub fn take_error_message(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.error_message, ::std::string::String::new())
}
pub fn get_output_format(&self) -> &str {
&self.output_format
}
pub fn clear_output_format(&mut self) {
self.output_format.clear();
}
pub fn set_output_format(&mut self, v: ::std::string::String) {
self.output_format = v;
}
pub fn mut_output_format(&mut self) -> &mut ::std::string::String {
&mut self.output_format
}
pub fn take_output_format(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.output_format, ::std::string::String::new())
}
pub fn get_output(&self) -> &[u8] {
&self.output
}
pub fn clear_output(&mut self) {
self.output.clear();
}
pub fn set_output(&mut self, v: ::std::vec::Vec<u8>) {
self.output = v;
}
pub fn mut_output(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.output
}
pub fn take_output(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.output, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for ProfileSessionDataResponse {
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.error_message)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.output_format)?;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.output)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.error_message.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.error_message);
}
if !self.output_format.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.output_format);
}
if !self.output.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.output);
}
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.error_message.is_empty() {
os.write_string(1, &self.error_message)?;
}
if !self.output_format.is_empty() {
os.write_string(2, &self.output_format)?;
}
if !self.output.is_empty() {
os.write_bytes(3, &self.output)?;
}
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() -> ProfileSessionDataResponse {
ProfileSessionDataResponse::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>(
"error_message",
|m: &ProfileSessionDataResponse| { &m.error_message },
|m: &mut ProfileSessionDataResponse| { &mut m.error_message },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"output_format",
|m: &ProfileSessionDataResponse| { &m.output_format },
|m: &mut ProfileSessionDataResponse| { &mut m.output_format },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"output",
|m: &ProfileSessionDataResponse| { &m.output },
|m: &mut ProfileSessionDataResponse| { &mut m.output },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<ProfileSessionDataResponse>(
"ProfileSessionDataResponse",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static ProfileSessionDataResponse {
static instance: ::protobuf::rt::LazyV2<ProfileSessionDataResponse> = ::protobuf::rt::LazyV2::INIT;
instance.get(ProfileSessionDataResponse::new)
}
}
impl ::protobuf::Clear for ProfileSessionDataResponse {
fn clear(&mut self) {
self.error_message.clear();
self.output_format.clear();
self.output.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for ProfileSessionDataResponse {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ProfileSessionDataResponse {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n0tensorflow/core/profiler/profiler_analysis.proto\x12\ntensorflow\x1a/\
tensorflow/core/profiler/profiler_service.proto\"\xae\x01\n\x18NewProfil\
eSessionRequest\x124\n\x07request\x18\x01\x20\x01(\x0b2\x1a.tensorflow.P\
rofileRequestR\x07request\x12'\n\x0frepository_root\x18\x02\x20\x01(\tR\
\x0erepositoryRoot\x12\x14\n\x05hosts\x18\x03\x20\x03(\tR\x05hosts\x12\
\x1d\n\nsession_id\x18\x04\x20\x01(\tR\tsessionId\"a\n\x19NewProfileSess\
ionResponse\x12#\n\rerror_message\x18\x01\x20\x01(\tR\x0cerrorMessage\
\x12\x1f\n\x0bempty_trace\x18\x02\x20\x01(\x08R\nemptyTrace\"M\n\"EnumPr\
ofileSessionsAndToolsRequest\x12'\n\x0frepository_root\x18\x01\x20\x01(\
\tR\x0erepositoryRoot\"\\\n\x12ProfileSessionInfo\x12\x1d\n\nsession_id\
\x18\x01\x20\x01(\tR\tsessionId\x12'\n\x0favailable_tools\x18\x02\x20\
\x03(\tR\x0eavailableTools\"\x86\x01\n#EnumProfileSessionsAndToolsRespon\
se\x12#\n\rerror_message\x18\x01\x20\x01(\tR\x0cerrorMessage\x12:\n\x08s\
essions\x18\x02\x20\x03(\x0b2\x1e.tensorflow.ProfileSessionInfoR\x08sess\
ions\"\xb3\x02\n\x19ProfileSessionDataRequest\x12'\n\x0frepository_root\
\x18\x01\x20\x01(\tR\x0erepositoryRoot\x12\x1d\n\nsession_id\x18\x02\x20\
\x01(\tR\tsessionId\x12\x1b\n\thost_name\x18\x05\x20\x01(\tR\x08hostName\
\x12\x1b\n\ttool_name\x18\x03\x20\x01(\tR\x08toolName\x12U\n\nparameters\
\x18\x04\x20\x03(\x0b25.tensorflow.ProfileSessionDataRequest.ParametersE\
ntryR\nparameters\x1a=\n\x0fParametersEntry\x12\x10\n\x03key\x18\x01\x20\
\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05value:\x028\
\x01\"~\n\x1aProfileSessionDataResponse\x12#\n\rerror_message\x18\x01\
\x20\x01(\tR\x0cerrorMessage\x12#\n\routput_format\x18\x02\x20\x01(\tR\
\x0coutputFormat\x12\x16\n\x06output\x18\x03\x20\x01(\x0cR\x06output2\
\xc8\x02\n\x0fProfileAnalysis\x12[\n\nNewSession\x12$.tensorflow.NewProf\
ileSessionRequest\x1a%.tensorflow.NewProfileSessionResponse\"\0\x12q\n\
\x0cEnumSessions\x12..tensorflow.EnumProfileSessionsAndToolsRequest\x1a/\
.tensorflow.EnumProfileSessionsAndToolsResponse\"\0\x12e\n\x12GetSession\
ToolData\x12%.tensorflow.ProfileSessionDataRequest\x1a&.tensorflow.Profi\
leSessionDataResponse\"\0b\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()
})
}