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
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

#[macro_export]
macro_rules! lifeline_bus (
            // match one or more generics separated by a comma
    (struct $name:ident $(< $( $gen:ident ),+ >)? ) => {
        lifeline_bus! { () struct $name $(< $( $gen ),+ >)?; }
    };

    (pub struct $name:ident $(< $( $gen:ident ),+ >)* ) => {
        lifeline_bus! { (pub) struct $name $(< $( $gen ),+ >)* }
    };

    (($($vis:tt)*) struct $name:ident $(< $( $gen:ident ),+ >)? ) => {
        #[derive(Debug)]
        #[allow(non_snake_case)]
        $($vis)* struct $name $(< $( $gen: std::fmt::Debug ),+ >)? {
            storage: $crate::dyn_bus::DynBusStorage<Self>,
            $(
                $( $gen: std::marker::PhantomData<$gen> ),+
            )?
        }

        impl$(< $( $gen: std::fmt::Debug ),+ >)? std::default::Default for $name $(< $( $gen ),+ >)? {
            fn default() -> Self {
                Self {
                    storage: $crate::dyn_bus::DynBusStorage::default(),
                    $(
                        $( $gen: std::marker::PhantomData::<$gen> ),+
                    )?
                }
            }
        }

        impl$(< $( $gen: std::fmt::Debug ),+ >)? $crate::dyn_bus::DynBus for $name$(< $( $gen ),+ >)? {
            fn store_rx<Msg>(&self, rx: <Msg::Channel as $crate::Channel>::Rx) -> Result<(), $crate::error::AlreadyLinkedError>
                where Msg: $crate::Message<Self> + 'static
            {
                self.storage().store_channel::<Msg, Msg::Channel, Self>(Some(rx), None)
            }

            fn store_tx<Msg>(&self, tx: <Msg::Channel as $crate::Channel>::Tx) -> Result<(), $crate::error::AlreadyLinkedError>
                where Msg: $crate::Message<Self> + 'static
            {
                self.storage().store_channel::<Msg, Msg::Channel, Self>(None, Some(tx))
            }

            fn store_channel<Msg>(
                &self,
                rx: <Msg::Channel as $crate::Channel>::Rx,
                tx: <Msg::Channel as $crate::Channel>::Tx
            ) -> Result<(), $crate::error::AlreadyLinkedError>
                where Msg: $crate::Message<Self> + 'static
            {
                self.storage().store_channel::<Msg, Msg::Channel, Self>(Some(rx), Some(tx))
            }

            fn store_resource<R: $crate::Resource<Self>>(&self, resource: R) {
                self.storage.store_resource::<R, Self>(resource)
            }

            // fn take_channel<Msg, Source>(
            //     &self,
            //     other: &Source,
            // ) -> Result<(), $crate::TakeChannelError>
            // where
            //     Msg: $crate::Message<Self> + 'static,
            //     Msg: $crate::Message<Source, Channel = <Msg as $crate::Message<Self>>::Channel>,
            //     Source: $crate::dyn_bus::DynBus
            // {
            //     self.storage.take_channel::<Msg, Source, Self, <Msg as $crate::Message<Self>>::Channel>(other, true, true)
            // }

            // fn take_rx<Msg, Source>(
            //     &self,
            //     other: &Source,
            // ) -> Result<(), $crate::TakeChannelError>
            // where
            //     Msg: $crate::Message<Self> + 'static,
            //     Msg: $crate::Message<Source, Channel = <Msg as $crate::Message<Self>>::Channel>,
            //     Source: $crate::dyn_bus::DynBus
            // {
            //     self.storage.take_channel::<Msg, Source, Self, <Msg as $crate::Message<Self>>::Channel>(other, true, false)
            // }

            // fn take_tx<Msg, Source>(
            //     &self,
            //     other: &Source,
            // ) -> Result<(), $crate::TakeChannelError>
            // where
            //     Msg: $crate::Message<Self> + 'static,
            //     Msg: $crate::Message<Source, Channel = <Msg as $crate::Message<Self>>::Channel>,
            //     Source: $crate::dyn_bus::DynBus
            // {
            //     self.storage.take_channel::<Msg, Source, Self, <Msg as $crate::Message<Self>>::Channel>(other, false, true)
            // }

            // fn take_resource<Res, Source>(
            //     &self,
            //     other: &Source,
            // ) -> Result<(), $crate::error::TakeResourceError>
            // where
            //     Res: $crate::Storage,
            //     Res: $crate::Resource<Source>,
            //     Res: $crate::Resource<Self>,
            //     Source: $crate::dyn_bus::DynBus
            // {
            //     self.storage.take_resource::<Res, Source, Self>(other)
            // }

            fn storage(&self) -> &$crate::dyn_bus::DynBusStorage<Self> {
                &self.storage
            }
        }
    }
    // ($name:ident) => {
    //     #[derive(Debug, Default)]
    //     struct $name {
    //         storage: $crate::dyn_bus::DynBusStorage<Self>,
    //     }

    //     impl $crate::dyn_bus::DynBus for $name {
    //         fn storage(&self) -> &$crate::dyn_bus::DynBusStorage<Self> {
    //             &self.storage
    //         }
    //     }
    // };
);