Enum rocket::mtls::oid::asn1_rs::Real

pub enum Real {
    Binary {
        mantissa: f64,
        base: u32,
        exponent: i32,
        enc_base: u8,
    },
    Infinity,
    NegInfinity,
    Zero,
}

Available on crate feature mtls only.

ASN.1 REAL type

Limitations

When encoding binary values, only base 2 is supported

Variants

Binary

Fields

mantissa: f64

base: u32

exponent: i32

enc_base: u8

Non-special values

Infinity

Infinity (∞).

NegInfinity

Negative infinity (−∞).

Zero

Zero

Implementations

impl Real

pub fn new(f: f64) -> Real

Create a new REAL from the f64 value.

pub const fn with_enc_base(self, enc_base: u8) -> Real

pub const fn binary(mantissa: f64, base: u32, exponent: i32) -> Real

Create a new binary REAL

pub fn is_infinite(&self) -> bool

Returns true if this value is positive infinity or negative infinity, and false otherwise.

pub fn is_finite(&self) -> bool

Returns true if this number is not infinite.

pub fn f64(&self) -> f64

Returns the ‘f64’ value of this REAL.

Returned value is a float, and may be infinite.

pub fn f32(&self) -> f32

Returns the ‘f32’ value of this REAL.

This functions casts the result of Real::f64 to a f32, and loses precision.

Trait Implementations

impl<'a> CheckDerConstraints for Real

fn check_constraints(any: &Any<'_>) -> Result<(), Error>

impl Debug for Real

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl From<Real> for f32

fn from(r: Real) -> f32

Converts to this type from the input type.

impl From<Real> for f64

fn from(r: Real) -> f64

Converts to this type from the input type.

impl From<f32> for Real

fn from(f: f32) -> Real

Converts to this type from the input type.

impl From<f64> for Real

fn from(f: f64) -> Real

Converts to this type from the input type.

impl PartialEq<Real> for Real

fn eq(&self, other: &Real) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Tagged for Real

const TAG: Tag = Tag::RealType

impl ToDer for Real

fn to_der_len(&self) -> Result<usize, Error>

Get the length of the object, when encoded

fn write_der_header( &self, writer: &mut dyn Write ) -> Result<usize, SerializeError>

Attempt to write the DER header to this writer.

fn write_der_content( &self, writer: &mut dyn Write ) -> Result<usize, SerializeError>

Attempt to write the DER content (all except header) to this writer.

fn to_der_vec(&self) -> Result<Vec<u8, Global>, SerializeError>

Write the DER encoded representation to a newly allocated Vec<u8>.

fn to_der_vec_raw(&self) -> Result<Vec<u8, Global>, SerializeError>

Similar to using to_vec, but uses provided values without changes. This can generate an invalid encoding for a DER object.

fn write_der(&self, writer: &mut dyn Write) -> Result<usize, SerializeError>

Attempt to write the DER encoded representation (header and content) into this writer.

fn write_der_raw(&self, writer: &mut dyn Write) -> Result<usize, SerializeError>

Similar to using to_der, but uses provided values without changes. This can generate an invalid encoding for a DER object.

impl<'a> TryFrom<Any<'a>> for Real

type Error = Error

The type returned in the event of a conversion error.

fn try_from(any: Any<'a>) -> Result<Real, Error>

Performs the conversion.

impl StructuralPartialEq for Real