#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_results)]
#![allow(unused_mut)]
const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_2_0;
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PipelineStep {
pub id: ::std::string::String,
pub name: ::std::string::String,
pub wasm_id: ::std::string::String,
pub wasm_bytes: ::std::string::String,
pub wasm_function: ::std::string::String,
pub step: ::std::option::Option<pipeline_step::Step>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a PipelineStep {
fn default() -> &'a PipelineStep {
<PipelineStep as ::protobuf::Message>::default_instance()
}
}
impl PipelineStep {
pub fn new() -> PipelineStep {
::std::default::Default::default()
}
pub fn detective(&self) -> &super::detective::DetectiveStep {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Detective(ref v)) => v,
_ => <super::detective::DetectiveStep as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_detective(&mut self) {
self.step = ::std::option::Option::None;
}
pub fn has_detective(&self) -> bool {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Detective(..)) => true,
_ => false,
}
}
pub fn set_detective(&mut self, v: super::detective::DetectiveStep) {
self.step = ::std::option::Option::Some(pipeline_step::Step::Detective(v))
}
pub fn mut_detective(&mut self) -> &mut super::detective::DetectiveStep {
if let ::std::option::Option::Some(pipeline_step::Step::Detective(_)) = self.step {
} else {
self.step = ::std::option::Option::Some(pipeline_step::Step::Detective(super::detective::DetectiveStep::new()));
}
match self.step {
::std::option::Option::Some(pipeline_step::Step::Detective(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_detective(&mut self) -> super::detective::DetectiveStep {
if self.has_detective() {
match self.step.take() {
::std::option::Option::Some(pipeline_step::Step::Detective(v)) => v,
_ => panic!(),
}
} else {
super::detective::DetectiveStep::new()
}
}
pub fn transform(&self) -> &super::transform::TransformStep {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Transform(ref v)) => v,
_ => <super::transform::TransformStep as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_transform(&mut self) {
self.step = ::std::option::Option::None;
}
pub fn has_transform(&self) -> bool {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Transform(..)) => true,
_ => false,
}
}
pub fn set_transform(&mut self, v: super::transform::TransformStep) {
self.step = ::std::option::Option::Some(pipeline_step::Step::Transform(v))
}
pub fn mut_transform(&mut self) -> &mut super::transform::TransformStep {
if let ::std::option::Option::Some(pipeline_step::Step::Transform(_)) = self.step {
} else {
self.step = ::std::option::Option::Some(pipeline_step::Step::Transform(super::transform::TransformStep::new()));
}
match self.step {
::std::option::Option::Some(pipeline_step::Step::Transform(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_transform(&mut self) -> super::transform::TransformStep {
if self.has_transform() {
match self.step.take() {
::std::option::Option::Some(pipeline_step::Step::Transform(v)) => v,
_ => panic!(),
}
} else {
super::transform::TransformStep::new()
}
}
pub fn encode(&self) -> &super::encode::EncodeStep {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Encode(ref v)) => v,
_ => <super::encode::EncodeStep as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_encode(&mut self) {
self.step = ::std::option::Option::None;
}
pub fn has_encode(&self) -> bool {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Encode(..)) => true,
_ => false,
}
}
pub fn set_encode(&mut self, v: super::encode::EncodeStep) {
self.step = ::std::option::Option::Some(pipeline_step::Step::Encode(v))
}
pub fn mut_encode(&mut self) -> &mut super::encode::EncodeStep {
if let ::std::option::Option::Some(pipeline_step::Step::Encode(_)) = self.step {
} else {
self.step = ::std::option::Option::Some(pipeline_step::Step::Encode(super::encode::EncodeStep::new()));
}
match self.step {
::std::option::Option::Some(pipeline_step::Step::Encode(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_encode(&mut self) -> super::encode::EncodeStep {
if self.has_encode() {
match self.step.take() {
::std::option::Option::Some(pipeline_step::Step::Encode(v)) => v,
_ => panic!(),
}
} else {
super::encode::EncodeStep::new()
}
}
pub fn decode(&self) -> &super::decode::DecodeStep {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Decode(ref v)) => v,
_ => <super::decode::DecodeStep as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_decode(&mut self) {
self.step = ::std::option::Option::None;
}
pub fn has_decode(&self) -> bool {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Decode(..)) => true,
_ => false,
}
}
pub fn set_decode(&mut self, v: super::decode::DecodeStep) {
self.step = ::std::option::Option::Some(pipeline_step::Step::Decode(v))
}
pub fn mut_decode(&mut self) -> &mut super::decode::DecodeStep {
if let ::std::option::Option::Some(pipeline_step::Step::Decode(_)) = self.step {
} else {
self.step = ::std::option::Option::Some(pipeline_step::Step::Decode(super::decode::DecodeStep::new()));
}
match self.step {
::std::option::Option::Some(pipeline_step::Step::Decode(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_decode(&mut self) -> super::decode::DecodeStep {
if self.has_decode() {
match self.step.take() {
::std::option::Option::Some(pipeline_step::Step::Decode(v)) => v,
_ => panic!(),
}
} else {
super::decode::DecodeStep::new()
}
}
pub fn custom(&self) -> &super::custom::CustomStep {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Custom(ref v)) => v,
_ => <super::custom::CustomStep as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_custom(&mut self) {
self.step = ::std::option::Option::None;
}
pub fn has_custom(&self) -> bool {
match self.step {
::std::option::Option::Some(pipeline_step::Step::Custom(..)) => true,
_ => false,
}
}
pub fn set_custom(&mut self, v: super::custom::CustomStep) {
self.step = ::std::option::Option::Some(pipeline_step::Step::Custom(v))
}
pub fn mut_custom(&mut self) -> &mut super::custom::CustomStep {
if let ::std::option::Option::Some(pipeline_step::Step::Custom(_)) = self.step {
} else {
self.step = ::std::option::Option::Some(pipeline_step::Step::Custom(super::custom::CustomStep::new()));
}
match self.step {
::std::option::Option::Some(pipeline_step::Step::Custom(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_custom(&mut self) -> super::custom::CustomStep {
if self.has_custom() {
match self.step.take() {
::std::option::Option::Some(pipeline_step::Step::Custom(v)) => v,
_ => panic!(),
}
} else {
super::custom::CustomStep::new()
}
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(10);
let mut oneofs = ::std::vec::Vec::with_capacity(1);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"id",
|m: &PipelineStep| { &m.id },
|m: &mut PipelineStep| { &mut m.id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"name",
|m: &PipelineStep| { &m.name },
|m: &mut PipelineStep| { &mut m.name },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"wasm_id",
|m: &PipelineStep| { &m.wasm_id },
|m: &mut PipelineStep| { &mut m.wasm_id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"wasm_bytes",
|m: &PipelineStep| { &m.wasm_bytes },
|m: &mut PipelineStep| { &mut m.wasm_bytes },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"wasm_function",
|m: &PipelineStep| { &m.wasm_function },
|m: &mut PipelineStep| { &mut m.wasm_function },
));
fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, super::detective::DetectiveStep>(
"detective",
PipelineStep::has_detective,
PipelineStep::detective,
PipelineStep::mut_detective,
PipelineStep::set_detective,
));
fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, super::transform::TransformStep>(
"transform",
PipelineStep::has_transform,
PipelineStep::transform,
PipelineStep::mut_transform,
PipelineStep::set_transform,
));
fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, super::encode::EncodeStep>(
"encode",
PipelineStep::has_encode,
PipelineStep::encode,
PipelineStep::mut_encode,
PipelineStep::set_encode,
));
fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, super::decode::DecodeStep>(
"decode",
PipelineStep::has_decode,
PipelineStep::decode,
PipelineStep::mut_decode,
PipelineStep::set_decode,
));
fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, super::custom::CustomStep>(
"custom",
PipelineStep::has_custom,
PipelineStep::custom,
PipelineStep::mut_custom,
PipelineStep::set_custom,
));
oneofs.push(pipeline_step::Step::generated_oneof_descriptor_data());
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PipelineStep>(
"PipelineStep",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for PipelineStep {
const NAME: &'static str = "PipelineStep";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.id = is.read_string()?;
},
18 => {
self.name = is.read_string()?;
},
26 => {
self.wasm_id = is.read_string()?;
},
34 => {
self.wasm_bytes = is.read_string()?;
},
42 => {
self.wasm_function = is.read_string()?;
},
8002 => {
self.step = ::std::option::Option::Some(pipeline_step::Step::Detective(is.read_message()?));
},
8010 => {
self.step = ::std::option::Option::Some(pipeline_step::Step::Transform(is.read_message()?));
},
8018 => {
self.step = ::std::option::Option::Some(pipeline_step::Step::Encode(is.read_message()?));
},
8026 => {
self.step = ::std::option::Option::Some(pipeline_step::Step::Decode(is.read_message()?));
},
8034 => {
self.step = ::std::option::Option::Some(pipeline_step::Step::Custom(is.read_message()?));
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.id);
}
if !self.name.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.name);
}
if !self.wasm_id.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.wasm_id);
}
if !self.wasm_bytes.is_empty() {
my_size += ::protobuf::rt::string_size(4, &self.wasm_bytes);
}
if !self.wasm_function.is_empty() {
my_size += ::protobuf::rt::string_size(5, &self.wasm_function);
}
if let ::std::option::Option::Some(ref v) = self.step {
match v {
&pipeline_step::Step::Detective(ref v) => {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
},
&pipeline_step::Step::Transform(ref v) => {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
},
&pipeline_step::Step::Encode(ref v) => {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
},
&pipeline_step::Step::Decode(ref v) => {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
},
&pipeline_step::Step::Custom(ref v) => {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
},
};
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.id.is_empty() {
os.write_string(1, &self.id)?;
}
if !self.name.is_empty() {
os.write_string(2, &self.name)?;
}
if !self.wasm_id.is_empty() {
os.write_string(3, &self.wasm_id)?;
}
if !self.wasm_bytes.is_empty() {
os.write_string(4, &self.wasm_bytes)?;
}
if !self.wasm_function.is_empty() {
os.write_string(5, &self.wasm_function)?;
}
if let ::std::option::Option::Some(ref v) = self.step {
match v {
&pipeline_step::Step::Detective(ref v) => {
::protobuf::rt::write_message_field_with_cached_size(1000, v, os)?;
},
&pipeline_step::Step::Transform(ref v) => {
::protobuf::rt::write_message_field_with_cached_size(1001, v, os)?;
},
&pipeline_step::Step::Encode(ref v) => {
::protobuf::rt::write_message_field_with_cached_size(1002, v, os)?;
},
&pipeline_step::Step::Decode(ref v) => {
::protobuf::rt::write_message_field_with_cached_size(1003, v, os)?;
},
&pipeline_step::Step::Custom(ref v) => {
::protobuf::rt::write_message_field_with_cached_size(1004, v, os)?;
},
};
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> PipelineStep {
PipelineStep::new()
}
fn clear(&mut self) {
self.id.clear();
self.name.clear();
self.wasm_id.clear();
self.wasm_bytes.clear();
self.wasm_function.clear();
self.step = ::std::option::Option::None;
self.step = ::std::option::Option::None;
self.step = ::std::option::Option::None;
self.step = ::std::option::Option::None;
self.step = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static PipelineStep {
static instance: PipelineStep = PipelineStep {
id: ::std::string::String::new(),
name: ::std::string::String::new(),
wasm_id: ::std::string::String::new(),
wasm_bytes: ::std::string::String::new(),
wasm_function: ::std::string::String::new(),
step: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for PipelineStep {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("PipelineStep").unwrap()).clone()
}
}
impl ::std::fmt::Display for PipelineStep {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for PipelineStep {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
pub mod pipeline_step {
#[derive(Clone,PartialEq,Debug)]
#[non_exhaustive]
pub enum Step {
Detective(super::super::detective::DetectiveStep),
Transform(super::super::transform::TransformStep),
Encode(super::super::encode::EncodeStep),
Decode(super::super::decode::DecodeStep),
Custom(super::super::custom::CustomStep),
}
impl ::protobuf::Oneof for Step {
}
impl ::protobuf::OneofFull for Step {
fn descriptor() -> ::protobuf::reflect::OneofDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::OneofDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| <super::PipelineStep as ::protobuf::MessageFull>::descriptor().oneof_by_name("step").unwrap()).clone()
}
}
impl Step {
pub(in super) fn generated_oneof_descriptor_data() -> ::protobuf::reflect::GeneratedOneofDescriptorData {
::protobuf::reflect::GeneratedOneofDescriptorData::new::<Step>("step")
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PipelineStepResponse {
pub output: ::std::vec::Vec<u8>,
pub status: ::protobuf::EnumOrUnknown<PipelineStepStatus>,
pub status_message: ::std::string::String,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a PipelineStepResponse {
fn default() -> &'a PipelineStepResponse {
<PipelineStepResponse as ::protobuf::Message>::default_instance()
}
}
impl PipelineStepResponse {
pub fn new() -> PipelineStepResponse {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(3);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"output",
|m: &PipelineStepResponse| { &m.output },
|m: &mut PipelineStepResponse| { &mut m.output },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"status",
|m: &PipelineStepResponse| { &m.status },
|m: &mut PipelineStepResponse| { &mut m.status },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"status_message",
|m: &PipelineStepResponse| { &m.status_message },
|m: &mut PipelineStepResponse| { &mut m.status_message },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PipelineStepResponse>(
"PipelineStepResponse",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for PipelineStepResponse {
const NAME: &'static str = "PipelineStepResponse";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.output = is.read_bytes()?;
},
16 => {
self.status = is.read_enum_or_unknown()?;
},
26 => {
self.status_message = is.read_string()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.output.is_empty() {
my_size += ::protobuf::rt::bytes_size(1, &self.output);
}
if self.status != ::protobuf::EnumOrUnknown::new(PipelineStepStatus::PIPELINE_STEP_STATUS_UNSET) {
my_size += ::protobuf::rt::int32_size(2, self.status.value());
}
if !self.status_message.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.status_message);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.output.is_empty() {
os.write_bytes(1, &self.output)?;
}
if self.status != ::protobuf::EnumOrUnknown::new(PipelineStepStatus::PIPELINE_STEP_STATUS_UNSET) {
os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.status))?;
}
if !self.status_message.is_empty() {
os.write_string(3, &self.status_message)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> PipelineStepResponse {
PipelineStepResponse::new()
}
fn clear(&mut self) {
self.output.clear();
self.status = ::protobuf::EnumOrUnknown::new(PipelineStepStatus::PIPELINE_STEP_STATUS_UNSET);
self.status_message.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static PipelineStepResponse {
static instance: PipelineStepResponse = PipelineStepResponse {
output: ::std::vec::Vec::new(),
status: ::protobuf::EnumOrUnknown::from_i32(0),
status_message: ::std::string::String::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for PipelineStepResponse {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("PipelineStepResponse").unwrap()).clone()
}
}
impl ::std::fmt::Display for PipelineStepResponse {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for PipelineStepResponse {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GetPipelineRequest {
pub id: ::std::string::String,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a GetPipelineRequest {
fn default() -> &'a GetPipelineRequest {
<GetPipelineRequest as ::protobuf::Message>::default_instance()
}
}
impl GetPipelineRequest {
pub fn new() -> GetPipelineRequest {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(1);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"id",
|m: &GetPipelineRequest| { &m.id },
|m: &mut GetPipelineRequest| { &mut m.id },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetPipelineRequest>(
"GetPipelineRequest",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for GetPipelineRequest {
const NAME: &'static str = "GetPipelineRequest";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.id = is.read_string()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.id);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.id.is_empty() {
os.write_string(1, &self.id)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> GetPipelineRequest {
GetPipelineRequest::new()
}
fn clear(&mut self) {
self.id.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static GetPipelineRequest {
static instance: GetPipelineRequest = GetPipelineRequest {
id: ::std::string::String::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for GetPipelineRequest {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("GetPipelineRequest").unwrap()).clone()
}
}
impl ::std::fmt::Display for GetPipelineRequest {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for GetPipelineRequest {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GetPipelineResponse {
pub pipeline: ::protobuf::MessageField<SetPipelineRequest>,
pub status: ::protobuf::EnumOrUnknown<super::common::ResponseStatus>,
pub message: ::std::string::String,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a GetPipelineResponse {
fn default() -> &'a GetPipelineResponse {
<GetPipelineResponse as ::protobuf::Message>::default_instance()
}
}
impl GetPipelineResponse {
pub fn new() -> GetPipelineResponse {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(3);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, SetPipelineRequest>(
"pipeline",
|m: &GetPipelineResponse| { &m.pipeline },
|m: &mut GetPipelineResponse| { &mut m.pipeline },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"status",
|m: &GetPipelineResponse| { &m.status },
|m: &mut GetPipelineResponse| { &mut m.status },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"message",
|m: &GetPipelineResponse| { &m.message },
|m: &mut GetPipelineResponse| { &mut m.message },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetPipelineResponse>(
"GetPipelineResponse",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for GetPipelineResponse {
const NAME: &'static str = "GetPipelineResponse";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
::protobuf::rt::read_singular_message_into_field(is, &mut self.pipeline)?;
},
16 => {
self.status = is.read_enum_or_unknown()?;
},
26 => {
self.message = is.read_string()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.pipeline.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
}
if self.status != ::protobuf::EnumOrUnknown::new(super::common::ResponseStatus::RESPONSE_STATUS_UNSET) {
my_size += ::protobuf::rt::int32_size(2, self.status.value());
}
if !self.message.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.message);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.pipeline.as_ref() {
::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
}
if self.status != ::protobuf::EnumOrUnknown::new(super::common::ResponseStatus::RESPONSE_STATUS_UNSET) {
os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.status))?;
}
if !self.message.is_empty() {
os.write_string(3, &self.message)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> GetPipelineResponse {
GetPipelineResponse::new()
}
fn clear(&mut self) {
self.pipeline.clear();
self.status = ::protobuf::EnumOrUnknown::new(super::common::ResponseStatus::RESPONSE_STATUS_UNSET);
self.message.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static GetPipelineResponse {
static instance: GetPipelineResponse = GetPipelineResponse {
pipeline: ::protobuf::MessageField::none(),
status: ::protobuf::EnumOrUnknown::from_i32(0),
message: ::std::string::String::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for GetPipelineResponse {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("GetPipelineResponse").unwrap()).clone()
}
}
impl ::std::fmt::Display for GetPipelineResponse {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for GetPipelineResponse {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GetAllPipelinesRequest {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a GetAllPipelinesRequest {
fn default() -> &'a GetAllPipelinesRequest {
<GetAllPipelinesRequest as ::protobuf::Message>::default_instance()
}
}
impl GetAllPipelinesRequest {
pub fn new() -> GetAllPipelinesRequest {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(0);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetAllPipelinesRequest>(
"GetAllPipelinesRequest",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for GetAllPipelinesRequest {
const NAME: &'static str = "GetAllPipelinesRequest";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> GetAllPipelinesRequest {
GetAllPipelinesRequest::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static GetAllPipelinesRequest {
static instance: GetAllPipelinesRequest = GetAllPipelinesRequest {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for GetAllPipelinesRequest {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("GetAllPipelinesRequest").unwrap()).clone()
}
}
impl ::std::fmt::Display for GetAllPipelinesRequest {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for GetAllPipelinesRequest {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GetAllPipelinesResponse {
pub pipelines: ::std::vec::Vec<SetPipelineRequest>,
pub status: ::protobuf::EnumOrUnknown<super::common::ResponseStatus>,
pub message: ::std::string::String,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a GetAllPipelinesResponse {
fn default() -> &'a GetAllPipelinesResponse {
<GetAllPipelinesResponse as ::protobuf::Message>::default_instance()
}
}
impl GetAllPipelinesResponse {
pub fn new() -> GetAllPipelinesResponse {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(3);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"pipelines",
|m: &GetAllPipelinesResponse| { &m.pipelines },
|m: &mut GetAllPipelinesResponse| { &mut m.pipelines },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"status",
|m: &GetAllPipelinesResponse| { &m.status },
|m: &mut GetAllPipelinesResponse| { &mut m.status },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"message",
|m: &GetAllPipelinesResponse| { &m.message },
|m: &mut GetAllPipelinesResponse| { &mut m.message },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetAllPipelinesResponse>(
"GetAllPipelinesResponse",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for GetAllPipelinesResponse {
const NAME: &'static str = "GetAllPipelinesResponse";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.pipelines.push(is.read_message()?);
},
16 => {
self.status = is.read_enum_or_unknown()?;
},
26 => {
self.message = is.read_string()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
for value in &self.pipelines {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
if self.status != ::protobuf::EnumOrUnknown::new(super::common::ResponseStatus::RESPONSE_STATUS_UNSET) {
my_size += ::protobuf::rt::int32_size(2, self.status.value());
}
if !self.message.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.message);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
for v in &self.pipelines {
::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
};
if self.status != ::protobuf::EnumOrUnknown::new(super::common::ResponseStatus::RESPONSE_STATUS_UNSET) {
os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.status))?;
}
if !self.message.is_empty() {
os.write_string(3, &self.message)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> GetAllPipelinesResponse {
GetAllPipelinesResponse::new()
}
fn clear(&mut self) {
self.pipelines.clear();
self.status = ::protobuf::EnumOrUnknown::new(super::common::ResponseStatus::RESPONSE_STATUS_UNSET);
self.message.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static GetAllPipelinesResponse {
static instance: GetAllPipelinesResponse = GetAllPipelinesResponse {
pipelines: ::std::vec::Vec::new(),
status: ::protobuf::EnumOrUnknown::from_i32(0),
message: ::std::string::String::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for GetAllPipelinesResponse {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("GetAllPipelinesResponse").unwrap()).clone()
}
}
impl ::std::fmt::Display for GetAllPipelinesResponse {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for GetAllPipelinesResponse {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct SetPipelineRequest {
pub id: ::std::string::String,
pub name: ::std::string::String,
pub steps: ::std::vec::Vec<PipelineStep>,
pub global_conditions: ::std::vec::Vec<::protobuf::EnumOrUnknown<super::common::Condition>>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a SetPipelineRequest {
fn default() -> &'a SetPipelineRequest {
<SetPipelineRequest as ::protobuf::Message>::default_instance()
}
}
impl SetPipelineRequest {
pub fn new() -> SetPipelineRequest {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(4);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"id",
|m: &SetPipelineRequest| { &m.id },
|m: &mut SetPipelineRequest| { &mut m.id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"name",
|m: &SetPipelineRequest| { &m.name },
|m: &mut SetPipelineRequest| { &mut m.name },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"steps",
|m: &SetPipelineRequest| { &m.steps },
|m: &mut SetPipelineRequest| { &mut m.steps },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"global_conditions",
|m: &SetPipelineRequest| { &m.global_conditions },
|m: &mut SetPipelineRequest| { &mut m.global_conditions },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetPipelineRequest>(
"SetPipelineRequest",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for SetPipelineRequest {
const NAME: &'static str = "SetPipelineRequest";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.id = is.read_string()?;
},
18 => {
self.name = is.read_string()?;
},
26 => {
self.steps.push(is.read_message()?);
},
32 => {
self.global_conditions.push(is.read_enum_or_unknown()?);
},
34 => {
::protobuf::rt::read_repeated_packed_enum_or_unknown_into(is, &mut self.global_conditions)?
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.id);
}
if !self.name.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.name);
}
for value in &self.steps {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
for value in &self.global_conditions {
my_size += ::protobuf::rt::int32_size(4, value.value());
};
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.id.is_empty() {
os.write_string(1, &self.id)?;
}
if !self.name.is_empty() {
os.write_string(2, &self.name)?;
}
for v in &self.steps {
::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
};
for v in &self.global_conditions {
os.write_enum(4, ::protobuf::EnumOrUnknown::value(v))?;
};
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> SetPipelineRequest {
SetPipelineRequest::new()
}
fn clear(&mut self) {
self.id.clear();
self.name.clear();
self.steps.clear();
self.global_conditions.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static SetPipelineRequest {
static instance: SetPipelineRequest = SetPipelineRequest {
id: ::std::string::String::new(),
name: ::std::string::String::new(),
steps: ::std::vec::Vec::new(),
global_conditions: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for SetPipelineRequest {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("SetPipelineRequest").unwrap()).clone()
}
}
impl ::std::fmt::Display for SetPipelineRequest {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SetPipelineRequest {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct SetPipelineResponse {
pub id: ::std::string::String,
pub status: ::protobuf::EnumOrUnknown<super::common::ResponseStatus>,
pub message: ::std::string::String,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a SetPipelineResponse {
fn default() -> &'a SetPipelineResponse {
<SetPipelineResponse as ::protobuf::Message>::default_instance()
}
}
impl SetPipelineResponse {
pub fn new() -> SetPipelineResponse {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(3);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"id",
|m: &SetPipelineResponse| { &m.id },
|m: &mut SetPipelineResponse| { &mut m.id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"status",
|m: &SetPipelineResponse| { &m.status },
|m: &mut SetPipelineResponse| { &mut m.status },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"message",
|m: &SetPipelineResponse| { &m.message },
|m: &mut SetPipelineResponse| { &mut m.message },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetPipelineResponse>(
"SetPipelineResponse",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for SetPipelineResponse {
const NAME: &'static str = "SetPipelineResponse";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.id = is.read_string()?;
},
16 => {
self.status = is.read_enum_or_unknown()?;
},
26 => {
self.message = is.read_string()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.id);
}
if self.status != ::protobuf::EnumOrUnknown::new(super::common::ResponseStatus::RESPONSE_STATUS_UNSET) {
my_size += ::protobuf::rt::int32_size(2, self.status.value());
}
if !self.message.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.message);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.id.is_empty() {
os.write_string(1, &self.id)?;
}
if self.status != ::protobuf::EnumOrUnknown::new(super::common::ResponseStatus::RESPONSE_STATUS_UNSET) {
os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.status))?;
}
if !self.message.is_empty() {
os.write_string(3, &self.message)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> SetPipelineResponse {
SetPipelineResponse::new()
}
fn clear(&mut self) {
self.id.clear();
self.status = ::protobuf::EnumOrUnknown::new(super::common::ResponseStatus::RESPONSE_STATUS_UNSET);
self.message.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static SetPipelineResponse {
static instance: SetPipelineResponse = SetPipelineResponse {
id: ::std::string::String::new(),
status: ::protobuf::EnumOrUnknown::from_i32(0),
message: ::std::string::String::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for SetPipelineResponse {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("SetPipelineResponse").unwrap()).clone()
}
}
impl ::std::fmt::Display for SetPipelineResponse {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SetPipelineResponse {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct DeletePipelineRequest {
pub id: ::std::string::String,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a DeletePipelineRequest {
fn default() -> &'a DeletePipelineRequest {
<DeletePipelineRequest as ::protobuf::Message>::default_instance()
}
}
impl DeletePipelineRequest {
pub fn new() -> DeletePipelineRequest {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(1);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"id",
|m: &DeletePipelineRequest| { &m.id },
|m: &mut DeletePipelineRequest| { &mut m.id },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<DeletePipelineRequest>(
"DeletePipelineRequest",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for DeletePipelineRequest {
const NAME: &'static str = "DeletePipelineRequest";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.id = is.read_string()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.id);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.id.is_empty() {
os.write_string(1, &self.id)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> DeletePipelineRequest {
DeletePipelineRequest::new()
}
fn clear(&mut self) {
self.id.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static DeletePipelineRequest {
static instance: DeletePipelineRequest = DeletePipelineRequest {
id: ::std::string::String::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for DeletePipelineRequest {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("DeletePipelineRequest").unwrap()).clone()
}
}
impl ::std::fmt::Display for DeletePipelineRequest {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for DeletePipelineRequest {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct DeletePipelineResponse {
pub id: ::std::string::String,
pub status: ::protobuf::EnumOrUnknown<super::common::ResponseStatus>,
pub message: ::std::string::String,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a DeletePipelineResponse {
fn default() -> &'a DeletePipelineResponse {
<DeletePipelineResponse as ::protobuf::Message>::default_instance()
}
}
impl DeletePipelineResponse {
pub fn new() -> DeletePipelineResponse {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(3);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"id",
|m: &DeletePipelineResponse| { &m.id },
|m: &mut DeletePipelineResponse| { &mut m.id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"status",
|m: &DeletePipelineResponse| { &m.status },
|m: &mut DeletePipelineResponse| { &mut m.status },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"message",
|m: &DeletePipelineResponse| { &m.message },
|m: &mut DeletePipelineResponse| { &mut m.message },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<DeletePipelineResponse>(
"DeletePipelineResponse",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for DeletePipelineResponse {
const NAME: &'static str = "DeletePipelineResponse";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.id = is.read_string()?;
},
16 => {
self.status = is.read_enum_or_unknown()?;
},
26 => {
self.message = is.read_string()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.id);
}
if self.status != ::protobuf::EnumOrUnknown::new(super::common::ResponseStatus::RESPONSE_STATUS_UNSET) {
my_size += ::protobuf::rt::int32_size(2, self.status.value());
}
if !self.message.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.message);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.id.is_empty() {
os.write_string(1, &self.id)?;
}
if self.status != ::protobuf::EnumOrUnknown::new(super::common::ResponseStatus::RESPONSE_STATUS_UNSET) {
os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.status))?;
}
if !self.message.is_empty() {
os.write_string(3, &self.message)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> DeletePipelineResponse {
DeletePipelineResponse::new()
}
fn clear(&mut self) {
self.id.clear();
self.status = ::protobuf::EnumOrUnknown::new(super::common::ResponseStatus::RESPONSE_STATUS_UNSET);
self.message.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static DeletePipelineResponse {
static instance: DeletePipelineResponse = DeletePipelineResponse {
id: ::std::string::String::new(),
status: ::protobuf::EnumOrUnknown::from_i32(0),
message: ::std::string::String::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for DeletePipelineResponse {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("DeletePipelineResponse").unwrap()).clone()
}
}
impl ::std::fmt::Display for DeletePipelineResponse {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for DeletePipelineResponse {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PausePipelineRequest {
pub id: ::std::string::String,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a PausePipelineRequest {
fn default() -> &'a PausePipelineRequest {
<PausePipelineRequest as ::protobuf::Message>::default_instance()
}
}
impl PausePipelineRequest {
pub fn new() -> PausePipelineRequest {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(1);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"id",
|m: &PausePipelineRequest| { &m.id },
|m: &mut PausePipelineRequest| { &mut m.id },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PausePipelineRequest>(
"PausePipelineRequest",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for PausePipelineRequest {
const NAME: &'static str = "PausePipelineRequest";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.id = is.read_string()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.id);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.id.is_empty() {
os.write_string(1, &self.id)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> PausePipelineRequest {
PausePipelineRequest::new()
}
fn clear(&mut self) {
self.id.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static PausePipelineRequest {
static instance: PausePipelineRequest = PausePipelineRequest {
id: ::std::string::String::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for PausePipelineRequest {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("PausePipelineRequest").unwrap()).clone()
}
}
impl ::std::fmt::Display for PausePipelineRequest {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for PausePipelineRequest {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PausePipelineResponse {
pub id: ::std::string::String,
pub status: ::protobuf::EnumOrUnknown<super::common::ResponseStatus>,
pub message: ::std::string::String,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a PausePipelineResponse {
fn default() -> &'a PausePipelineResponse {
<PausePipelineResponse as ::protobuf::Message>::default_instance()
}
}
impl PausePipelineResponse {
pub fn new() -> PausePipelineResponse {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(3);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"id",
|m: &PausePipelineResponse| { &m.id },
|m: &mut PausePipelineResponse| { &mut m.id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"status",
|m: &PausePipelineResponse| { &m.status },
|m: &mut PausePipelineResponse| { &mut m.status },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"message",
|m: &PausePipelineResponse| { &m.message },
|m: &mut PausePipelineResponse| { &mut m.message },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PausePipelineResponse>(
"PausePipelineResponse",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for PausePipelineResponse {
const NAME: &'static str = "PausePipelineResponse";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.id = is.read_string()?;
},
16 => {
self.status = is.read_enum_or_unknown()?;
},
26 => {
self.message = is.read_string()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.id);
}
if self.status != ::protobuf::EnumOrUnknown::new(super::common::ResponseStatus::RESPONSE_STATUS_UNSET) {
my_size += ::protobuf::rt::int32_size(2, self.status.value());
}
if !self.message.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.message);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.id.is_empty() {
os.write_string(1, &self.id)?;
}
if self.status != ::protobuf::EnumOrUnknown::new(super::common::ResponseStatus::RESPONSE_STATUS_UNSET) {
os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.status))?;
}
if !self.message.is_empty() {
os.write_string(3, &self.message)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> PausePipelineResponse {
PausePipelineResponse::new()
}
fn clear(&mut self) {
self.id.clear();
self.status = ::protobuf::EnumOrUnknown::new(super::common::ResponseStatus::RESPONSE_STATUS_UNSET);
self.message.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static PausePipelineResponse {
static instance: PausePipelineResponse = PausePipelineResponse {
id: ::std::string::String::new(),
status: ::protobuf::EnumOrUnknown::from_i32(0),
message: ::std::string::String::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for PausePipelineResponse {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("PausePipelineResponse").unwrap()).clone()
}
}
impl ::std::fmt::Display for PausePipelineResponse {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for PausePipelineResponse {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct UnpausePipelineRequest {
pub id: ::std::string::String,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a UnpausePipelineRequest {
fn default() -> &'a UnpausePipelineRequest {
<UnpausePipelineRequest as ::protobuf::Message>::default_instance()
}
}
impl UnpausePipelineRequest {
pub fn new() -> UnpausePipelineRequest {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(1);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"id",
|m: &UnpausePipelineRequest| { &m.id },
|m: &mut UnpausePipelineRequest| { &mut m.id },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UnpausePipelineRequest>(
"UnpausePipelineRequest",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for UnpausePipelineRequest {
const NAME: &'static str = "UnpausePipelineRequest";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.id = is.read_string()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.id);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.id.is_empty() {
os.write_string(1, &self.id)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> UnpausePipelineRequest {
UnpausePipelineRequest::new()
}
fn clear(&mut self) {
self.id.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static UnpausePipelineRequest {
static instance: UnpausePipelineRequest = UnpausePipelineRequest {
id: ::std::string::String::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for UnpausePipelineRequest {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("UnpausePipelineRequest").unwrap()).clone()
}
}
impl ::std::fmt::Display for UnpausePipelineRequest {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for UnpausePipelineRequest {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct UnpausePipelineResponse {
pub id: ::std::string::String,
pub status: ::protobuf::EnumOrUnknown<super::common::ResponseStatus>,
pub message: ::std::string::String,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a UnpausePipelineResponse {
fn default() -> &'a UnpausePipelineResponse {
<UnpausePipelineResponse as ::protobuf::Message>::default_instance()
}
}
impl UnpausePipelineResponse {
pub fn new() -> UnpausePipelineResponse {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(3);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"id",
|m: &UnpausePipelineResponse| { &m.id },
|m: &mut UnpausePipelineResponse| { &mut m.id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"status",
|m: &UnpausePipelineResponse| { &m.status },
|m: &mut UnpausePipelineResponse| { &mut m.status },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"message",
|m: &UnpausePipelineResponse| { &m.message },
|m: &mut UnpausePipelineResponse| { &mut m.message },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UnpausePipelineResponse>(
"UnpausePipelineResponse",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for UnpausePipelineResponse {
const NAME: &'static str = "UnpausePipelineResponse";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.id = is.read_string()?;
},
16 => {
self.status = is.read_enum_or_unknown()?;
},
26 => {
self.message = is.read_string()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.id);
}
if self.status != ::protobuf::EnumOrUnknown::new(super::common::ResponseStatus::RESPONSE_STATUS_UNSET) {
my_size += ::protobuf::rt::int32_size(2, self.status.value());
}
if !self.message.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.message);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.id.is_empty() {
os.write_string(1, &self.id)?;
}
if self.status != ::protobuf::EnumOrUnknown::new(super::common::ResponseStatus::RESPONSE_STATUS_UNSET) {
os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.status))?;
}
if !self.message.is_empty() {
os.write_string(3, &self.message)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> UnpausePipelineResponse {
UnpausePipelineResponse::new()
}
fn clear(&mut self) {
self.id.clear();
self.status = ::protobuf::EnumOrUnknown::new(super::common::ResponseStatus::RESPONSE_STATUS_UNSET);
self.message.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static UnpausePipelineResponse {
static instance: UnpausePipelineResponse = UnpausePipelineResponse {
id: ::std::string::String::new(),
status: ::protobuf::EnumOrUnknown::from_i32(0),
message: ::std::string::String::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for UnpausePipelineResponse {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("UnpausePipelineResponse").unwrap()).clone()
}
}
impl ::std::fmt::Display for UnpausePipelineResponse {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for UnpausePipelineResponse {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
pub enum PipelineStepStatus {
PIPELINE_STEP_STATUS_UNSET = 0,
PIPELINE_STEP_STATUS_SUCCESS = 1,
PIPELINE_STEP_STATUS_FAILURE = 2,
PIPELINE_STEP_STATUS_ERROR = 3,
}
impl ::protobuf::Enum for PipelineStepStatus {
const NAME: &'static str = "PipelineStepStatus";
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<PipelineStepStatus> {
match value {
0 => ::std::option::Option::Some(PipelineStepStatus::PIPELINE_STEP_STATUS_UNSET),
1 => ::std::option::Option::Some(PipelineStepStatus::PIPELINE_STEP_STATUS_SUCCESS),
2 => ::std::option::Option::Some(PipelineStepStatus::PIPELINE_STEP_STATUS_FAILURE),
3 => ::std::option::Option::Some(PipelineStepStatus::PIPELINE_STEP_STATUS_ERROR),
_ => ::std::option::Option::None
}
}
const VALUES: &'static [PipelineStepStatus] = &[
PipelineStepStatus::PIPELINE_STEP_STATUS_UNSET,
PipelineStepStatus::PIPELINE_STEP_STATUS_SUCCESS,
PipelineStepStatus::PIPELINE_STEP_STATUS_FAILURE,
PipelineStepStatus::PIPELINE_STEP_STATUS_ERROR,
];
}
impl ::protobuf::EnumFull for PipelineStepStatus {
fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().enum_by_package_relative_name("PipelineStepStatus").unwrap()).clone()
}
fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
let index = *self as usize;
Self::enum_descriptor().value_by_index(index)
}
}
impl ::std::default::Default for PipelineStepStatus {
fn default() -> Self {
PipelineStepStatus::PIPELINE_STEP_STATUS_UNSET
}
}
impl PipelineStepStatus {
fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
::protobuf::reflect::GeneratedEnumDescriptorData::new::<PipelineStepStatus>("PipelineStepStatus")
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x0epipeline.proto\x12\x06protos\x1a\x15steps/detective.proto\x1a\x15s\
teps/transform.proto\x1a\x12steps/encode.proto\x1a\x12steps/decode.proto\
\x1a\x12steps/custom.proto\x1a\x0ccommon.proto\"\xb2\x03\n\x0cPipelineSt\
ep\x12\x0e\n\x02id\x18\x01\x20\x01(\tR\x02id\x12\x12\n\x04name\x18\x02\
\x20\x01(\tR\x04name\x12\x17\n\x07wasm_id\x18\x03\x20\x01(\tR\x06wasmId\
\x12\x1d\n\nwasm_bytes\x18\x04\x20\x01(\tR\twasmBytes\x12#\n\rwasm_funct\
ion\x18\x05\x20\x01(\tR\x0cwasmFunction\x12<\n\tdetective\x18\xe8\x07\
\x20\x01(\x0b2\x1b.protos.steps.DetectiveStepH\0R\tdetective\x12<\n\ttra\
nsform\x18\xe9\x07\x20\x01(\x0b2\x1b.protos.steps.TransformStepH\0R\ttra\
nsform\x123\n\x06encode\x18\xea\x07\x20\x01(\x0b2\x18.protos.steps.Encod\
eStepH\0R\x06encode\x123\n\x06decode\x18\xeb\x07\x20\x01(\x0b2\x18.proto\
s.steps.DecodeStepH\0R\x06decode\x123\n\x06custom\x18\xec\x07\x20\x01(\
\x0b2\x18.protos.steps.CustomStepH\0R\x06customB\x06\n\x04step\"\x89\x01\
\n\x14PipelineStepResponse\x12\x16\n\x06output\x18\x01\x20\x01(\x0cR\x06\
output\x122\n\x06status\x18\x02\x20\x01(\x0e2\x1a.protos.PipelineStepSta\
tusR\x06status\x12%\n\x0estatus_message\x18\x03\x20\x01(\tR\rstatusMessa\
ge\"$\n\x12GetPipelineRequest\x12\x0e\n\x02id\x18\x01\x20\x01(\tR\x02id\
\"\x97\x01\n\x13GetPipelineResponse\x126\n\x08pipeline\x18\x01\x20\x01(\
\x0b2\x1a.protos.SetPipelineRequestR\x08pipeline\x12.\n\x06status\x18\
\x02\x20\x01(\x0e2\x16.protos.ResponseStatusR\x06status\x12\x18\n\x07mes\
sage\x18\x03\x20\x01(\tR\x07message\"\x18\n\x16GetAllPipelinesRequest\"\
\x9d\x01\n\x17GetAllPipelinesResponse\x128\n\tpipelines\x18\x01\x20\x03(\
\x0b2\x1a.protos.SetPipelineRequestR\tpipelines\x12.\n\x06status\x18\x02\
\x20\x01(\x0e2\x16.protos.ResponseStatusR\x06status\x12\x18\n\x07message\
\x18\x03\x20\x01(\tR\x07message\"\xa4\x01\n\x12SetPipelineRequest\x12\
\x0e\n\x02id\x18\x01\x20\x01(\tR\x02id\x12\x12\n\x04name\x18\x02\x20\x01\
(\tR\x04name\x12*\n\x05steps\x18\x03\x20\x03(\x0b2\x14.protos.PipelineSt\
epR\x05steps\x12>\n\x11global_conditions\x18\x04\x20\x03(\x0e2\x11.proto\
s.ConditionR\x10globalConditions\"o\n\x13SetPipelineResponse\x12\x0e\n\
\x02id\x18\x01\x20\x01(\tR\x02id\x12.\n\x06status\x18\x02\x20\x01(\x0e2\
\x16.protos.ResponseStatusR\x06status\x12\x18\n\x07message\x18\x03\x20\
\x01(\tR\x07message\"'\n\x15DeletePipelineRequest\x12\x0e\n\x02id\x18\
\x01\x20\x01(\tR\x02id\"r\n\x16DeletePipelineResponse\x12\x0e\n\x02id\
\x18\x01\x20\x01(\tR\x02id\x12.\n\x06status\x18\x02\x20\x01(\x0e2\x16.pr\
otos.ResponseStatusR\x06status\x12\x18\n\x07message\x18\x03\x20\x01(\tR\
\x07message\"&\n\x14PausePipelineRequest\x12\x0e\n\x02id\x18\x01\x20\x01\
(\tR\x02id\"q\n\x15PausePipelineResponse\x12\x0e\n\x02id\x18\x01\x20\x01\
(\tR\x02id\x12.\n\x06status\x18\x02\x20\x01(\x0e2\x16.protos.ResponseSta\
tusR\x06status\x12\x18\n\x07message\x18\x03\x20\x01(\tR\x07message\"(\n\
\x16UnpausePipelineRequest\x12\x0e\n\x02id\x18\x01\x20\x01(\tR\x02id\"s\
\n\x17UnpausePipelineResponse\x12\x0e\n\x02id\x18\x01\x20\x01(\tR\x02id\
\x12.\n\x06status\x18\x02\x20\x01(\x0e2\x16.protos.ResponseStatusR\x06st\
atus\x12\x18\n\x07message\x18\x03\x20\x01(\tR\x07message*\x98\x01\n\x12P\
ipelineStepStatus\x12\x1e\n\x1aPIPELINE_STEP_STATUS_UNSET\x10\0\x12\x20\
\n\x1cPIPELINE_STEP_STATUS_SUCCESS\x10\x01\x12\x20\n\x1cPIPELINE_STEP_ST\
ATUS_FAILURE\x10\x02\x12\x1e\n\x1aPIPELINE_STEP_STATUS_ERROR\x10\x03B4Z2\
github.com/streamdal/snitch-protos/build/go/protosJ\xaa\x1f\n\x07\x12\
\x05\0\0\x8d\x01\x01\n\x08\n\x01\x0c\x12\x03\0\0\x12\n\x08\n\x01\x02\x12\
\x03\x02\0\x0f\n\t\n\x02\x03\0\x12\x03\x04\0\x1f\n\t\n\x02\x03\x01\x12\
\x03\x05\0\x1f\n\t\n\x02\x03\x02\x12\x03\x06\0\x1c\n\t\n\x02\x03\x03\x12\
\x03\x07\0\x1c\n\t\n\x02\x03\x04\x12\x03\x08\0\x1c\n\t\n\x02\x03\x05\x12\
\x03\t\0\x16\n\x08\n\x01\x08\x12\x03\x0b\0I\n\t\n\x02\x08\x0b\x12\x03\
\x0b\0I\n\n\n\x02\x05\0\x12\x04\r\0\x12\x01\n\n\n\x03\x05\0\x01\x12\x03\
\r\x05\x17\n\x0b\n\x04\x05\0\x02\0\x12\x03\x0e\x02!\n\x0c\n\x05\x05\0\
\x02\0\x01\x12\x03\x0e\x02\x1c\n\x0c\n\x05\x05\0\x02\0\x02\x12\x03\x0e\
\x1f\x20\n\x0b\n\x04\x05\0\x02\x01\x12\x03\x0f\x02#\n\x0c\n\x05\x05\0\
\x02\x01\x01\x12\x03\x0f\x02\x1e\n\x0c\n\x05\x05\0\x02\x01\x02\x12\x03\
\x0f!\"\n\x0b\n\x04\x05\0\x02\x02\x12\x03\x10\x02#\n\x0c\n\x05\x05\0\x02\
\x02\x01\x12\x03\x10\x02\x1e\n\x0c\n\x05\x05\0\x02\x02\x02\x12\x03\x10!\
\"\n\x0b\n\x04\x05\0\x02\x03\x12\x03\x11\x02!\n\x0c\n\x05\x05\0\x02\x03\
\x01\x12\x03\x11\x02\x1c\n\x0c\n\x05\x05\0\x02\x03\x02\x12\x03\x11\x1f\
\x20\n\n\n\x02\x04\0\x12\x04\x14\0,\x01\n\n\n\x03\x04\0\x01\x12\x03\x14\
\x08\x14\n%\n\x04\x04\0\x02\0\x12\x03\x16\x02\x10\x1a\x18\x20Unique\x20I\
D\x20for\x20the\x20step\n\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x16\x02\
\x08\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x16\t\x0b\n\x0c\n\x05\x04\0\x02\
\0\x03\x12\x03\x16\x0e\x0f\n)\n\x04\x04\0\x02\x01\x12\x03\x19\x02\x12\
\x1a\x1c\x20Friendly\x20name\x20for\x20the\x20step\n\n\x0c\n\x05\x04\0\
\x02\x01\x05\x12\x03\x19\x02\x08\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03\
\x19\t\r\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03\x19\x10\x11\n\x1d\n\x04\
\x04\0\x02\x02\x12\x03\x1c\x02\x15\x1a\x10\x20WASM\x20module\x20ID\n\n\
\x0c\n\x05\x04\0\x02\x02\x05\x12\x03\x1c\x02\x08\n\x0c\n\x05\x04\0\x02\
\x02\x01\x12\x03\x1c\t\x10\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x03\x1c\x13\
\x14\n\x20\n\x04\x04\0\x02\x03\x12\x03\x1f\x02\x18\x1a\x13\x20WASM\x20mo\
dule\x20bytes\n\n\x0c\n\x05\x04\0\x02\x03\x05\x12\x03\x1f\x02\x08\n\x0c\
\n\x05\x04\0\x02\x03\x01\x12\x03\x1f\t\x13\n\x0c\n\x05\x04\0\x02\x03\x03\
\x12\x03\x1f\x16\x17\n,\n\x04\x04\0\x02\x04\x12\x03\"\x02\x1b\x1a\x1f\
\x20WASM\x20function\x20name\x20to\x20execute\n\n\x0c\n\x05\x04\0\x02\
\x04\x05\x12\x03\"\x02\x08\n\x0c\n\x05\x04\0\x02\x04\x01\x12\x03\"\t\x16\
\n\x0c\n\x05\x04\0\x02\x04\x03\x12\x03\"\x19\x1a\nE\n\x04\x04\0\x08\0\
\x12\x04%\x02+\x03\x1a7\x20All\x20steps\x20return\x20PipelineStepRespons\
e\x20upon\x20completion\n\n\x0c\n\x05\x04\0\x08\0\x01\x12\x03%\x08\x0c\n\
\x0b\n\x04\x04\0\x02\x05\x12\x03&\x04)\n\x0c\n\x05\x04\0\x02\x05\x06\x12\
\x03&\x04\x17\n\x0c\n\x05\x04\0\x02\x05\x01\x12\x03&\x18!\n\x0c\n\x05\
\x04\0\x02\x05\x03\x12\x03&$(\n\x0b\n\x04\x04\0\x02\x06\x12\x03'\x04)\n\
\x0c\n\x05\x04\0\x02\x06\x06\x12\x03'\x04\x17\n\x0c\n\x05\x04\0\x02\x06\
\x01\x12\x03'\x18!\n\x0c\n\x05\x04\0\x02\x06\x03\x12\x03'$(\n\x0b\n\x04\
\x04\0\x02\x07\x12\x03(\x04#\n\x0c\n\x05\x04\0\x02\x07\x06\x12\x03(\x04\
\x14\n\x0c\n\x05\x04\0\x02\x07\x01\x12\x03(\x15\x1b\n\x0c\n\x05\x04\0\
\x02\x07\x03\x12\x03(\x1e\"\n\x0b\n\x04\x04\0\x02\x08\x12\x03)\x04#\n\
\x0c\n\x05\x04\0\x02\x08\x06\x12\x03)\x04\x14\n\x0c\n\x05\x04\0\x02\x08\
\x01\x12\x03)\x15\x1b\n\x0c\n\x05\x04\0\x02\x08\x03\x12\x03)\x1e\"\n\x0b\
\n\x04\x04\0\x02\t\x12\x03*\x04#\n\x0c\n\x05\x04\0\x02\t\x06\x12\x03*\
\x04\x14\n\x0c\n\x05\x04\0\x02\t\x01\x12\x03*\x15\x1b\n\x0c\n\x05\x04\0\
\x02\t\x03\x12\x03*\x1e\"\n\x87\x01\n\x02\x04\x01\x12\x040\04\x01\x1a{\
\x20All\x20WASM\x20funcs\x20return\x20this\x20upon\x20completion.\x20All\
\x20WASM\x20funcs\x20MUST\x20include\x20`output`\n\x20(even\x20if\x20the\
y\x20do\x20not\x20modify\x20the\x20input).\n\n\n\n\x03\x04\x01\x01\x12\
\x030\x08\x1c\n\x0b\n\x04\x04\x01\x02\0\x12\x031\x02\x13\n\x0c\n\x05\x04\
\x01\x02\0\x05\x12\x031\x02\x07\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x031\
\x08\x0e\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x031\x11\x12\n\x0b\n\x04\x04\
\x01\x02\x01\x12\x032\x02\x20\n\x0c\n\x05\x04\x01\x02\x01\x06\x12\x032\
\x02\x14\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x032\x15\x1b\n\x0c\n\x05\
\x04\x01\x02\x01\x03\x12\x032\x1e\x1f\n\x0b\n\x04\x04\x01\x02\x02\x12\
\x033\x02\x1c\n\x0c\n\x05\x04\x01\x02\x02\x05\x12\x033\x02\x08\n\x0c\n\
\x05\x04\x01\x02\x02\x01\x12\x033\t\x17\n\x0c\n\x05\x04\x01\x02\x02\x03\
\x12\x033\x1a\x1b\nM\n\x02\x04\x02\x12\x048\0:\x012A********************\
*\x20Get\x20(single)\x20pipeline\x20*********************\n\n\n\x03\x04\
\x02\x01\x12\x038\x08\x1a\n\x0b\n\x04\x04\x02\x02\0\x12\x039\x02\x10\n\
\x0c\n\x05\x04\x02\x02\0\x05\x12\x039\x02\x08\n\x0c\n\x05\x04\x02\x02\0\
\x01\x12\x039\t\x0b\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x039\x0e\x0f\n\n\n\
\x02\x04\x03\x12\x04<\0@\x01\n\n\n\x03\x04\x03\x01\x12\x03<\x08\x1b\n\
\x0b\n\x04\x04\x03\x02\0\x12\x03=\x02\"\n\x0c\n\x05\x04\x03\x02\0\x06\
\x12\x03=\x02\x14\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03=\x15\x1d\n\x0c\n\
\x05\x04\x03\x02\0\x03\x12\x03=\x20!\n\x0b\n\x04\x04\x03\x02\x01\x12\x03\
>\x02\x1c\n\x0c\n\x05\x04\x03\x02\x01\x06\x12\x03>\x02\x10\n\x0c\n\x05\
\x04\x03\x02\x01\x01\x12\x03>\x11\x17\n\x0c\n\x05\x04\x03\x02\x01\x03\
\x12\x03>\x1a\x1b\n\x0b\n\x04\x04\x03\x02\x02\x12\x03?\x02\x15\n\x0c\n\
\x05\x04\x03\x02\x02\x05\x12\x03?\x02\x08\n\x0c\n\x05\x04\x03\x02\x02\
\x01\x12\x03?\t\x10\n\x0c\n\x05\x04\x03\x02\x02\x03\x12\x03?\x13\x14\nH\
\n\x02\x04\x04\x12\x03D\0!2=*********************\x20Get\x20all\x20pipel\
ines\x20*********************\n\n\n\x03\x04\x04\x01\x12\x03D\x08\x1e\n\n\
\n\x02\x04\x05\x12\x04F\0J\x01\n\n\n\x03\x04\x05\x01\x12\x03F\x08\x1f\n\
\x0b\n\x04\x04\x05\x02\0\x12\x03G\x02,\n\x0c\n\x05\x04\x05\x02\0\x04\x12\
\x03G\x02\n\n\x0c\n\x05\x04\x05\x02\0\x06\x12\x03G\x0b\x1d\n\x0c\n\x05\
\x04\x05\x02\0\x01\x12\x03G\x1e'\n\x0c\n\x05\x04\x05\x02\0\x03\x12\x03G*\
+\n\x0b\n\x04\x04\x05\x02\x01\x12\x03H\x02\x1c\n\x0c\n\x05\x04\x05\x02\
\x01\x06\x12\x03H\x02\x10\n\x0c\n\x05\x04\x05\x02\x01\x01\x12\x03H\x11\
\x17\n\x0c\n\x05\x04\x05\x02\x01\x03\x12\x03H\x1a\x1b\n\x0b\n\x04\x04\
\x05\x02\x02\x12\x03I\x02\x15\n\x0c\n\x05\x04\x05\x02\x02\x05\x12\x03I\
\x02\x08\n\x0c\n\x05\x04\x05\x02\x02\x01\x12\x03I\t\x10\n\x0c\n\x05\x04\
\x05\x02\x02\x03\x12\x03I\x13\x14\no\n\x02\x04\x06\x12\x04O\0[\x01\x1a\
\x1e\x20Used\x20for\x20both\x20Add\x20and\x20Update\n2C*****************\
****\x20Add/Set/Update\x20pipeline\x20*********************\n\n\n\x03\
\x04\x06\x01\x12\x03O\x08\x1a\n)\n\x04\x04\x06\x02\0\x12\x03Q\x02\x10\
\x1a\x1c\x20Unique\x20ID\x20for\x20the\x20pipeline\n\n\x0c\n\x05\x04\x06\
\x02\0\x05\x12\x03Q\x02\x08\n\x0c\n\x05\x04\x06\x02\0\x01\x12\x03Q\t\x0b\
\n\x0c\n\x05\x04\x06\x02\0\x03\x12\x03Q\x0e\x0f\n-\n\x04\x04\x06\x02\x01\
\x12\x03T\x02\x12\x1a\x20\x20Friendly\x20name\x20for\x20the\x20pipeline\
\n\n\x0c\n\x05\x04\x06\x02\x01\x05\x12\x03T\x02\x08\n\x0c\n\x05\x04\x06\
\x02\x01\x01\x12\x03T\t\r\n\x0c\n\x05\x04\x06\x02\x01\x03\x12\x03T\x10\
\x11\n+\n\x04\x04\x06\x02\x02\x12\x03W\x02\"\x1a\x1e\x20One\x20or\x20mor\
e\x20steps\x20to\x20execute\n\n\x0c\n\x05\x04\x06\x02\x02\x04\x12\x03W\
\x02\n\n\x0c\n\x05\x04\x06\x02\x02\x06\x12\x03W\x0b\x17\n\x0c\n\x05\x04\
\x06\x02\x02\x01\x12\x03W\x18\x1d\n\x0c\n\x05\x04\x06\x02\x02\x03\x12\
\x03W\x20!\nP\n\x04\x04\x06\x02\x03\x12\x03Z\x02+\x1aC\x20Conditions\x20\
that\x20have\x20to\x20be\x20met\x20for\x20pipeline\x20to\x20continue\x20\
executing\n\n\x0c\n\x05\x04\x06\x02\x03\x04\x12\x03Z\x02\n\n\x0c\n\x05\
\x04\x06\x02\x03\x06\x12\x03Z\x0b\x14\n\x0c\n\x05\x04\x06\x02\x03\x01\
\x12\x03Z\x15&\n\x0c\n\x05\x04\x06\x02\x03\x03\x12\x03Z)*\n\n\n\x02\x04\
\x07\x12\x04]\0f\x01\n\n\n\x03\x04\x07\x01\x12\x03]\x08\x1b\n)\n\x04\x04\
\x07\x02\0\x12\x03_\x02\x10\x1a\x1c\x20Unique\x20ID\x20for\x20the\x20pip\
eline\n\n\x0c\n\x05\x04\x07\x02\0\x05\x12\x03_\x02\x08\n\x0c\n\x05\x04\
\x07\x02\0\x01\x12\x03_\t\x0b\n\x0c\n\x05\x04\x07\x02\0\x03\x12\x03_\x0e\
\x0f\nS\n\x04\x04\x07\x02\x01\x12\x03b\x02\x1c\x1aF\x20Response\x20statu\
s\x20code;\x20use\x20for\x20identifying\x20request\x20success\x20or\x20f\
ailure\n\n\x0c\n\x05\x04\x07\x02\x01\x06\x12\x03b\x02\x10\n\x0c\n\x05\
\x04\x07\x02\x01\x01\x12\x03b\x11\x17\n\x0c\n\x05\x04\x07\x02\x01\x03\
\x12\x03b\x1a\x1b\n?\n\x04\x04\x07\x02\x02\x12\x03e\x02\x15\x1a2\x20Addi\
tional\x20information\x20regarding\x20response\x20status\n\n\x0c\n\x05\
\x04\x07\x02\x02\x05\x12\x03e\x02\x08\n\x0c\n\x05\x04\x07\x02\x02\x01\
\x12\x03e\t\x10\n\x0c\n\x05\x04\x07\x02\x02\x03\x12\x03e\x13\x14\nF\n\
\x02\x04\x08\x12\x04j\0m\x012:*********************\x20Delete\x20pipelin\
e\x20********************\n\n\n\x03\x04\x08\x01\x12\x03j\x08\x1d\n)\n\
\x04\x04\x08\x02\0\x12\x03l\x02\x10\x1a\x1c\x20Unique\x20ID\x20for\x20th\
e\x20pipeline\n\n\x0c\n\x05\x04\x08\x02\0\x05\x12\x03l\x02\x08\n\x0c\n\
\x05\x04\x08\x02\0\x01\x12\x03l\t\x0b\n\x0c\n\x05\x04\x08\x02\0\x03\x12\
\x03l\x0e\x0f\n\n\n\x02\x04\t\x12\x04o\0s\x01\n\n\n\x03\x04\t\x01\x12\
\x03o\x08\x1e\n\x0b\n\x04\x04\t\x02\0\x12\x03p\x02\x10\n\x0c\n\x05\x04\t\
\x02\0\x05\x12\x03p\x02\x08\n\x0c\n\x05\x04\t\x02\0\x01\x12\x03p\t\x0b\n\
\x0c\n\x05\x04\t\x02\0\x03\x12\x03p\x0e\x0f\n\x0b\n\x04\x04\t\x02\x01\
\x12\x03q\x02\x1c\n\x0c\n\x05\x04\t\x02\x01\x06\x12\x03q\x02\x10\n\x0c\n\
\x05\x04\t\x02\x01\x01\x12\x03q\x11\x17\n\x0c\n\x05\x04\t\x02\x01\x03\
\x12\x03q\x1a\x1b\n\x0b\n\x04\x04\t\x02\x02\x12\x03r\x02\x15\n\x0c\n\x05\
\x04\t\x02\x02\x05\x12\x03r\x02\x08\n\x0c\n\x05\x04\t\x02\x02\x01\x12\
\x03r\t\x10\n\x0c\n\x05\x04\t\x02\x02\x03\x12\x03r\x13\x14\nF\n\x02\x04\
\n\x12\x04w\0z\x012:*********************\x20Pause\x20pipeline\x20******\
***************\n\n\n\x03\x04\n\x01\x12\x03w\x08\x1c\n)\n\x04\x04\n\x02\
\0\x12\x03y\x02\x10\x1a\x1c\x20Unique\x20ID\x20for\x20the\x20pipeline\n\
\n\x0c\n\x05\x04\n\x02\0\x05\x12\x03y\x02\x08\n\x0c\n\x05\x04\n\x02\0\
\x01\x12\x03y\t\x0b\n\x0c\n\x05\x04\n\x02\0\x03\x12\x03y\x0e\x0f\n\x0b\n\
\x02\x04\x0b\x12\x05|\0\x80\x01\x01\n\n\n\x03\x04\x0b\x01\x12\x03|\x08\
\x1d\n\x0b\n\x04\x04\x0b\x02\0\x12\x03}\x02\x10\n\x0c\n\x05\x04\x0b\x02\
\0\x05\x12\x03}\x02\x08\n\x0c\n\x05\x04\x0b\x02\0\x01\x12\x03}\t\x0b\n\
\x0c\n\x05\x04\x0b\x02\0\x03\x12\x03}\x0e\x0f\n\x0b\n\x04\x04\x0b\x02\
\x01\x12\x03~\x02\x1c\n\x0c\n\x05\x04\x0b\x02\x01\x06\x12\x03~\x02\x10\n\
\x0c\n\x05\x04\x0b\x02\x01\x01\x12\x03~\x11\x17\n\x0c\n\x05\x04\x0b\x02\
\x01\x03\x12\x03~\x1a\x1b\n\x0b\n\x04\x04\x0b\x02\x02\x12\x03\x7f\x02\
\x15\n\x0c\n\x05\x04\x0b\x02\x02\x05\x12\x03\x7f\x02\x08\n\x0c\n\x05\x04\
\x0b\x02\x02\x01\x12\x03\x7f\t\x10\n\x0c\n\x05\x04\x0b\x02\x02\x03\x12\
\x03\x7f\x13\x14\nJ\n\x02\x04\x0c\x12\x06\x84\x01\0\x87\x01\x012<*******\
**************\x20Unpause\x20pipeline\x20*********************\n\x0b\n\
\x03\x04\x0c\x01\x12\x04\x84\x01\x08\x1e\n*\n\x04\x04\x0c\x02\0\x12\x04\
\x86\x01\x02\x10\x1a\x1c\x20Unique\x20ID\x20for\x20the\x20pipeline\n\n\r\
\n\x05\x04\x0c\x02\0\x05\x12\x04\x86\x01\x02\x08\n\r\n\x05\x04\x0c\x02\0\
\x01\x12\x04\x86\x01\t\x0b\n\r\n\x05\x04\x0c\x02\0\x03\x12\x04\x86\x01\
\x0e\x0f\n\x0c\n\x02\x04\r\x12\x06\x89\x01\0\x8d\x01\x01\n\x0b\n\x03\x04\
\r\x01\x12\x04\x89\x01\x08\x1f\n\x0c\n\x04\x04\r\x02\0\x12\x04\x8a\x01\
\x02\x10\n\r\n\x05\x04\r\x02\0\x05\x12\x04\x8a\x01\x02\x08\n\r\n\x05\x04\
\r\x02\0\x01\x12\x04\x8a\x01\t\x0b\n\r\n\x05\x04\r\x02\0\x03\x12\x04\x8a\
\x01\x0e\x0f\n\x0c\n\x04\x04\r\x02\x01\x12\x04\x8b\x01\x02\x1c\n\r\n\x05\
\x04\r\x02\x01\x06\x12\x04\x8b\x01\x02\x10\n\r\n\x05\x04\r\x02\x01\x01\
\x12\x04\x8b\x01\x11\x17\n\r\n\x05\x04\r\x02\x01\x03\x12\x04\x8b\x01\x1a\
\x1b\n\x0c\n\x04\x04\r\x02\x02\x12\x04\x8c\x01\x02\x15\n\r\n\x05\x04\r\
\x02\x02\x05\x12\x04\x8c\x01\x02\x08\n\r\n\x05\x04\r\x02\x02\x01\x12\x04\
\x8c\x01\t\x10\n\r\n\x05\x04\r\x02\x02\x03\x12\x04\x8c\x01\x13\x14b\x06p\
roto3\
";
fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
file_descriptor_proto_lazy.get(|| {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
})
}
pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
file_descriptor.get(|| {
let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
let mut deps = ::std::vec::Vec::with_capacity(6);
deps.push(super::detective::file_descriptor().clone());
deps.push(super::transform::file_descriptor().clone());
deps.push(super::encode::file_descriptor().clone());
deps.push(super::decode::file_descriptor().clone());
deps.push(super::custom::file_descriptor().clone());
deps.push(super::common::file_descriptor().clone());
let mut messages = ::std::vec::Vec::with_capacity(14);
messages.push(PipelineStep::generated_message_descriptor_data());
messages.push(PipelineStepResponse::generated_message_descriptor_data());
messages.push(GetPipelineRequest::generated_message_descriptor_data());
messages.push(GetPipelineResponse::generated_message_descriptor_data());
messages.push(GetAllPipelinesRequest::generated_message_descriptor_data());
messages.push(GetAllPipelinesResponse::generated_message_descriptor_data());
messages.push(SetPipelineRequest::generated_message_descriptor_data());
messages.push(SetPipelineResponse::generated_message_descriptor_data());
messages.push(DeletePipelineRequest::generated_message_descriptor_data());
messages.push(DeletePipelineResponse::generated_message_descriptor_data());
messages.push(PausePipelineRequest::generated_message_descriptor_data());
messages.push(PausePipelineResponse::generated_message_descriptor_data());
messages.push(UnpausePipelineRequest::generated_message_descriptor_data());
messages.push(UnpausePipelineResponse::generated_message_descriptor_data());
let mut enums = ::std::vec::Vec::with_capacity(1);
enums.push(PipelineStepStatus::generated_enum_descriptor_data());
::protobuf::reflect::GeneratedFileDescriptor::new_generated(
file_descriptor_proto(),
deps,
messages,
enums,
)
});
::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
})
}