pub mod transforms {
#![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_2;
#[derive(PartialEq,Clone,Default)]
pub struct TypeMismatch {
pub expected: ::std::string::String,
pub found: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TypeMismatch {
fn default() -> &'a TypeMismatch {
<TypeMismatch as ::protobuf::Message>::default_instance()
}
}
impl TypeMismatch {
pub fn new() -> TypeMismatch {
::std::default::Default::default()
}
pub fn get_expected(&self) -> &str {
&self.expected
}
pub fn clear_expected(&mut self) {
self.expected.clear();
}
pub fn set_expected(&mut self, v: ::std::string::String) {
self.expected = v;
}
pub fn mut_expected(&mut self) -> &mut ::std::string::String {
&mut self.expected
}
pub fn take_expected(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.expected, ::std::string::String::new())
}
pub fn get_found(&self) -> &str {
&self.found
}
pub fn clear_found(&mut self) {
self.found.clear();
}
pub fn set_found(&mut self, v: ::std::string::String) {
self.found = v;
}
pub fn mut_found(&mut self) -> &mut ::std::string::String {
&mut self.found
}
pub fn take_found(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.found, ::std::string::String::new())
}
}
impl ::protobuf::Message for TypeMismatch {
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.expected)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.found)?;
},
_ => {
::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.expected.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.expected);
}
if !self.found.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.found);
}
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.expected.is_empty() {
os.write_string(1, &self.expected)?;
}
if !self.found.is_empty() {
os.write_string(2, &self.found)?;
}
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() -> TypeMismatch {
TypeMismatch::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>(
"expected",
|m: &TypeMismatch| { &m.expected },
|m: &mut TypeMismatch| { &mut m.expected },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"found",
|m: &TypeMismatch| { &m.found },
|m: &mut TypeMismatch| { &mut m.found },
));
::protobuf::reflect::MessageDescriptor::new::<TypeMismatch>(
"TypeMismatch",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static TypeMismatch {
static mut instance: ::protobuf::lazy::Lazy<TypeMismatch> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const TypeMismatch,
};
unsafe {
instance.get(TypeMismatch::new)
}
}
}
impl ::protobuf::Clear for TypeMismatch {
fn clear(&mut self) {
self.expected.clear();
self.found.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TypeMismatch {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TypeMismatch {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Transform {
pub transform_instance: ::std::option::Option<Transform_oneof_transform_instance>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Transform {
fn default() -> &'a Transform {
<Transform as ::protobuf::Message>::default_instance()
}
}
#[derive(Clone,PartialEq,Debug)]
pub enum Transform_oneof_transform_instance {
identity(TransformIdentity),
add_i32(TransformAddInt32),
add_u64(TransformAddUInt64),
write(TransformWrite),
add_keys(TransformAddKeys),
failure(TransformFailure),
add_big_int(TransformAddBigInt),
}
impl Transform {
pub fn new() -> Transform {
::std::default::Default::default()
}
pub fn get_identity(&self) -> &TransformIdentity {
match self.transform_instance {
::std::option::Option::Some(Transform_oneof_transform_instance::identity(ref v)) => v,
_ => TransformIdentity::default_instance(),
}
}
pub fn clear_identity(&mut self) {
self.transform_instance = ::std::option::Option::None;
}
pub fn has_identity(&self) -> bool {
match self.transform_instance {
::std::option::Option::Some(Transform_oneof_transform_instance::identity(..)) => true,
_ => false,
}
}
pub fn set_identity(&mut self, v: TransformIdentity) {
self.transform_instance = ::std::option::Option::Some(Transform_oneof_transform_instance::identity(v))
}
pub fn mut_identity(&mut self) -> &mut TransformIdentity {
if let ::std::option::Option::Some(Transform_oneof_transform_instance::identity(_)) = self.transform_instance {
} else {
self.transform_instance = ::std::option::Option::Some(Transform_oneof_transform_instance::identity(TransformIdentity::new()));
}
match self.transform_instance {
::std::option::Option::Some(Transform_oneof_transform_instance::identity(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_identity(&mut self) -> TransformIdentity {
if self.has_identity() {
match self.transform_instance.take() {
::std::option::Option::Some(Transform_oneof_transform_instance::identity(v)) => v,
_ => panic!(),
}
} else {
TransformIdentity::new()
}
}
pub fn get_add_i32(&self) -> &TransformAddInt32 {
match self.transform_instance {
::std::option::Option::Some(Transform_oneof_transform_instance::add_i32(ref v)) => v,
_ => TransformAddInt32::default_instance(),
}
}
pub fn clear_add_i32(&mut self) {
self.transform_instance = ::std::option::Option::None;
}
pub fn has_add_i32(&self) -> bool {
match self.transform_instance {
::std::option::Option::Some(Transform_oneof_transform_instance::add_i32(..)) => true,
_ => false,
}
}
pub fn set_add_i32(&mut self, v: TransformAddInt32) {
self.transform_instance = ::std::option::Option::Some(Transform_oneof_transform_instance::add_i32(v))
}
pub fn mut_add_i32(&mut self) -> &mut TransformAddInt32 {
if let ::std::option::Option::Some(Transform_oneof_transform_instance::add_i32(_)) = self.transform_instance {
} else {
self.transform_instance = ::std::option::Option::Some(Transform_oneof_transform_instance::add_i32(TransformAddInt32::new()));
}
match self.transform_instance {
::std::option::Option::Some(Transform_oneof_transform_instance::add_i32(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_add_i32(&mut self) -> TransformAddInt32 {
if self.has_add_i32() {
match self.transform_instance.take() {
::std::option::Option::Some(Transform_oneof_transform_instance::add_i32(v)) => v,
_ => panic!(),
}
} else {
TransformAddInt32::new()
}
}
pub fn get_add_u64(&self) -> &TransformAddUInt64 {
match self.transform_instance {
::std::option::Option::Some(Transform_oneof_transform_instance::add_u64(ref v)) => v,
_ => TransformAddUInt64::default_instance(),
}
}
pub fn clear_add_u64(&mut self) {
self.transform_instance = ::std::option::Option::None;
}
pub fn has_add_u64(&self) -> bool {
match self.transform_instance {
::std::option::Option::Some(Transform_oneof_transform_instance::add_u64(..)) => true,
_ => false,
}
}
pub fn set_add_u64(&mut self, v: TransformAddUInt64) {
self.transform_instance = ::std::option::Option::Some(Transform_oneof_transform_instance::add_u64(v))
}
pub fn mut_add_u64(&mut self) -> &mut TransformAddUInt64 {
if let ::std::option::Option::Some(Transform_oneof_transform_instance::add_u64(_)) = self.transform_instance {
} else {
self.transform_instance = ::std::option::Option::Some(Transform_oneof_transform_instance::add_u64(TransformAddUInt64::new()));
}
match self.transform_instance {
::std::option::Option::Some(Transform_oneof_transform_instance::add_u64(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_add_u64(&mut self) -> TransformAddUInt64 {
if self.has_add_u64() {
match self.transform_instance.take() {
::std::option::Option::Some(Transform_oneof_transform_instance::add_u64(v)) => v,
_ => panic!(),
}
} else {
TransformAddUInt64::new()
}
}
pub fn get_write(&self) -> &TransformWrite {
match self.transform_instance {
::std::option::Option::Some(Transform_oneof_transform_instance::write(ref v)) => v,
_ => TransformWrite::default_instance(),
}
}
pub fn clear_write(&mut self) {
self.transform_instance = ::std::option::Option::None;
}
pub fn has_write(&self) -> bool {
match self.transform_instance {
::std::option::Option::Some(Transform_oneof_transform_instance::write(..)) => true,
_ => false,
}
}
pub fn set_write(&mut self, v: TransformWrite) {
self.transform_instance = ::std::option::Option::Some(Transform_oneof_transform_instance::write(v))
}
pub fn mut_write(&mut self) -> &mut TransformWrite {
if let ::std::option::Option::Some(Transform_oneof_transform_instance::write(_)) = self.transform_instance {
} else {
self.transform_instance = ::std::option::Option::Some(Transform_oneof_transform_instance::write(TransformWrite::new()));
}
match self.transform_instance {
::std::option::Option::Some(Transform_oneof_transform_instance::write(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_write(&mut self) -> TransformWrite {
if self.has_write() {
match self.transform_instance.take() {
::std::option::Option::Some(Transform_oneof_transform_instance::write(v)) => v,
_ => panic!(),
}
} else {
TransformWrite::new()
}
}
pub fn get_add_keys(&self) -> &TransformAddKeys {
match self.transform_instance {
::std::option::Option::Some(Transform_oneof_transform_instance::add_keys(ref v)) => v,
_ => TransformAddKeys::default_instance(),
}
}
pub fn clear_add_keys(&mut self) {
self.transform_instance = ::std::option::Option::None;
}
pub fn has_add_keys(&self) -> bool {
match self.transform_instance {
::std::option::Option::Some(Transform_oneof_transform_instance::add_keys(..)) => true,
_ => false,
}
}
pub fn set_add_keys(&mut self, v: TransformAddKeys) {
self.transform_instance = ::std::option::Option::Some(Transform_oneof_transform_instance::add_keys(v))
}
pub fn mut_add_keys(&mut self) -> &mut TransformAddKeys {
if let ::std::option::Option::Some(Transform_oneof_transform_instance::add_keys(_)) = self.transform_instance {
} else {
self.transform_instance = ::std::option::Option::Some(Transform_oneof_transform_instance::add_keys(TransformAddKeys::new()));
}
match self.transform_instance {
::std::option::Option::Some(Transform_oneof_transform_instance::add_keys(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_add_keys(&mut self) -> TransformAddKeys {
if self.has_add_keys() {
match self.transform_instance.take() {
::std::option::Option::Some(Transform_oneof_transform_instance::add_keys(v)) => v,
_ => panic!(),
}
} else {
TransformAddKeys::new()
}
}
pub fn get_failure(&self) -> &TransformFailure {
match self.transform_instance {
::std::option::Option::Some(Transform_oneof_transform_instance::failure(ref v)) => v,
_ => TransformFailure::default_instance(),
}
}
pub fn clear_failure(&mut self) {
self.transform_instance = ::std::option::Option::None;
}
pub fn has_failure(&self) -> bool {
match self.transform_instance {
::std::option::Option::Some(Transform_oneof_transform_instance::failure(..)) => true,
_ => false,
}
}
pub fn set_failure(&mut self, v: TransformFailure) {
self.transform_instance = ::std::option::Option::Some(Transform_oneof_transform_instance::failure(v))
}
pub fn mut_failure(&mut self) -> &mut TransformFailure {
if let ::std::option::Option::Some(Transform_oneof_transform_instance::failure(_)) = self.transform_instance {
} else {
self.transform_instance = ::std::option::Option::Some(Transform_oneof_transform_instance::failure(TransformFailure::new()));
}
match self.transform_instance {
::std::option::Option::Some(Transform_oneof_transform_instance::failure(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_failure(&mut self) -> TransformFailure {
if self.has_failure() {
match self.transform_instance.take() {
::std::option::Option::Some(Transform_oneof_transform_instance::failure(v)) => v,
_ => panic!(),
}
} else {
TransformFailure::new()
}
}
pub fn get_add_big_int(&self) -> &TransformAddBigInt {
match self.transform_instance {
::std::option::Option::Some(Transform_oneof_transform_instance::add_big_int(ref v)) => v,
_ => TransformAddBigInt::default_instance(),
}
}
pub fn clear_add_big_int(&mut self) {
self.transform_instance = ::std::option::Option::None;
}
pub fn has_add_big_int(&self) -> bool {
match self.transform_instance {
::std::option::Option::Some(Transform_oneof_transform_instance::add_big_int(..)) => true,
_ => false,
}
}
pub fn set_add_big_int(&mut self, v: TransformAddBigInt) {
self.transform_instance = ::std::option::Option::Some(Transform_oneof_transform_instance::add_big_int(v))
}
pub fn mut_add_big_int(&mut self) -> &mut TransformAddBigInt {
if let ::std::option::Option::Some(Transform_oneof_transform_instance::add_big_int(_)) = self.transform_instance {
} else {
self.transform_instance = ::std::option::Option::Some(Transform_oneof_transform_instance::add_big_int(TransformAddBigInt::new()));
}
match self.transform_instance {
::std::option::Option::Some(Transform_oneof_transform_instance::add_big_int(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_add_big_int(&mut self) -> TransformAddBigInt {
if self.has_add_big_int() {
match self.transform_instance.take() {
::std::option::Option::Some(Transform_oneof_transform_instance::add_big_int(v)) => v,
_ => panic!(),
}
} else {
TransformAddBigInt::new()
}
}
}
impl ::protobuf::Message for Transform {
fn is_initialized(&self) -> bool {
if let Some(Transform_oneof_transform_instance::identity(ref v)) = self.transform_instance {
if !v.is_initialized() {
return false;
}
}
if let Some(Transform_oneof_transform_instance::add_i32(ref v)) = self.transform_instance {
if !v.is_initialized() {
return false;
}
}
if let Some(Transform_oneof_transform_instance::add_u64(ref v)) = self.transform_instance {
if !v.is_initialized() {
return false;
}
}
if let Some(Transform_oneof_transform_instance::write(ref v)) = self.transform_instance {
if !v.is_initialized() {
return false;
}
}
if let Some(Transform_oneof_transform_instance::add_keys(ref v)) = self.transform_instance {
if !v.is_initialized() {
return false;
}
}
if let Some(Transform_oneof_transform_instance::failure(ref v)) = self.transform_instance {
if !v.is_initialized() {
return false;
}
}
if let Some(Transform_oneof_transform_instance::add_big_int(ref v)) = self.transform_instance {
if !v.is_initialized() {
return false;
}
}
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.transform_instance = ::std::option::Option::Some(Transform_oneof_transform_instance::identity(is.read_message()?));
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.transform_instance = ::std::option::Option::Some(Transform_oneof_transform_instance::add_i32(is.read_message()?));
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.transform_instance = ::std::option::Option::Some(Transform_oneof_transform_instance::add_u64(is.read_message()?));
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.transform_instance = ::std::option::Option::Some(Transform_oneof_transform_instance::write(is.read_message()?));
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.transform_instance = ::std::option::Option::Some(Transform_oneof_transform_instance::add_keys(is.read_message()?));
},
6 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.transform_instance = ::std::option::Option::Some(Transform_oneof_transform_instance::failure(is.read_message()?));
},
7 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.transform_instance = ::std::option::Option::Some(Transform_oneof_transform_instance::add_big_int(is.read_message()?));
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let ::std::option::Option::Some(ref v) = self.transform_instance {
match v {
&Transform_oneof_transform_instance::identity(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&Transform_oneof_transform_instance::add_i32(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&Transform_oneof_transform_instance::add_u64(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&Transform_oneof_transform_instance::write(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&Transform_oneof_transform_instance::add_keys(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&Transform_oneof_transform_instance::failure(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&Transform_oneof_transform_instance::add_big_int(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
};
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let ::std::option::Option::Some(ref v) = self.transform_instance {
match v {
&Transform_oneof_transform_instance::identity(ref v) => {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
&Transform_oneof_transform_instance::add_i32(ref v) => {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
&Transform_oneof_transform_instance::add_u64(ref v) => {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
&Transform_oneof_transform_instance::write(ref v) => {
os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
&Transform_oneof_transform_instance::add_keys(ref v) => {
os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
&Transform_oneof_transform_instance::failure(ref v) => {
os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
&Transform_oneof_transform_instance::add_big_int(ref v) => {
os.write_tag(7, ::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() -> Transform {
Transform::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_singular_message_accessor::<_, TransformIdentity>(
"identity",
Transform::has_identity,
Transform::get_identity,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TransformAddInt32>(
"add_i32",
Transform::has_add_i32,
Transform::get_add_i32,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TransformAddUInt64>(
"add_u64",
Transform::has_add_u64,
Transform::get_add_u64,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TransformWrite>(
"write",
Transform::has_write,
Transform::get_write,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TransformAddKeys>(
"add_keys",
Transform::has_add_keys,
Transform::get_add_keys,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TransformFailure>(
"failure",
Transform::has_failure,
Transform::get_failure,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TransformAddBigInt>(
"add_big_int",
Transform::has_add_big_int,
Transform::get_add_big_int,
));
::protobuf::reflect::MessageDescriptor::new::<Transform>(
"Transform",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Transform {
static mut instance: ::protobuf::lazy::Lazy<Transform> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Transform,
};
unsafe {
instance.get(Transform::new)
}
}
}
impl ::protobuf::Clear for Transform {
fn clear(&mut self) {
self.transform_instance = ::std::option::Option::None;
self.transform_instance = ::std::option::Option::None;
self.transform_instance = ::std::option::Option::None;
self.transform_instance = ::std::option::Option::None;
self.transform_instance = ::std::option::Option::None;
self.transform_instance = ::std::option::Option::None;
self.transform_instance = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Transform {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Transform {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TransformIdentity {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TransformIdentity {
fn default() -> &'a TransformIdentity {
<TransformIdentity as ::protobuf::Message>::default_instance()
}
}
impl TransformIdentity {
pub fn new() -> TransformIdentity {
::std::default::Default::default()
}
}
impl ::protobuf::Message for TransformIdentity {
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 {
_ => {
::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;
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<()> {
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() -> TransformIdentity {
TransformIdentity::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 fields = ::std::vec::Vec::new();
::protobuf::reflect::MessageDescriptor::new::<TransformIdentity>(
"TransformIdentity",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static TransformIdentity {
static mut instance: ::protobuf::lazy::Lazy<TransformIdentity> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const TransformIdentity,
};
unsafe {
instance.get(TransformIdentity::new)
}
}
}
impl ::protobuf::Clear for TransformIdentity {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TransformIdentity {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TransformIdentity {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TransformAddInt32 {
pub value: i32,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TransformAddInt32 {
fn default() -> &'a TransformAddInt32 {
<TransformAddInt32 as ::protobuf::Message>::default_instance()
}
}
impl TransformAddInt32 {
pub fn new() -> TransformAddInt32 {
::std::default::Default::default()
}
pub fn get_value(&self) -> i32 {
self.value
}
pub fn clear_value(&mut self) {
self.value = 0;
}
pub fn set_value(&mut self, v: i32) {
self.value = v;
}
}
impl ::protobuf::Message for TransformAddInt32 {
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 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_int32()?;
self.value = 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.value != 0 {
my_size += ::protobuf::rt::value_size(1, self.value, ::protobuf::wire_format::WireTypeVarint);
}
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.value != 0 {
os.write_int32(1, self.value)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> TransformAddInt32 {
TransformAddInt32::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::ProtobufTypeInt32>(
"value",
|m: &TransformAddInt32| { &m.value },
|m: &mut TransformAddInt32| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new::<TransformAddInt32>(
"TransformAddInt32",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static TransformAddInt32 {
static mut instance: ::protobuf::lazy::Lazy<TransformAddInt32> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const TransformAddInt32,
};
unsafe {
instance.get(TransformAddInt32::new)
}
}
}
impl ::protobuf::Clear for TransformAddInt32 {
fn clear(&mut self) {
self.value = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TransformAddInt32 {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TransformAddInt32 {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TransformAddUInt64 {
pub value: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TransformAddUInt64 {
fn default() -> &'a TransformAddUInt64 {
<TransformAddUInt64 as ::protobuf::Message>::default_instance()
}
}
impl TransformAddUInt64 {
pub fn new() -> TransformAddUInt64 {
::std::default::Default::default()
}
pub fn get_value(&self) -> u64 {
self.value
}
pub fn clear_value(&mut self) {
self.value = 0;
}
pub fn set_value(&mut self, v: u64) {
self.value = v;
}
}
impl ::protobuf::Message for TransformAddUInt64 {
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 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.value = 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.value != 0 {
my_size += ::protobuf::rt::value_size(1, self.value, ::protobuf::wire_format::WireTypeVarint);
}
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.value != 0 {
os.write_uint64(1, self.value)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> TransformAddUInt64 {
TransformAddUInt64::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::ProtobufTypeUint64>(
"value",
|m: &TransformAddUInt64| { &m.value },
|m: &mut TransformAddUInt64| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new::<TransformAddUInt64>(
"TransformAddUInt64",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static TransformAddUInt64 {
static mut instance: ::protobuf::lazy::Lazy<TransformAddUInt64> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const TransformAddUInt64,
};
unsafe {
instance.get(TransformAddUInt64::new)
}
}
}
impl ::protobuf::Clear for TransformAddUInt64 {
fn clear(&mut self) {
self.value = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TransformAddUInt64 {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TransformAddUInt64 {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TransformAddBigInt {
pub value: ::protobuf::SingularPtrField<super::state::BigInt>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TransformAddBigInt {
fn default() -> &'a TransformAddBigInt {
<TransformAddBigInt as ::protobuf::Message>::default_instance()
}
}
impl TransformAddBigInt {
pub fn new() -> TransformAddBigInt {
::std::default::Default::default()
}
pub fn get_value(&self) -> &super::state::BigInt {
self.value.as_ref().unwrap_or_else(|| super::state::BigInt::default_instance())
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn has_value(&self) -> bool {
self.value.is_some()
}
pub fn set_value(&mut self, v: super::state::BigInt) {
self.value = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_value(&mut self) -> &mut super::state::BigInt {
if self.value.is_none() {
self.value.set_default();
}
self.value.as_mut().unwrap()
}
pub fn take_value(&mut self) -> super::state::BigInt {
self.value.take().unwrap_or_else(|| super::state::BigInt::new())
}
}
impl ::protobuf::Message for TransformAddBigInt {
fn is_initialized(&self) -> bool {
for v in &self.value {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.value)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.value.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.value.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
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() -> TransformAddBigInt {
TransformAddBigInt::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_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::state::BigInt>>(
"value",
|m: &TransformAddBigInt| { &m.value },
|m: &mut TransformAddBigInt| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new::<TransformAddBigInt>(
"TransformAddBigInt",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static TransformAddBigInt {
static mut instance: ::protobuf::lazy::Lazy<TransformAddBigInt> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const TransformAddBigInt,
};
unsafe {
instance.get(TransformAddBigInt::new)
}
}
}
impl ::protobuf::Clear for TransformAddBigInt {
fn clear(&mut self) {
self.value.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TransformAddBigInt {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TransformAddBigInt {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TransformAddKeys {
pub value: ::protobuf::RepeatedField<super::state::NamedKey>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TransformAddKeys {
fn default() -> &'a TransformAddKeys {
<TransformAddKeys as ::protobuf::Message>::default_instance()
}
}
impl TransformAddKeys {
pub fn new() -> TransformAddKeys {
::std::default::Default::default()
}
pub fn get_value(&self) -> &[super::state::NamedKey] {
&self.value
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn set_value(&mut self, v: ::protobuf::RepeatedField<super::state::NamedKey>) {
self.value = v;
}
pub fn mut_value(&mut self) -> &mut ::protobuf::RepeatedField<super::state::NamedKey> {
&mut self.value
}
pub fn take_value(&mut self) -> ::protobuf::RepeatedField<super::state::NamedKey> {
::std::mem::replace(&mut self.value, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for TransformAddKeys {
fn is_initialized(&self) -> bool {
for v in &self.value {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.value)?;
},
_ => {
::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;
for value in &self.value {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
for v in &self.value {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> TransformAddKeys {
TransformAddKeys::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_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::state::NamedKey>>(
"value",
|m: &TransformAddKeys| { &m.value },
|m: &mut TransformAddKeys| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new::<TransformAddKeys>(
"TransformAddKeys",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static TransformAddKeys {
static mut instance: ::protobuf::lazy::Lazy<TransformAddKeys> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const TransformAddKeys,
};
unsafe {
instance.get(TransformAddKeys::new)
}
}
}
impl ::protobuf::Clear for TransformAddKeys {
fn clear(&mut self) {
self.value.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TransformAddKeys {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TransformAddKeys {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TransformWrite {
pub value: ::protobuf::SingularPtrField<super::state::StoredValue>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TransformWrite {
fn default() -> &'a TransformWrite {
<TransformWrite as ::protobuf::Message>::default_instance()
}
}
impl TransformWrite {
pub fn new() -> TransformWrite {
::std::default::Default::default()
}
pub fn get_value(&self) -> &super::state::StoredValue {
self.value.as_ref().unwrap_or_else(|| super::state::StoredValue::default_instance())
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn has_value(&self) -> bool {
self.value.is_some()
}
pub fn set_value(&mut self, v: super::state::StoredValue) {
self.value = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_value(&mut self) -> &mut super::state::StoredValue {
if self.value.is_none() {
self.value.set_default();
}
self.value.as_mut().unwrap()
}
pub fn take_value(&mut self) -> super::state::StoredValue {
self.value.take().unwrap_or_else(|| super::state::StoredValue::new())
}
}
impl ::protobuf::Message for TransformWrite {
fn is_initialized(&self) -> bool {
for v in &self.value {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.value)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.value.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.value.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
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() -> TransformWrite {
TransformWrite::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_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::state::StoredValue>>(
"value",
|m: &TransformWrite| { &m.value },
|m: &mut TransformWrite| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new::<TransformWrite>(
"TransformWrite",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static TransformWrite {
static mut instance: ::protobuf::lazy::Lazy<TransformWrite> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const TransformWrite,
};
unsafe {
instance.get(TransformWrite::new)
}
}
}
impl ::protobuf::Clear for TransformWrite {
fn clear(&mut self) {
self.value.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TransformWrite {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TransformWrite {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TransformFailure {
pub failure_instance: ::std::option::Option<TransformFailure_oneof_failure_instance>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TransformFailure {
fn default() -> &'a TransformFailure {
<TransformFailure as ::protobuf::Message>::default_instance()
}
}
#[derive(Clone,PartialEq,Debug)]
pub enum TransformFailure_oneof_failure_instance {
type_mismatch(TypeMismatch),
}
impl TransformFailure {
pub fn new() -> TransformFailure {
::std::default::Default::default()
}
pub fn get_type_mismatch(&self) -> &TypeMismatch {
match self.failure_instance {
::std::option::Option::Some(TransformFailure_oneof_failure_instance::type_mismatch(ref v)) => v,
_ => TypeMismatch::default_instance(),
}
}
pub fn clear_type_mismatch(&mut self) {
self.failure_instance = ::std::option::Option::None;
}
pub fn has_type_mismatch(&self) -> bool {
match self.failure_instance {
::std::option::Option::Some(TransformFailure_oneof_failure_instance::type_mismatch(..)) => true,
_ => false,
}
}
pub fn set_type_mismatch(&mut self, v: TypeMismatch) {
self.failure_instance = ::std::option::Option::Some(TransformFailure_oneof_failure_instance::type_mismatch(v))
}
pub fn mut_type_mismatch(&mut self) -> &mut TypeMismatch {
if let ::std::option::Option::Some(TransformFailure_oneof_failure_instance::type_mismatch(_)) = self.failure_instance {
} else {
self.failure_instance = ::std::option::Option::Some(TransformFailure_oneof_failure_instance::type_mismatch(TypeMismatch::new()));
}
match self.failure_instance {
::std::option::Option::Some(TransformFailure_oneof_failure_instance::type_mismatch(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_type_mismatch(&mut self) -> TypeMismatch {
if self.has_type_mismatch() {
match self.failure_instance.take() {
::std::option::Option::Some(TransformFailure_oneof_failure_instance::type_mismatch(v)) => v,
_ => panic!(),
}
} else {
TypeMismatch::new()
}
}
}
impl ::protobuf::Message for TransformFailure {
fn is_initialized(&self) -> bool {
if let Some(TransformFailure_oneof_failure_instance::type_mismatch(ref v)) = self.failure_instance {
if !v.is_initialized() {
return false;
}
}
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.failure_instance = ::std::option::Option::Some(TransformFailure_oneof_failure_instance::type_mismatch(is.read_message()?));
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let ::std::option::Option::Some(ref v) = self.failure_instance {
match v {
&TransformFailure_oneof_failure_instance::type_mismatch(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
};
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let ::std::option::Option::Some(ref v) = self.failure_instance {
match v {
&TransformFailure_oneof_failure_instance::type_mismatch(ref v) => {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
};
}
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() -> TransformFailure {
TransformFailure::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_singular_message_accessor::<_, TypeMismatch>(
"type_mismatch",
TransformFailure::has_type_mismatch,
TransformFailure::get_type_mismatch,
));
::protobuf::reflect::MessageDescriptor::new::<TransformFailure>(
"TransformFailure",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static TransformFailure {
static mut instance: ::protobuf::lazy::Lazy<TransformFailure> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const TransformFailure,
};
unsafe {
instance.get(TransformFailure::new)
}
}
}
impl ::protobuf::Clear for TransformFailure {
fn clear(&mut self) {
self.failure_instance = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TransformFailure {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TransformFailure {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TransformEntry {
pub key: ::protobuf::SingularPtrField<super::state::Key>,
pub transform: ::protobuf::SingularPtrField<Transform>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TransformEntry {
fn default() -> &'a TransformEntry {
<TransformEntry as ::protobuf::Message>::default_instance()
}
}
impl TransformEntry {
pub fn new() -> TransformEntry {
::std::default::Default::default()
}
pub fn get_key(&self) -> &super::state::Key {
self.key.as_ref().unwrap_or_else(|| super::state::Key::default_instance())
}
pub fn clear_key(&mut self) {
self.key.clear();
}
pub fn has_key(&self) -> bool {
self.key.is_some()
}
pub fn set_key(&mut self, v: super::state::Key) {
self.key = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_key(&mut self) -> &mut super::state::Key {
if self.key.is_none() {
self.key.set_default();
}
self.key.as_mut().unwrap()
}
pub fn take_key(&mut self) -> super::state::Key {
self.key.take().unwrap_or_else(|| super::state::Key::new())
}
pub fn get_transform(&self) -> &Transform {
self.transform.as_ref().unwrap_or_else(|| Transform::default_instance())
}
pub fn clear_transform(&mut self) {
self.transform.clear();
}
pub fn has_transform(&self) -> bool {
self.transform.is_some()
}
pub fn set_transform(&mut self, v: Transform) {
self.transform = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_transform(&mut self) -> &mut Transform {
if self.transform.is_none() {
self.transform.set_default();
}
self.transform.as_mut().unwrap()
}
pub fn take_transform(&mut self) -> Transform {
self.transform.take().unwrap_or_else(|| Transform::new())
}
}
impl ::protobuf::Message for TransformEntry {
fn is_initialized(&self) -> bool {
for v in &self.key {
if !v.is_initialized() {
return false;
}
};
for v in &self.transform {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.key)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.transform)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.key.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.transform.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.key.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.transform.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)?;
}
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() -> TransformEntry {
TransformEntry::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_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::state::Key>>(
"key",
|m: &TransformEntry| { &m.key },
|m: &mut TransformEntry| { &mut m.key },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Transform>>(
"transform",
|m: &TransformEntry| { &m.transform },
|m: &mut TransformEntry| { &mut m.transform },
));
::protobuf::reflect::MessageDescriptor::new::<TransformEntry>(
"TransformEntry",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static TransformEntry {
static mut instance: ::protobuf::lazy::Lazy<TransformEntry> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const TransformEntry,
};
unsafe {
instance.get(TransformEntry::new)
}
}
}
impl ::protobuf::Clear for TransformEntry {
fn clear(&mut self) {
self.key.clear();
self.transform.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TransformEntry {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TransformEntry {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x17casper/transforms.proto\x12\x11casper.transforms\x1a\x12casper/sta\
te.proto\"@\n\x0cTypeMismatch\x12\x1a\n\x08expected\x18\x01\x20\x01(\tR\
\x08expected\x12\x14\n\x05found\x18\x02\x20\x01(\tR\x05found\"\xef\x03\n\
\tTransform\x12B\n\x08identity\x18\x01\x20\x01(\x0b2$.casper.transforms.\
TransformIdentityH\0R\x08identity\x12?\n\x07add_i32\x18\x02\x20\x01(\x0b\
2$.casper.transforms.TransformAddInt32H\0R\x06addI32\x12@\n\x07add_u64\
\x18\x03\x20\x01(\x0b2%.casper.transforms.TransformAddUInt64H\0R\x06addU\
64\x129\n\x05write\x18\x04\x20\x01(\x0b2!.casper.transforms.TransformWri\
teH\0R\x05write\x12@\n\x08add_keys\x18\x05\x20\x01(\x0b2#.casper.transfo\
rms.TransformAddKeysH\0R\x07addKeys\x12?\n\x07failure\x18\x06\x20\x01(\
\x0b2#.casper.transforms.TransformFailureH\0R\x07failure\x12G\n\x0badd_b\
ig_int\x18\x07\x20\x01(\x0b2%.casper.transforms.TransformAddBigIntH\0R\t\
addBigIntB\x14\n\x12transform_instance\"\x13\n\x11TransformIdentity\")\n\
\x11TransformAddInt32\x12\x14\n\x05value\x18\x01\x20\x01(\x05R\x05value\
\"*\n\x12TransformAddUInt64\x12\x14\n\x05value\x18\x01\x20\x01(\x04R\x05\
value\"@\n\x12TransformAddBigInt\x12*\n\x05value\x18\x01\x20\x01(\x0b2\
\x14.casper.state.BigIntR\x05value\"@\n\x10TransformAddKeys\x12,\n\x05va\
lue\x18\x01\x20\x03(\x0b2\x16.casper.state.NamedKeyR\x05value\"A\n\x0eTr\
ansformWrite\x12/\n\x05value\x18\x01\x20\x01(\x0b2\x19.casper.state.Stor\
edValueR\x05value\"n\n\x10TransformFailure\x12F\n\rtype_mismatch\x18\x01\
\x20\x01(\x0b2\x1f.casper.transforms.TypeMismatchH\0R\x0ctypeMismatchB\
\x12\n\x10failure_instance\"q\n\x0eTransformEntry\x12#\n\x03key\x18\x01\
\x20\x01(\x0b2\x11.casper.state.KeyR\x03key\x12:\n\ttransform\x18\x02\
\x20\x01(\x0b2\x1c.casper.transforms.TransformR\ttransformb\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()
})
}
}
}