rsrs_core/frame/

macros.rs

#[macro_export]
macro_rules! frame {
    ($($tt:tt)*) => {
        $crate::gen_frame!(@frame $($tt)*);
    };
}

#[macro_export]
macro_rules! gen_frame {
    (@frame
        $( #[$($meta:meta)*] )*
        $name:ident [ $hdr:ident ] {
            // flags mask
            #mask = [ $($flags:tt)* ];

            // reqiured flags
            $( #requires = [ $($required_flags:tt)* ]; )?

            // fields
            $(
                // meta
                $( #[$($field_meta:meta)*] )*

                // options
                $( @$field_opt:ident $(($field_opt_val:literal))?; )*

                // visibility
                $field_vis:vis

                // name
                $field:ident

                // modifier
                $(($field_mod:ident))?

                // data type
                : $field_ty:ty

                // generators
                $( => [
                   $(
                       $gen:ident $($gen_tt:tt)?
                   ),*
                ])?
            );* $(;)?
        }$(;)?

    ) => {
        #[derive(Debug, Clone, recode::Recode)]
        #[recode(error = "crate::Error")]
        $( #[$($meta)*] )*
        pub struct $name {
            /// Frame header.
            pub(crate) $hdr: $crate::FrameHeader,
            $(
                // options
                 $( #[recode($field_opt $(= $field_opt_val)?) ] )*

                // meta
                $( #[$($field_meta)*] )*

                // declaration
                $field_vis $field: $field_ty,
            )*
        }

        impl $crate::FrameVariant for $name {
            const FLAGS_MASK: $crate::FrameFlags = $crate::const_flags![
                $($flags)*
            ];

            $(
                const REQUIRED_FLAGS: $crate::FrameFlags = $crate::const_flags![
                    $($required_flags)*
                ];
            )?

            #[inline(always)]
            fn flags(&self) -> $crate::FrameFlags {
                self.$hdr.flags()
            }
        }

        impl $name {
            $( $( $(
                $crate::expand_gen!(
                    $name[$hdr]; $field: $field_ty => $gen $($gen_tt)?
                );
            )* )? )*

            paste::paste! {
                /// Creates a builder to builder a frame of this type.
                #[inline(always)]
                pub const fn builder() -> [<$name Builder>] {
                    [<$name Builder>]::new()
                }
            }
        }

        paste::paste! {
            #[derive(Debug)]
            pub struct [<$name Builder>] {
                __flags: $crate::FrameFlags,
                $( $field: Option<$field_ty>, )*
            }

            impl [<$name Builder>] {
                const FRAME_TYPE: $crate::FrameType =
                    $crate::FrameType::$name;

                /// Creates a new builder instance
                #[inline(always)]
                pub const fn new() -> Self {
                    Self {
                        __flags: $crate::FrameFlags::empty(),
                        $( $field: None, )*
                    }
                }

                /// Sets flag(s) with value of `flags`
                #[inline]
                pub fn flag(mut self, flags: $crate::FrameFlags) -> Self {
                    self.__flags.insert(flags);
                    self
                }

                $(
                    #[doc = "Sets `" $field "` value\n"]
                    #[doc = "\n"]
                    #[doc = "# Parameters\n"]
                    #[doc = "* `" $field "` - The new value to be set"]
                    #[inline]
                    $field_vis fn $field(mut self, $field: $field_ty) -> Self {
                        $( $(
                            $crate::expand_gen!(
                                @builder: self.__flags; $gen $($gen_tt)?
                            );
                        )* )?

                        self.$field = Option::<$field_ty>::Some($field);
                        self
                    }
                )*

                #[doc = "Builds a new [`" $name "`] instance from this builder."]
                pub fn build(self) -> $crate::Result<$name> {
                    let $hdr = $crate::FrameHeader::new(
                        Self::FRAME_TYPE,
                        self.__flags,
                    );

                    let frame = $name {
                        $hdr,
                        $(
                            $field: $crate::extract!($($field_mod)? self.$field),
                        )*
                    };

                    Ok(frame)
                }
            }

            impl From<$name> for $crate::frame::Frame {
                #[inline(always)]
                fn from(value: $name) -> Self {
                    Self::$name(value)
                }
            }
        }
    };
}

#[macro_export]
macro_rules! expand_gen {
    ($name:ident[$hdr:ident]; $field:ident: $field_type:ty => get) => {
        paste::paste! {
            #[doc = "Gets a reference to `" $name "." $field "`"]
            #[inline]
            pub fn $field(&self) -> &$field_type {
                &self.$field
            }
        }
    };

    ($name:ident[$hdr:ident]; $field:ident: $field_type:ty => get $((const $($ref:tt)?))?) => {
        paste::paste! {
            #[doc = "Gets `" $name "." $field "`"]
            #[inline]
            pub const fn $field(&self) -> $($($ref)?)? $field_type {
                $($($ref)?)? self.$field
            }
        }
    };

    ($name:ident[$hdr:ident]; $field:ident: $field_type:ty => get(&mut)) => {
        paste::paste! {
            #[doc = "Gets a mutable reference to `" $name "." $field "`"]
            #[inline]
            pub fn [<$field _mut>](&mut self) -> &mut $field_type {
                &mut self.$field
            }
        }
    };

    ($name:ident[$hdr:ident]; $field:ident: $field_type:ty => set $(($flag:ident $(if $expr:expr)?))?) => {
        paste::paste! {
            #[doc = "Sets the value of `" $name "." $field "`"]
            #[inline]
            pub fn [<set_ $field>](&mut self, $field: $field_type) {
                $(
                    $( if ($expr) )? {
                        self.$hdr.set($crate::const_flags![ $flag ], true);
                    }
                )?

                self.$field = $field;
            }
        }
    };

    (@builder: $self:ident.$flags:ident; set $(($flag:ident $(if $expr:expr)?))?) => {
        $(
            $( if ($expr) )? {
                $self.$flags.set($crate::const_flags![ $flag ], true);
            }
        )?
    };

    (@builder: $hdr:ident; $other:ident $($tt:tt)*) => { };
}

#[macro_export]
macro_rules! extract {
    ($obj:ident.$name:ident) => {
        $obj.$name.unwrap_or_default()
    };

    (required $obj:ident.$name:ident) => {
        match $obj.$name {
            | Some($name) => $name,
            | None => {
                return Err($crate::Error::MissingFieldValue {
                    frame_type: Self::FRAME_TYPE,
                    field: stringify!($name),
                })
            }
        }
    };

    (critical $obj:ident.$name:ident) => {
        $obj.$name.unwrap_or_else(|| {
            panic!(concat!("field `", stringify!($name), "` is required"))
        })
    };
}