Struct Plugin 

pub struct Plugin<T>
where
    T: 'static + Clone,
{
    pub state: T,
    pub option: HashMap<String, RpcOption>,
    pub rpc_method: HashMap<String, Box<dyn RPCCommand<T>>>,
    pub rpc_info: HashSet<RPCMethodInfo>,
    pub rpc_hook: HashMap<String, Box<dyn RPCCommand<T>>>,
    pub hook_info: HashSet<RPCHookInfo>,
    pub rpc_notification: HashMap<String, Box<dyn RPCCommand<T>>>,
    pub dynamic: bool,
    pub configuration: Option<CLNConf>,
    /* private fields */
}

Fields

state: T

option: HashMap<String, RpcOption>

all the option contained inside the hash map.

rpc_method: HashMap<String, Box<dyn RPCCommand<T>>>

all the options rpc method that the plugin need to support, included the builtin rpc method.

rpc_info: HashSet<RPCMethodInfo>

keep the info of the method in a separate list FIXME: move the RPCMethodInfo as key of the rpc_method map.

rpc_hook: HashMap<String, Box<dyn RPCCommand<T>>>

all the hook where the plugin is register during the configuration

hook_info: HashSet<RPCHookInfo>

keep all the info about the hooks in a separate set. FIXME: put the RPCHookInfo as key of the hash map.

rpc_notification: HashMap<String, Box<dyn RPCCommand<T>>>

all the notification that the plugin is register on

dynamic: bool

mark a plugin as dynamic, in this way the plugin can be run from core lightning without stop the lightningd daemon

configuration: Option<CLNConf>

core lightning configuration sent with the init call.

Implementations

impl<'a, T: 'a + Clone> Plugin<T>

pub fn new(state: T, dynamic: bool) -> Self

pub fn on_init<C>(&'a mut self, callback: C) -> Self

where C: Fn(&mut Plugin<T>) -> Value + 'static,

pub fn log(&self, level: LogLevel, msg: &str)

pub fn add_opt( &mut self, name: &str, opt_type: &str, def_val: Option<String>, description: &str, deprecated: bool, ) -> &mut Self

register the plugin option.

pub fn get_opt<R: for<'de> Deserialize<'de>>( &self, name: &str, ) -> Result<R, PluginError>

get an optionue that cln sent back to the plugin.

pub fn add_rpc_method<F>( &'a mut self, name: &str, usage: &str, description: &str, callback: F, ) -> Self

where F: RPCCommand<T> + 'static,

pub fn register_hook<F>( &'a mut self, hook_name: &str, before: Option<Vec<String>>, after: Option<Vec<String>>, callback: F, ) -> Self

where F: RPCCommand<T> + 'static,

pub fn register_notification<F>(&mut self, name: &str, callback: F) -> Self

where F: 'static + RPCCommand<T> + Clone,

pub fn start(self)

Trait Implementations

impl<T> Clone for Plugin<T>

where T: 'static + Clone + Clone,

fn clone(&self) -> Plugin<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.