#![allow(unknown_lints)]
#![allow(clippy::all)]
#![cfg_attr(rustfmt, rustfmt_skip)]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unsafe_code)]
#![allow(unused_imports)]
#![allow(unused_results)]
use protobuf::Message as Message_imported_for_functions;
use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;
#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct InstanceInitParams {
pub instance_spec: ::protobuf::SingularPtrField<super::base::InstanceSpec>,
pub constructor: ::std::vec::Vec<u8>,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a InstanceInitParams {
fn default() -> &'a InstanceInitParams {
<InstanceInitParams as ::protobuf::Message>::default_instance()
}
}
impl InstanceInitParams {
pub fn new() -> InstanceInitParams {
::std::default::Default::default()
}
pub fn get_instance_spec(&self) -> &super::base::InstanceSpec {
self.instance_spec.as_ref().unwrap_or_else(|| super::base::InstanceSpec::default_instance())
}
pub fn clear_instance_spec(&mut self) {
self.instance_spec.clear();
}
pub fn has_instance_spec(&self) -> bool {
self.instance_spec.is_some()
}
pub fn set_instance_spec(&mut self, v: super::base::InstanceSpec) {
self.instance_spec = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_instance_spec(&mut self) -> &mut super::base::InstanceSpec {
if self.instance_spec.is_none() {
self.instance_spec.set_default();
}
self.instance_spec.as_mut().unwrap()
}
pub fn take_instance_spec(&mut self) -> super::base::InstanceSpec {
self.instance_spec.take().unwrap_or_else(|| super::base::InstanceSpec::new())
}
pub fn get_constructor(&self) -> &[u8] {
&self.constructor
}
pub fn clear_constructor(&mut self) {
self.constructor.clear();
}
pub fn set_constructor(&mut self, v: ::std::vec::Vec<u8>) {
self.constructor = v;
}
pub fn mut_constructor(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.constructor
}
pub fn take_constructor(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.constructor, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for InstanceInitParams {
fn is_initialized(&self) -> bool {
for v in &self.instance_spec {
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.instance_spec)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.constructor)?;
},
_ => {
::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.instance_spec.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.constructor.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.constructor);
}
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.instance_spec.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.constructor.is_empty() {
os.write_bytes(2, &self.constructor)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> InstanceInitParams {
InstanceInitParams::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::base::InstanceSpec>>(
"instance_spec",
|m: &InstanceInitParams| { &m.instance_spec },
|m: &mut InstanceInitParams| { &mut m.instance_spec },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"constructor",
|m: &InstanceInitParams| { &m.constructor },
|m: &mut InstanceInitParams| { &mut m.constructor },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<InstanceInitParams>(
"InstanceInitParams",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static InstanceInitParams {
static mut instance: ::protobuf::lazy::Lazy<InstanceInitParams> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(InstanceInitParams::new)
}
}
}
impl ::protobuf::Clear for InstanceInitParams {
fn clear(&mut self) {
self.instance_spec.clear();
self.constructor.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for InstanceInitParams {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for InstanceInitParams {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct GenesisConfig {
pub consensus_config: ::protobuf::SingularPtrField<super::blockchain::Config>,
pub artifacts: ::protobuf::RepeatedField<super::base::ArtifactSpec>,
pub builtin_instances: ::protobuf::RepeatedField<InstanceInitParams>,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a GenesisConfig {
fn default() -> &'a GenesisConfig {
<GenesisConfig as ::protobuf::Message>::default_instance()
}
}
impl GenesisConfig {
pub fn new() -> GenesisConfig {
::std::default::Default::default()
}
pub fn get_consensus_config(&self) -> &super::blockchain::Config {
self.consensus_config.as_ref().unwrap_or_else(|| super::blockchain::Config::default_instance())
}
pub fn clear_consensus_config(&mut self) {
self.consensus_config.clear();
}
pub fn has_consensus_config(&self) -> bool {
self.consensus_config.is_some()
}
pub fn set_consensus_config(&mut self, v: super::blockchain::Config) {
self.consensus_config = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_consensus_config(&mut self) -> &mut super::blockchain::Config {
if self.consensus_config.is_none() {
self.consensus_config.set_default();
}
self.consensus_config.as_mut().unwrap()
}
pub fn take_consensus_config(&mut self) -> super::blockchain::Config {
self.consensus_config.take().unwrap_or_else(|| super::blockchain::Config::new())
}
pub fn get_artifacts(&self) -> &[super::base::ArtifactSpec] {
&self.artifacts
}
pub fn clear_artifacts(&mut self) {
self.artifacts.clear();
}
pub fn set_artifacts(&mut self, v: ::protobuf::RepeatedField<super::base::ArtifactSpec>) {
self.artifacts = v;
}
pub fn mut_artifacts(&mut self) -> &mut ::protobuf::RepeatedField<super::base::ArtifactSpec> {
&mut self.artifacts
}
pub fn take_artifacts(&mut self) -> ::protobuf::RepeatedField<super::base::ArtifactSpec> {
::std::mem::replace(&mut self.artifacts, ::protobuf::RepeatedField::new())
}
pub fn get_builtin_instances(&self) -> &[InstanceInitParams] {
&self.builtin_instances
}
pub fn clear_builtin_instances(&mut self) {
self.builtin_instances.clear();
}
pub fn set_builtin_instances(&mut self, v: ::protobuf::RepeatedField<InstanceInitParams>) {
self.builtin_instances = v;
}
pub fn mut_builtin_instances(&mut self) -> &mut ::protobuf::RepeatedField<InstanceInitParams> {
&mut self.builtin_instances
}
pub fn take_builtin_instances(&mut self) -> ::protobuf::RepeatedField<InstanceInitParams> {
::std::mem::replace(&mut self.builtin_instances, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for GenesisConfig {
fn is_initialized(&self) -> bool {
for v in &self.consensus_config {
if !v.is_initialized() {
return false;
}
};
for v in &self.artifacts {
if !v.is_initialized() {
return false;
}
};
for v in &self.builtin_instances {
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.consensus_config)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.artifacts)?;
},
3 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.builtin_instances)?;
},
_ => {
::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.consensus_config.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.artifacts {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
for value in &self.builtin_instances {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.consensus_config.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.artifacts {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
for v in &self.builtin_instances {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> GenesisConfig {
GenesisConfig::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::blockchain::Config>>(
"consensus_config",
|m: &GenesisConfig| { &m.consensus_config },
|m: &mut GenesisConfig| { &mut m.consensus_config },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::base::ArtifactSpec>>(
"artifacts",
|m: &GenesisConfig| { &m.artifacts },
|m: &mut GenesisConfig| { &mut m.artifacts },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<InstanceInitParams>>(
"builtin_instances",
|m: &GenesisConfig| { &m.builtin_instances },
|m: &mut GenesisConfig| { &mut m.builtin_instances },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<GenesisConfig>(
"GenesisConfig",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static GenesisConfig {
static mut instance: ::protobuf::lazy::Lazy<GenesisConfig> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(GenesisConfig::new)
}
}
}
impl ::protobuf::Clear for GenesisConfig {
fn clear(&mut self) {
self.consensus_config.clear();
self.artifacts.clear();
self.builtin_instances.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for GenesisConfig {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for GenesisConfig {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct ArtifactState {
pub deploy_spec: ::std::vec::Vec<u8>,
pub status: ArtifactState_Status,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ArtifactState {
fn default() -> &'a ArtifactState {
<ArtifactState as ::protobuf::Message>::default_instance()
}
}
impl ArtifactState {
pub fn new() -> ArtifactState {
::std::default::Default::default()
}
pub fn get_deploy_spec(&self) -> &[u8] {
&self.deploy_spec
}
pub fn clear_deploy_spec(&mut self) {
self.deploy_spec.clear();
}
pub fn set_deploy_spec(&mut self, v: ::std::vec::Vec<u8>) {
self.deploy_spec = v;
}
pub fn mut_deploy_spec(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.deploy_spec
}
pub fn take_deploy_spec(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.deploy_spec, ::std::vec::Vec::new())
}
pub fn get_status(&self) -> ArtifactState_Status {
self.status
}
pub fn clear_status(&mut self) {
self.status = ArtifactState_Status::UNLOADING;
}
pub fn set_status(&mut self, v: ArtifactState_Status) {
self.status = v;
}
}
impl ::protobuf::Message for ArtifactState {
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_bytes_into(wire_type, is, &mut self.deploy_spec)?;
},
2 => {
::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.status, 2, &mut self.unknown_fields)?
},
_ => {
::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.deploy_spec.is_empty() {
my_size += ::protobuf::rt::bytes_size(1, &self.deploy_spec);
}
if self.status != ArtifactState_Status::UNLOADING {
my_size += ::protobuf::rt::enum_size(2, self.status);
}
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.deploy_spec.is_empty() {
os.write_bytes(1, &self.deploy_spec)?;
}
if self.status != ArtifactState_Status::UNLOADING {
os.write_enum(2, self.status.value())?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ArtifactState {
ArtifactState::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"deploy_spec",
|m: &ArtifactState| { &m.deploy_spec },
|m: &mut ArtifactState| { &mut m.deploy_spec },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<ArtifactState_Status>>(
"status",
|m: &ArtifactState| { &m.status },
|m: &mut ArtifactState| { &mut m.status },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<ArtifactState>(
"ArtifactState",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ArtifactState {
static mut instance: ::protobuf::lazy::Lazy<ArtifactState> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(ArtifactState::new)
}
}
}
impl ::protobuf::Clear for ArtifactState {
fn clear(&mut self) {
self.deploy_spec.clear();
self.status = ArtifactState_Status::UNLOADING;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for ArtifactState {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ArtifactState {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub enum ArtifactState_Status {
UNLOADING = 0,
DEPLOYING = 1,
ACTIVE = 2,
}
impl ::protobuf::ProtobufEnum for ArtifactState_Status {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<ArtifactState_Status> {
match value {
0 => ::std::option::Option::Some(ArtifactState_Status::UNLOADING),
1 => ::std::option::Option::Some(ArtifactState_Status::DEPLOYING),
2 => ::std::option::Option::Some(ArtifactState_Status::ACTIVE),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [ArtifactState_Status] = &[
ArtifactState_Status::UNLOADING,
ArtifactState_Status::DEPLOYING,
ArtifactState_Status::ACTIVE,
];
values
}
fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new_pb_name::<ArtifactState_Status>("ArtifactState.Status", file_descriptor_proto())
})
}
}
}
impl ::std::marker::Copy for ArtifactState_Status {
}
impl ::std::default::Default for ArtifactState_Status {
fn default() -> Self {
ArtifactState_Status::UNLOADING
}
}
impl ::protobuf::reflect::ProtobufValue for ArtifactState_Status {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Enum(self.descriptor())
}
}
#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct InstanceStatus {
pub status: ::std::option::Option<InstanceStatus_oneof_status>,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a InstanceStatus {
fn default() -> &'a InstanceStatus {
<InstanceStatus as ::protobuf::Message>::default_instance()
}
}
#[derive(Clone,PartialEq,Debug)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub enum InstanceStatus_oneof_status {
simple(InstanceStatus_Simple),
migration(InstanceMigration),
}
impl InstanceStatus {
pub fn new() -> InstanceStatus {
::std::default::Default::default()
}
pub fn get_simple(&self) -> InstanceStatus_Simple {
match self.status {
::std::option::Option::Some(InstanceStatus_oneof_status::simple(v)) => v,
_ => InstanceStatus_Simple::NONE,
}
}
pub fn clear_simple(&mut self) {
self.status = ::std::option::Option::None;
}
pub fn has_simple(&self) -> bool {
match self.status {
::std::option::Option::Some(InstanceStatus_oneof_status::simple(..)) => true,
_ => false,
}
}
pub fn set_simple(&mut self, v: InstanceStatus_Simple) {
self.status = ::std::option::Option::Some(InstanceStatus_oneof_status::simple(v))
}
pub fn get_migration(&self) -> &InstanceMigration {
match self.status {
::std::option::Option::Some(InstanceStatus_oneof_status::migration(ref v)) => v,
_ => InstanceMigration::default_instance(),
}
}
pub fn clear_migration(&mut self) {
self.status = ::std::option::Option::None;
}
pub fn has_migration(&self) -> bool {
match self.status {
::std::option::Option::Some(InstanceStatus_oneof_status::migration(..)) => true,
_ => false,
}
}
pub fn set_migration(&mut self, v: InstanceMigration) {
self.status = ::std::option::Option::Some(InstanceStatus_oneof_status::migration(v))
}
pub fn mut_migration(&mut self) -> &mut InstanceMigration {
if let ::std::option::Option::Some(InstanceStatus_oneof_status::migration(_)) = self.status {
} else {
self.status = ::std::option::Option::Some(InstanceStatus_oneof_status::migration(InstanceMigration::new()));
}
match self.status {
::std::option::Option::Some(InstanceStatus_oneof_status::migration(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_migration(&mut self) -> InstanceMigration {
if self.has_migration() {
match self.status.take() {
::std::option::Option::Some(InstanceStatus_oneof_status::migration(v)) => v,
_ => panic!(),
}
} else {
InstanceMigration::new()
}
}
}
impl ::protobuf::Message for InstanceStatus {
fn is_initialized(&self) -> bool {
if let Some(InstanceStatus_oneof_status::migration(ref v)) = self.status {
if !v.is_initialized() {
return false;
}
}
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.status = ::std::option::Option::Some(InstanceStatus_oneof_status::simple(is.read_enum()?));
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.status = ::std::option::Option::Some(InstanceStatus_oneof_status::migration(is.read_message()?));
},
_ => {
::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 ::std::option::Option::Some(ref v) = self.status {
match v {
&InstanceStatus_oneof_status::simple(v) => {
my_size += ::protobuf::rt::enum_size(1, v);
},
&InstanceStatus_oneof_status::migration(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
};
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let ::std::option::Option::Some(ref v) = self.status {
match v {
&InstanceStatus_oneof_status::simple(v) => {
os.write_enum(1, v.value())?;
},
&InstanceStatus_oneof_status::migration(ref v) => {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
};
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> InstanceStatus {
InstanceStatus::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor::<_, InstanceStatus_Simple>(
"simple",
InstanceStatus::has_simple,
InstanceStatus::get_simple,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, InstanceMigration>(
"migration",
InstanceStatus::has_migration,
InstanceStatus::get_migration,
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<InstanceStatus>(
"InstanceStatus",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static InstanceStatus {
static mut instance: ::protobuf::lazy::Lazy<InstanceStatus> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(InstanceStatus::new)
}
}
}
impl ::protobuf::Clear for InstanceStatus {
fn clear(&mut self) {
self.status = ::std::option::Option::None;
self.status = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for InstanceStatus {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for InstanceStatus {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub enum InstanceStatus_Simple {
NONE = 0,
ACTIVE = 1,
STOPPED = 2,
FROZEN = 3,
}
impl ::protobuf::ProtobufEnum for InstanceStatus_Simple {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<InstanceStatus_Simple> {
match value {
0 => ::std::option::Option::Some(InstanceStatus_Simple::NONE),
1 => ::std::option::Option::Some(InstanceStatus_Simple::ACTIVE),
2 => ::std::option::Option::Some(InstanceStatus_Simple::STOPPED),
3 => ::std::option::Option::Some(InstanceStatus_Simple::FROZEN),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [InstanceStatus_Simple] = &[
InstanceStatus_Simple::NONE,
InstanceStatus_Simple::ACTIVE,
InstanceStatus_Simple::STOPPED,
InstanceStatus_Simple::FROZEN,
];
values
}
fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new_pb_name::<InstanceStatus_Simple>("InstanceStatus.Simple", file_descriptor_proto())
})
}
}
}
impl ::std::marker::Copy for InstanceStatus_Simple {
}
impl ::std::default::Default for InstanceStatus_Simple {
fn default() -> Self {
InstanceStatus_Simple::NONE
}
}
impl ::protobuf::reflect::ProtobufValue for InstanceStatus_Simple {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Enum(self.descriptor())
}
}
#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct InstanceMigration {
pub target: ::protobuf::SingularPtrField<super::base::ArtifactId>,
pub end_version: ::std::string::String,
pub completed_hash: ::protobuf::SingularPtrField<super::types::Hash>,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a InstanceMigration {
fn default() -> &'a InstanceMigration {
<InstanceMigration as ::protobuf::Message>::default_instance()
}
}
impl InstanceMigration {
pub fn new() -> InstanceMigration {
::std::default::Default::default()
}
pub fn get_target(&self) -> &super::base::ArtifactId {
self.target.as_ref().unwrap_or_else(|| super::base::ArtifactId::default_instance())
}
pub fn clear_target(&mut self) {
self.target.clear();
}
pub fn has_target(&self) -> bool {
self.target.is_some()
}
pub fn set_target(&mut self, v: super::base::ArtifactId) {
self.target = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_target(&mut self) -> &mut super::base::ArtifactId {
if self.target.is_none() {
self.target.set_default();
}
self.target.as_mut().unwrap()
}
pub fn take_target(&mut self) -> super::base::ArtifactId {
self.target.take().unwrap_or_else(|| super::base::ArtifactId::new())
}
pub fn get_end_version(&self) -> &str {
&self.end_version
}
pub fn clear_end_version(&mut self) {
self.end_version.clear();
}
pub fn set_end_version(&mut self, v: ::std::string::String) {
self.end_version = v;
}
pub fn mut_end_version(&mut self) -> &mut ::std::string::String {
&mut self.end_version
}
pub fn take_end_version(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.end_version, ::std::string::String::new())
}
pub fn get_completed_hash(&self) -> &super::types::Hash {
self.completed_hash.as_ref().unwrap_or_else(|| super::types::Hash::default_instance())
}
pub fn clear_completed_hash(&mut self) {
self.completed_hash.clear();
}
pub fn has_completed_hash(&self) -> bool {
self.completed_hash.is_some()
}
pub fn set_completed_hash(&mut self, v: super::types::Hash) {
self.completed_hash = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_completed_hash(&mut self) -> &mut super::types::Hash {
if self.completed_hash.is_none() {
self.completed_hash.set_default();
}
self.completed_hash.as_mut().unwrap()
}
pub fn take_completed_hash(&mut self) -> super::types::Hash {
self.completed_hash.take().unwrap_or_else(|| super::types::Hash::new())
}
}
impl ::protobuf::Message for InstanceMigration {
fn is_initialized(&self) -> bool {
for v in &self.target {
if !v.is_initialized() {
return false;
}
};
for v in &self.completed_hash {
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.target)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.end_version)?;
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.completed_hash)?;
},
_ => {
::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.target.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.end_version.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.end_version);
}
if let Some(ref v) = self.completed_hash.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.target.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.end_version.is_empty() {
os.write_string(2, &self.end_version)?;
}
if let Some(ref v) = self.completed_hash.as_ref() {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> InstanceMigration {
InstanceMigration::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::base::ArtifactId>>(
"target",
|m: &InstanceMigration| { &m.target },
|m: &mut InstanceMigration| { &mut m.target },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"end_version",
|m: &InstanceMigration| { &m.end_version },
|m: &mut InstanceMigration| { &mut m.end_version },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::types::Hash>>(
"completed_hash",
|m: &InstanceMigration| { &m.completed_hash },
|m: &mut InstanceMigration| { &mut m.completed_hash },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<InstanceMigration>(
"InstanceMigration",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static InstanceMigration {
static mut instance: ::protobuf::lazy::Lazy<InstanceMigration> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(InstanceMigration::new)
}
}
}
impl ::protobuf::Clear for InstanceMigration {
fn clear(&mut self) {
self.target.clear();
self.end_version.clear();
self.completed_hash.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for InstanceMigration {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for InstanceMigration {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct InstanceState {
pub spec: ::protobuf::SingularPtrField<super::base::InstanceSpec>,
pub status: ::protobuf::SingularPtrField<InstanceStatus>,
pub pending_status: ::protobuf::SingularPtrField<InstanceStatus>,
pub data_version: ::std::string::String,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a InstanceState {
fn default() -> &'a InstanceState {
<InstanceState as ::protobuf::Message>::default_instance()
}
}
impl InstanceState {
pub fn new() -> InstanceState {
::std::default::Default::default()
}
pub fn get_spec(&self) -> &super::base::InstanceSpec {
self.spec.as_ref().unwrap_or_else(|| super::base::InstanceSpec::default_instance())
}
pub fn clear_spec(&mut self) {
self.spec.clear();
}
pub fn has_spec(&self) -> bool {
self.spec.is_some()
}
pub fn set_spec(&mut self, v: super::base::InstanceSpec) {
self.spec = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_spec(&mut self) -> &mut super::base::InstanceSpec {
if self.spec.is_none() {
self.spec.set_default();
}
self.spec.as_mut().unwrap()
}
pub fn take_spec(&mut self) -> super::base::InstanceSpec {
self.spec.take().unwrap_or_else(|| super::base::InstanceSpec::new())
}
pub fn get_status(&self) -> &InstanceStatus {
self.status.as_ref().unwrap_or_else(|| InstanceStatus::default_instance())
}
pub fn clear_status(&mut self) {
self.status.clear();
}
pub fn has_status(&self) -> bool {
self.status.is_some()
}
pub fn set_status(&mut self, v: InstanceStatus) {
self.status = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_status(&mut self) -> &mut InstanceStatus {
if self.status.is_none() {
self.status.set_default();
}
self.status.as_mut().unwrap()
}
pub fn take_status(&mut self) -> InstanceStatus {
self.status.take().unwrap_or_else(|| InstanceStatus::new())
}
pub fn get_pending_status(&self) -> &InstanceStatus {
self.pending_status.as_ref().unwrap_or_else(|| InstanceStatus::default_instance())
}
pub fn clear_pending_status(&mut self) {
self.pending_status.clear();
}
pub fn has_pending_status(&self) -> bool {
self.pending_status.is_some()
}
pub fn set_pending_status(&mut self, v: InstanceStatus) {
self.pending_status = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_pending_status(&mut self) -> &mut InstanceStatus {
if self.pending_status.is_none() {
self.pending_status.set_default();
}
self.pending_status.as_mut().unwrap()
}
pub fn take_pending_status(&mut self) -> InstanceStatus {
self.pending_status.take().unwrap_or_else(|| InstanceStatus::new())
}
pub fn get_data_version(&self) -> &str {
&self.data_version
}
pub fn clear_data_version(&mut self) {
self.data_version.clear();
}
pub fn set_data_version(&mut self, v: ::std::string::String) {
self.data_version = v;
}
pub fn mut_data_version(&mut self) -> &mut ::std::string::String {
&mut self.data_version
}
pub fn take_data_version(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.data_version, ::std::string::String::new())
}
}
impl ::protobuf::Message for InstanceState {
fn is_initialized(&self) -> bool {
for v in &self.spec {
if !v.is_initialized() {
return false;
}
};
for v in &self.status {
if !v.is_initialized() {
return false;
}
};
for v in &self.pending_status {
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.spec)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.status)?;
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.pending_status)?;
},
4 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.data_version)?;
},
_ => {
::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.spec.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.status.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.pending_status.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.data_version.is_empty() {
my_size += ::protobuf::rt::string_size(4, &self.data_version);
}
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.spec.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.status.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.pending_status.as_ref() {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.data_version.is_empty() {
os.write_string(4, &self.data_version)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> InstanceState {
InstanceState::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::base::InstanceSpec>>(
"spec",
|m: &InstanceState| { &m.spec },
|m: &mut InstanceState| { &mut m.spec },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<InstanceStatus>>(
"status",
|m: &InstanceState| { &m.status },
|m: &mut InstanceState| { &mut m.status },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<InstanceStatus>>(
"pending_status",
|m: &InstanceState| { &m.pending_status },
|m: &mut InstanceState| { &mut m.pending_status },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"data_version",
|m: &InstanceState| { &m.data_version },
|m: &mut InstanceState| { &mut m.data_version },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<InstanceState>(
"InstanceState",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static InstanceState {
static mut instance: ::protobuf::lazy::Lazy<InstanceState> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(InstanceState::new)
}
}
}
impl ::protobuf::Clear for InstanceState {
fn clear(&mut self) {
self.spec.clear();
self.status.clear();
self.pending_status.clear();
self.data_version.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for InstanceState {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for InstanceState {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct MigrationStatus {
pub result: ::std::option::Option<MigrationStatus_oneof_result>,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a MigrationStatus {
fn default() -> &'a MigrationStatus {
<MigrationStatus as ::protobuf::Message>::default_instance()
}
}
#[derive(Clone,PartialEq,Debug)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub enum MigrationStatus_oneof_result {
hash(super::types::Hash),
error(::std::string::String),
}
impl MigrationStatus {
pub fn new() -> MigrationStatus {
::std::default::Default::default()
}
pub fn get_hash(&self) -> &super::types::Hash {
match self.result {
::std::option::Option::Some(MigrationStatus_oneof_result::hash(ref v)) => v,
_ => super::types::Hash::default_instance(),
}
}
pub fn clear_hash(&mut self) {
self.result = ::std::option::Option::None;
}
pub fn has_hash(&self) -> bool {
match self.result {
::std::option::Option::Some(MigrationStatus_oneof_result::hash(..)) => true,
_ => false,
}
}
pub fn set_hash(&mut self, v: super::types::Hash) {
self.result = ::std::option::Option::Some(MigrationStatus_oneof_result::hash(v))
}
pub fn mut_hash(&mut self) -> &mut super::types::Hash {
if let ::std::option::Option::Some(MigrationStatus_oneof_result::hash(_)) = self.result {
} else {
self.result = ::std::option::Option::Some(MigrationStatus_oneof_result::hash(super::types::Hash::new()));
}
match self.result {
::std::option::Option::Some(MigrationStatus_oneof_result::hash(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_hash(&mut self) -> super::types::Hash {
if self.has_hash() {
match self.result.take() {
::std::option::Option::Some(MigrationStatus_oneof_result::hash(v)) => v,
_ => panic!(),
}
} else {
super::types::Hash::new()
}
}
pub fn get_error(&self) -> &str {
match self.result {
::std::option::Option::Some(MigrationStatus_oneof_result::error(ref v)) => v,
_ => "",
}
}
pub fn clear_error(&mut self) {
self.result = ::std::option::Option::None;
}
pub fn has_error(&self) -> bool {
match self.result {
::std::option::Option::Some(MigrationStatus_oneof_result::error(..)) => true,
_ => false,
}
}
pub fn set_error(&mut self, v: ::std::string::String) {
self.result = ::std::option::Option::Some(MigrationStatus_oneof_result::error(v))
}
pub fn mut_error(&mut self) -> &mut ::std::string::String {
if let ::std::option::Option::Some(MigrationStatus_oneof_result::error(_)) = self.result {
} else {
self.result = ::std::option::Option::Some(MigrationStatus_oneof_result::error(::std::string::String::new()));
}
match self.result {
::std::option::Option::Some(MigrationStatus_oneof_result::error(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_error(&mut self) -> ::std::string::String {
if self.has_error() {
match self.result.take() {
::std::option::Option::Some(MigrationStatus_oneof_result::error(v)) => v,
_ => panic!(),
}
} else {
::std::string::String::new()
}
}
}
impl ::protobuf::Message for MigrationStatus {
fn is_initialized(&self) -> bool {
if let Some(MigrationStatus_oneof_result::hash(ref v)) = self.result {
if !v.is_initialized() {
return false;
}
}
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.result = ::std::option::Option::Some(MigrationStatus_oneof_result::hash(is.read_message()?));
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.result = ::std::option::Option::Some(MigrationStatus_oneof_result::error(is.read_string()?));
},
_ => {
::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 ::std::option::Option::Some(ref v) = self.result {
match v {
&MigrationStatus_oneof_result::hash(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&MigrationStatus_oneof_result::error(ref v) => {
my_size += ::protobuf::rt::string_size(2, &v);
},
};
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let ::std::option::Option::Some(ref v) = self.result {
match v {
&MigrationStatus_oneof_result::hash(ref v) => {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
&MigrationStatus_oneof_result::error(ref v) => {
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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> MigrationStatus {
MigrationStatus::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, super::types::Hash>(
"hash",
MigrationStatus::has_hash,
MigrationStatus::get_hash,
));
fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
"error",
MigrationStatus::has_error,
MigrationStatus::get_error,
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<MigrationStatus>(
"MigrationStatus",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static MigrationStatus {
static mut instance: ::protobuf::lazy::Lazy<MigrationStatus> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(MigrationStatus::new)
}
}
}
impl ::protobuf::Clear for MigrationStatus {
fn clear(&mut self) {
self.result = ::std::option::Option::None;
self.result = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for MigrationStatus {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for MigrationStatus {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x1eexonum/runtime/lifecycle.proto\x12\x0eexonum.runtime\x1a\x17exonum\
/blockchain.proto\x1a\x19exonum/crypto/types.proto\x1a\x19exonum/runtime\
/base.proto\"y\n\x12InstanceInitParams\x12A\n\rinstance_spec\x18\x01\x20\
\x01(\x0b2\x1c.exonum.runtime.InstanceSpecR\x0cinstanceSpec\x12\x20\n\
\x0bconstructor\x18\x02\x20\x01(\x0cR\x0bconstructor\"\xd7\x01\n\rGenesi\
sConfig\x129\n\x10consensus_config\x18\x01\x20\x01(\x0b2\x0e.exonum.Conf\
igR\x0fconsensusConfig\x12:\n\tartifacts\x18\x02\x20\x03(\x0b2\x1c.exonu\
m.runtime.ArtifactSpecR\tartifacts\x12O\n\x11builtin_instances\x18\x03\
\x20\x03(\x0b2\".exonum.runtime.InstanceInitParamsR\x10builtinInstances\
\"\xa2\x01\n\rArtifactState\x12\x1f\n\x0bdeploy_spec\x18\x01\x20\x01(\
\x0cR\ndeploySpec\x12<\n\x06status\x18\x02\x20\x01(\x0e2$.exonum.runtime\
.ArtifactState.StatusR\x06status\"2\n\x06Status\x12\r\n\tUNLOADING\x10\0\
\x12\r\n\tDEPLOYING\x10\x01\x12\n\n\x06ACTIVE\x10\x02\"\xd7\x01\n\x0eIns\
tanceStatus\x12?\n\x06simple\x18\x01\x20\x01(\x0e2%.exonum.runtime.Insta\
nceStatus.SimpleH\0R\x06simple\x12A\n\tmigration\x18\x02\x20\x01(\x0b2!.\
exonum.runtime.InstanceMigrationH\0R\tmigration\"7\n\x06Simple\x12\x08\n\
\x04NONE\x10\0\x12\n\n\x06ACTIVE\x10\x01\x12\x0b\n\x07STOPPED\x10\x02\
\x12\n\n\x06FROZEN\x10\x03B\x08\n\x06status\"\xa4\x01\n\x11InstanceMigra\
tion\x122\n\x06target\x18\x01\x20\x01(\x0b2\x1a.exonum.runtime.ArtifactI\
dR\x06target\x12\x1f\n\x0bend_version\x18\x02\x20\x01(\tR\nendVersion\
\x12:\n\x0ecompleted_hash\x18\x03\x20\x01(\x0b2\x13.exonum.crypto.HashR\
\rcompletedHash\"\xe3\x01\n\rInstanceState\x120\n\x04spec\x18\x01\x20\
\x01(\x0b2\x1c.exonum.runtime.InstanceSpecR\x04spec\x126\n\x06status\x18\
\x02\x20\x01(\x0b2\x1e.exonum.runtime.InstanceStatusR\x06status\x12E\n\
\x0epending_status\x18\x03\x20\x01(\x0b2\x1e.exonum.runtime.InstanceStat\
usR\rpendingStatus\x12!\n\x0cdata_version\x18\x04\x20\x01(\tR\x0bdataVer\
sion\"^\n\x0fMigrationStatus\x12)\n\x04hash\x18\x01\x20\x01(\x0b2\x13.ex\
onum.crypto.HashH\0R\x04hash\x12\x16\n\x05error\x18\x02\x20\x01(\tH\0R\
\x05errorB\x08\n\x06resultB\"\n\x20com.exonum.messages.core.runtimeb\x06\
proto3\
";
static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT;
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
unsafe {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}
}