I suppose that the definitions at

parsec-interface-rs/src/operations_protobuf/generated_ops/mod.rs

Lines 41 to 130 in 8527a3a

    
           impl TryFrom<i32> for Cipher { 
        
               type Error = ResponseStatus; 
        
               fn try_from(cipher_val: i32) -> Result<Self> { 
        
                   Cipher::from_i32(cipher_val).ok_or_else(|| { 
        
                       error!( 
        
                           "Value {} not supported as a cipher algorithm encoding.", 
        
                           cipher_val 
        
                       ); 
        
                       ResponseStatus::InvalidEncoding 
        
                   }) 
        
               } 
        
           } 
        
           impl TryFrom<i32> for Hash { 
        
               type Error = ResponseStatus; 
        
               fn try_from(hash_val: i32) -> Result<Self> { 
        
                   Hash::from_i32(hash_val).ok_or_else(|| { 
        
                       error!( 
        
                           "Value {} not supported as a hash algorithm encoding.", 
        
                           hash_val 
        
                       ); 
        
                       ResponseStatus::InvalidEncoding 
        
                   }) 
        
               } 
        
           } 
        
           impl TryFrom<i32> for AeadWithDefaultLengthTag { 
        
               type Error = ResponseStatus; 
        
               fn try_from(aead_val: i32) -> Result<Self> { 
        
                   AeadWithDefaultLengthTag::from_i32(aead_val).ok_or_else(|| { 
        
                       error!( 
        
                           "Value {} not supported as an AEAD with default tag length algorithm encoding.", 
        
                           aead_val 
        
                       ); 
        
                       ResponseStatus::InvalidEncoding 
        
                   }) 
        
               } 
        
           } 
        
           impl TryFrom<i32> for Raw { 
        
               type Error = ResponseStatus; 
        
               fn try_from(key_agreement_val: i32) -> Result<Self> { 
        
                   Raw::from_i32(key_agreement_val).ok_or_else(|| { 
        
                       error!( 
        
                           "Value {} not supported as a raw key agreement algorithm encoding.", 
        
                           key_agreement_val 
        
                       ); 
        
                       ResponseStatus::InvalidEncoding 
        
                   }) 
        
               } 
        
           } 
        
           impl TryFrom<i32> for EccFamily { 
        
               type Error = ResponseStatus; 
        
               fn try_from(ecc_family_val: i32) -> Result<Self> { 
        
                   EccFamily::from_i32(ecc_family_val).ok_or_else(|| { 
        
                       error!( 
        
                           "Value {} not supported as an ECC family encoding.", 
        
                           ecc_family_val 
        
                       ); 
        
                       ResponseStatus::InvalidEncoding 
        
                   }) 
        
               } 
        
           } 
        
           impl TryFrom<i32> for DhFamily { 
        
               type Error = ResponseStatus; 
        
               fn try_from(dh_family_val: i32) -> Result<Self> { 
        
                   DhFamily::from_i32(dh_family_val).ok_or_else(|| { 
        
                       error!( 
        
                           "Value {} not supported as a DH family encoding.", 
        
                           dh_family_val 
        
                       ); 
        
                       ResponseStatus::InvalidEncoding 
        
                   }) 
        
               } 
        
           } 
        
           impl TryFrom<i32> for CheckType { 
        
               type Error = ResponseStatus; 
        
               fn try_from(check_type_val: i32) -> Result<Self> { 
        
                   CheckType::from_i32(check_type_val).ok_or_else(|| { 
        
                       error!( 
        
                           "Value {} not supported as a check type.", 
        
                           check_type_val 
        
                       ); 
        
                       ResponseStatus::InvalidEncoding 
        
                   }) 
        
               } 
        
           }

are in conflict. However, just removing them seems to be insufficient.

	impl TryFrom<i32> for Cipher {
	type Error = ResponseStatus;
	fn try_from(cipher_val: i32) -> Result<Self> {
	Cipher::from_i32(cipher_val).ok_or_else(\|\| {
	error!(
	"Value {} not supported as a cipher algorithm encoding.",
	cipher_val
	);
	ResponseStatus::InvalidEncoding
	})
	}
	}

	impl TryFrom<i32> for Hash {
	type Error = ResponseStatus;
	fn try_from(hash_val: i32) -> Result<Self> {
	Hash::from_i32(hash_val).ok_or_else(\|\| {
	error!(
	"Value {} not supported as a hash algorithm encoding.",
	hash_val
	);
	ResponseStatus::InvalidEncoding
	})
	}
	}

	impl TryFrom<i32> for AeadWithDefaultLengthTag {
	type Error = ResponseStatus;
	fn try_from(aead_val: i32) -> Result<Self> {
	AeadWithDefaultLengthTag::from_i32(aead_val).ok_or_else(\|\| {
	error!(
	"Value {} not supported as an AEAD with default tag length algorithm encoding.",
	aead_val
	);
	ResponseStatus::InvalidEncoding
	})
	}
	}

	impl TryFrom<i32> for Raw {
	type Error = ResponseStatus;
	fn try_from(key_agreement_val: i32) -> Result<Self> {
	Raw::from_i32(key_agreement_val).ok_or_else(\|\| {
	error!(
	"Value {} not supported as a raw key agreement algorithm encoding.",
	key_agreement_val
	);
	ResponseStatus::InvalidEncoding
	})
	}
	}

	impl TryFrom<i32> for EccFamily {
	type Error = ResponseStatus;
	fn try_from(ecc_family_val: i32) -> Result<Self> {
	EccFamily::from_i32(ecc_family_val).ok_or_else(\|\| {
	error!(
	"Value {} not supported as an ECC family encoding.",
	ecc_family_val
	);
	ResponseStatus::InvalidEncoding
	})
	}
	}

	impl TryFrom<i32> for DhFamily {
	type Error = ResponseStatus;
	fn try_from(dh_family_val: i32) -> Result<Self> {
	DhFamily::from_i32(dh_family_val).ok_or_else(\|\| {
	error!(
	"Value {} not supported as a DH family encoding.",
	dh_family_val
	);
	ResponseStatus::InvalidEncoding
	})
	}
	}

	impl TryFrom<i32> for CheckType {
	type Error = ResponseStatus;
	fn try_from(check_type_val: i32) -> Result<Self> {
	CheckType::from_i32(check_type_val).ok_or_else(\|\| {
	error!(
	"Value {} not supported as a check type.",
	check_type_val
	);
	ResponseStatus::InvalidEncoding
	})
	}
	}

Uh oh!

Please bump to prost 0.12 #153

Description

Metadata

Metadata

Assignees

Labels

Type

Fields

Projects

Milestone

Relationships

Development

Issue actions