[−][src]Crate new_home_application_macro
New Home Application (Macro)
This crate provides a macro for deriving the Method trait.
Attributes
There are a couple of attributes that can be used on the struct and/or fields in the struct
Name | Scope | Description |
---|---|---|
description | Struct | Provides a description for the method |
help | Struct/Field | Provides a help text for an argument/struct field or the method itself |
argument | Field | Marks a struct field as an argument and contains a description for it |
default | Field | Contains a default value for a struct field |
Arguments
The word "Arguments" describes fields on the Method struct, that are set through the Method::set_arguments
method. While you can implement the Method trait by yourself and just handle it on your own, this
macro allows you to have the argument
attribute on a field which causes the field to be automatically
set by the set_arguments method. This however requires the field to have the type serde_json::Value.
The argument attribute also has to have a content, which will become the description for the field.
To set a default value for the argument, there is the default
attribute. The content of this
attribute will be literally passed to the serde_json::Value::from method. So you will have to
wrap strings in quotes. On the other side however, you can easily put a plain number or boolean
in there and it will be filled in to the argument.
Example
You can see a full example in the examples/macro-example.rs
file, but here you also have a small
example for applying the macro onto a struct:
use serde_json::Value; use new_home_application::method::{Method, MethodCallable}; use new_home_application::communication::{MethodCall, MethodResult}; use new_home_application_macro::Method; #[derive(Method)] #[description("Can convert a word into uppercase")] #[help("Will convert the word to uppercase if uppercase flag is set")] struct ExampleMethod { #[argument("The word that should be converted")] #[help("Can be any valid string")] pub word: Value, #[argument("Determines if the word will be converted to uppercase")] #[default(false)] pub uppercase: Value, } impl MethodCallable for ExampleMethod { fn call(&mut self, _: MethodCall) -> MethodResult { unimplemented!() } }
The logic for executing whatever the method should do is not implemented here as the Method trait only provides basic information for the method. The logic will be added through the MethodCallable trait which cannot be derived and has to be implemented by yourself.
Derive Macros
Method |