Refactoring generic type-names

guFalcon · guFalcon · commit 2c187b1c0699 · 2017-09-06T22:41:22.000+02:00
diff --git a/StateMachine/Fsm.cs b/StateMachine/Fsm.cs
@@ -34,32 +34,32 @@
 namespace StateMachine
 {
     [PublicAPI]
-    public class Fsm<TState, TTrigger> : Fsm<TState, TTrigger, float>
+    public class Fsm<TS, TT> : Fsm<TS, TT, float>
     {
-        public Fsm(FsmModel<TState, TTrigger, float> model) : base(model)
+        public Fsm(FsmModel<TS, TT, float> model) : base(model)
         {
         }
 
-        public Fsm(State<TState, TTrigger, float> current, bool stackEnabled = false) : base(current, stackEnabled)
+        public Fsm(State<TS, TT, float> current, bool stackEnabled = false) : base(current, stackEnabled)
         {
         }
 
         public void Update()
         {
-            Model.Current.RaiseUpdated(new UpdateArgs<TState, TTrigger, float>(this, Current, 0f));
+            Model.Current.RaiseUpdated(new UpdateArgs<TS, TT, float>(this, Current, 0f));
         }
     }
 
     [PublicAPI]
-    public class Fsm<TState, TTrigger, TData>
+    public class Fsm<TS, TT, TD>
     {
-        protected FsmModel<TState, TTrigger, TData> Model { get; set; } = new FsmModel<TState, TTrigger, TData>();
+        protected FsmModel<TS, TT, TD> Model { get; set; } = new FsmModel<TS, TT, TD>();
 
-        public State<TState, TTrigger, TData> Current => Model.Current;
-        public Stack<State<TState, TTrigger, TData>> Stack => Model.Stack;
+        public State<TS, TT, TD> Current => Model.Current;
+        public Stack<State<TS, TT, TD>> Stack => Model.Stack;
 
         /// <exception cref="FsmBuilderException">When the model is null</exception>
-        public Fsm(FsmModel<TState, TTrigger, TData> model)
+        public Fsm(FsmModel<TS, TT, TD> model)
         {
             if (model == null) throw FsmBuilderException.ModelCannotBeNull();
 
@@ -71,7 +71,7 @@ public Fsm(FsmModel<TState, TTrigger, TData> model)
         }
 
         /// <exception cref="FsmBuilderException">When the initial state is null</exception>
-        public Fsm(State<TState, TTrigger, TData> current, bool stackEnabled = false)
+        public Fsm(State<TS, TT, TD> current, bool stackEnabled = false)
         {
             Model.StackEnabled = stackEnabled;
             if (current == null) throw FsmBuilderException.StateCannotBeNull();
@@ -84,18 +84,18 @@ public Fsm(State<TState, TTrigger, TData> current, bool stackEnabled = false)
         }
 
         /// <summary>
-        /// Gets you a builder for a Finite-State-Machine (FSM).
+        ///     Gets you a builder for a Finite-State-Machine (FSM).
         /// </summary>
         /// <param name="startState">The start state's key.</param>
         /// <returns></returns>
-        public static BuilderFluent<TState, TTrigger, TData> Builder(TState startState)
+        public static BuilderFluent<TS, TT, TD> Builder(TS startState)
         {
-            return new FluentImplementation<TState, TTrigger, TData>(startState);
+            return new FluentImplementation<TS, TT, TD>(startState);
         }
 
         /// <exception cref="FsmBuilderException">When the handler is null</exception>
-        public Fsm<TState, TTrigger, TData> AddStateChangeHandler(
-            EventHandler<StateChangeArgs<TState, TTrigger, TData>> e)
+        public Fsm<TS, TT, TD> AddStateChangeHandler(
+            EventHandler<StateChangeArgs<TS, TT, TD>> e)
         {
             if (e == null) throw FsmBuilderException.HandlerCannotBeNull();
 
@@ -104,7 +104,7 @@ public Fsm<TState, TTrigger, TData> AddStateChangeHandler(
         }
 
         /// <exception cref="FsmBuilderException">When the state is null or the state has already been added before</exception>
-        public Fsm<TState, TTrigger, TData> Add(State<TState, TTrigger, TData> state)
+        public Fsm<TS, TT, TD> Add(State<TS, TT, TD> state)
         {
             if (state == null) throw FsmBuilderException.StateCannotBeNull();
             if (Model.States.ContainsKey(state.Identifier)) throw FsmBuilderException.StateCanOnlyBeAddedOnce(state);
@@ -117,28 +117,28 @@ public Fsm<TState, TTrigger, TData> Add(State<TState, TTrigger, TData> state)
         ///     When the transition is null or another transition already leads to the same
         ///     target state
         /// </exception>
-        public Fsm<TState, TTrigger, TData> Add(Transition<TState, TTrigger, TData> t)
+        public Fsm<TS, TT, TD> Add(Transition<TS, TT, TD> t)
         {
             if (t == null) throw FsmBuilderException.TransitionCannotBeNull();
 
             Model.GlobalTransitions.Add(t.Target, t);
             return this;
         }
 
-        public void JumpTo(TState state, bool isPop = false)
+        public void JumpTo(TS state, bool isPop = false)
         {
-            State<TState, TTrigger, TData> s;
+            State<TS, TT, TD> s;
             if (Model.States.TryGetValue(state, out s))
             {
-                DoTransition(state, default(TTrigger), isPop);
+                DoTransition(state, default(TT), isPop);
             }
         }
-        
-        private void DoTransition(TState state, TTrigger input, bool isPop)
+
+        private void DoTransition(TS state, TT input, bool isPop)
         {
             if (state == null || input == null) return;
 
-            State<TState, TTrigger, TData> old = Model.Current;
+            State<TS, TT, TD> old = Model.Current;
             if (Model.StackEnabled && isPop)
             {
                 Model.Stack.Pop();
@@ -158,15 +158,15 @@ private void DoTransition(TState state, TTrigger input, bool isPop)
 
             if (!Model.Current.Equals(old))
             {
-                StateChangeArgs<TState, TTrigger, TData> args =
-                    new StateChangeArgs<TState, TTrigger, TData>(this, old, Model.Current, input);
+                StateChangeArgs<TS, TT, TD> args =
+                    new StateChangeArgs<TS, TT, TD>(this, old, Model.Current, input);
                 old.RaiseExited(args);
                 Model.Current.RaiseEntered(args);
                 Model.RaiseStateChanged(args);
             }
         }
 
-        public void Trigger(TTrigger input)
+        public void Trigger(TT input)
         {
             if (input == null) return;
 
@@ -179,16 +179,16 @@ public void Trigger(TTrigger input)
                 }
             }
 
-            Transition<TState, TTrigger, TData> t = Model.Current.Process(input);
+            Transition<TS, TT, TD> t = Model.Current.Process(input);
             if (t != null)
             {
                 DoTransition(t.Target, input, t.Pop);
             }
         }
 
-        public void Update(TData data)
+        public void Update(TD data)
         {
-            Model.Current.RaiseUpdated(new UpdateArgs<TState, TTrigger, TData>(this, Current, data));
+            Model.Current.RaiseUpdated(new UpdateArgs<TS, TT, TD>(this, Current, data));
         }
     }
 }
diff --git a/StateMachine/FsmBuilderException.cs b/StateMachine/FsmBuilderException.cs
@@ -39,8 +39,8 @@ private FsmBuilderException(string message, Exception innerException) : base(mes
         {
         }
 
-        public static FsmBuilderException StateCanOnlyBeAddedOnce<TState, TTrigger, TData>(
-            State<TState, TTrigger, TData> state)
+        public static FsmBuilderException StateCanOnlyBeAddedOnce<TS, TT, TD>(
+            State<TS, TT, TD> state)
         {
             return
                 new FsmBuilderException($"A state [{state.Identifier}] has already been added. You can only one add" +
@@ -72,7 +72,7 @@ public static FsmBuilderException ModelCannotBeNull()
             return new FsmBuilderException("The model cannot be null.");
         }
 
-        public static FsmBuilderException TriggerAlreadyDeclared<TTrigger>(TTrigger trigger)
+        public static FsmBuilderException TriggerAlreadyDeclared<TT>(TT trigger)
         {
             return new FsmBuilderException($"The transition already contains the trigger [{trigger}]");
         }
diff --git a/StateMachine/FsmModel.cs b/StateMachine/FsmModel.cs
@@ -33,30 +33,30 @@
 namespace StateMachine
 {
     [PublicAPI]
-    public class FsmModel<TState, TTrigger, TData>
+    public class FsmModel<TS, TT, TD>
     {
-        public event EventHandler<StateChangeArgs<TState, TTrigger, TData>> StateChanged;
+        public event EventHandler<StateChangeArgs<TS, TT, TD>> StateChanged;
 
-        public State<TState, TTrigger, TData> Current { get; set; }
+        public State<TS, TT, TD> Current { get; set; }
 
-        public Stack<State<TState, TTrigger, TData>> Stack { get; } = new Stack<State<TState, TTrigger, TData>>();
+        public Stack<State<TS, TT, TD>> Stack { get; } = new Stack<State<TS, TT, TD>>();
         public bool StackEnabled { get; set; }
 
-        public Dictionary<TState, State<TState, TTrigger, TData>> States { get; } =
-            new Dictionary<TState, State<TState, TTrigger, TData>>();
+        public Dictionary<TS, State<TS, TT, TD>> States { get; } =
+            new Dictionary<TS, State<TS, TT, TD>>();
 
-        public Dictionary<TState, Transition<TState, TTrigger, TData>> GlobalTransitions { get; } =
-            new Dictionary<TState, Transition<TState, TTrigger, TData>>();
+        public Dictionary<TS, Transition<TS, TT, TD>> GlobalTransitions { get; } =
+            new Dictionary<TS, Transition<TS, TT, TD>>();
 
         public void AddStateChangedHandler(
-            EventHandler<StateChangeArgs<TState, TTrigger, TData>> e)
+            EventHandler<StateChangeArgs<TS, TT, TD>> e)
         {
             if (e == null) throw FsmBuilderException.HandlerCannotBeNull();
 
             StateChanged += e;
         }
 
-        public void RaiseStateChanged(StateChangeArgs<TState, TTrigger, TData> e)
+        public void RaiseStateChanged(StateChangeArgs<TS, TT, TD> e)
         {
             StateChanged?.Invoke(this, e);
         }
diff --git a/StateMachine/NUnitTests/TestTools.cs b/StateMachine/NUnitTests/TestTools.cs
@@ -32,7 +32,7 @@ namespace StateMachine.NUnitTests
 {
     public static class TestTools
     {
-        public static void ConsoleOut<TState, TTrigger, TData>(object sender, StateChangeArgs<TState, TTrigger, TData> e)
+        public static void ConsoleOut<TS, TT, TD>(object sender, StateChangeArgs<TS, TT, TD> e)
         {
             Console.Out.WriteLine($"From [{e.From}] with [{e.Input}] to [{e.To}]");
         }
diff --git a/StateMachine/State.cs b/StateMachine/State.cs
@@ -31,33 +31,33 @@
 namespace StateMachine
 {
     [PublicAPI]
-    public class State<TState, TTrigger, TData>
+    public class State<TS, TT, TD>
     {
-        private StateModel<TState, TTrigger, TData> Model { get; set; }
+        private StateModel<TS, TT, TD> Model { get; set; }
 
-        public TState Identifier => Model.Identifier;
+        public TS Identifier => Model.Identifier;
 
         public bool ClearStack
         {
             get { return Model.ClearStack; }
             set { Model.ClearStack = value; }
         }
 
-        public void RaiseUpdated(UpdateArgs<TState, TTrigger, TData> args) => Model.RaiseUpdated(args);
-        public void RaiseEntered(StateChangeArgs<TState, TTrigger, TData> args) => Model.RaiseEntered(args);
-        public void RaiseExited(StateChangeArgs<TState, TTrigger, TData> args) => Model.RaiseExited(args);
+        public void RaiseUpdated(UpdateArgs<TS, TT, TD> args) => Model.RaiseUpdated(args);
+        public void RaiseEntered(StateChangeArgs<TS, TT, TD> args) => Model.RaiseEntered(args);
+        public void RaiseExited(StateChangeArgs<TS, TT, TD> args) => Model.RaiseExited(args);
 
-        public State(StateModel<TState, TTrigger, TData> model)
+        public State(StateModel<TS, TT, TD> model)
         {
             Model = model;
         }
 
-        public State(TState identifier) : this(new StateModel<TState, TTrigger, TData>(identifier))
+        public State(TS identifier) : this(new StateModel<TS, TT, TD>(identifier))
         {
         }
 
         /// <exception cref="FsmBuilderException"> When the transition is null</exception>
-        public State<TState, TTrigger, TData> Add(Transition<TState, TTrigger, TData> t)
+        public State<TS, TT, TD> Add(Transition<TS, TT, TD> t)
         {
             if (t == null) throw FsmBuilderException.TransitionCannotBeNull();
 
@@ -66,17 +66,17 @@ public State<TState, TTrigger, TData> Add(Transition<TState, TTrigger, TData> t)
             return this;
         }
 
-        public State<TState, TTrigger, TData> AddTransisionOn(TTrigger trigger, TState target)
+        public State<TS, TT, TD> AddTransisionOn(TT trigger, TS target)
         {
-            return Add(new Transition<TState, TTrigger, TData>(trigger, Identifier, target));
+            return Add(new Transition<TS, TT, TD>(trigger, Identifier, target));
         }
 
-        public State<TState, TTrigger, TData> AddPopTransisionOn(TTrigger trigger)
+        public State<TS, TT, TD> AddPopTransisionOn(TT trigger)
         {
-            return Add(new Transition<TState, TTrigger, TData>(trigger, Identifier));
+            return Add(new Transition<TS, TT, TD>(trigger, Identifier));
         }
 
-        public Transition<TState, TTrigger, TData> Process(TTrigger input)
+        public Transition<TS, TT, TD> Process(TT input)
         {
             foreach (var t in Model.Transitions.Values)
             {
diff --git a/StateMachine/StateModel.cs b/StateMachine/StateModel.cs
@@ -33,59 +33,59 @@
 namespace StateMachine
 {
     [PublicAPI]
-    public class StateModel<TState, TTrigger, TData>
+    public class StateModel<TS, TT, TD>
     {
-        public event Action<StateChangeArgs<TState, TTrigger, TData>> Entered;
-        public event Action<StateChangeArgs<TState, TTrigger, TData>> Exited;
-        public event Action<UpdateArgs<TState, TTrigger, TData>> Updated;
+        public event Action<StateChangeArgs<TS, TT, TD>> Entered;
+        public event Action<StateChangeArgs<TS, TT, TD>> Exited;
+        public event Action<UpdateArgs<TS, TT, TD>> Updated;
 
-        public TState Identifier { get; private set; }
+        public TS Identifier { get; private set; }
         public bool EndState { get; set; }
         public bool ClearStack { get; set; }
 
-        public Dictionary<TState, Transition<TState, TTrigger, TData>> Transitions { get; } =
-            new Dictionary<TState, Transition<TState, TTrigger, TData>>();
+        public Dictionary<TS, Transition<TS, TT, TD>> Transitions { get; } =
+            new Dictionary<TS, Transition<TS, TT, TD>>();
 
-        public StateModel(TState identifier)
+        public StateModel(TS identifier)
         {
             Identifier = identifier;
         }
 
         /// <exception cref="FsmBuilderException">When the handler is null</exception>
-        public void AddEnteredHandler(Action<StateChangeArgs<TState, TTrigger, TData>> e)
+        public void AddEnteredHandler(Action<StateChangeArgs<TS, TT, TD>> e)
         {
             if (e == null) throw FsmBuilderException.HandlerCannotBeNull();
 
             Entered += e;
         }
 
-        public void RaiseEntered(StateChangeArgs<TState, TTrigger, TData> e)
+        public void RaiseEntered(StateChangeArgs<TS, TT, TD> e)
         {
             Entered?.Invoke(e);
         }
 
         /// <exception cref="FsmBuilderException">When the handler is null</exception>
-        public void AddExitedHandler(Action<StateChangeArgs<TState, TTrigger, TData>> e)
+        public void AddExitedHandler(Action<StateChangeArgs<TS, TT, TD>> e)
         {
             if (e == null) throw FsmBuilderException.HandlerCannotBeNull();
 
             Exited += e;
         }
 
-        public void RaiseExited(StateChangeArgs<TState, TTrigger, TData> e)
+        public void RaiseExited(StateChangeArgs<TS, TT, TD> e)
         {
             Exited?.Invoke(e);
         }
 
         /// <exception cref="FsmBuilderException">When the handler is null</exception>
-        public void AddUpdatedHandler(Action<UpdateArgs<TState, TTrigger, TData>> e)
+        public void AddUpdatedHandler(Action<UpdateArgs<TS, TT, TD>> e)
         {
             if (e == null) throw FsmBuilderException.HandlerCannotBeNull();
 
             Updated += e;
         }
 
-        public void RaiseUpdated(UpdateArgs<TState, TTrigger, TData> data)
+        public void RaiseUpdated(UpdateArgs<TS, TT, TD> data)
         {
             Updated?.Invoke(data);
         }
diff --git a/StateMachine/Transition.cs b/StateMachine/Transition.cs
diff --git a/StateMachine/TransitionModel.cs b/StateMachine/TransitionModel.cs

Original file line number	Diff line number	Diff line change
`@@ -34,32 +34,32 @@`
`34`	`34`	`namespace StateMachine`
`35`	`35`	`{`
`36`	`36`	`[PublicAPI]`
`37`		`- public class Fsm<TState, TTrigger> : Fsm<TState, TTrigger, float>`
	`37`	`+ public class Fsm<TS, TT> : Fsm<TS, TT, float>`
`38`	`38`	`{`
`39`		`- public Fsm(FsmModel<TState, TTrigger, float> model) : base(model)`
	`39`	`+ public Fsm(FsmModel<TS, TT, float> model) : base(model)`
`40`	`40`	`{`
`41`	`41`	`}`
`42`	`42`
`43`		`- public Fsm(State<TState, TTrigger, float> current, bool stackEnabled = false) : base(current, stackEnabled)`
	`43`	`+ public Fsm(State<TS, TT, float> current, bool stackEnabled = false) : base(current, stackEnabled)`
`44`	`44`	`{`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`public void Update()`
`48`	`48`	`{`
`49`		`- Model.Current.RaiseUpdated(new UpdateArgs<TState, TTrigger, float>(this, Current, 0f));`
	`49`	`+ Model.Current.RaiseUpdated(new UpdateArgs<TS, TT, float>(this, Current, 0f));`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`[PublicAPI]`
`54`		`- public class Fsm<TState, TTrigger, TData>`
	`54`	`+ public class Fsm<TS, TT, TD>`
`55`	`55`	`{`
`56`		`- protected FsmModel<TState, TTrigger, TData> Model { get; set; } = new FsmModel<TState, TTrigger, TData>();`
	`56`	`+ protected FsmModel<TS, TT, TD> Model { get; set; } = new FsmModel<TS, TT, TD>();`
`57`	`57`
`58`		`- public State<TState, TTrigger, TData> Current => Model.Current;`
`59`		`- public Stack<State<TState, TTrigger, TData>> Stack => Model.Stack;`
	`58`	`+ public State<TS, TT, TD> Current => Model.Current;`
	`59`	`+ public Stack<State<TS, TT, TD>> Stack => Model.Stack;`
`60`	`60`
`61`	`61`	`/// <exception cref="FsmBuilderException">When the model is null</exception>`
`62`		`- public Fsm(FsmModel<TState, TTrigger, TData> model)`
	`62`	`+ public Fsm(FsmModel<TS, TT, TD> model)`
`63`	`63`	`{`
`64`	`64`	`if (model == null) throw FsmBuilderException.ModelCannotBeNull();`
`65`	`65`
`@@ -71,7 +71,7 @@ public Fsm(FsmModel<TState, TTrigger, TData> model)`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`/// <exception cref="FsmBuilderException">When the initial state is null</exception>`
`74`		`- public Fsm(State<TState, TTrigger, TData> current, bool stackEnabled = false)`
	`74`	`+ public Fsm(State<TS, TT, TD> current, bool stackEnabled = false)`
`75`	`75`	`{`
`76`	`76`	`Model.StackEnabled = stackEnabled;`
`77`	`77`	`if (current == null) throw FsmBuilderException.StateCannotBeNull();`
`@@ -84,18 +84,18 @@ public Fsm(State<TState, TTrigger, TData> current, bool stackEnabled = false)`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`/// <summary>`
`87`		`- /// Gets you a builder for a Finite-State-Machine (FSM).`
	`87`	`+ /// Gets you a builder for a Finite-State-Machine (FSM).`
`88`	`88`	`/// </summary>`
`89`	`89`	`/// <param name="startState">The start state's key.</param>`
`90`	`90`	`/// <returns></returns>`
`91`		`- public static BuilderFluent<TState, TTrigger, TData> Builder(TState startState)`
	`91`	`+ public static BuilderFluent<TS, TT, TD> Builder(TS startState)`
`92`	`92`	`{`
`93`		`- return new FluentImplementation<TState, TTrigger, TData>(startState);`
	`93`	`+ return new FluentImplementation<TS, TT, TD>(startState);`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`/// <exception cref="FsmBuilderException">When the handler is null</exception>`
`97`		`- public Fsm<TState, TTrigger, TData> AddStateChangeHandler(`
`98`		`- EventHandler<StateChangeArgs<TState, TTrigger, TData>> e)`
	`97`	`+ public Fsm<TS, TT, TD> AddStateChangeHandler(`
	`98`	`+ EventHandler<StateChangeArgs<TS, TT, TD>> e)`
`99`	`99`	`{`
`100`	`100`	`if (e == null) throw FsmBuilderException.HandlerCannotBeNull();`
`101`	`101`
`@@ -104,7 +104,7 @@ public Fsm<TState, TTrigger, TData> AddStateChangeHandler(`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`/// <exception cref="FsmBuilderException">When the state is null or the state has already been added before</exception>`
`107`		`- public Fsm<TState, TTrigger, TData> Add(State<TState, TTrigger, TData> state)`
	`107`	`+ public Fsm<TS, TT, TD> Add(State<TS, TT, TD> state)`
`108`	`108`	`{`
`109`	`109`	`if (state == null) throw FsmBuilderException.StateCannotBeNull();`
`110`	`110`	`if (Model.States.ContainsKey(state.Identifier)) throw FsmBuilderException.StateCanOnlyBeAddedOnce(state);`
`@@ -117,28 +117,28 @@ public Fsm<TState, TTrigger, TData> Add(State<TState, TTrigger, TData> state)`
`117`	`117`	`/// When the transition is null or another transition already leads to the same`
`118`	`118`	`/// target state`
`119`	`119`	`/// </exception>`
`120`		`- public Fsm<TState, TTrigger, TData> Add(Transition<TState, TTrigger, TData> t)`
	`120`	`+ public Fsm<TS, TT, TD> Add(Transition<TS, TT, TD> t)`
`121`	`121`	`{`
`122`	`122`	`if (t == null) throw FsmBuilderException.TransitionCannotBeNull();`
`123`	`123`
`124`	`124`	`Model.GlobalTransitions.Add(t.Target, t);`
`125`	`125`	`return this;`
`126`	`126`	`}`
`127`	`127`
`128`		`- public void JumpTo(TState state, bool isPop = false)`
	`128`	`+ public void JumpTo(TS state, bool isPop = false)`
`129`	`129`	`{`
`130`		`- State<TState, TTrigger, TData> s;`
	`130`	`+ State<TS, TT, TD> s;`
`131`	`131`	`if (Model.States.TryGetValue(state, out s))`
`132`	`132`	`{`
`133`		`- DoTransition(state, default(TTrigger), isPop);`
	`133`	`+ DoTransition(state, default(TT), isPop);`
`134`	`134`	`}`
`135`	`135`	`}`
`136`		`-`
`137`		`- private void DoTransition(TState state, TTrigger input, bool isPop)`
	`136`	`+`
	`137`	`+ private void DoTransition(TS state, TT input, bool isPop)`
`138`	`138`	`{`
`139`	`139`	`if (state == null \|\| input == null) return;`
`140`	`140`
`141`		`- State<TState, TTrigger, TData> old = Model.Current;`
	`141`	`+ State<TS, TT, TD> old = Model.Current;`
`142`	`142`	`if (Model.StackEnabled && isPop)`
`143`	`143`	`{`
`144`	`144`	`Model.Stack.Pop();`
`@@ -158,15 +158,15 @@ private void DoTransition(TState state, TTrigger input, bool isPop)`
`158`	`158`
`159`	`159`	`if (!Model.Current.Equals(old))`
`160`	`160`	`{`
`161`		`- StateChangeArgs<TState, TTrigger, TData> args =`
`162`		`- new StateChangeArgs<TState, TTrigger, TData>(this, old, Model.Current, input);`
	`161`	`+ StateChangeArgs<TS, TT, TD> args =`
	`162`	`+ new StateChangeArgs<TS, TT, TD>(this, old, Model.Current, input);`
`163`	`163`	`old.RaiseExited(args);`
`164`	`164`	`Model.Current.RaiseEntered(args);`
`165`	`165`	`Model.RaiseStateChanged(args);`
`166`	`166`	`}`
`167`	`167`	`}`
`168`	`168`
`169`		`- public void Trigger(TTrigger input)`
	`169`	`+ public void Trigger(TT input)`
`170`	`170`	`{`
`171`	`171`	`if (input == null) return;`
`172`	`172`
`@@ -179,16 +179,16 @@ public void Trigger(TTrigger input)`
`179`	`179`	`}`
`180`	`180`	`}`
`181`	`181`
`182`		`- Transition<TState, TTrigger, TData> t = Model.Current.Process(input);`
	`182`	`+ Transition<TS, TT, TD> t = Model.Current.Process(input);`
`183`	`183`	`if (t != null)`
`184`	`184`	`{`
`185`	`185`	`DoTransition(t.Target, input, t.Pop);`
`186`	`186`	`}`
`187`	`187`	`}`
`188`	`188`
`189`		`- public void Update(TData data)`
	`189`	`+ public void Update(TD data)`
`190`	`190`	`{`
`191`		`- Model.Current.RaiseUpdated(new UpdateArgs<TState, TTrigger, TData>(this, Current, data));`
	`191`	`+ Model.Current.RaiseUpdated(new UpdateArgs<TS, TT, TD>(this, Current, data));`
`192`	`192`	`}`
`193`	`193`	`}`
`194`	`194`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,8 +39,8 @@ private FsmBuilderException(string message, Exception innerException) : base(mes`
`39`	`39`	`{`
`40`	`40`	`}`
`41`	`41`
`42`		`- public static FsmBuilderException StateCanOnlyBeAddedOnce<TState, TTrigger, TData>(`
`43`		`- State<TState, TTrigger, TData> state)`
	`42`	`+ public static FsmBuilderException StateCanOnlyBeAddedOnce<TS, TT, TD>(`
	`43`	`+ State<TS, TT, TD> state)`
`44`	`44`	`{`
`45`	`45`	`return`
`46`	`46`	`new FsmBuilderException($"A state [{state.Identifier}] has already been added. You can only one add" +`
`@@ -72,7 +72,7 @@ public static FsmBuilderException ModelCannotBeNull()`
`72`	`72`	`return new FsmBuilderException("The model cannot be null.");`
`73`	`73`	`}`
`74`	`74`
`75`		`- public static FsmBuilderException TriggerAlreadyDeclared<TTrigger>(TTrigger trigger)`
	`75`	`+ public static FsmBuilderException TriggerAlreadyDeclared<TT>(TT trigger)`
`76`	`76`	`{`
`77`	`77`	`return new FsmBuilderException($"The transition already contains the trigger [{trigger}]");`
`78`	`78`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,30 +33,30 @@`
`33`	`33`	`namespace StateMachine`
`34`	`34`	`{`
`35`	`35`	`[PublicAPI]`
`36`		`- public class FsmModel<TState, TTrigger, TData>`
	`36`	`+ public class FsmModel<TS, TT, TD>`
`37`	`37`	`{`
`38`		`- public event EventHandler<StateChangeArgs<TState, TTrigger, TData>> StateChanged;`
	`38`	`+ public event EventHandler<StateChangeArgs<TS, TT, TD>> StateChanged;`
`39`	`39`
`40`		`- public State<TState, TTrigger, TData> Current { get; set; }`
	`40`	`+ public State<TS, TT, TD> Current { get; set; }`
`41`	`41`
`42`		`- public Stack<State<TState, TTrigger, TData>> Stack { get; } = new Stack<State<TState, TTrigger, TData>>();`
	`42`	`+ public Stack<State<TS, TT, TD>> Stack { get; } = new Stack<State<TS, TT, TD>>();`
`43`	`43`	`public bool StackEnabled { get; set; }`
`44`	`44`
`45`		`- public Dictionary<TState, State<TState, TTrigger, TData>> States { get; } =`
`46`		`- new Dictionary<TState, State<TState, TTrigger, TData>>();`
	`45`	`+ public Dictionary<TS, State<TS, TT, TD>> States { get; } =`
	`46`	`+ new Dictionary<TS, State<TS, TT, TD>>();`
`47`	`47`
`48`		`- public Dictionary<TState, Transition<TState, TTrigger, TData>> GlobalTransitions { get; } =`
`49`		`- new Dictionary<TState, Transition<TState, TTrigger, TData>>();`
	`48`	`+ public Dictionary<TS, Transition<TS, TT, TD>> GlobalTransitions { get; } =`
	`49`	`+ new Dictionary<TS, Transition<TS, TT, TD>>();`
`50`	`50`
`51`	`51`	`public void AddStateChangedHandler(`
`52`		`- EventHandler<StateChangeArgs<TState, TTrigger, TData>> e)`
	`52`	`+ EventHandler<StateChangeArgs<TS, TT, TD>> e)`
`53`	`53`	`{`
`54`	`54`	`if (e == null) throw FsmBuilderException.HandlerCannotBeNull();`
`55`	`55`
`56`	`56`	`StateChanged += e;`
`57`	`57`	`}`
`58`	`58`
`59`		`- public void RaiseStateChanged(StateChangeArgs<TState, TTrigger, TData> e)`
	`59`	`+ public void RaiseStateChanged(StateChangeArgs<TS, TT, TD> e)`
`60`	`60`	`{`
`61`	`61`	`StateChanged?.Invoke(this, e);`
`62`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ namespace StateMachine.NUnitTests`
`32`	`32`	`{`
`33`	`33`	`public static class TestTools`
`34`	`34`	`{`
`35`		`- public static void ConsoleOut<TState, TTrigger, TData>(object sender, StateChangeArgs<TState, TTrigger, TData> e)`
	`35`	`+ public static void ConsoleOut<TS, TT, TD>(object sender, StateChangeArgs<TS, TT, TD> e)`
`36`	`36`	`{`
`37`	`37`	`Console.Out.WriteLine($"From [{e.From}] with [{e.Input}] to [{e.To}]");`
`38`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,33 +31,33 @@`
`31`	`31`	`namespace StateMachine`
`32`	`32`	`{`
`33`	`33`	`[PublicAPI]`
`34`		`- public class State<TState, TTrigger, TData>`
	`34`	`+ public class State<TS, TT, TD>`
`35`	`35`	`{`
`36`		`- private StateModel<TState, TTrigger, TData> Model { get; set; }`
	`36`	`+ private StateModel<TS, TT, TD> Model { get; set; }`
`37`	`37`
`38`		`- public TState Identifier => Model.Identifier;`
	`38`	`+ public TS Identifier => Model.Identifier;`
`39`	`39`
`40`	`40`	`public bool ClearStack`
`41`	`41`	`{`
`42`	`42`	`get { return Model.ClearStack; }`
`43`	`43`	`set { Model.ClearStack = value; }`
`44`	`44`	`}`
`45`	`45`
`46`		`- public void RaiseUpdated(UpdateArgs<TState, TTrigger, TData> args) => Model.RaiseUpdated(args);`
`47`		`- public void RaiseEntered(StateChangeArgs<TState, TTrigger, TData> args) => Model.RaiseEntered(args);`
`48`		`- public void RaiseExited(StateChangeArgs<TState, TTrigger, TData> args) => Model.RaiseExited(args);`
	`46`	`+ public void RaiseUpdated(UpdateArgs<TS, TT, TD> args) => Model.RaiseUpdated(args);`
	`47`	`+ public void RaiseEntered(StateChangeArgs<TS, TT, TD> args) => Model.RaiseEntered(args);`
	`48`	`+ public void RaiseExited(StateChangeArgs<TS, TT, TD> args) => Model.RaiseExited(args);`
`49`	`49`
`50`		`- public State(StateModel<TState, TTrigger, TData> model)`
	`50`	`+ public State(StateModel<TS, TT, TD> model)`
`51`	`51`	`{`
`52`	`52`	`Model = model;`
`53`	`53`	`}`
`54`	`54`
`55`		`- public State(TState identifier) : this(new StateModel<TState, TTrigger, TData>(identifier))`
	`55`	`+ public State(TS identifier) : this(new StateModel<TS, TT, TD>(identifier))`
`56`	`56`	`{`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`/// <exception cref="FsmBuilderException"> When the transition is null</exception>`
`60`		`- public State<TState, TTrigger, TData> Add(Transition<TState, TTrigger, TData> t)`
	`60`	`+ public State<TS, TT, TD> Add(Transition<TS, TT, TD> t)`
`61`	`61`	`{`
`62`	`62`	`if (t == null) throw FsmBuilderException.TransitionCannotBeNull();`
`63`	`63`
`@@ -66,17 +66,17 @@ public State<TState, TTrigger, TData> Add(Transition<TState, TTrigger, TData> t)`
`66`	`66`	`return this;`
`67`	`67`	`}`
`68`	`68`
`69`		`- public State<TState, TTrigger, TData> AddTransisionOn(TTrigger trigger, TState target)`
	`69`	`+ public State<TS, TT, TD> AddTransisionOn(TT trigger, TS target)`
`70`	`70`	`{`
`71`		`- return Add(new Transition<TState, TTrigger, TData>(trigger, Identifier, target));`
	`71`	`+ return Add(new Transition<TS, TT, TD>(trigger, Identifier, target));`
`72`	`72`	`}`
`73`	`73`
`74`		`- public State<TState, TTrigger, TData> AddPopTransisionOn(TTrigger trigger)`
	`74`	`+ public State<TS, TT, TD> AddPopTransisionOn(TT trigger)`
`75`	`75`	`{`
`76`		`- return Add(new Transition<TState, TTrigger, TData>(trigger, Identifier));`
	`76`	`+ return Add(new Transition<TS, TT, TD>(trigger, Identifier));`
`77`	`77`	`}`
`78`	`78`
`79`		`- public Transition<TState, TTrigger, TData> Process(TTrigger input)`
	`79`	`+ public Transition<TS, TT, TD> Process(TT input)`
`80`	`80`	`{`
`81`	`81`	`foreach (var t in Model.Transitions.Values)`
`82`	`82`	`{`
Original file line number	Diff line number	Diff line change
`@@ -33,59 +33,59 @@`
`33`	`33`	`namespace StateMachine`
`34`	`34`	`{`
`35`	`35`	`[PublicAPI]`
`36`		`- public class StateModel<TState, TTrigger, TData>`
	`36`	`+ public class StateModel<TS, TT, TD>`
`37`	`37`	`{`
`38`		`- public event Action<StateChangeArgs<TState, TTrigger, TData>> Entered;`
`39`		`- public event Action<StateChangeArgs<TState, TTrigger, TData>> Exited;`
`40`		`- public event Action<UpdateArgs<TState, TTrigger, TData>> Updated;`
	`38`	`+ public event Action<StateChangeArgs<TS, TT, TD>> Entered;`
	`39`	`+ public event Action<StateChangeArgs<TS, TT, TD>> Exited;`
	`40`	`+ public event Action<UpdateArgs<TS, TT, TD>> Updated;`
`41`	`41`
`42`		`- public TState Identifier { get; private set; }`
	`42`	`+ public TS Identifier { get; private set; }`
`43`	`43`	`public bool EndState { get; set; }`
`44`	`44`	`public bool ClearStack { get; set; }`
`45`	`45`
`46`		`- public Dictionary<TState, Transition<TState, TTrigger, TData>> Transitions { get; } =`
`47`		`- new Dictionary<TState, Transition<TState, TTrigger, TData>>();`
	`46`	`+ public Dictionary<TS, Transition<TS, TT, TD>> Transitions { get; } =`
	`47`	`+ new Dictionary<TS, Transition<TS, TT, TD>>();`
`48`	`48`
`49`		`- public StateModel(TState identifier)`
	`49`	`+ public StateModel(TS identifier)`
`50`	`50`	`{`
`51`	`51`	`Identifier = identifier;`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`/// <exception cref="FsmBuilderException">When the handler is null</exception>`
`55`		`- public void AddEnteredHandler(Action<StateChangeArgs<TState, TTrigger, TData>> e)`
	`55`	`+ public void AddEnteredHandler(Action<StateChangeArgs<TS, TT, TD>> e)`
`56`	`56`	`{`
`57`	`57`	`if (e == null) throw FsmBuilderException.HandlerCannotBeNull();`
`58`	`58`
`59`	`59`	`Entered += e;`
`60`	`60`	`}`
`61`	`61`
`62`		`- public void RaiseEntered(StateChangeArgs<TState, TTrigger, TData> e)`
	`62`	`+ public void RaiseEntered(StateChangeArgs<TS, TT, TD> e)`
`63`	`63`	`{`
`64`	`64`	`Entered?.Invoke(e);`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`/// <exception cref="FsmBuilderException">When the handler is null</exception>`
`68`		`- public void AddExitedHandler(Action<StateChangeArgs<TState, TTrigger, TData>> e)`
	`68`	`+ public void AddExitedHandler(Action<StateChangeArgs<TS, TT, TD>> e)`
`69`	`69`	`{`
`70`	`70`	`if (e == null) throw FsmBuilderException.HandlerCannotBeNull();`
`71`	`71`
`72`	`72`	`Exited += e;`
`73`	`73`	`}`
`74`	`74`
`75`		`- public void RaiseExited(StateChangeArgs<TState, TTrigger, TData> e)`
	`75`	`+ public void RaiseExited(StateChangeArgs<TS, TT, TD> e)`
`76`	`76`	`{`
`77`	`77`	`Exited?.Invoke(e);`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`/// <exception cref="FsmBuilderException">When the handler is null</exception>`
`81`		`- public void AddUpdatedHandler(Action<UpdateArgs<TState, TTrigger, TData>> e)`
	`81`	`+ public void AddUpdatedHandler(Action<UpdateArgs<TS, TT, TD>> e)`
`82`	`82`	`{`
`83`	`83`	`if (e == null) throw FsmBuilderException.HandlerCannotBeNull();`
`84`	`84`
`85`	`85`	`Updated += e;`
`86`	`86`	`}`
`87`	`87`
`88`		`- public void RaiseUpdated(UpdateArgs<TState, TTrigger, TData> data)`
	`88`	`+ public void RaiseUpdated(UpdateArgs<TS, TT, TD> data)`
`89`	`89`	`{`
`90`	`90`	`Updated?.Invoke(data);`
`91`	`91`	`}`