question on generic property type

[jbbjarnason]

what trait shall I use to support generic type T when T is bounded to some specific types? example:

mod detail {
    pub trait SupportedTypes {}
    impl SupportedTypes for i64 {}
}

struct SlotInterface<T> {
    last_value: Arc<Mutex<Option<T>>>,
    log_key: String,
}

impl<T: detail::SupportedTypes + zbus::zvariant::Type + Sync + Send + 'static> SlotInterface<T> {
    pub fn new(last_value: Arc<Mutex<Option<T>>>, key: &str) -> Self {
        Self {
            last_value,
            log_key: key.to_string(),
        }
    }
}
#[interface(name = "is.centroid.Slot")]
impl<T: detail::SupportedTypes + zbus::zvariant::Type + Sync + Send + 'static> SlotInterface<T>
{
    #[zbus(property)]
    async fn value(&self) -> Result<T, zbus::fdo::Error> {
        Ok(137)
        // Ok("self.foo.clone()".to_string())
        // let guard = self.last_value.lock().await;

        // if let Some(value) = guard.clone() {
            // Ok(value.into())
        // } else {
            // Err(zbus::fdo::Error::Failed("No value set".into()))
        // }
    }
}

error[E0277]: the trait bound `zbus::zvariant::Structure<'_>: From<T>` is not satisfied
   --> src/ipc.rs:175:1
    |
175 | #[interface(name = "is.centroid.Slot")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `From<T>` is not implemented for `zbus::zvariant::Structure<'_>`, which is required by `zbus::zvariant::Value<'_>: From<T>`

[zeenix]

As the error message suggests and documented in the book, property methods require their return value to be transformable to zvariant::Value. I've never seen generics use with properties before so I can't guarantee it will work out of the box, but you need to add Value<'static>: From<T> constraint or something like that (or TryFrom<T>, I can't remember).

[zeenix]

This fails to compile when the zbus::zvariant::Value<'static>: From<T>, is there.

The main error is the first one. You're declaring the type to be generic but then using a specific type inside the impl. I think it will be ok if you resolve that.

[zeenix]

BTW, I hope you're not ending up reinventing the wheel here with this scema. D-Bus already has a concept of signature that represents the encoded bytes' type. This is the entire point of Type trait actually: providing the signature of the type. In git main (and upcoming 5.0) signature has been changed to be in (efficient) parsed format even and Type only has a const, ensuring that all the signature business is all done at compile type.

I'm not sure any of that is relevant to you, but just in case. :)

[jbbjarnason]

Really appreciate your feedback on this.

What I would like to achieve is one property named Value which is generic, and have achieved that with your help from yesterday.

The other property I need is Schema which will provide additional information of the type in Value, I will use const in this case. The schema is customized json schema of the value type, so I can provide information on the unit for example m/s and division kilo etc.

So to boil it down, I would like one property being generic and another property as String which will be const on one interface. And I am unsure how to make it work.

[jbbjarnason]

In cpp this was like the following, https://github.com/centroid-is/framework/blob/main/libs/ipc/inc/public/tfc/ipc/details/dbus_ipc.hpp#L48

  void initialize() {
    interface_->register_signal<value_t>(std::string{ dbus::tags::value });
    interface_->register_property_r<value_t>(std::string{ dbus::tags::value }, sdbusplus::vtable::property_::none,
                                             [this](const auto&) { return value_; });
    interface_->register_property(std::string{ dbus::tags::type }, schema);

    interface_->initialize();
  }

Where the register_property_r<value_t> is the templated generic Value and the below is the Schema which is String

[jbbjarnason]

Just for reference, I am now using Dbus Variant as Value, but I might just go with a method LastValue and signal Value since those support generics along with other property.

mod detail {
    pub trait SupportedTypes {
        fn to_value(&self) -> zbus::zvariant::Value<'static>;
    }
    impl SupportedTypes for i64 {
        fn to_value(&self) -> zbus::zvariant::Value<'static> {
            zbus::zvariant::Value::from(*self)
        }
    }
}

struct SlotInterface<T> {
    last_value: Arc<Mutex<Option<T>>>,
    log_key: String,
}

impl<T: detail::SupportedTypes + zbus::zvariant::Type + Sync + Send + 'static> SlotInterface<T> {
    pub fn new(last_value: Arc<Mutex<Option<T>>>, key: &str) -> Self {
        Self {
            last_value,
            log_key: key.to_string(),
        }
    }
}

#[interface(name = "is.centroid.Slot")]
impl<T> SlotInterface<T>
where
    T: Clone
        + detail::SupportedTypes
        + zbus::zvariant::Type
        + Sync
        + Send
        + 'static
        + JsonSchema
        + for<'a> zbus::export::serde::de::Deserialize<'a>
        + zbus::export::serde::ser::Serialize,
{
    #[zbus(property, name = "Value")]
    async fn value_prop(&self) -> Result<zbus::zvariant::Value<'static>, zbus::fdo::Error> {
        let guard = self.last_value.lock().await;

        match *guard {
            Some(ref value) => Ok(value.to_value()),
            None => Err(zbus::fdo::Error::Failed("No value set".into())),
        }
    }
    #[zbus(property)]
    async fn schema(&self) -> Result<String, zbus::fdo::Error> {
        serde_json::to_string_pretty(&schemars::schema_for!(T)).map_err(|e| {
            let err_msg = format!("Error serializing to JSON schema: {}", e);
            log!(target: &self.log_key, Level::Error, "{}", err_msg);
            zbus::fdo::Error::Failed(err_msg)
        })
    }
    async fn last_value(&self) -> Result<T, zbus::fdo::Error> {
        let guard = self.last_value.lock().await;
        match *guard {
            Some(ref value) => Ok(value.clone()),
            None => Err(zbus::fdo::Error::Failed("No value set".into())),
        }
    }
    async fn tinker(&mut self, value: T) -> Result<(), zbus::fdo::Error> {
        let mut guard = self.last_value.lock().await;
        *guard = Some(value);
        Ok(())
    }
    #[zbus(signal)]
    async fn value(signal_ctxt: &zbus::SignalContext<'_>, val: &T) -> zbus::Result<()>;
}