Reduce boilerplate code with macros

[bewee]

This suggests splitting xxx_handle_mut() functions into separate traits, and adding functions xxx_handle() to these which return an immutable references. A proc macro can then be used to auto-implement these traits, including adding a field holding the handle to the struct.
Ultimately, this should also unify the code by wrapping EventHandles in Events, and adding an APIHandlerHandle. Solely the Action would remain different (would they?).

Examples

#[adapter]
struct ExampleAdapter { foo: i32 }
impl AdapterStructure for ExampleAdapter {
    fn id(&self) -> String {
        "example-adapter".to_owned()
    }
    fn name(&self) -> String {
        "Example Adapter".to_owned()
    }
}
#[async_trait]
impl Adapter for BuiltExampleAdapter {
    async fn on_remove_device(&mut self, device_id: String) -> Result<(), String> {
        log::debug!("Device {} for {} removed", device_id, self.foo);
        Ok(())
    }
}

is equivalent to

struct ExampleAdapter { foo: i32 }
impl AdapterStructure for ExampleAdapter {
    fn id(&self) -> String {
        "example-adapter".to_owned()
    }
    fn name(&self) -> String {
        "Example Adapter".to_owned()
    }
}
impl AdapterBuilder for ExampleAdapter {
    type BuiltAdapter = BuiltExampleAdapter;
    fn build(data: Self, adapter_handle: AdapterHandle) -> Self::BuiltAdapter {
        BuiltExampleAdapter { data, adapter_handle }
    }
}
struct BuiltExampleAdapter {
    data: ExampleAdapter,
    adapter_handle: AdapterHandle
}
impl BuiltAdapter for BuiltExampleAdapter {
    fn adapter_handle(&self) -> &AdapterHandle {
        &self.adapter_handle
    }
    fn adapter_handle_mut(&mut self) -> &mut AdapterHandle {
        &mut self.adapter_handle
    }
}
impl std::ops::Deref for ExampleAdapter{
    type Target = AdapterHandle;
    fn deref(&self) -> &Self::Target {
        &self.adapter_handle
    }
}
impl std::ops::DerefMut for ExampleAdapter {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.adapter_handle
    }
}
#[async_trait]
impl Adapter for BuiltExampleAdapter {
    async fn on_remove_device(&mut self, device_id: String) -> Result<(), String> {
        log::debug!("Device {} for {} removed", device_id, self.foo);
        Ok(())
    }
}

and is equivalent to previously doing

struct ExampleAdapter{
    adapter_handle: AdapterHandle,
    foo: i32,
}
impl ExampleAdapter {
    fn id() -> String {
        "example-adapter".to_owned()
    }
    fn name() -> String {
        "Example Adapter".to_owned()
    }
}
#[async_trait]
impl Adapter for ExampleAdapter {
    fn adapter_handle_mut(&mut self) -> &mut AdapterHandle {
        &mut self.adapter_handle
    }
    async fn on_remove_device(&mut self, device_id: String) -> Result<(), String> {
        log::debug!("Device {} for {} removed", device_id, self.foo);
        Ok(())
    }
}

[bewee]

Currently, property handles have to be exposed to the user during building. However, I may have an idea to solve this too 🤔

[tim-hellhake]

That will save a lot of typing 😬

[bewee]

PR description updated

[bewee]

When rust-lang/rust#29635 was stabilized, we wouldn't even need the proc macro for this, but could simply provide a generic wrapper struct Built<T> and then implement trait Adapter on this.

[tim-hellhake]

Awesome!