#![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;
const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_8_0;
#[derive(PartialEq,Clone,Default)]
pub struct SabrePayload {
pub action: SabrePayload_Action,
pub create_contract: ::protobuf::SingularPtrField<CreateContractAction>,
pub delete_contract: ::protobuf::SingularPtrField<DeleteContractAction>,
pub execute_contract: ::protobuf::SingularPtrField<ExecuteContractAction>,
pub create_contract_registry: ::protobuf::SingularPtrField<CreateContractRegistryAction>,
pub delete_contract_registry: ::protobuf::SingularPtrField<DeleteContractRegistryAction>,
pub update_contract_registry_owners: ::protobuf::SingularPtrField<UpdateContractRegistryOwnersAction>,
pub create_namespace_registry: ::protobuf::SingularPtrField<CreateNamespaceRegistryAction>,
pub delete_namespace_registry: ::protobuf::SingularPtrField<DeleteNamespaceRegistryAction>,
pub update_namespace_registry_owners: ::protobuf::SingularPtrField<UpdateNamespaceRegistryOwnersAction>,
pub create_namespace_registry_permission: ::protobuf::SingularPtrField<CreateNamespaceRegistryPermissionAction>,
pub delete_namespace_registry_permission: ::protobuf::SingularPtrField<DeleteNamespaceRegistryPermissionAction>,
pub create_smart_permission: ::protobuf::SingularPtrField<CreateSmartPermissionAction>,
pub update_smart_permission: ::protobuf::SingularPtrField<UpdateSmartPermissionAction>,
pub delete_smart_permission: ::protobuf::SingularPtrField<DeleteSmartPermissionAction>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SabrePayload {
fn default() -> &'a SabrePayload {
<SabrePayload as ::protobuf::Message>::default_instance()
}
}
impl SabrePayload {
pub fn new() -> SabrePayload {
::std::default::Default::default()
}
pub fn get_action(&self) -> SabrePayload_Action {
self.action
}
pub fn clear_action(&mut self) {
self.action = SabrePayload_Action::ACTION_UNSET;
}
pub fn set_action(&mut self, v: SabrePayload_Action) {
self.action = v;
}
pub fn get_create_contract(&self) -> &CreateContractAction {
self.create_contract.as_ref().unwrap_or_else(|| CreateContractAction::default_instance())
}
pub fn clear_create_contract(&mut self) {
self.create_contract.clear();
}
pub fn has_create_contract(&self) -> bool {
self.create_contract.is_some()
}
pub fn set_create_contract(&mut self, v: CreateContractAction) {
self.create_contract = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_create_contract(&mut self) -> &mut CreateContractAction {
if self.create_contract.is_none() {
self.create_contract.set_default();
}
self.create_contract.as_mut().unwrap()
}
pub fn take_create_contract(&mut self) -> CreateContractAction {
self.create_contract.take().unwrap_or_else(|| CreateContractAction::new())
}
pub fn get_delete_contract(&self) -> &DeleteContractAction {
self.delete_contract.as_ref().unwrap_or_else(|| DeleteContractAction::default_instance())
}
pub fn clear_delete_contract(&mut self) {
self.delete_contract.clear();
}
pub fn has_delete_contract(&self) -> bool {
self.delete_contract.is_some()
}
pub fn set_delete_contract(&mut self, v: DeleteContractAction) {
self.delete_contract = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_delete_contract(&mut self) -> &mut DeleteContractAction {
if self.delete_contract.is_none() {
self.delete_contract.set_default();
}
self.delete_contract.as_mut().unwrap()
}
pub fn take_delete_contract(&mut self) -> DeleteContractAction {
self.delete_contract.take().unwrap_or_else(|| DeleteContractAction::new())
}
pub fn get_execute_contract(&self) -> &ExecuteContractAction {
self.execute_contract.as_ref().unwrap_or_else(|| ExecuteContractAction::default_instance())
}
pub fn clear_execute_contract(&mut self) {
self.execute_contract.clear();
}
pub fn has_execute_contract(&self) -> bool {
self.execute_contract.is_some()
}
pub fn set_execute_contract(&mut self, v: ExecuteContractAction) {
self.execute_contract = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_execute_contract(&mut self) -> &mut ExecuteContractAction {
if self.execute_contract.is_none() {
self.execute_contract.set_default();
}
self.execute_contract.as_mut().unwrap()
}
pub fn take_execute_contract(&mut self) -> ExecuteContractAction {
self.execute_contract.take().unwrap_or_else(|| ExecuteContractAction::new())
}
pub fn get_create_contract_registry(&self) -> &CreateContractRegistryAction {
self.create_contract_registry.as_ref().unwrap_or_else(|| CreateContractRegistryAction::default_instance())
}
pub fn clear_create_contract_registry(&mut self) {
self.create_contract_registry.clear();
}
pub fn has_create_contract_registry(&self) -> bool {
self.create_contract_registry.is_some()
}
pub fn set_create_contract_registry(&mut self, v: CreateContractRegistryAction) {
self.create_contract_registry = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_create_contract_registry(&mut self) -> &mut CreateContractRegistryAction {
if self.create_contract_registry.is_none() {
self.create_contract_registry.set_default();
}
self.create_contract_registry.as_mut().unwrap()
}
pub fn take_create_contract_registry(&mut self) -> CreateContractRegistryAction {
self.create_contract_registry.take().unwrap_or_else(|| CreateContractRegistryAction::new())
}
pub fn get_delete_contract_registry(&self) -> &DeleteContractRegistryAction {
self.delete_contract_registry.as_ref().unwrap_or_else(|| DeleteContractRegistryAction::default_instance())
}
pub fn clear_delete_contract_registry(&mut self) {
self.delete_contract_registry.clear();
}
pub fn has_delete_contract_registry(&self) -> bool {
self.delete_contract_registry.is_some()
}
pub fn set_delete_contract_registry(&mut self, v: DeleteContractRegistryAction) {
self.delete_contract_registry = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_delete_contract_registry(&mut self) -> &mut DeleteContractRegistryAction {
if self.delete_contract_registry.is_none() {
self.delete_contract_registry.set_default();
}
self.delete_contract_registry.as_mut().unwrap()
}
pub fn take_delete_contract_registry(&mut self) -> DeleteContractRegistryAction {
self.delete_contract_registry.take().unwrap_or_else(|| DeleteContractRegistryAction::new())
}
pub fn get_update_contract_registry_owners(&self) -> &UpdateContractRegistryOwnersAction {
self.update_contract_registry_owners.as_ref().unwrap_or_else(|| UpdateContractRegistryOwnersAction::default_instance())
}
pub fn clear_update_contract_registry_owners(&mut self) {
self.update_contract_registry_owners.clear();
}
pub fn has_update_contract_registry_owners(&self) -> bool {
self.update_contract_registry_owners.is_some()
}
pub fn set_update_contract_registry_owners(&mut self, v: UpdateContractRegistryOwnersAction) {
self.update_contract_registry_owners = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_update_contract_registry_owners(&mut self) -> &mut UpdateContractRegistryOwnersAction {
if self.update_contract_registry_owners.is_none() {
self.update_contract_registry_owners.set_default();
}
self.update_contract_registry_owners.as_mut().unwrap()
}
pub fn take_update_contract_registry_owners(&mut self) -> UpdateContractRegistryOwnersAction {
self.update_contract_registry_owners.take().unwrap_or_else(|| UpdateContractRegistryOwnersAction::new())
}
pub fn get_create_namespace_registry(&self) -> &CreateNamespaceRegistryAction {
self.create_namespace_registry.as_ref().unwrap_or_else(|| CreateNamespaceRegistryAction::default_instance())
}
pub fn clear_create_namespace_registry(&mut self) {
self.create_namespace_registry.clear();
}
pub fn has_create_namespace_registry(&self) -> bool {
self.create_namespace_registry.is_some()
}
pub fn set_create_namespace_registry(&mut self, v: CreateNamespaceRegistryAction) {
self.create_namespace_registry = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_create_namespace_registry(&mut self) -> &mut CreateNamespaceRegistryAction {
if self.create_namespace_registry.is_none() {
self.create_namespace_registry.set_default();
}
self.create_namespace_registry.as_mut().unwrap()
}
pub fn take_create_namespace_registry(&mut self) -> CreateNamespaceRegistryAction {
self.create_namespace_registry.take().unwrap_or_else(|| CreateNamespaceRegistryAction::new())
}
pub fn get_delete_namespace_registry(&self) -> &DeleteNamespaceRegistryAction {
self.delete_namespace_registry.as_ref().unwrap_or_else(|| DeleteNamespaceRegistryAction::default_instance())
}
pub fn clear_delete_namespace_registry(&mut self) {
self.delete_namespace_registry.clear();
}
pub fn has_delete_namespace_registry(&self) -> bool {
self.delete_namespace_registry.is_some()
}
pub fn set_delete_namespace_registry(&mut self, v: DeleteNamespaceRegistryAction) {
self.delete_namespace_registry = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_delete_namespace_registry(&mut self) -> &mut DeleteNamespaceRegistryAction {
if self.delete_namespace_registry.is_none() {
self.delete_namespace_registry.set_default();
}
self.delete_namespace_registry.as_mut().unwrap()
}
pub fn take_delete_namespace_registry(&mut self) -> DeleteNamespaceRegistryAction {
self.delete_namespace_registry.take().unwrap_or_else(|| DeleteNamespaceRegistryAction::new())
}
pub fn get_update_namespace_registry_owners(&self) -> &UpdateNamespaceRegistryOwnersAction {
self.update_namespace_registry_owners.as_ref().unwrap_or_else(|| UpdateNamespaceRegistryOwnersAction::default_instance())
}
pub fn clear_update_namespace_registry_owners(&mut self) {
self.update_namespace_registry_owners.clear();
}
pub fn has_update_namespace_registry_owners(&self) -> bool {
self.update_namespace_registry_owners.is_some()
}
pub fn set_update_namespace_registry_owners(&mut self, v: UpdateNamespaceRegistryOwnersAction) {
self.update_namespace_registry_owners = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_update_namespace_registry_owners(&mut self) -> &mut UpdateNamespaceRegistryOwnersAction {
if self.update_namespace_registry_owners.is_none() {
self.update_namespace_registry_owners.set_default();
}
self.update_namespace_registry_owners.as_mut().unwrap()
}
pub fn take_update_namespace_registry_owners(&mut self) -> UpdateNamespaceRegistryOwnersAction {
self.update_namespace_registry_owners.take().unwrap_or_else(|| UpdateNamespaceRegistryOwnersAction::new())
}
pub fn get_create_namespace_registry_permission(&self) -> &CreateNamespaceRegistryPermissionAction {
self.create_namespace_registry_permission.as_ref().unwrap_or_else(|| CreateNamespaceRegistryPermissionAction::default_instance())
}
pub fn clear_create_namespace_registry_permission(&mut self) {
self.create_namespace_registry_permission.clear();
}
pub fn has_create_namespace_registry_permission(&self) -> bool {
self.create_namespace_registry_permission.is_some()
}
pub fn set_create_namespace_registry_permission(&mut self, v: CreateNamespaceRegistryPermissionAction) {
self.create_namespace_registry_permission = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_create_namespace_registry_permission(&mut self) -> &mut CreateNamespaceRegistryPermissionAction {
if self.create_namespace_registry_permission.is_none() {
self.create_namespace_registry_permission.set_default();
}
self.create_namespace_registry_permission.as_mut().unwrap()
}
pub fn take_create_namespace_registry_permission(&mut self) -> CreateNamespaceRegistryPermissionAction {
self.create_namespace_registry_permission.take().unwrap_or_else(|| CreateNamespaceRegistryPermissionAction::new())
}
pub fn get_delete_namespace_registry_permission(&self) -> &DeleteNamespaceRegistryPermissionAction {
self.delete_namespace_registry_permission.as_ref().unwrap_or_else(|| DeleteNamespaceRegistryPermissionAction::default_instance())
}
pub fn clear_delete_namespace_registry_permission(&mut self) {
self.delete_namespace_registry_permission.clear();
}
pub fn has_delete_namespace_registry_permission(&self) -> bool {
self.delete_namespace_registry_permission.is_some()
}
pub fn set_delete_namespace_registry_permission(&mut self, v: DeleteNamespaceRegistryPermissionAction) {
self.delete_namespace_registry_permission = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_delete_namespace_registry_permission(&mut self) -> &mut DeleteNamespaceRegistryPermissionAction {
if self.delete_namespace_registry_permission.is_none() {
self.delete_namespace_registry_permission.set_default();
}
self.delete_namespace_registry_permission.as_mut().unwrap()
}
pub fn take_delete_namespace_registry_permission(&mut self) -> DeleteNamespaceRegistryPermissionAction {
self.delete_namespace_registry_permission.take().unwrap_or_else(|| DeleteNamespaceRegistryPermissionAction::new())
}
pub fn get_create_smart_permission(&self) -> &CreateSmartPermissionAction {
self.create_smart_permission.as_ref().unwrap_or_else(|| CreateSmartPermissionAction::default_instance())
}
pub fn clear_create_smart_permission(&mut self) {
self.create_smart_permission.clear();
}
pub fn has_create_smart_permission(&self) -> bool {
self.create_smart_permission.is_some()
}
pub fn set_create_smart_permission(&mut self, v: CreateSmartPermissionAction) {
self.create_smart_permission = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_create_smart_permission(&mut self) -> &mut CreateSmartPermissionAction {
if self.create_smart_permission.is_none() {
self.create_smart_permission.set_default();
}
self.create_smart_permission.as_mut().unwrap()
}
pub fn take_create_smart_permission(&mut self) -> CreateSmartPermissionAction {
self.create_smart_permission.take().unwrap_or_else(|| CreateSmartPermissionAction::new())
}
pub fn get_update_smart_permission(&self) -> &UpdateSmartPermissionAction {
self.update_smart_permission.as_ref().unwrap_or_else(|| UpdateSmartPermissionAction::default_instance())
}
pub fn clear_update_smart_permission(&mut self) {
self.update_smart_permission.clear();
}
pub fn has_update_smart_permission(&self) -> bool {
self.update_smart_permission.is_some()
}
pub fn set_update_smart_permission(&mut self, v: UpdateSmartPermissionAction) {
self.update_smart_permission = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_update_smart_permission(&mut self) -> &mut UpdateSmartPermissionAction {
if self.update_smart_permission.is_none() {
self.update_smart_permission.set_default();
}
self.update_smart_permission.as_mut().unwrap()
}
pub fn take_update_smart_permission(&mut self) -> UpdateSmartPermissionAction {
self.update_smart_permission.take().unwrap_or_else(|| UpdateSmartPermissionAction::new())
}
pub fn get_delete_smart_permission(&self) -> &DeleteSmartPermissionAction {
self.delete_smart_permission.as_ref().unwrap_or_else(|| DeleteSmartPermissionAction::default_instance())
}
pub fn clear_delete_smart_permission(&mut self) {
self.delete_smart_permission.clear();
}
pub fn has_delete_smart_permission(&self) -> bool {
self.delete_smart_permission.is_some()
}
pub fn set_delete_smart_permission(&mut self, v: DeleteSmartPermissionAction) {
self.delete_smart_permission = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_delete_smart_permission(&mut self) -> &mut DeleteSmartPermissionAction {
if self.delete_smart_permission.is_none() {
self.delete_smart_permission.set_default();
}
self.delete_smart_permission.as_mut().unwrap()
}
pub fn take_delete_smart_permission(&mut self) -> DeleteSmartPermissionAction {
self.delete_smart_permission.take().unwrap_or_else(|| DeleteSmartPermissionAction::new())
}
}
impl ::protobuf::Message for SabrePayload {
fn is_initialized(&self) -> bool {
for v in &self.create_contract {
if !v.is_initialized() {
return false;
}
};
for v in &self.delete_contract {
if !v.is_initialized() {
return false;
}
};
for v in &self.execute_contract {
if !v.is_initialized() {
return false;
}
};
for v in &self.create_contract_registry {
if !v.is_initialized() {
return false;
}
};
for v in &self.delete_contract_registry {
if !v.is_initialized() {
return false;
}
};
for v in &self.update_contract_registry_owners {
if !v.is_initialized() {
return false;
}
};
for v in &self.create_namespace_registry {
if !v.is_initialized() {
return false;
}
};
for v in &self.delete_namespace_registry {
if !v.is_initialized() {
return false;
}
};
for v in &self.update_namespace_registry_owners {
if !v.is_initialized() {
return false;
}
};
for v in &self.create_namespace_registry_permission {
if !v.is_initialized() {
return false;
}
};
for v in &self.delete_namespace_registry_permission {
if !v.is_initialized() {
return false;
}
};
for v in &self.create_smart_permission {
if !v.is_initialized() {
return false;
}
};
for v in &self.update_smart_permission {
if !v.is_initialized() {
return false;
}
};
for v in &self.delete_smart_permission {
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_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.action, 1, &mut self.unknown_fields)?
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.create_contract)?;
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.delete_contract)?;
},
4 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.execute_contract)?;
},
5 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.create_contract_registry)?;
},
6 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.delete_contract_registry)?;
},
7 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.update_contract_registry_owners)?;
},
8 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.create_namespace_registry)?;
},
9 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.delete_namespace_registry)?;
},
10 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.update_namespace_registry_owners)?;
},
11 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.create_namespace_registry_permission)?;
},
12 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.delete_namespace_registry_permission)?;
},
13 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.create_smart_permission)?;
},
14 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.update_smart_permission)?;
},
15 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.delete_smart_permission)?;
},
_ => {
::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.action != SabrePayload_Action::ACTION_UNSET {
my_size += ::protobuf::rt::enum_size(1, self.action);
}
if let Some(ref v) = self.create_contract.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.delete_contract.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.execute_contract.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.create_contract_registry.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.delete_contract_registry.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.update_contract_registry_owners.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.create_namespace_registry.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.delete_namespace_registry.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.update_namespace_registry_owners.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.create_namespace_registry_permission.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.delete_namespace_registry_permission.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.create_smart_permission.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.update_smart_permission.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.delete_smart_permission.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 self.action != SabrePayload_Action::ACTION_UNSET {
os.write_enum(1, self.action.value())?;
}
if let Some(ref v) = self.create_contract.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.delete_contract.as_ref() {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.execute_contract.as_ref() {
os.write_tag(4, ::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.create_contract_registry.as_ref() {
os.write_tag(5, ::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.delete_contract_registry.as_ref() {
os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.update_contract_registry_owners.as_ref() {
os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.create_namespace_registry.as_ref() {
os.write_tag(8, ::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.delete_namespace_registry.as_ref() {
os.write_tag(9, ::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.update_namespace_registry_owners.as_ref() {
os.write_tag(10, ::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.create_namespace_registry_permission.as_ref() {
os.write_tag(11, ::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.delete_namespace_registry_permission.as_ref() {
os.write_tag(12, ::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.create_smart_permission.as_ref() {
os.write_tag(13, ::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.update_smart_permission.as_ref() {
os.write_tag(14, ::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.delete_smart_permission.as_ref() {
os.write_tag(15, ::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() -> SabrePayload {
SabrePayload::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<SabrePayload_Action>>(
"action",
|m: &SabrePayload| { &m.action },
|m: &mut SabrePayload| { &mut m.action },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CreateContractAction>>(
"create_contract",
|m: &SabrePayload| { &m.create_contract },
|m: &mut SabrePayload| { &mut m.create_contract },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<DeleteContractAction>>(
"delete_contract",
|m: &SabrePayload| { &m.delete_contract },
|m: &mut SabrePayload| { &mut m.delete_contract },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ExecuteContractAction>>(
"execute_contract",
|m: &SabrePayload| { &m.execute_contract },
|m: &mut SabrePayload| { &mut m.execute_contract },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CreateContractRegistryAction>>(
"create_contract_registry",
|m: &SabrePayload| { &m.create_contract_registry },
|m: &mut SabrePayload| { &mut m.create_contract_registry },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<DeleteContractRegistryAction>>(
"delete_contract_registry",
|m: &SabrePayload| { &m.delete_contract_registry },
|m: &mut SabrePayload| { &mut m.delete_contract_registry },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UpdateContractRegistryOwnersAction>>(
"update_contract_registry_owners",
|m: &SabrePayload| { &m.update_contract_registry_owners },
|m: &mut SabrePayload| { &mut m.update_contract_registry_owners },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CreateNamespaceRegistryAction>>(
"create_namespace_registry",
|m: &SabrePayload| { &m.create_namespace_registry },
|m: &mut SabrePayload| { &mut m.create_namespace_registry },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<DeleteNamespaceRegistryAction>>(
"delete_namespace_registry",
|m: &SabrePayload| { &m.delete_namespace_registry },
|m: &mut SabrePayload| { &mut m.delete_namespace_registry },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UpdateNamespaceRegistryOwnersAction>>(
"update_namespace_registry_owners",
|m: &SabrePayload| { &m.update_namespace_registry_owners },
|m: &mut SabrePayload| { &mut m.update_namespace_registry_owners },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CreateNamespaceRegistryPermissionAction>>(
"create_namespace_registry_permission",
|m: &SabrePayload| { &m.create_namespace_registry_permission },
|m: &mut SabrePayload| { &mut m.create_namespace_registry_permission },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<DeleteNamespaceRegistryPermissionAction>>(
"delete_namespace_registry_permission",
|m: &SabrePayload| { &m.delete_namespace_registry_permission },
|m: &mut SabrePayload| { &mut m.delete_namespace_registry_permission },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CreateSmartPermissionAction>>(
"create_smart_permission",
|m: &SabrePayload| { &m.create_smart_permission },
|m: &mut SabrePayload| { &mut m.create_smart_permission },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UpdateSmartPermissionAction>>(
"update_smart_permission",
|m: &SabrePayload| { &m.update_smart_permission },
|m: &mut SabrePayload| { &mut m.update_smart_permission },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<DeleteSmartPermissionAction>>(
"delete_smart_permission",
|m: &SabrePayload| { &m.delete_smart_permission },
|m: &mut SabrePayload| { &mut m.delete_smart_permission },
));
::protobuf::reflect::MessageDescriptor::new::<SabrePayload>(
"SabrePayload",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static SabrePayload {
static mut instance: ::protobuf::lazy::Lazy<SabrePayload> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const SabrePayload,
};
unsafe {
instance.get(SabrePayload::new)
}
}
}
impl ::protobuf::Clear for SabrePayload {
fn clear(&mut self) {
self.action = SabrePayload_Action::ACTION_UNSET;
self.create_contract.clear();
self.delete_contract.clear();
self.execute_contract.clear();
self.create_contract_registry.clear();
self.delete_contract_registry.clear();
self.update_contract_registry_owners.clear();
self.create_namespace_registry.clear();
self.delete_namespace_registry.clear();
self.update_namespace_registry_owners.clear();
self.create_namespace_registry_permission.clear();
self.delete_namespace_registry_permission.clear();
self.create_smart_permission.clear();
self.update_smart_permission.clear();
self.delete_smart_permission.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SabrePayload {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SabrePayload {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum SabrePayload_Action {
ACTION_UNSET = 0,
CREATE_CONTRACT = 1,
DELETE_CONTRACT = 2,
EXECUTE_CONTRACT = 3,
CREATE_CONTRACT_REGISTRY = 4,
DELETE_CONTRACT_REGISTRY = 5,
UPDATE_CONTRACT_REGISTRY_OWNERS = 6,
CREATE_NAMESPACE_REGISTRY = 7,
DELETE_NAMESPACE_REGISTRY = 8,
UPDATE_NAMESPACE_REGISTRY_OWNERS = 9,
CREATE_NAMESPACE_REGISTRY_PERMISSION = 10,
DELETE_NAMESPACE_REGISTRY_PERMISSION = 11,
CREATE_SMART_PERMISSION = 12,
UPDATE_SMART_PERMISSION = 13,
DELETE_SMART_PERMISSION = 14,
}
impl ::protobuf::ProtobufEnum for SabrePayload_Action {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<SabrePayload_Action> {
match value {
0 => ::std::option::Option::Some(SabrePayload_Action::ACTION_UNSET),
1 => ::std::option::Option::Some(SabrePayload_Action::CREATE_CONTRACT),
2 => ::std::option::Option::Some(SabrePayload_Action::DELETE_CONTRACT),
3 => ::std::option::Option::Some(SabrePayload_Action::EXECUTE_CONTRACT),
4 => ::std::option::Option::Some(SabrePayload_Action::CREATE_CONTRACT_REGISTRY),
5 => ::std::option::Option::Some(SabrePayload_Action::DELETE_CONTRACT_REGISTRY),
6 => ::std::option::Option::Some(SabrePayload_Action::UPDATE_CONTRACT_REGISTRY_OWNERS),
7 => ::std::option::Option::Some(SabrePayload_Action::CREATE_NAMESPACE_REGISTRY),
8 => ::std::option::Option::Some(SabrePayload_Action::DELETE_NAMESPACE_REGISTRY),
9 => ::std::option::Option::Some(SabrePayload_Action::UPDATE_NAMESPACE_REGISTRY_OWNERS),
10 => ::std::option::Option::Some(SabrePayload_Action::CREATE_NAMESPACE_REGISTRY_PERMISSION),
11 => ::std::option::Option::Some(SabrePayload_Action::DELETE_NAMESPACE_REGISTRY_PERMISSION),
12 => ::std::option::Option::Some(SabrePayload_Action::CREATE_SMART_PERMISSION),
13 => ::std::option::Option::Some(SabrePayload_Action::UPDATE_SMART_PERMISSION),
14 => ::std::option::Option::Some(SabrePayload_Action::DELETE_SMART_PERMISSION),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [SabrePayload_Action] = &[
SabrePayload_Action::ACTION_UNSET,
SabrePayload_Action::CREATE_CONTRACT,
SabrePayload_Action::DELETE_CONTRACT,
SabrePayload_Action::EXECUTE_CONTRACT,
SabrePayload_Action::CREATE_CONTRACT_REGISTRY,
SabrePayload_Action::DELETE_CONTRACT_REGISTRY,
SabrePayload_Action::UPDATE_CONTRACT_REGISTRY_OWNERS,
SabrePayload_Action::CREATE_NAMESPACE_REGISTRY,
SabrePayload_Action::DELETE_NAMESPACE_REGISTRY,
SabrePayload_Action::UPDATE_NAMESPACE_REGISTRY_OWNERS,
SabrePayload_Action::CREATE_NAMESPACE_REGISTRY_PERMISSION,
SabrePayload_Action::DELETE_NAMESPACE_REGISTRY_PERMISSION,
SabrePayload_Action::CREATE_SMART_PERMISSION,
SabrePayload_Action::UPDATE_SMART_PERMISSION,
SabrePayload_Action::DELETE_SMART_PERMISSION,
];
values
}
fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::EnumDescriptor,
};
unsafe {
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new("SabrePayload_Action", file_descriptor_proto())
})
}
}
}
impl ::std::marker::Copy for SabrePayload_Action {
}
impl ::std::default::Default for SabrePayload_Action {
fn default() -> Self {
SabrePayload_Action::ACTION_UNSET
}
}
impl ::protobuf::reflect::ProtobufValue for SabrePayload_Action {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CreateContractAction {
pub name: ::std::string::String,
pub version: ::std::string::String,
pub inputs: ::protobuf::RepeatedField<::std::string::String>,
pub outputs: ::protobuf::RepeatedField<::std::string::String>,
pub contract: ::std::vec::Vec<u8>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CreateContractAction {
fn default() -> &'a CreateContractAction {
<CreateContractAction as ::protobuf::Message>::default_instance()
}
}
impl CreateContractAction {
pub fn new() -> CreateContractAction {
::std::default::Default::default()
}
pub fn get_name(&self) -> &str {
&self.name
}
pub fn clear_name(&mut self) {
self.name.clear();
}
pub fn set_name(&mut self, v: ::std::string::String) {
self.name = v;
}
pub fn mut_name(&mut self) -> &mut ::std::string::String {
&mut self.name
}
pub fn take_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.name, ::std::string::String::new())
}
pub fn get_version(&self) -> &str {
&self.version
}
pub fn clear_version(&mut self) {
self.version.clear();
}
pub fn set_version(&mut self, v: ::std::string::String) {
self.version = v;
}
pub fn mut_version(&mut self) -> &mut ::std::string::String {
&mut self.version
}
pub fn take_version(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.version, ::std::string::String::new())
}
pub fn get_inputs(&self) -> &[::std::string::String] {
&self.inputs
}
pub fn clear_inputs(&mut self) {
self.inputs.clear();
}
pub fn set_inputs(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
self.inputs = v;
}
pub fn mut_inputs(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
&mut self.inputs
}
pub fn take_inputs(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
::std::mem::replace(&mut self.inputs, ::protobuf::RepeatedField::new())
}
pub fn get_outputs(&self) -> &[::std::string::String] {
&self.outputs
}
pub fn clear_outputs(&mut self) {
self.outputs.clear();
}
pub fn set_outputs(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
self.outputs = v;
}
pub fn mut_outputs(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
&mut self.outputs
}
pub fn take_outputs(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
::std::mem::replace(&mut self.outputs, ::protobuf::RepeatedField::new())
}
pub fn get_contract(&self) -> &[u8] {
&self.contract
}
pub fn clear_contract(&mut self) {
self.contract.clear();
}
pub fn set_contract(&mut self, v: ::std::vec::Vec<u8>) {
self.contract = v;
}
pub fn mut_contract(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.contract
}
pub fn take_contract(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.contract, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for CreateContractAction {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.version)?;
},
3 => {
::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.inputs)?;
},
4 => {
::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.outputs)?;
},
5 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.contract)?;
},
_ => {
::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.name.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.name);
}
if !self.version.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.version);
}
for value in &self.inputs {
my_size += ::protobuf::rt::string_size(3, &value);
};
for value in &self.outputs {
my_size += ::protobuf::rt::string_size(4, &value);
};
if !self.contract.is_empty() {
my_size += ::protobuf::rt::bytes_size(5, &self.contract);
}
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.name.is_empty() {
os.write_string(1, &self.name)?;
}
if !self.version.is_empty() {
os.write_string(2, &self.version)?;
}
for v in &self.inputs {
os.write_string(3, &v)?;
};
for v in &self.outputs {
os.write_string(4, &v)?;
};
if !self.contract.is_empty() {
os.write_bytes(5, &self.contract)?;
}
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() -> CreateContractAction {
CreateContractAction::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"name",
|m: &CreateContractAction| { &m.name },
|m: &mut CreateContractAction| { &mut m.name },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"version",
|m: &CreateContractAction| { &m.version },
|m: &mut CreateContractAction| { &mut m.version },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"inputs",
|m: &CreateContractAction| { &m.inputs },
|m: &mut CreateContractAction| { &mut m.inputs },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"outputs",
|m: &CreateContractAction| { &m.outputs },
|m: &mut CreateContractAction| { &mut m.outputs },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"contract",
|m: &CreateContractAction| { &m.contract },
|m: &mut CreateContractAction| { &mut m.contract },
));
::protobuf::reflect::MessageDescriptor::new::<CreateContractAction>(
"CreateContractAction",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static CreateContractAction {
static mut instance: ::protobuf::lazy::Lazy<CreateContractAction> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const CreateContractAction,
};
unsafe {
instance.get(CreateContractAction::new)
}
}
}
impl ::protobuf::Clear for CreateContractAction {
fn clear(&mut self) {
self.name.clear();
self.version.clear();
self.inputs.clear();
self.outputs.clear();
self.contract.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CreateContractAction {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CreateContractAction {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct DeleteContractAction {
pub name: ::std::string::String,
pub version: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a DeleteContractAction {
fn default() -> &'a DeleteContractAction {
<DeleteContractAction as ::protobuf::Message>::default_instance()
}
}
impl DeleteContractAction {
pub fn new() -> DeleteContractAction {
::std::default::Default::default()
}
pub fn get_name(&self) -> &str {
&self.name
}
pub fn clear_name(&mut self) {
self.name.clear();
}
pub fn set_name(&mut self, v: ::std::string::String) {
self.name = v;
}
pub fn mut_name(&mut self) -> &mut ::std::string::String {
&mut self.name
}
pub fn take_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.name, ::std::string::String::new())
}
pub fn get_version(&self) -> &str {
&self.version
}
pub fn clear_version(&mut self) {
self.version.clear();
}
pub fn set_version(&mut self, v: ::std::string::String) {
self.version = v;
}
pub fn mut_version(&mut self) -> &mut ::std::string::String {
&mut self.version
}
pub fn take_version(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.version, ::std::string::String::new())
}
}
impl ::protobuf::Message for DeleteContractAction {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.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 !self.name.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.name);
}
if !self.version.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.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 !self.name.is_empty() {
os.write_string(1, &self.name)?;
}
if !self.version.is_empty() {
os.write_string(2, &self.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() -> DeleteContractAction {
DeleteContractAction::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"name",
|m: &DeleteContractAction| { &m.name },
|m: &mut DeleteContractAction| { &mut m.name },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"version",
|m: &DeleteContractAction| { &m.version },
|m: &mut DeleteContractAction| { &mut m.version },
));
::protobuf::reflect::MessageDescriptor::new::<DeleteContractAction>(
"DeleteContractAction",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static DeleteContractAction {
static mut instance: ::protobuf::lazy::Lazy<DeleteContractAction> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const DeleteContractAction,
};
unsafe {
instance.get(DeleteContractAction::new)
}
}
}
impl ::protobuf::Clear for DeleteContractAction {
fn clear(&mut self) {
self.name.clear();
self.version.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for DeleteContractAction {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for DeleteContractAction {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ExecuteContractAction {
pub name: ::std::string::String,
pub version: ::std::string::String,
pub inputs: ::protobuf::RepeatedField<::std::string::String>,
pub outputs: ::protobuf::RepeatedField<::std::string::String>,
pub payload: ::std::vec::Vec<u8>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ExecuteContractAction {
fn default() -> &'a ExecuteContractAction {
<ExecuteContractAction as ::protobuf::Message>::default_instance()
}
}
impl ExecuteContractAction {
pub fn new() -> ExecuteContractAction {
::std::default::Default::default()
}
pub fn get_name(&self) -> &str {
&self.name
}
pub fn clear_name(&mut self) {
self.name.clear();
}
pub fn set_name(&mut self, v: ::std::string::String) {
self.name = v;
}
pub fn mut_name(&mut self) -> &mut ::std::string::String {
&mut self.name
}
pub fn take_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.name, ::std::string::String::new())
}
pub fn get_version(&self) -> &str {
&self.version
}
pub fn clear_version(&mut self) {
self.version.clear();
}
pub fn set_version(&mut self, v: ::std::string::String) {
self.version = v;
}
pub fn mut_version(&mut self) -> &mut ::std::string::String {
&mut self.version
}
pub fn take_version(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.version, ::std::string::String::new())
}
pub fn get_inputs(&self) -> &[::std::string::String] {
&self.inputs
}
pub fn clear_inputs(&mut self) {
self.inputs.clear();
}
pub fn set_inputs(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
self.inputs = v;
}
pub fn mut_inputs(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
&mut self.inputs
}
pub fn take_inputs(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
::std::mem::replace(&mut self.inputs, ::protobuf::RepeatedField::new())
}
pub fn get_outputs(&self) -> &[::std::string::String] {
&self.outputs
}
pub fn clear_outputs(&mut self) {
self.outputs.clear();
}
pub fn set_outputs(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
self.outputs = v;
}
pub fn mut_outputs(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
&mut self.outputs
}
pub fn take_outputs(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
::std::mem::replace(&mut self.outputs, ::protobuf::RepeatedField::new())
}
pub fn get_payload(&self) -> &[u8] {
&self.payload
}
pub fn clear_payload(&mut self) {
self.payload.clear();
}
pub fn set_payload(&mut self, v: ::std::vec::Vec<u8>) {
self.payload = v;
}
pub fn mut_payload(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.payload
}
pub fn take_payload(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.payload, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for ExecuteContractAction {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.version)?;
},
3 => {
::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.inputs)?;
},
4 => {
::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.outputs)?;
},
5 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.payload)?;
},
_ => {
::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.name.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.name);
}
if !self.version.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.version);
}
for value in &self.inputs {
my_size += ::protobuf::rt::string_size(3, &value);
};
for value in &self.outputs {
my_size += ::protobuf::rt::string_size(4, &value);
};
if !self.payload.is_empty() {
my_size += ::protobuf::rt::bytes_size(5, &self.payload);
}
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.name.is_empty() {
os.write_string(1, &self.name)?;
}
if !self.version.is_empty() {
os.write_string(2, &self.version)?;
}
for v in &self.inputs {
os.write_string(3, &v)?;
};
for v in &self.outputs {
os.write_string(4, &v)?;
};
if !self.payload.is_empty() {
os.write_bytes(5, &self.payload)?;
}
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() -> ExecuteContractAction {
ExecuteContractAction::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"name",
|m: &ExecuteContractAction| { &m.name },
|m: &mut ExecuteContractAction| { &mut m.name },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"version",
|m: &ExecuteContractAction| { &m.version },
|m: &mut ExecuteContractAction| { &mut m.version },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"inputs",
|m: &ExecuteContractAction| { &m.inputs },
|m: &mut ExecuteContractAction| { &mut m.inputs },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"outputs",
|m: &ExecuteContractAction| { &m.outputs },
|m: &mut ExecuteContractAction| { &mut m.outputs },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"payload",
|m: &ExecuteContractAction| { &m.payload },
|m: &mut ExecuteContractAction| { &mut m.payload },
));
::protobuf::reflect::MessageDescriptor::new::<ExecuteContractAction>(
"ExecuteContractAction",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ExecuteContractAction {
static mut instance: ::protobuf::lazy::Lazy<ExecuteContractAction> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ExecuteContractAction,
};
unsafe {
instance.get(ExecuteContractAction::new)
}
}
}
impl ::protobuf::Clear for ExecuteContractAction {
fn clear(&mut self) {
self.name.clear();
self.version.clear();
self.inputs.clear();
self.outputs.clear();
self.payload.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for ExecuteContractAction {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ExecuteContractAction {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CreateContractRegistryAction {
pub name: ::std::string::String,
pub owners: ::protobuf::RepeatedField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CreateContractRegistryAction {
fn default() -> &'a CreateContractRegistryAction {
<CreateContractRegistryAction as ::protobuf::Message>::default_instance()
}
}
impl CreateContractRegistryAction {
pub fn new() -> CreateContractRegistryAction {
::std::default::Default::default()
}
pub fn get_name(&self) -> &str {
&self.name
}
pub fn clear_name(&mut self) {
self.name.clear();
}
pub fn set_name(&mut self, v: ::std::string::String) {
self.name = v;
}
pub fn mut_name(&mut self) -> &mut ::std::string::String {
&mut self.name
}
pub fn take_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.name, ::std::string::String::new())
}
pub fn get_owners(&self) -> &[::std::string::String] {
&self.owners
}
pub fn clear_owners(&mut self) {
self.owners.clear();
}
pub fn set_owners(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
self.owners = v;
}
pub fn mut_owners(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
&mut self.owners
}
pub fn take_owners(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
::std::mem::replace(&mut self.owners, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for CreateContractRegistryAction {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
},
2 => {
::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.owners)?;
},
_ => {
::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.name.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.name);
}
for value in &self.owners {
my_size += ::protobuf::rt::string_size(2, &value);
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if !self.name.is_empty() {
os.write_string(1, &self.name)?;
}
for v in &self.owners {
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() -> CreateContractRegistryAction {
CreateContractRegistryAction::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"name",
|m: &CreateContractRegistryAction| { &m.name },
|m: &mut CreateContractRegistryAction| { &mut m.name },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"owners",
|m: &CreateContractRegistryAction| { &m.owners },
|m: &mut CreateContractRegistryAction| { &mut m.owners },
));
::protobuf::reflect::MessageDescriptor::new::<CreateContractRegistryAction>(
"CreateContractRegistryAction",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static CreateContractRegistryAction {
static mut instance: ::protobuf::lazy::Lazy<CreateContractRegistryAction> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const CreateContractRegistryAction,
};
unsafe {
instance.get(CreateContractRegistryAction::new)
}
}
}
impl ::protobuf::Clear for CreateContractRegistryAction {
fn clear(&mut self) {
self.name.clear();
self.owners.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CreateContractRegistryAction {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CreateContractRegistryAction {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct DeleteContractRegistryAction {
pub name: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a DeleteContractRegistryAction {
fn default() -> &'a DeleteContractRegistryAction {
<DeleteContractRegistryAction as ::protobuf::Message>::default_instance()
}
}
impl DeleteContractRegistryAction {
pub fn new() -> DeleteContractRegistryAction {
::std::default::Default::default()
}
pub fn get_name(&self) -> &str {
&self.name
}
pub fn clear_name(&mut self) {
self.name.clear();
}
pub fn set_name(&mut self, v: ::std::string::String) {
self.name = v;
}
pub fn mut_name(&mut self) -> &mut ::std::string::String {
&mut self.name
}
pub fn take_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.name, ::std::string::String::new())
}
}
impl ::protobuf::Message for DeleteContractRegistryAction {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
},
_ => {
::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.name.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.name);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if !self.name.is_empty() {
os.write_string(1, &self.name)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> DeleteContractRegistryAction {
DeleteContractRegistryAction::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"name",
|m: &DeleteContractRegistryAction| { &m.name },
|m: &mut DeleteContractRegistryAction| { &mut m.name },
));
::protobuf::reflect::MessageDescriptor::new::<DeleteContractRegistryAction>(
"DeleteContractRegistryAction",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static DeleteContractRegistryAction {
static mut instance: ::protobuf::lazy::Lazy<DeleteContractRegistryAction> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const DeleteContractRegistryAction,
};
unsafe {
instance.get(DeleteContractRegistryAction::new)
}
}
}
impl ::protobuf::Clear for DeleteContractRegistryAction {
fn clear(&mut self) {
self.name.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for DeleteContractRegistryAction {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for DeleteContractRegistryAction {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct UpdateContractRegistryOwnersAction {
pub name: ::std::string::String,
pub owners: ::protobuf::RepeatedField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a UpdateContractRegistryOwnersAction {
fn default() -> &'a UpdateContractRegistryOwnersAction {
<UpdateContractRegistryOwnersAction as ::protobuf::Message>::default_instance()
}
}
impl UpdateContractRegistryOwnersAction {
pub fn new() -> UpdateContractRegistryOwnersAction {
::std::default::Default::default()
}
pub fn get_name(&self) -> &str {
&self.name
}
pub fn clear_name(&mut self) {
self.name.clear();
}
pub fn set_name(&mut self, v: ::std::string::String) {
self.name = v;
}
pub fn mut_name(&mut self) -> &mut ::std::string::String {
&mut self.name
}
pub fn take_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.name, ::std::string::String::new())
}
pub fn get_owners(&self) -> &[::std::string::String] {
&self.owners
}
pub fn clear_owners(&mut self) {
self.owners.clear();
}
pub fn set_owners(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
self.owners = v;
}
pub fn mut_owners(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
&mut self.owners
}
pub fn take_owners(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
::std::mem::replace(&mut self.owners, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for UpdateContractRegistryOwnersAction {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
},
2 => {
::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.owners)?;
},
_ => {
::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.name.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.name);
}
for value in &self.owners {
my_size += ::protobuf::rt::string_size(2, &value);
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if !self.name.is_empty() {
os.write_string(1, &self.name)?;
}
for v in &self.owners {
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() -> UpdateContractRegistryOwnersAction {
UpdateContractRegistryOwnersAction::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"name",
|m: &UpdateContractRegistryOwnersAction| { &m.name },
|m: &mut UpdateContractRegistryOwnersAction| { &mut m.name },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"owners",
|m: &UpdateContractRegistryOwnersAction| { &m.owners },
|m: &mut UpdateContractRegistryOwnersAction| { &mut m.owners },
));
::protobuf::reflect::MessageDescriptor::new::<UpdateContractRegistryOwnersAction>(
"UpdateContractRegistryOwnersAction",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static UpdateContractRegistryOwnersAction {
static mut instance: ::protobuf::lazy::Lazy<UpdateContractRegistryOwnersAction> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const UpdateContractRegistryOwnersAction,
};
unsafe {
instance.get(UpdateContractRegistryOwnersAction::new)
}
}
}
impl ::protobuf::Clear for UpdateContractRegistryOwnersAction {
fn clear(&mut self) {
self.name.clear();
self.owners.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for UpdateContractRegistryOwnersAction {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for UpdateContractRegistryOwnersAction {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CreateNamespaceRegistryAction {
pub namespace: ::std::string::String,
pub owners: ::protobuf::RepeatedField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CreateNamespaceRegistryAction {
fn default() -> &'a CreateNamespaceRegistryAction {
<CreateNamespaceRegistryAction as ::protobuf::Message>::default_instance()
}
}
impl CreateNamespaceRegistryAction {
pub fn new() -> CreateNamespaceRegistryAction {
::std::default::Default::default()
}
pub fn get_namespace(&self) -> &str {
&self.namespace
}
pub fn clear_namespace(&mut self) {
self.namespace.clear();
}
pub fn set_namespace(&mut self, v: ::std::string::String) {
self.namespace = v;
}
pub fn mut_namespace(&mut self) -> &mut ::std::string::String {
&mut self.namespace
}
pub fn take_namespace(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.namespace, ::std::string::String::new())
}
pub fn get_owners(&self) -> &[::std::string::String] {
&self.owners
}
pub fn clear_owners(&mut self) {
self.owners.clear();
}
pub fn set_owners(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
self.owners = v;
}
pub fn mut_owners(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
&mut self.owners
}
pub fn take_owners(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
::std::mem::replace(&mut self.owners, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for CreateNamespaceRegistryAction {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.namespace)?;
},
2 => {
::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.owners)?;
},
_ => {
::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.namespace.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.namespace);
}
for value in &self.owners {
my_size += ::protobuf::rt::string_size(2, &value);
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if !self.namespace.is_empty() {
os.write_string(1, &self.namespace)?;
}
for v in &self.owners {
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() -> CreateNamespaceRegistryAction {
CreateNamespaceRegistryAction::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"namespace",
|m: &CreateNamespaceRegistryAction| { &m.namespace },
|m: &mut CreateNamespaceRegistryAction| { &mut m.namespace },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"owners",
|m: &CreateNamespaceRegistryAction| { &m.owners },
|m: &mut CreateNamespaceRegistryAction| { &mut m.owners },
));
::protobuf::reflect::MessageDescriptor::new::<CreateNamespaceRegistryAction>(
"CreateNamespaceRegistryAction",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static CreateNamespaceRegistryAction {
static mut instance: ::protobuf::lazy::Lazy<CreateNamespaceRegistryAction> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const CreateNamespaceRegistryAction,
};
unsafe {
instance.get(CreateNamespaceRegistryAction::new)
}
}
}
impl ::protobuf::Clear for CreateNamespaceRegistryAction {
fn clear(&mut self) {
self.namespace.clear();
self.owners.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CreateNamespaceRegistryAction {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CreateNamespaceRegistryAction {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct DeleteNamespaceRegistryAction {
pub namespace: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a DeleteNamespaceRegistryAction {
fn default() -> &'a DeleteNamespaceRegistryAction {
<DeleteNamespaceRegistryAction as ::protobuf::Message>::default_instance()
}
}
impl DeleteNamespaceRegistryAction {
pub fn new() -> DeleteNamespaceRegistryAction {
::std::default::Default::default()
}
pub fn get_namespace(&self) -> &str {
&self.namespace
}
pub fn clear_namespace(&mut self) {
self.namespace.clear();
}
pub fn set_namespace(&mut self, v: ::std::string::String) {
self.namespace = v;
}
pub fn mut_namespace(&mut self) -> &mut ::std::string::String {
&mut self.namespace
}
pub fn take_namespace(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.namespace, ::std::string::String::new())
}
}
impl ::protobuf::Message for DeleteNamespaceRegistryAction {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.namespace)?;
},
_ => {
::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.namespace.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.namespace);
}
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.namespace.is_empty() {
os.write_string(1, &self.namespace)?;
}
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() -> DeleteNamespaceRegistryAction {
DeleteNamespaceRegistryAction::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"namespace",
|m: &DeleteNamespaceRegistryAction| { &m.namespace },
|m: &mut DeleteNamespaceRegistryAction| { &mut m.namespace },
));
::protobuf::reflect::MessageDescriptor::new::<DeleteNamespaceRegistryAction>(
"DeleteNamespaceRegistryAction",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static DeleteNamespaceRegistryAction {
static mut instance: ::protobuf::lazy::Lazy<DeleteNamespaceRegistryAction> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const DeleteNamespaceRegistryAction,
};
unsafe {
instance.get(DeleteNamespaceRegistryAction::new)
}
}
}
impl ::protobuf::Clear for DeleteNamespaceRegistryAction {
fn clear(&mut self) {
self.namespace.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for DeleteNamespaceRegistryAction {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for DeleteNamespaceRegistryAction {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct UpdateNamespaceRegistryOwnersAction {
pub namespace: ::std::string::String,
pub owners: ::protobuf::RepeatedField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a UpdateNamespaceRegistryOwnersAction {
fn default() -> &'a UpdateNamespaceRegistryOwnersAction {
<UpdateNamespaceRegistryOwnersAction as ::protobuf::Message>::default_instance()
}
}
impl UpdateNamespaceRegistryOwnersAction {
pub fn new() -> UpdateNamespaceRegistryOwnersAction {
::std::default::Default::default()
}
pub fn get_namespace(&self) -> &str {
&self.namespace
}
pub fn clear_namespace(&mut self) {
self.namespace.clear();
}
pub fn set_namespace(&mut self, v: ::std::string::String) {
self.namespace = v;
}
pub fn mut_namespace(&mut self) -> &mut ::std::string::String {
&mut self.namespace
}
pub fn take_namespace(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.namespace, ::std::string::String::new())
}
pub fn get_owners(&self) -> &[::std::string::String] {
&self.owners
}
pub fn clear_owners(&mut self) {
self.owners.clear();
}
pub fn set_owners(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
self.owners = v;
}
pub fn mut_owners(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
&mut self.owners
}
pub fn take_owners(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
::std::mem::replace(&mut self.owners, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for UpdateNamespaceRegistryOwnersAction {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.namespace)?;
},
2 => {
::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.owners)?;
},
_ => {
::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.namespace.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.namespace);
}
for value in &self.owners {
my_size += ::protobuf::rt::string_size(2, &value);
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if !self.namespace.is_empty() {
os.write_string(1, &self.namespace)?;
}
for v in &self.owners {
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() -> UpdateNamespaceRegistryOwnersAction {
UpdateNamespaceRegistryOwnersAction::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"namespace",
|m: &UpdateNamespaceRegistryOwnersAction| { &m.namespace },
|m: &mut UpdateNamespaceRegistryOwnersAction| { &mut m.namespace },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"owners",
|m: &UpdateNamespaceRegistryOwnersAction| { &m.owners },
|m: &mut UpdateNamespaceRegistryOwnersAction| { &mut m.owners },
));
::protobuf::reflect::MessageDescriptor::new::<UpdateNamespaceRegistryOwnersAction>(
"UpdateNamespaceRegistryOwnersAction",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static UpdateNamespaceRegistryOwnersAction {
static mut instance: ::protobuf::lazy::Lazy<UpdateNamespaceRegistryOwnersAction> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const UpdateNamespaceRegistryOwnersAction,
};
unsafe {
instance.get(UpdateNamespaceRegistryOwnersAction::new)
}
}
}
impl ::protobuf::Clear for UpdateNamespaceRegistryOwnersAction {
fn clear(&mut self) {
self.namespace.clear();
self.owners.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for UpdateNamespaceRegistryOwnersAction {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for UpdateNamespaceRegistryOwnersAction {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CreateNamespaceRegistryPermissionAction {
pub namespace: ::std::string::String,
pub contract_name: ::std::string::String,
pub read: bool,
pub write: bool,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CreateNamespaceRegistryPermissionAction {
fn default() -> &'a CreateNamespaceRegistryPermissionAction {
<CreateNamespaceRegistryPermissionAction as ::protobuf::Message>::default_instance()
}
}
impl CreateNamespaceRegistryPermissionAction {
pub fn new() -> CreateNamespaceRegistryPermissionAction {
::std::default::Default::default()
}
pub fn get_namespace(&self) -> &str {
&self.namespace
}
pub fn clear_namespace(&mut self) {
self.namespace.clear();
}
pub fn set_namespace(&mut self, v: ::std::string::String) {
self.namespace = v;
}
pub fn mut_namespace(&mut self) -> &mut ::std::string::String {
&mut self.namespace
}
pub fn take_namespace(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.namespace, ::std::string::String::new())
}
pub fn get_contract_name(&self) -> &str {
&self.contract_name
}
pub fn clear_contract_name(&mut self) {
self.contract_name.clear();
}
pub fn set_contract_name(&mut self, v: ::std::string::String) {
self.contract_name = v;
}
pub fn mut_contract_name(&mut self) -> &mut ::std::string::String {
&mut self.contract_name
}
pub fn take_contract_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.contract_name, ::std::string::String::new())
}
pub fn get_read(&self) -> bool {
self.read
}
pub fn clear_read(&mut self) {
self.read = false;
}
pub fn set_read(&mut self, v: bool) {
self.read = v;
}
pub fn get_write(&self) -> bool {
self.write
}
pub fn clear_write(&mut self) {
self.write = false;
}
pub fn set_write(&mut self, v: bool) {
self.write = v;
}
}
impl ::protobuf::Message for CreateNamespaceRegistryPermissionAction {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.namespace)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.contract_name)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.read = tmp;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.write = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.namespace.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.namespace);
}
if !self.contract_name.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.contract_name);
}
if self.read != false {
my_size += 2;
}
if self.write != false {
my_size += 2;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if !self.namespace.is_empty() {
os.write_string(1, &self.namespace)?;
}
if !self.contract_name.is_empty() {
os.write_string(2, &self.contract_name)?;
}
if self.read != false {
os.write_bool(3, self.read)?;
}
if self.write != false {
os.write_bool(4, self.write)?;
}
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() -> CreateNamespaceRegistryPermissionAction {
CreateNamespaceRegistryPermissionAction::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"namespace",
|m: &CreateNamespaceRegistryPermissionAction| { &m.namespace },
|m: &mut CreateNamespaceRegistryPermissionAction| { &mut m.namespace },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"contract_name",
|m: &CreateNamespaceRegistryPermissionAction| { &m.contract_name },
|m: &mut CreateNamespaceRegistryPermissionAction| { &mut m.contract_name },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"read",
|m: &CreateNamespaceRegistryPermissionAction| { &m.read },
|m: &mut CreateNamespaceRegistryPermissionAction| { &mut m.read },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"write",
|m: &CreateNamespaceRegistryPermissionAction| { &m.write },
|m: &mut CreateNamespaceRegistryPermissionAction| { &mut m.write },
));
::protobuf::reflect::MessageDescriptor::new::<CreateNamespaceRegistryPermissionAction>(
"CreateNamespaceRegistryPermissionAction",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static CreateNamespaceRegistryPermissionAction {
static mut instance: ::protobuf::lazy::Lazy<CreateNamespaceRegistryPermissionAction> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const CreateNamespaceRegistryPermissionAction,
};
unsafe {
instance.get(CreateNamespaceRegistryPermissionAction::new)
}
}
}
impl ::protobuf::Clear for CreateNamespaceRegistryPermissionAction {
fn clear(&mut self) {
self.namespace.clear();
self.contract_name.clear();
self.read = false;
self.write = false;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CreateNamespaceRegistryPermissionAction {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CreateNamespaceRegistryPermissionAction {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct DeleteNamespaceRegistryPermissionAction {
pub namespace: ::std::string::String,
pub contract_name: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a DeleteNamespaceRegistryPermissionAction {
fn default() -> &'a DeleteNamespaceRegistryPermissionAction {
<DeleteNamespaceRegistryPermissionAction as ::protobuf::Message>::default_instance()
}
}
impl DeleteNamespaceRegistryPermissionAction {
pub fn new() -> DeleteNamespaceRegistryPermissionAction {
::std::default::Default::default()
}
pub fn get_namespace(&self) -> &str {
&self.namespace
}
pub fn clear_namespace(&mut self) {
self.namespace.clear();
}
pub fn set_namespace(&mut self, v: ::std::string::String) {
self.namespace = v;
}
pub fn mut_namespace(&mut self) -> &mut ::std::string::String {
&mut self.namespace
}
pub fn take_namespace(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.namespace, ::std::string::String::new())
}
pub fn get_contract_name(&self) -> &str {
&self.contract_name
}
pub fn clear_contract_name(&mut self) {
self.contract_name.clear();
}
pub fn set_contract_name(&mut self, v: ::std::string::String) {
self.contract_name = v;
}
pub fn mut_contract_name(&mut self) -> &mut ::std::string::String {
&mut self.contract_name
}
pub fn take_contract_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.contract_name, ::std::string::String::new())
}
}
impl ::protobuf::Message for DeleteNamespaceRegistryPermissionAction {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.namespace)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.contract_name)?;
},
_ => {
::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.namespace.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.namespace);
}
if !self.contract_name.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.contract_name);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if !self.namespace.is_empty() {
os.write_string(1, &self.namespace)?;
}
if !self.contract_name.is_empty() {
os.write_string(2, &self.contract_name)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> DeleteNamespaceRegistryPermissionAction {
DeleteNamespaceRegistryPermissionAction::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"namespace",
|m: &DeleteNamespaceRegistryPermissionAction| { &m.namespace },
|m: &mut DeleteNamespaceRegistryPermissionAction| { &mut m.namespace },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"contract_name",
|m: &DeleteNamespaceRegistryPermissionAction| { &m.contract_name },
|m: &mut DeleteNamespaceRegistryPermissionAction| { &mut m.contract_name },
));
::protobuf::reflect::MessageDescriptor::new::<DeleteNamespaceRegistryPermissionAction>(
"DeleteNamespaceRegistryPermissionAction",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static DeleteNamespaceRegistryPermissionAction {
static mut instance: ::protobuf::lazy::Lazy<DeleteNamespaceRegistryPermissionAction> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const DeleteNamespaceRegistryPermissionAction,
};
unsafe {
instance.get(DeleteNamespaceRegistryPermissionAction::new)
}
}
}
impl ::protobuf::Clear for DeleteNamespaceRegistryPermissionAction {
fn clear(&mut self) {
self.namespace.clear();
self.contract_name.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for DeleteNamespaceRegistryPermissionAction {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for DeleteNamespaceRegistryPermissionAction {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CreateSmartPermissionAction {
pub name: ::std::string::String,
pub org_id: ::std::string::String,
pub function: ::std::vec::Vec<u8>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CreateSmartPermissionAction {
fn default() -> &'a CreateSmartPermissionAction {
<CreateSmartPermissionAction as ::protobuf::Message>::default_instance()
}
}
impl CreateSmartPermissionAction {
pub fn new() -> CreateSmartPermissionAction {
::std::default::Default::default()
}
pub fn get_name(&self) -> &str {
&self.name
}
pub fn clear_name(&mut self) {
self.name.clear();
}
pub fn set_name(&mut self, v: ::std::string::String) {
self.name = v;
}
pub fn mut_name(&mut self) -> &mut ::std::string::String {
&mut self.name
}
pub fn take_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.name, ::std::string::String::new())
}
pub fn get_org_id(&self) -> &str {
&self.org_id
}
pub fn clear_org_id(&mut self) {
self.org_id.clear();
}
pub fn set_org_id(&mut self, v: ::std::string::String) {
self.org_id = v;
}
pub fn mut_org_id(&mut self) -> &mut ::std::string::String {
&mut self.org_id
}
pub fn take_org_id(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.org_id, ::std::string::String::new())
}
pub fn get_function(&self) -> &[u8] {
&self.function
}
pub fn clear_function(&mut self) {
self.function.clear();
}
pub fn set_function(&mut self, v: ::std::vec::Vec<u8>) {
self.function = v;
}
pub fn mut_function(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.function
}
pub fn take_function(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.function, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for CreateSmartPermissionAction {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.org_id)?;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.function)?;
},
_ => {
::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.name.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.name);
}
if !self.org_id.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.org_id);
}
if !self.function.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.function);
}
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.name.is_empty() {
os.write_string(1, &self.name)?;
}
if !self.org_id.is_empty() {
os.write_string(2, &self.org_id)?;
}
if !self.function.is_empty() {
os.write_bytes(3, &self.function)?;
}
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() -> CreateSmartPermissionAction {
CreateSmartPermissionAction::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"name",
|m: &CreateSmartPermissionAction| { &m.name },
|m: &mut CreateSmartPermissionAction| { &mut m.name },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"org_id",
|m: &CreateSmartPermissionAction| { &m.org_id },
|m: &mut CreateSmartPermissionAction| { &mut m.org_id },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"function",
|m: &CreateSmartPermissionAction| { &m.function },
|m: &mut CreateSmartPermissionAction| { &mut m.function },
));
::protobuf::reflect::MessageDescriptor::new::<CreateSmartPermissionAction>(
"CreateSmartPermissionAction",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static CreateSmartPermissionAction {
static mut instance: ::protobuf::lazy::Lazy<CreateSmartPermissionAction> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const CreateSmartPermissionAction,
};
unsafe {
instance.get(CreateSmartPermissionAction::new)
}
}
}
impl ::protobuf::Clear for CreateSmartPermissionAction {
fn clear(&mut self) {
self.name.clear();
self.org_id.clear();
self.function.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CreateSmartPermissionAction {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CreateSmartPermissionAction {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct UpdateSmartPermissionAction {
pub name: ::std::string::String,
pub org_id: ::std::string::String,
pub function: ::std::vec::Vec<u8>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a UpdateSmartPermissionAction {
fn default() -> &'a UpdateSmartPermissionAction {
<UpdateSmartPermissionAction as ::protobuf::Message>::default_instance()
}
}
impl UpdateSmartPermissionAction {
pub fn new() -> UpdateSmartPermissionAction {
::std::default::Default::default()
}
pub fn get_name(&self) -> &str {
&self.name
}
pub fn clear_name(&mut self) {
self.name.clear();
}
pub fn set_name(&mut self, v: ::std::string::String) {
self.name = v;
}
pub fn mut_name(&mut self) -> &mut ::std::string::String {
&mut self.name
}
pub fn take_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.name, ::std::string::String::new())
}
pub fn get_org_id(&self) -> &str {
&self.org_id
}
pub fn clear_org_id(&mut self) {
self.org_id.clear();
}
pub fn set_org_id(&mut self, v: ::std::string::String) {
self.org_id = v;
}
pub fn mut_org_id(&mut self) -> &mut ::std::string::String {
&mut self.org_id
}
pub fn take_org_id(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.org_id, ::std::string::String::new())
}
pub fn get_function(&self) -> &[u8] {
&self.function
}
pub fn clear_function(&mut self) {
self.function.clear();
}
pub fn set_function(&mut self, v: ::std::vec::Vec<u8>) {
self.function = v;
}
pub fn mut_function(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.function
}
pub fn take_function(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.function, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for UpdateSmartPermissionAction {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.org_id)?;
},
3 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.function)?;
},
_ => {
::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.name.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.name);
}
if !self.org_id.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.org_id);
}
if !self.function.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.function);
}
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.name.is_empty() {
os.write_string(1, &self.name)?;
}
if !self.org_id.is_empty() {
os.write_string(2, &self.org_id)?;
}
if !self.function.is_empty() {
os.write_bytes(3, &self.function)?;
}
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() -> UpdateSmartPermissionAction {
UpdateSmartPermissionAction::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"name",
|m: &UpdateSmartPermissionAction| { &m.name },
|m: &mut UpdateSmartPermissionAction| { &mut m.name },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"org_id",
|m: &UpdateSmartPermissionAction| { &m.org_id },
|m: &mut UpdateSmartPermissionAction| { &mut m.org_id },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"function",
|m: &UpdateSmartPermissionAction| { &m.function },
|m: &mut UpdateSmartPermissionAction| { &mut m.function },
));
::protobuf::reflect::MessageDescriptor::new::<UpdateSmartPermissionAction>(
"UpdateSmartPermissionAction",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static UpdateSmartPermissionAction {
static mut instance: ::protobuf::lazy::Lazy<UpdateSmartPermissionAction> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const UpdateSmartPermissionAction,
};
unsafe {
instance.get(UpdateSmartPermissionAction::new)
}
}
}
impl ::protobuf::Clear for UpdateSmartPermissionAction {
fn clear(&mut self) {
self.name.clear();
self.org_id.clear();
self.function.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for UpdateSmartPermissionAction {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for UpdateSmartPermissionAction {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct DeleteSmartPermissionAction {
pub name: ::std::string::String,
pub org_id: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a DeleteSmartPermissionAction {
fn default() -> &'a DeleteSmartPermissionAction {
<DeleteSmartPermissionAction as ::protobuf::Message>::default_instance()
}
}
impl DeleteSmartPermissionAction {
pub fn new() -> DeleteSmartPermissionAction {
::std::default::Default::default()
}
pub fn get_name(&self) -> &str {
&self.name
}
pub fn clear_name(&mut self) {
self.name.clear();
}
pub fn set_name(&mut self, v: ::std::string::String) {
self.name = v;
}
pub fn mut_name(&mut self) -> &mut ::std::string::String {
&mut self.name
}
pub fn take_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.name, ::std::string::String::new())
}
pub fn get_org_id(&self) -> &str {
&self.org_id
}
pub fn clear_org_id(&mut self) {
self.org_id.clear();
}
pub fn set_org_id(&mut self, v: ::std::string::String) {
self.org_id = v;
}
pub fn mut_org_id(&mut self) -> &mut ::std::string::String {
&mut self.org_id
}
pub fn take_org_id(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.org_id, ::std::string::String::new())
}
}
impl ::protobuf::Message for DeleteSmartPermissionAction {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.org_id)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.name.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.name);
}
if !self.org_id.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.org_id);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if !self.name.is_empty() {
os.write_string(1, &self.name)?;
}
if !self.org_id.is_empty() {
os.write_string(2, &self.org_id)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> DeleteSmartPermissionAction {
DeleteSmartPermissionAction::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"name",
|m: &DeleteSmartPermissionAction| { &m.name },
|m: &mut DeleteSmartPermissionAction| { &mut m.name },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"org_id",
|m: &DeleteSmartPermissionAction| { &m.org_id },
|m: &mut DeleteSmartPermissionAction| { &mut m.org_id },
));
::protobuf::reflect::MessageDescriptor::new::<DeleteSmartPermissionAction>(
"DeleteSmartPermissionAction",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static DeleteSmartPermissionAction {
static mut instance: ::protobuf::lazy::Lazy<DeleteSmartPermissionAction> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const DeleteSmartPermissionAction,
};
unsafe {
instance.get(DeleteSmartPermissionAction::new)
}
}
}
impl ::protobuf::Clear for DeleteSmartPermissionAction {
fn clear(&mut self) {
self.name.clear();
self.org_id.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for DeleteSmartPermissionAction {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for DeleteSmartPermissionAction {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\rpayload.proto\"\x89\x0e\n\x0cSabrePayload\x12,\n\x06action\x18\x01\
\x20\x01(\x0e2\x14.SabrePayload.ActionR\x06action\x12>\n\x0fcreate_contr\
act\x18\x02\x20\x01(\x0b2\x15.CreateContractActionR\x0ecreateContract\
\x12>\n\x0fdelete_contract\x18\x03\x20\x01(\x0b2\x15.DeleteContractActio\
nR\x0edeleteContract\x12A\n\x10execute_contract\x18\x04\x20\x01(\x0b2\
\x16.ExecuteContractActionR\x0fexecuteContract\x12W\n\x18create_contract\
_registry\x18\x05\x20\x01(\x0b2\x1d.CreateContractRegistryActionR\x16cre\
ateContractRegistry\x12W\n\x18delete_contract_registry\x18\x06\x20\x01(\
\x0b2\x1d.DeleteContractRegistryActionR\x16deleteContractRegistry\x12j\n\
\x1fupdate_contract_registry_owners\x18\x07\x20\x01(\x0b2#.UpdateContrac\
tRegistryOwnersActionR\x1cupdateContractRegistryOwners\x12Z\n\x19create_\
namespace_registry\x18\x08\x20\x01(\x0b2\x1e.CreateNamespaceRegistryActi\
onR\x17createNamespaceRegistry\x12Z\n\x19delete_namespace_registry\x18\t\
\x20\x01(\x0b2\x1e.DeleteNamespaceRegistryActionR\x17deleteNamespaceRegi\
stry\x12m\n\x20update_namespace_registry_owners\x18\n\x20\x01(\x0b2$.Upd\
ateNamespaceRegistryOwnersActionR\x1dupdateNamespaceRegistryOwners\x12y\
\n$create_namespace_registry_permission\x18\x0b\x20\x01(\x0b2(.CreateNam\
espaceRegistryPermissionActionR!createNamespaceRegistryPermission\x12y\n\
$delete_namespace_registry_permission\x18\x0c\x20\x01(\x0b2(.DeleteNames\
paceRegistryPermissionActionR!deleteNamespaceRegistryPermission\x12T\n\
\x17create_smart_permission\x18\r\x20\x01(\x0b2\x1c.CreateSmartPermissio\
nActionR\x15createSmartPermission\x12T\n\x17update_smart_permission\x18\
\x0e\x20\x01(\x0b2\x1c.UpdateSmartPermissionActionR\x15updateSmartPermis\
sion\x12T\n\x17delete_smart_permission\x18\x0f\x20\x01(\x0b2\x1c.DeleteS\
martPermissionActionR\x15deleteSmartPermission\"\xca\x03\n\x06Action\x12\
\x10\n\x0cACTION_UNSET\x10\0\x12\x13\n\x0fCREATE_CONTRACT\x10\x01\x12\
\x13\n\x0fDELETE_CONTRACT\x10\x02\x12\x14\n\x10EXECUTE_CONTRACT\x10\x03\
\x12\x1c\n\x18CREATE_CONTRACT_REGISTRY\x10\x04\x12\x1c\n\x18DELETE_CONTR\
ACT_REGISTRY\x10\x05\x12#\n\x1fUPDATE_CONTRACT_REGISTRY_OWNERS\x10\x06\
\x12\x1d\n\x19CREATE_NAMESPACE_REGISTRY\x10\x07\x12\x1d\n\x19DELETE_NAME\
SPACE_REGISTRY\x10\x08\x12$\n\x20UPDATE_NAMESPACE_REGISTRY_OWNERS\x10\t\
\x12(\n$CREATE_NAMESPACE_REGISTRY_PERMISSION\x10\n\x12(\n$DELETE_NAMESPA\
CE_REGISTRY_PERMISSION\x10\x0b\x12\x1b\n\x17CREATE_SMART_PERMISSION\x10\
\x0c\x12\x1b\n\x17UPDATE_SMART_PERMISSION\x10\r\x12\x1b\n\x17DELETE_SMAR\
T_PERMISSION\x10\x0e\"\x92\x01\n\x14CreateContractAction\x12\x12\n\x04na\
me\x18\x01\x20\x01(\tR\x04name\x12\x18\n\x07version\x18\x02\x20\x01(\tR\
\x07version\x12\x16\n\x06inputs\x18\x03\x20\x03(\tR\x06inputs\x12\x18\n\
\x07outputs\x18\x04\x20\x03(\tR\x07outputs\x12\x1a\n\x08contract\x18\x05\
\x20\x01(\x0cR\x08contract\"D\n\x14DeleteContractAction\x12\x12\n\x04nam\
e\x18\x01\x20\x01(\tR\x04name\x12\x18\n\x07version\x18\x02\x20\x01(\tR\
\x07version\"\x91\x01\n\x15ExecuteContractAction\x12\x12\n\x04name\x18\
\x01\x20\x01(\tR\x04name\x12\x18\n\x07version\x18\x02\x20\x01(\tR\x07ver\
sion\x12\x16\n\x06inputs\x18\x03\x20\x03(\tR\x06inputs\x12\x18\n\x07outp\
uts\x18\x04\x20\x03(\tR\x07outputs\x12\x18\n\x07payload\x18\x05\x20\x01(\
\x0cR\x07payload\"J\n\x1cCreateContractRegistryAction\x12\x12\n\x04name\
\x18\x01\x20\x01(\tR\x04name\x12\x16\n\x06owners\x18\x02\x20\x03(\tR\x06\
owners\"2\n\x1cDeleteContractRegistryAction\x12\x12\n\x04name\x18\x01\
\x20\x01(\tR\x04name\"P\n\"UpdateContractRegistryOwnersAction\x12\x12\n\
\x04name\x18\x01\x20\x01(\tR\x04name\x12\x16\n\x06owners\x18\x02\x20\x03\
(\tR\x06owners\"U\n\x1dCreateNamespaceRegistryAction\x12\x1c\n\tnamespac\
e\x18\x01\x20\x01(\tR\tnamespace\x12\x16\n\x06owners\x18\x02\x20\x03(\tR\
\x06owners\"=\n\x1dDeleteNamespaceRegistryAction\x12\x1c\n\tnamespace\
\x18\x01\x20\x01(\tR\tnamespace\"[\n#UpdateNamespaceRegistryOwnersAction\
\x12\x1c\n\tnamespace\x18\x01\x20\x01(\tR\tnamespace\x12\x16\n\x06owners\
\x18\x02\x20\x03(\tR\x06owners\"\x96\x01\n'CreateNamespaceRegistryPermis\
sionAction\x12\x1c\n\tnamespace\x18\x01\x20\x01(\tR\tnamespace\x12#\n\rc\
ontract_name\x18\x02\x20\x01(\tR\x0ccontractName\x12\x12\n\x04read\x18\
\x03\x20\x01(\x08R\x04read\x12\x14\n\x05write\x18\x04\x20\x01(\x08R\x05w\
rite\"l\n'DeleteNamespaceRegistryPermissionAction\x12\x1c\n\tnamespace\
\x18\x01\x20\x01(\tR\tnamespace\x12#\n\rcontract_name\x18\x02\x20\x01(\t\
R\x0ccontractName\"d\n\x1bCreateSmartPermissionAction\x12\x12\n\x04name\
\x18\x01\x20\x01(\tR\x04name\x12\x15\n\x06org_id\x18\x02\x20\x01(\tR\x05\
orgId\x12\x1a\n\x08function\x18\x03\x20\x01(\x0cR\x08function\"d\n\x1bUp\
dateSmartPermissionAction\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\
\x12\x15\n\x06org_id\x18\x02\x20\x01(\tR\x05orgId\x12\x1a\n\x08function\
\x18\x03\x20\x01(\x0cR\x08function\"H\n\x1bDeleteSmartPermissionAction\
\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\x15\n\x06org_id\x18\
\x02\x20\x01(\tR\x05orgIdb\x06proto3\
";
static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto,
};
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()
})
}
}