Custom Type serialization

[Matthew-Skeer]

Hi, I am wondering if someone can point me into the right direction,

I am writing a dbus service for a module we have previouly written. this code is stored in a seperate library,

For simplicity, Im just going to put some pseudo code, we have:

pub struct SomeData { 
   pub name: String,
   pub value: u8
}

We have a function in that returns a vector of these structs, we would like to have an ZBUS service interface that we could query this infomation, so we have created an interface:

#[interface(name = SomeInterface )]
impl DBusInterface {
    async fn get_data(&mut self) -> Vec<SomeData> {
      OtherModule::get_data()
    }
} 

On this I get the following error

the trait `zbus::zvariant::Type` is not implemented for `SomeData`, which is required by `Vec<SomeData>: zbus::zvariant::DynamicType`

Which I understand but what is the best way to do this, I dont want to alter the code in the other module and use the derive macro on the SomeData Struct, as thats used elsewhere.

I have had a look at how zvarient does it internally, and use the impl_type_with_repr but I am getting a

_impl doesn't use only types from inside the current crate

I have looked over the documents and just cant see how to do this, so im obviously missing something, and help or pointers in the right direction would be greatly appreciated.

[zeenix]

All you need is:

#[derive(zbus::zvariant::Type)] on your type. We should actually explain this better in our book.

[Matthew-Skeer]

Is that the only way, as the type is declared inside another library, which we dont really want to change.

[zeenix]

See the Type trait (but ignore the instruction to use zvariant_derive for the derive since you can use the derive directly from zvariant itself) and derive docs.

[zeenix]

Is that the only way, as the type is declared inside another library, which we dont really want to change.

Ah sorry, I missed that part. Yeah, the orphan rule won't allow you to implement external traits for external types. As usual, the solution is to either create a wrapper type in your code that implements the Type trait, or ask the implementation to be added to zvariant (but it has to be a type that's used a lot for that to be justified since we can't and won't provide implementations for every type on the planet).

BTW, this is a Rust question, not really zbus specific.