/// <summary> /// Handles the given event. /// </summary> /// <param name="e">Event to handle</param> private void HandleEvent(Event e) { // Do not process an ignored event. if (this.IgnoredEvents.Contains(e.GetType())) { Output.Log("<IgnoreLog> Monitor '{0}' ignored event '{1}'.", this.GetType().Name, e.GetType()); return; } // Assign trigger and payload. this.Trigger = e.GetType(); this.Payload = e.Payload; while (true) { if (this.State == null) { // If the event cannot be handled then report an error and exit. this.Assert(false, "Monitor '{0}' received event '{1}' that cannot be handled.", this.GetType().Name, e.GetType().Name); } // If current state cannot handle the event then null the state. if (!this.CanHandleEvent(e.GetType())) { Output.Debug(DebugType.Runtime, "<ExitLog> Monitor '{0}' exiting state '{1}'.", this, this.State.GetType().Name); this.State = null; continue; } // Checks if the event can trigger a goto state transition. if (this.GotoTransitions.ContainsKey(e.GetType())) { var transition = this.GotoTransitions[e.GetType()]; Type targetState = transition.Item1; Action onExitAction = transition.Item2; this.GotoState(targetState, onExitAction); } // Checks if the event can trigger an action. else if (this.ActionBindings.ContainsKey(e.GetType())) { Action action = this.ActionBindings[e.GetType()]; this.Do(action); } break; } }
/// <summary> /// Initializes information about the states of the monitor. /// </summary> private void InitializeStateInformation() { this.StateTypes = new HashSet<Type>(); this.States = new HashSet<MonitorState>(); Type monitorType = this.GetType(); Type initialStateType = null; while (monitorType != typeof(Monitor)) { foreach (var s in monitorType.GetNestedTypes(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.DeclaredOnly)) { if (s.IsClass && s.IsSubclassOf(typeof(MonitorState))) { if (s.IsDefined(typeof(Start), false)) { this.Assert(initialStateType == null, "Monitor '{0}' can not have " + "more than one start states.\n", this.GetType().Name); initialStateType = s; } this.Assert(s.BaseType == typeof(MonitorState), "State '{0}' is " + "not of the correct type.\n", s.Name); this.StateTypes.Add(s); } } monitorType = monitorType.BaseType; } foreach (var type in this.StateTypes) { var isHot = false; var isCold = false; var hotAttribute = type.GetCustomAttribute(typeof(Hot), false) as Hot; if (hotAttribute != null) { isHot = true; } var coldAttribute = type.GetCustomAttribute(typeof(Cold), false) as Cold; if (coldAttribute != null) { isCold = true; } MonitorState state = Activator.CreateInstance(type) as MonitorState; state.InitializeState(this, isHot, isCold); this.States.Add(state); } var initialState = this.States.First(val => val.GetType().Equals(initialStateType)); this.ConfigureStateTransitions(initialState); this.State = initialState; }
/// <summary> /// Configures the state transitions of the monitor. /// </summary> /// <param name="state">State</param> private void ConfigureStateTransitions(MonitorState state) { this.GotoTransitions = state.GotoTransitions; this.ActionBindings = state.ActionBindings; this.IgnoredEvents = state.IgnoredEvents; }
/// <summary> /// Performs a goto transition to the given state. /// </summary> /// <param name="s">Type of the state</param> /// <param name="onExit">Goto on exit action</param> private void GotoState(Type s, Action onExit) { // The monitor performs the on exit statements of the current state. this.ExecuteCurrentStateOnExit(onExit); var nextState = this.States.First(val => val.GetType().Equals(s)); this.ConfigureStateTransitions(nextState); // The monitor transitions to the new state. this.State = nextState; // The monitor performs the on entry statements of the new state. this.ExecuteCurrentStateOnEntry(); }
/// <summary> /// Handles the given event. /// </summary> /// <param name="e">Event to handle</param> private void HandleEvent(Event e) { // Do not process an ignored event. if (this.IgnoredEvents.Contains(e.GetType())) { return; } // Assigns the receieved event. this.ReceivedEvent = e; while (true) { if (this.State == null) { // If the event cannot be handled, then report an error and exit. this.Assert(false, $"Monitor '{this.GetType().Name}' received event " + $"'{e.GetType().FullName}' that cannot be handled."); } // If current state cannot handle the event then null the state. if (!this.CanHandleEvent(e.GetType())) { base.Runtime.NotifyExitedState(this); this.State = null; continue; } // Checks if the event is a goto state event. if (e.GetType() == typeof(GotoStateEvent)) { Type targetState = (e as GotoStateEvent).State; this.GotoState(targetState, null); } // Checks if the event can trigger a goto state transition. else if (this.GotoTransitions.ContainsKey(e.GetType())) { var transition = this.GotoTransitions[e.GetType()]; this.GotoState(transition.Item1, transition.Item2); } // Checks if the event can trigger an action. else if (this.ActionBindings.ContainsKey(e.GetType())) { string actionName = this.ActionBindings[e.GetType()]; this.Do(actionName); } break; } }
/// <summary> /// Performs a goto transition to the given state. /// </summary> /// <param name="s">Type of the state</param> /// <param name="onExitActionName">Action name</param> private void GotoState(Type s, string onExitActionName) { // The monitor performs the on exit statements of the current state. this.ExecuteCurrentStateOnExit(onExitActionName); var nextState = StateMap[this.GetType()].First(val => val.GetType().Equals(s)); this.ConfigureStateTransitions(nextState); // The monitor transitions to the new state. this.State = nextState; if (nextState.IsCold) { this.LivenessTemperature = 0; } // The monitor performs the on entry statements of the new state. this.ExecuteCurrentStateOnEntry(); }
/// <summary> /// Initializes information about the states of the monitor. /// </summary> internal void InitializeStateInformation() { Type monitorType = this.GetType(); // Caches the available state types for this monitor type. if (StateTypeMap.TryAdd(monitorType, new HashSet<Type>())) { Type baseType = monitorType; while (baseType != typeof(Monitor)) { foreach (var s in baseType.GetNestedTypes(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.DeclaredOnly)) { this.ExtractStateTypes(s); } baseType = baseType.BaseType; } } // Caches the available state instances for this monitor type. if (StateMap.TryAdd(monitorType, new HashSet<MonitorState>())) { foreach (var type in StateTypeMap[monitorType]) { var state = Activator.CreateInstance(type) as MonitorState; state.InitializeState(); this.Assert((state.IsCold && !state.IsHot) || (!state.IsCold && state.IsHot) || (!state.IsCold && !state.IsHot), $"State '{type.FullName}' of monitor '{base.Id}' " + "cannot be both cold and hot."); StateMap[monitorType].Add(state); } } // Caches the actions declarations for this monitor type. if (MonitorActionMap.TryAdd(monitorType, new Dictionary<string, MethodInfo>())) { foreach (var state in StateMap[monitorType]) { if (state.EntryAction != null && !MonitorActionMap[monitorType].ContainsKey(state.EntryAction)) { MonitorActionMap[monitorType].Add(state.EntryAction, this.GetActionWithName(state.EntryAction)); } if (state.ExitAction != null && !MonitorActionMap[monitorType].ContainsKey(state.ExitAction)) { MonitorActionMap[monitorType].Add(state.ExitAction, this.GetActionWithName(state.ExitAction)); } foreach (var transition in state.GotoTransitions) { if (transition.Value.Item2 != null && !MonitorActionMap[monitorType].ContainsKey(transition.Value.Item2)) { MonitorActionMap[monitorType].Add(transition.Value.Item2, this.GetActionWithName(transition.Value.Item2)); } } foreach (var action in state.ActionBindings) { if (!MonitorActionMap[monitorType].ContainsKey(action.Value)) { MonitorActionMap[monitorType].Add(action.Value, this.GetActionWithName(action.Value)); } } } } // Populates the map of actions for this monitor instance. foreach (var kvp in MonitorActionMap[monitorType]) { this.ActionMap.Add(kvp.Key, kvp.Value); } var initialStates = StateMap[monitorType].Where(state => state.IsStart).ToList(); this.Assert(initialStates.Count != 0, $"Monitor '{base.Id}' must declare a start state."); this.Assert(initialStates.Count == 1, $"Monitor '{base.Id}' " + "can not declare more than one start states."); this.ConfigureStateTransitions(initialStates.Single()); this.State = initialStates.Single(); this.AssertStateValidity(); }
/// <summary> /// Configures the state transitions of the monitor. /// </summary> /// <param name="state">State</param> private void ConfigureStateTransitions(MonitorState state) { this.GotoTransitions = state.GotoTransitions; this.ActionBindings = state.ActionBindings; this.IgnoredEvents = state.IgnoredEvents; }
/// <summary> /// Initializes information about the states of the monitor. /// </summary> internal void InitializeStateInformation() { Type monitorType = this.GetType(); // Caches the available state types for this monitor type. if (StateTypeMap.TryAdd(monitorType, new HashSet <Type>())) { Type baseType = monitorType; while (baseType != typeof(Monitor)) { foreach (var s in baseType.GetNestedTypes(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.DeclaredOnly)) { this.ExtractStateTypes(s); } baseType = baseType.BaseType; } } // Caches the available state instances for this monitor type. if (StateMap.TryAdd(monitorType, new HashSet <MonitorState>())) { foreach (var type in StateTypeMap[monitorType]) { Type stateType = type; if (type.IsAbstract) { continue; } if (type.IsGenericType) { // If the state type is generic (only possible if inherited by a // generic monitor declaration), then iterate through the base // monitor classes to identify the runtime generic type, and use // it to instantiate the runtime state type. This type can be // then used to create the state constructor. Type declaringType = this.GetType(); while (!declaringType.IsGenericType || !type.DeclaringType.FullName.Equals(declaringType.FullName.Substring( 0, declaringType.FullName.IndexOf('[')))) { declaringType = declaringType.BaseType; } if (declaringType.IsGenericType) { stateType = type.MakeGenericType(declaringType.GetGenericArguments()); } } ConstructorInfo constructor = stateType.GetConstructor(Type.EmptyTypes); var lambda = Expression.Lambda <Func <MonitorState> >( Expression.New(constructor)).Compile(); MonitorState state = lambda(); state.InitializeState(); this.Assert((state.IsCold && !state.IsHot) || (!state.IsCold && state.IsHot) || (!state.IsCold && !state.IsHot), $"State '{type.FullName}' of monitor '{this.Id}' " + "cannot be both cold and hot."); StateMap[monitorType].Add(state); } } // Caches the actions declarations for this monitor type. if (MonitorActionMap.TryAdd(monitorType, new Dictionary <string, MethodInfo>())) { foreach (var state in StateMap[monitorType]) { if (state.EntryAction != null && !MonitorActionMap[monitorType].ContainsKey(state.EntryAction)) { MonitorActionMap[monitorType].Add(state.EntryAction, this.GetActionWithName(state.EntryAction)); } if (state.ExitAction != null && !MonitorActionMap[monitorType].ContainsKey(state.ExitAction)) { MonitorActionMap[monitorType].Add(state.ExitAction, this.GetActionWithName(state.ExitAction)); } foreach (var transition in state.GotoTransitions) { if (transition.Value.Lambda != null && !MonitorActionMap[monitorType].ContainsKey(transition.Value.Lambda)) { MonitorActionMap[monitorType].Add(transition.Value.Lambda, this.GetActionWithName(transition.Value.Lambda)); } } foreach (var action in state.ActionBindings) { if (!MonitorActionMap[monitorType].ContainsKey(action.Value.Name)) { MonitorActionMap[monitorType].Add(action.Value.Name, this.GetActionWithName(action.Value.Name)); } } } } // Populates the map of actions for this monitor instance. foreach (var kvp in MonitorActionMap[monitorType]) { this.ActionMap.Add(kvp.Key, kvp.Value); } var initialStates = StateMap[monitorType].Where(state => state.IsStart).ToList(); this.Assert(initialStates.Count != 0, $"Monitor '{this.Id}' must declare a start state."); this.Assert(initialStates.Count == 1, $"Monitor '{this.Id}' " + "can not declare more than one start states."); this.ConfigureStateTransitions(initialStates.Single()); this.State = initialStates.Single(); this.AssertStateValidity(); }