/// <summary>
/// Get Method Info structures that match
/// </summary>
/// <param name="methodName"></param>
/// <returns></returns>
public MethodInfo GetMethod(string methodName, GQHSMParameters Params)
{
List <MethodInfo> methodInfos = m_classHanderMethods[methodName];
foreach (MethodInfo methodInfo in methodInfos)
{
ParameterInfo[] paramInfo = methodInfo.GetParameters();
bool varsMatch = true;
if (paramInfo.Length == Params.Count)
{
for (int i = 0; i < Params.Count; i++)
{
// if Value is null, this is an unknown GQHSMVariable that can be mapped later
if ((Params[i].Value != null) && (Params[i].Value.GetType() != paramInfo[i].ParameterType))
{
varsMatch = false;
break;
}
}
}
if (varsMatch)
{
return(methodInfo);
}
}
if (methodInfos.Count != 0)
{
Logger.Debug("Unable to find matching method signature for action handler function: {0}({1});", _name, Params.GetParametersString());
}
return(null);
}
public bool GetGuardedTransition(string signalName, GQHSMParameters Params, ref GQHSMTransition transition)
{
List <GQHSMTransition> guardTansitions;
guardTansitions = _nameToGuardedTransitionMultiMap[signalName];
// retrieve unguarded transition if any
_nameToTransitionMap.TryGetValue(signalName, out transition);
if ((guardTansitions.Count == 0) && (transition == null))
{
return(false);
}
foreach (GQHSMTransition gTransition in guardTansitions)
{
// call methods directly if any.
if (gTransition.InvokeGuards())
{
transition = gTransition;
break;
}
if (CallGuardHandler(gTransition.GuardCondition, Params))
{
transition = gTransition;
break;
}
}
return(true);
}
/// <summary>
/// Do a internal transition to another state using signalName
/// </summary>
/// <returns>
/// true if handled
/// </returns>
/// <param name='signalName'>
/// The name of the signal that will transition to another state
/// </param>
/// <param name='data'>
/// any object that is passed between states
/// </param>
public bool StateTransitionInternal(string stateName, GQHSMParameters Params, string signalName)
{
GQHSMTransition transition = null;
string fullTransitionName = stateName + "." + signalName;
// if we know about the transition
bool retVal = false;
retVal = GetGuardedTransition(fullTransitionName, Params, ref transition);
if (transition != null)
{
GQHSMState toState = GetState(transition.GetDestinationStateID());
GQHSMState fromState = GetState(transition.GetSourceStateID());
QState stateHandler = GetTopState();
if (toState != null)
{
stateHandler = toState.GetStateHandler();
}
if (_instrument && !transition.DoNotInstrument)
{
LogStateEvent(StateLogType.EventTransition, GetCurrentState(), stateHandler, transition.Name, signalName);
}
if (!transition.IsInnerTransition)
{
DoTransitionTo(stateHandler, transition.GetSlot());
}
// still execute actions on this inner transition
transition.InvokeActions();
retVal = true;
}
else if (signalName == "Internal.TransitionTo")
{
if (Params.Count == 1)
{
GQHSMState state = (GQHSMState)Params[0].Value;
DoTransitionTo(state.GetStateHandler());
return(true);
}
return(false);
}
return(retVal);
}
public bool CallGuardHandler(string sGuardCondition, GQHSMParameters Params)
{
List <GQHSMHandler> guardList = null;
guardList = m_ActionHandlersMap[sGuardCondition];
foreach (GQHSMHandler gHandler in guardList)
{
bool validated = (bool)gHandler.Invoke(Params);
if (validated)
{
return(true);
}
}
return(false);
}
public GQHSMAction(GQHSM parent, string actionStr)
{
_parentHSM = parent;
string[] NameAndParams = actionStr.Split(new char[] { '(', ')' }, StringSplitOptions.RemoveEmptyEntries);
if (NameAndParams.Length > 1)
{
_params = new GQHSMParameters(NameAndParams[1]);
}
else if (NameAndParams.Length == 1)
{
_params = new GQHSMParameters();
}
_name = NameAndParams[0];
_globals = GQHSMManager.Instance.Globals;
if (!_name.StartsWith("^"))
{
_actionHandler = _parentHSM.GetMethod(_name, _params);
}
}
public object Invoke(GQHSMParameters Params)
{
GQHSMParameters _params = Params;
object retValue = null;
if (_params == null)
{
_params = new GQHSMParameters();
}
if (_classDelegateOO != null)
{
retValue = _classDelegateOO.Method.Invoke(_sourceObject, new object[] { _params });
}
if (_classDelegate != null)
{
_classDelegate.Method.Invoke(_sourceObject, new object[] { null });
}
return(retValue);
}
public QState StateHandler(IQEvent ev)
{
GQHSMManager manager = GQHSMManager.Instance;
switch (ev.QSignal)
{
case QSignals.Init:
{
GQHSMState childStartState = GetChildStartState();
if (childStartState != null)
{
if (_parentHSM.Instrument && !DoNotInstrument)
{
_parentHSM.LogStateEvent(StateLogType.Init, _stateHandler, childStartState.GetStateHandler());
}
_parentHSM.InitState(childStartState.GetStateHandler());
return(null);
}
_parentHSM.ResetTimeOuts(Id);
}
break;
case QSignals.Entry:
{
if (_parentHSM.Instrument && !DoNotInstrument)
{
_parentHSM.LogStateEvent(StateLogType.Entry, _stateHandler);
}
if (_entryActions != null)
{
_entryActions.InvokeActionHandlers();
}
_parentHSM.SetTimeOuts(Id);
}
return(null);
case QSignals.Exit:
{
_parentHSM.ClearTimeOuts(Id);
if (_parentHSM.Instrument && !DoNotInstrument)
{
_parentHSM.LogStateEvent(StateLogType.Exit, _stateHandler);
}
if (_exitActions != null)
{
_exitActions.InvokeActionHandlers();
}
}
return(null);
case QSignals.Empty:
{
}
break;
default:
{
GQHSMParameters evParams;
if (ev.QData is GQHSMParameters)
{
evParams = (GQHSMParameters)ev.QData;
}
else
{
evParams = new GQHSMParameters(ev.QData);
}
if (evParams[0] != null)
{
manager.Globals["ev"].Copy(evParams[0]);
}
if (_parentHSM.StateTransitionInternal(_fullName, evParams, ev.QSignal))
{
return(null);
}
}
break;
}
return(_parentHSM.GetStateHandler(ParentId));
}
