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