modified event constructor, added builder method with_metadata.

code cleanup

src/events.rs

@@ -56,14 +56,19 @@ pub struct Event {
 }
 
 impl Event {
-    pub fn new(kind: EventKind, tick: u64, metadata: Option<EventMetadata>) -> Self {
+    pub fn new(kind: EventKind, tick: u64) -> Self {
         Event {
             kind,
             tick,
-            metadata,
+            metadata: None,
         }
     }
 
+    pub fn with_metadata(mut self, metadata: Option<EventMetadata>) -> Self {
+        self.metadata = metadata;
+        self
+    }
+
     fn has_metadata(&self) -> bool {
         self.metadata.is_some()
     }

src/strategy.rs

@@ -4,11 +4,11 @@ use std::fmt::{Debug, Formatter};
 use dyn_clone::DynClone;
 use log::info;
 
+use crate::BoxError;
 use crate::connectors::Connector;
 use crate::events::{ActionMessage, Event, EventKind, EventMetadata};
 use crate::managers::OptionUpdate;
 use crate::models::{ActiveOrder, OrderBook, OrderForm, OrderKind, Position, PositionProfitState};
-use crate::BoxError;
 
 /***************
 * DEFINITIONS
@@ -156,6 +156,7 @@ impl Default for HiddenTrailingStop {
         }
     }
 }
+
 impl PositionStrategy for HiddenTrailingStop {
     fn name(&self) -> String {
         "Hidden Trailing Stop".into()
@@ -197,45 +198,40 @@ impl PositionStrategy for HiddenTrailingStop {
             None => return (new_position, None, None),
         };
 
-        let events = {
+        let event = match state {
-            let mut events = vec![];
+            PositionProfitState::Critical => {
-
+                Event::new(
-            if state == PositionProfitState::Profit {
-                events.push(Event::new(
-                    EventKind::ReachedGoodProfit,
-                    current_tick,
-                    Some(event_metadata),
-                ));
-            } else if state == PositionProfitState::MinimumProfit {
-                events.push(Event::new(
-                    EventKind::ReachedMinProfit,
-                    current_tick,
-                    Some(event_metadata),
-                ));
-            } else if state == PositionProfitState::BreakEven {
-                events.push(Event::new(
-                    EventKind::ReachedBreakEven,
-                    current_tick,
-                    Some(event_metadata),
-                ));
-            } else if state == PositionProfitState::Loss {
-                events.push(Event::new(
-                    EventKind::ReachedLoss,
-                    current_tick,
-                    Some(event_metadata),
-                ));
-            } else {
-                events.push(Event::new(
                     EventKind::ReachedMaxLoss,
                     current_tick,
-                    Some(event_metadata),
+                )
-                ));
             }
+            PositionProfitState::Loss => {
+                Event::new(
+                    EventKind::ReachedLoss,
+                    current_tick,
+                )
+            }
+            PositionProfitState::BreakEven => {
+                Event::new(
+                    EventKind::ReachedBreakEven,
+                    current_tick,
+                )
+            }
+            PositionProfitState::MinimumProfit => {
+                Event::new(
+                    EventKind::ReachedMinProfit,
+                    current_tick,
+                )
+            }
+            PositionProfitState::Profit => {
+                Event::new(
+                    EventKind::ReachedGoodProfit,
+                    current_tick,
+                )
+            }
+        }.with_metadata(Some(event_metadata));
 
-            events
+        (new_position, Some(vec![event]), None)
-        };
-
-        (new_position, Some(events), None)
     }
 
     fn post_tick(