wip

Author: nyurik

src/wrappers.rs

@@ -12,7 +12,7 @@ use crate::utils::{enum_variant_name, sanitize_name, ToIdent};
 
 /// Wrapper around [`Dbc`] used during code generation. Holds a pre-built vec of [`MessageGen`] for the DBC's messages.
 #[derive(Clone)]
-pub struct DbcGen<'a> {
+pub(crate) struct DbcGen<'a> {
     inner: &'a Dbc,
     messages: Vec<MessageGen<'a>>,
 }
@@ -53,15 +53,15 @@ impl<'a> DbcGen<'a> {
 
 /// Wrapper around [`Message`] used during code generation. Holds a pre-built vec of [`SignalGen`] for the message's signals.
 #[derive(Clone)]
-pub struct MessageGen<'a> {
+pub(crate) struct MessageGen<'a> {
     inner: &'a Message,
     signals: Vec<SignalGen<'a>>,
     type_name: Ident,
 }
 
 impl<'a> MessageGen<'a> {
     /// Creates a wrapper and builds the cached signals list and type name.
-    pub(crate) fn new(inner: &'a Message) -> MessageGen<'a> {
+    pub fn new(inner: &'a Message) -> MessageGen<'a> {
         MessageGen {
             inner,
             signals: inner.signals.iter().map(SignalGen::new).collect(),
@@ -151,12 +151,11 @@ impl Deref for MessageGen<'_> {
 
 /// Wrapper around [`Signal`] used during code generation. Caches [`ValType`] and name-derived idents to avoid repeated computation.
 #[derive(Clone)]
-pub struct SignalGen<'a> {
+pub(crate) struct SignalGen<'a> {
     inner: &'a Signal,
     typ: ValType,
     typ_int: ValType,
     typ_uint: ValType,
-    /// Cached field name (`snake_case`), built at construction.
     field_name: Ident,
 }
 
@@ -170,7 +169,7 @@ impl Deref for SignalGen<'_> {
 
 impl<'a> SignalGen<'a> {
     /// Creates a wrapper and caches the signal's value types and name-derived idents.
-    pub(crate) fn new(inner: &'a Signal) -> SignalGen<'a> {
+    pub fn new(inner: &'a Signal) -> SignalGen<'a> {
         SignalGen {
             inner,
             typ: ValType::from_signal(inner),
@@ -180,19 +179,19 @@ impl<'a> SignalGen<'a> {
         }
     }
 
-    pub(crate) fn typ(&self) -> ValType {
+    pub fn typ(&self) -> ValType {
         self.typ
     }
-    pub(crate) fn typ_ident(&self) -> Ident {
+    pub fn typ_ident(&self) -> Ident {
         self.typ.ident()
     }
-    pub(crate) fn typ_int(&self) -> ValType {
+    pub fn typ_int(&self) -> ValType {
         self.typ_int
     }
-    pub(crate) fn typ_uint(&self) -> ValType {
+    pub fn typ_uint(&self) -> ValType {
         self.typ_uint
     }
-    pub(crate) fn typ_uint_to_int(&self) -> Option<ValType> {
+    pub fn typ_uint_to_int(&self) -> Option<ValType> {
         self.typ_uint.unsigned_to_signed()
     }