canadensis_codegen_rust 0.6.0

Generates Rust code for data types based on Cyphal DSDL files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

//! Exposes constants declared in a DSDL file

use canadensis_dsdl_frontend::constants::ConstantValue;
use canadensis_dsdl_frontend::types::PrimitiveType;
use std::fmt::{Display, Formatter, Result};

use crate::{make_rust_identifier, round_up_integer_size, write_doc_comments, GeneratedType};

pub(crate) struct ImplementConstants<'t, 'c>(pub &'t GeneratedType<'c>);

impl Display for ImplementConstants<'_, '_> {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        writeln!(f, "impl {} {{", self.0.name.type_name)?;
        for (name, constant) in &self.0.constants {
            let name = make_rust_identifier(name.clone());
            let rust_type_name: String = match constant.ty() {
                PrimitiveType::Boolean => "bool".into(),
                PrimitiveType::Byte | PrimitiveType::Utf8 => {
                    panic!("Constant type can't be byte or utf8")
                }
                PrimitiveType::Int { bits } => format!("i{}", round_up_integer_size(*bits)),
                PrimitiveType::UInt { bits, .. } => format!("u{}", round_up_integer_size(*bits)),
                PrimitiveType::Float16 { .. } => "::half::f16".into(),
                PrimitiveType::Float32 { .. } => "f32".into(),
                PrimitiveType::Float64 { .. } => "f64".into(),
            };

            write_doc_comments(f, constant.comments())?;
            writeln!(
                f,
                "pub const {}: {} = {};",
                name,
                rust_type_name,
                PrintLiteral(constant.value())
            )?
        }
        writeln!(f, "}}")
    }
}

struct PrintLiteral<'v>(&'v ConstantValue);

impl Display for PrintLiteral<'_> {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        match &self.0 {
            ConstantValue::Boolean(inner) => Display::fmt(inner, f),
            ConstantValue::Int(inner) => Display::fmt(inner, f),
            ConstantValue::Float16(inner) => {
                // Because f16 doesn't have literals, use to_bits and from_bits.
                // from_bits is a const function.
                write!(f, "::half::f16::from_bits({})", inner.to_bits())
            }
            ConstantValue::Float32(inner) => write!(f, "{}_f32", inner),
            ConstantValue::Float64(inner) => write!(f, "{}_f64", inner),
        }
    }
}