Differences

This shows you the differences between two versions of the page.

--- beansdoc [2011/01/05 10:03] – More basic beans hourdin
+++ beansdoc [2011/06/21 16:08] (current) – [Beans managing time and threads] hourdin
@@ Line 30: / Line 30: @@
 A simple method is then used to trigger the boolean event:
   * **FireBool()**: method triggering the sending of the boolean event.
-  * **^BooleanCreated**: the boolean event emitted by the BooleanFactory bean.
+  * **^BooleanCreated**: the //boolean// event emitted by the BooleanFactory bean.
 ==== BoolFilter ====
 This bean is used to propagate a boolean event only when its value is either //true// or //false//, but not both. The filtered value of the boolean event can be parametrized by the **Filter** property of the bean. When the received event value matches the Filter property value, the BoolFilter can send two events, a void and an integer event:
-  * **^EventFiltered**: the void event sent by the bean when the incoming event matches the property value.
+  * **^EventFiltered**: the //void// event sent by the bean when the incoming event matches the property value.
-  * **^IntValEmitted**: the integer event sent by the bean when the incoming event matches the property value. The value of the integer is parametrized by the **SendValue** bean property.
+  * **^IntValEmitted**: the //integer// event sent by the bean when the incoming event matches the property value. The value of the integer is parametrized by the **SendValue** bean property.
   * **SetLevel(**//boolean//**)**: the input method of the bean, that will trigger the filtering and consequent event sending.
 ==== Counter ====
+This integer counter increments its internal value when the **Increment()** input method is called. It sends a //void// event indicating that its value has changed, and provides an //integer// property (Value) and thus the **get_Value()** property getter method to retrieve the value of the internal counter.
+Moreover, it has the ability to apply a modulo to the incrementing internal counter. This can be useful to make binary counters (modulo = 2) for example. In this case, when the counter comes back to 0, the Carry event is raised, allowing to cascade the counters when a modulo is used, and create a multi-bit counter for example. The value of the modulo is parametrized by the **Modulo** property.
+  * **Increment()**: input method, incrementing the internal counter value.
+  * **^ValueChanged**: //void// notification of incrementation. Use the **get_Value()** property getter as callback value to complete integer method calls.
+  * **^Carry**: //void// notification of reset of the counter value because of modulo value reaching.
+  * **Reset()**: resets the counter, setting 0 for the internal value and sending the ValueChanged event //(introduced in version 870)//.
 ==== EventFilter ====
+The EventFilter bean acts as an electric relay on a flow of //void// events. It has a boolean property indicating if it is closed or open, and an input method relayed to an output event.
+  * **FireEvent()**: input method of the event flow.
+  * **^EventOut**: output event of the event flow.
+  * **set_Propagate(**//boolean//**)**: the setter method of the **Propagate** property, indicating if the event flow is relayed (//true//) or not (//false//).
 ==== EventToggler ====
+This bean allows to create alternating event calls from a single event stream. It receives a //void// event and sends alternatively the **^EventOut0** and **^EventOut1** //void// events. It also sends a boolean event alternating between //true// and //false// values.
+  * **FireEvent()**: the input method that triggers the sending of one of the two EventOut[0|1] events in an alternate way. Also emits the EventOut //boolean// event.
+  * **^EventOut**: the //boolean// event sent alternatively with a //true// and a //false// value.
 ==== PrimitiveValueEmitter ====
 The PrimitiveValueEmitter is probably the most useful bean, since it can convert a void event to any primitive type of events, like //string//, //integer//, //boolean//, //double// and so on. All the available types can be seen in the property panel. The value of the primitive type event you want to send has to be configured using these properties too, and all events are triggered by the same method:
   * **FireValueEvent()**: this method triggers the sending of all primitive type events of the bean.
-  * **^Emit//Type//Value**: an event of a primitive type, sent when FireValueEvent() is invoked, and using the value set in the property **//Type//Value** of the bean.
+  * **^Emit//Type//Value**: an event of a primitive type //Type//, sent when FireValueEvent() is invoked, and using the value set in the property **//Type//Value** of the bean.
   * **set_//Type//Value(**//Type//**)**: a method allowing to remotely set the value that the bean will send (property setter method).
 ==== Threshold ====
+This bean allows to filter a //string// event flow containing decimal numbers according to a minimal or maximal value of the decimal number. For example, it can allow events to be relayed only when the value in the string is higher than "17.2".
+  * **set_Value(**//string//**)**: input method of the bean, receiving the string containing the decimal number.
+  * **^CeilledValue**: the //string//: event emitted when the input value (of set_Value()) was higher than the threshold, or lower if the bean is inverted (Inverted property set to //true//).
+  * **^ThresholdReachedBool**: a //boolean// event sent when the input values cross the threshold level, up or down. The value of the event is //true// when the value is above and //false// when value is below the threshold. This behavior is inverted when the bean is inverted (Inverted property set to //true//).
+  * The **ThresholdValue** property parametrizes the value of the threshold that evaluates incoming events.
 ==== ValueFormatter ====
+This bean allows to convert a primitive type event to a string. This is nearly the opposite of the [[beansdoc#primitivevalueemitter|PrimitiveValueEmitter]], since the ValueFormatter has as many inputs as handled types and only one (//string//) output.
+  * **Format(**//Type//**)**: input method, existing for many type arguments.
+  * **^StringValueChanged**: the //string// output event, sent when the above method is invoked.
+More than allowing to convert primitive types to a string, the ValueFormatter allows to modify the format of the output string, for example to add the unit of an integer value. The **ValueFormat** property of the bean allows to change the output format of the string. The format of the ValueFormat property is the standard C# formatting syntax [[http://msdn.microsoft.com/en-us/library/txafckwd.aspx|(doc page)]].
+Example: a "{0} ms" ValueFormat value will emit a "12 ms" string for a Format(12) method invocation.
+===== Beans managing time and threads (in the Basic category) =====
+==== Timer ====
+The timer bean allows an event to be sent periodically. It creates a single thread that manages the loop. A sleep is done before each event sending, for the time defined by the **Period** property. It means that if the methods called by the event sending (if the event is linked to methods of other beans) take one second to execute, the actual time between two events will be 1s+Period. The [[beansdoc#activetimer|ActiveTimer]] bean fixes this issue.
+  * **^TimerTick**: the void event that is sent periodically.
+  * **Start()**: this method is used to start the timer's loop once it has been created. It is also used to restart the loop once it has been stopped.
+  * **Stop()**: stops the loop and thus event sending.
+==== ActiveTimer ====
+This timer has the same goal than the [[beansdoc#timer|Timer]] bean, but creates a new thread on each event sending. The main difference with [[beansdoc#timer|Timer]] is thus that the time between two events is not affected by what's executed by the event in other beans.
+It has the same interface than [[beansdoc#timer|Timer]].
+==== Delay ====
+This bean acts as a simple event delayer. It is a generic bean, meaning that it can handle any type of event in input and methods in output. When its **Input()** method is called, it will wait for a delay configured by the **DelayMillisec** property, and send the **^Output** event with the same arguments than the Input.
+The method and event of this bean, and all other generic beans, won't appear in the compatible list when creating a link. It has to be searched in the incompatible list of methods.