reactive_graph_model_core/reactive_graph/core/
action.rs

1//! ---------------------------------------------
2//! This file was generated automatically.
3//! ---------------------------------------------
4#![allow(dead_code, unused)]
5#![cfg_attr(rustfmt, rustfmt_skip)]
6
7/// Namespace `reactive_graph::core::Action`
8#[cfg_attr(rustfmt, rustfmt_skip)]
9pub const ACTION_NAMESPACE: &str = "reactive_graph::core::Action";
10
11/// The [type identifier]() of Component `Action`.
12///
13/// ### Namespace
14///
15/// The fully qualified namespace is
16/// `reactive_graph::core::Action`
17pub static ACTION: std::sync::LazyLock<reactive_graph_graph::ComponentTypeId> = std::sync::LazyLock::new(||
18std::str::FromStr::from_str(ACTION_NAMESPACE).unwrap());
19
20/// The properties of Component `Action`.
21#[allow(non_camel_case_types)]
22#[derive(Debug, PartialEq, PartialOrd, Eq, Hash, Clone)]
23pub enum ActionProperties {
24    
25    /// ### Property `trigger`
26    ///
27    /// On receiving a boolean trigger the action will be executed
28    ///
29    /// Data Type: `Bool`
30    ///
31    /// Socket Type: `Input`
32    ///
33    /// Mutability: `Mutable`
34    ///
35    TRIGGER,
36}
37impl ActionProperties {
38    pub fn len() -> usize {
39        1usize
40    }
41    
42    pub fn property_types() -> reactive_graph_graph::PropertyTypes {
43        let property_types = reactive_graph_graph::PropertyTypes::new();
44        property_types.push(ActionProperties::TRIGGER);
45        property_types
46    }
47}
48
49impl AsRef<str> for ActionProperties {
50    #[inline]
51    fn as_ref(&self) -> &str {
52        match *self {
53            ActionProperties::TRIGGER => "trigger",
54        }
55    }
56}
57
58impl From<ActionProperties> for &'static str {
59    #[inline]
60    fn from(properties: ActionProperties) -> &'static str {
61        match properties {
62            ActionProperties::TRIGGER => "trigger",
63        }
64    }
65}
66
67impl From<ActionProperties> for String {
68    #[inline]
69    fn from(properties: ActionProperties) -> String {
70        match properties {
71            ActionProperties::TRIGGER => "trigger".to_owned(),
72        }
73    }
74}
75
76impl From<ActionProperties> for reactive_graph_graph::PropertyType {
77    #[inline]
78    fn from(properties: ActionProperties) -> reactive_graph_graph::PropertyType {
79        match properties {
80            ActionProperties::TRIGGER => {
81                reactive_graph_graph::PropertyType::new_with_all(
82                    "trigger",
83                    "On receiving a boolean trigger the action will be executed",
84                    reactive_graph_graph::DataType::Bool,
85                    reactive_graph_graph::SocketType::Input,
86                    reactive_graph_graph::Mutability::Mutable,
87                    reactive_graph_graph::Extensions::new(),
88                )
89            }
90        }
91    }
92}
93
94pub struct ActionPropertiesIterator(Option<ActionProperties>);
95
96impl ActionProperties {
97    pub fn into_iter() -> ActionPropertiesIterator {
98        ActionPropertiesIterator(None)
99    }
100}
101
102impl Iterator for ActionPropertiesIterator {
103    type Item = ActionProperties;
104    fn next(&mut self) -> Option<Self::Item> {
105        self.0 = match self.0 {
106            None => Some(ActionProperties::TRIGGER),
107            Some(ActionProperties::TRIGGER) => None,
108        };
109        self.0.clone()
110    }
111}
112
113impl IntoIterator for ActionProperties {
114    type Item = ActionProperties;
115    type IntoIter = ActionPropertiesIterator;
116    fn into_iter(self) -> Self::IntoIter {
117        ActionPropertiesIterator(None)
118    }
119}
120
121impl core::fmt::Display for ActionProperties {
122    fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {
123        match *self {
124            ActionProperties::TRIGGER => core::fmt::Display::fmt("trigger", f),
125        }
126    }
127}
128
129///
130pub static ACTION_EXTENSIONS: std::sync::LazyLock<reactive_graph_graph::Extensions> = std::sync::LazyLock::new(||
131{ reactive_graph_graph::Extensions::new() });
132
133pub static ACTION_TYPE: std::sync::LazyLock<reactive_graph_graph::Component> = std::sync::LazyLock::new(||
134{
135    reactive_graph_graph::Component::builder()
136        .ty(core::ops::Deref::deref(&ACTION))
137        .description("An action can be triggered")
138        .properties(ActionProperties::property_types())
139        .build()
140});
141
142/// # Component `Action`
143///
144/// ## Fully Qualified Namespace
145///
146/// `reactive_graph::core::Action`
147///
148/// ## Description
149///
150/// An action can be triggered
151///
152/// ### Properties
153///
154/// - trigger
155///
156/// ## JSON Schema
157///
158/// [https://schema.reactive-graph.io/schema/json/dynamic_graph/types/component/reactive_graph/core/Action.schema.json]()
159///
160pub trait Action {
161    
162    /// ### Property `trigger`
163    ///
164    /// On receiving a boolean trigger the action will be executed
165    ///
166    /// Data Type: `Bool`
167    ///
168    /// Socket Type: `Input`
169    ///
170    /// Mutability: `Mutable`
171    ///
172    fn trigger(&self) -> bool;
173    
174    /// ### Property `trigger`
175    ///
176    /// On receiving a boolean trigger the action will be executed
177    ///
178    /// Data Type: `Bool`
179    ///
180    /// Socket Type: `Input`
181    ///
182    /// Mutability: `Mutable`
183    ///
184    fn set_trigger(&mut self, trigger: bool);
185}