public DfaLexemeReader(IStateContainer stateContainer, IBufferReader bufferReader)
{
_stateContainer = stateContainer ?? throw new ArgumentNullException(nameof(bufferReader));
_bufferReader = bufferReader ?? throw new ArgumentNullException(nameof(bufferReader));
_bufferReader.AdvanceBuffer(); //Preload the buffer
}
private void OnStateChange(IStateContainer <DataStructureV1> container)
{
_logger.Information($"Previous State is: {container.PrevState}");
_logger.Information($"Current State is: {container.State}");
switch (container.State)
{
case StateEnumV1.Enabled:
{
_logger.Information($"Message: {container.Data?.StringValue}");
}
break;
case StateEnumV1.Start:
{
_logger.Information($"Message: {container.Data?.StringValue}");
}
break;
case StateEnumV1.Idle:
{
}
break;
case StateEnumV1.Animating:
{
}
break;
case StateEnumV1.Disabled:
{
_logger.Information($"Message: {container.Data?.StringValue}");
}
break;
}
}
// Todo: Clean up
public async Task Save <T>(IStateContainer <T> stateContainer) where T : IEventHandlerState
{
using (var context = await _frameworkContextFactory.CreateContext())
{
var state = context.EventHandlerStates.SingleOrDefault(s => s.Id == stateContainer.Id);
var insert = false;
if (state == null)
{
state = new EventHandlerState();
insert = true;
}
state.Id = stateContainer.Id;
state.ProcessedEventId = stateContainer.ProcessedEventId;
state.LastUpdated = stateContainer.LastUpdated;
state.Status = stateContainer.HandlerStatus;
state.Data = _eventHandlerStateSerializer.Serialize(stateContainer.State);
if (insert)
{
context.EventHandlerStates.Add(state);
}
await context.SaveChangesAsync();
}
}
public void RemoveState(StateSave stateSave, IStateContainer stateContainer)
{
var behaviorNeedingState = GetBehaviorsNeedingState(stateSave);
if (behaviorNeedingState.Any())
{
string message =
"This state cannot be removed because it is needed by the following behavior(s):";
foreach (var behavior in behaviorNeedingState)
{
message += "\n" + behavior.Name;
}
MessageBox.Show(message);
}
else if (stateSave.ParentContainer?.DefaultState == stateSave)
{
string message =
"This state cannot be removed because it is the default state.";
MessageBox.Show(message);
}
else
{
var response = MessageBox.Show($"Are you sure you want to delete the state {stateSave.Name}?", "Delete state?", MessageBoxButtons.YesNo);
if (response == DialogResult.Yes)
{
ObjectRemover.Self.Remove(stateSave);
}
}
}
public void RefreshUI(IStateContainer stateContainer)
{
bool changed = stateContainer != mLastElementRefreshedTo;
mLastElementRefreshedTo = stateContainer;
StateSave lastStateSave = SelectedState.Self.SelectedStateSave;
InstanceSave instance = SelectedState.Self.SelectedInstance;
if (stateContainer != null)
{
RemoveUnnecessaryNodes(stateContainer);
AddNeededNodes(stateContainer);
FixNodeOrder(stateContainer);
bool wasAnythingSelected = false;
foreach (var state in stateContainer.AllStates)
{
wasAnythingSelected = UpdateStateTreeNode(lastStateSave, instance, wasAnythingSelected, state);
}
foreach (var category in stateContainer.Categories)
{
UpdateCategoryTreeNode(category);
}
}
else
{
mTreeView.Nodes.Clear();
}
}
public IEnumerable <State> AllStates()
{
if (StartState != null)
{
yield return(StartState);
}
Stack <IStateContainer> containers = new Stack <IStateContainer>();
containers.Push(this);
while (containers.Any())
{
IStateContainer container = containers.Pop();
foreach (State state in container.States)
{
if (!state.IsStart)
{
yield return(state);
}
}
foreach (StateGroup group in container.Groups)
{
containers.Push(group);
}
}
}
public StateMachineV1(IStateContainer <DataStructureV1> stateContainer, ILogger logger)
{
_stateContainer = stateContainer ?? throw new ArgumentNullException(nameof(stateContainer));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_stateContainer.OnStateChange += OnStateChange;
}
public override IPStmt VisitGotoStmt(PParser.GotoStmtContext context)
{
var stateNameContext = context.stateName();
var stateName = stateNameContext.state.GetText();
IStateContainer current = machine;
foreach (var token in stateNameContext._groups)
{
current = current?.GetGroup(token.GetText());
if (current == null)
{
throw handler.MissingDeclaration(token, "group", token.GetText());
}
}
var state = current?.GetState(stateName);
if (state == null)
{
throw handler.MissingDeclaration(stateNameContext.state, "state", stateName);
}
var expectedType =
state.Entry?.Signature.ParameterTypes.ElementAtOrDefault(0) ?? PrimitiveType.Null;
var rvaluesList = TypeCheckingUtils.VisitRvalueList(context.rvalueList(), exprVisitor).ToArray();
foreach (var arg in rvaluesList)
{
if (arg is LinearAccessRefExpr linearArg && linearArg.LinearType == LinearType.Swap)
{
throw handler.InvalidSwap(linearArg, "swap not allowed on goto");
}
}
IPExpr payload;
if (rvaluesList.Length == 0)
{
payload = null;
}
else if (rvaluesList.Length == 1)
{
payload = rvaluesList[0];
}
else
{
payload = new UnnamedTupleExpr(context, rvaluesList);
}
var payloadType = payload?.Type ?? PrimitiveType.Null;
if (!expectedType.IsAssignableFrom(payloadType))
{
throw handler.TypeMismatch(context, payloadType, expectedType);
}
method.CanChangeState = true;
return(new GotoStmt(context, state, payload));
}
protected override void DoSetHeader(IStateContainer state, HttpRequestMessage req)
{
if (state.ContainsKey(StardustTimerKey))
{
return;
}
state.SetState(StardustTimerKey, Stopwatch.StartNew());
}
protected override void DoGetHeader(IStateContainer state, HttpResponseMessage response)
{
var code = response.Headers.Contains("x-supportCode") ? response.Headers.GetValues("x-supportCode").FirstOrDefault():null;
if (string.IsNullOrWhiteSpace(code))
{
return;
}
GetHandler()?.SetSupportCode(code);
}
protected override void DoSetServiceHeaders(IStateContainer state, IDictionary <string, StringValues> headers)
{
var sw = state.GetState <Stopwatch>(StardustTimerKey);
if (sw == null)
{
return;
}
sw.Stop();
headers.Add(StardustTimerKey, sw.ElapsedMilliseconds.ToString());
}
public void RefreshUi(IStateContainer stateContainer)
{
var foundNode = GetTreeNodeForTag(stateContainer);
if (foundNode != null)
{
RecordSelection();
RefreshUi(foundNode);
SelectRecordedSelection();
}
}
public void RemoveState(StateSave stateSave, IStateContainer elementToRemoveFrom)
{
elementToRemoveFrom.UncategorizedStates.Remove(stateSave);
foreach (var category in elementToRemoveFrom.Categories.Where(item => item.States.Contains(stateSave)))
{
category.States.Remove(stateSave);
}
GumCommands.Self.FileCommands.TryAutoSaveCurrentElement();
}
private async Task InitializeState(Guid stateKey, T initalState)
{
_stateContainer = await _eventHandlerStateStore.Get <T>(stateKey) ?? CreateDefaultStateContainer(stateKey, initalState);
if (_stateContainer.HandlerStatus == StatefulHandlerStatus.Faulted)
{
throw new Exception("Prior state suggests that handler is in an invalid state. Consider reinitializing handler.");
}
_stateContainer.HandlerStatus = StatefulHandlerStatus.SpoolingHistory;
State = _stateContainer.State;
}
private void RemoveUnnecessaryNodes(IStateContainer stateContainer)
{
var allNodes = mTreeView.Nodes.AllNodes().ToList();
foreach (var node in allNodes)
{
if (node.Tag is StateSave)
{
// First check to see if this doesn't exist at all...
bool shouldRemove = stateContainer.AllStates.Contains(node.Tag as StateSave) == false;
// ... and if it does exist, see if it's part of the wrong category
if (!shouldRemove)
{
if (node.Parent != null)
{
var category = node.Parent.Tag as StateSaveCategory;
if (!category.States.Contains(node.Tag as StateSave))
{
shouldRemove = true;
}
}
else
{
shouldRemove = stateContainer.Categories.Any(item => item.States.Contains(node.Tag as StateSave));
}
}
if (shouldRemove)
{
var parent = ParentOf(node);
parent.Remove(node);
}
}
else if (node.Tag is StateSaveCategory && stateContainer.Categories.Contains(node.Tag as StateSaveCategory) == false)
{
if (node.Parent == null)
{
mTreeView.Nodes.Remove(node);
}
else
{
node.Parent.Nodes.Remove(node);
}
}
}
}
protected override void DoSetHeader(IStateContainer state, HttpRequestMessage req)
{
try
{
var item = GetHandler()?.GetSupportCode();
if (string.IsNullOrWhiteSpace(item))
{
return;
}
req.Headers.Add("x-supportCode", item);
}
catch (Exception)
{
//ignored
}
}
private void FixNodeOrder(IStateContainer stateContainer)
{
// first make sure categories come first
int desiredIndex = 0;
foreach (var category in stateContainer.Categories.OrderBy(item => item.Name))
{
var node = GetTreeNodeForTag(category);
var parent = ParentOf(node);
var nodeIndex = parent.IndexOf(node);
if (nodeIndex != desiredIndex)
{
parent.Remove(node);
parent.Insert(desiredIndex, node);
}
FixNodeOrderInCategory(category);
desiredIndex++;
}
// do uncategorized states
for (int i = 0; i < stateContainer.UncategorizedStates.Count(); i++)
{
var state = stateContainer.UncategorizedStates.ElementAt(i);
var node = GetTreeNodeForTag(state);
var parent = ParentOf(node);
int nodeIndex = parent.IndexOf(node);
if (nodeIndex != desiredIndex)
{
parent.Remove(node);
parent.Insert(desiredIndex, node);
}
desiredIndex++;
}
}
public override IPStmt VisitGotoStmt(PParser.GotoStmtContext context)
{
PParser.StateNameContext stateNameContext = context.stateName();
string stateName = stateNameContext.state.GetText();
IStateContainer current = machine;
foreach (PParser.IdenContext token in stateNameContext._groups)
{
current = current?.GetGroup(token.GetText());
if (current == null)
{
throw handler.MissingDeclaration(token, "group", token.GetText());
}
}
State state = current?.GetState(stateName);
if (state == null)
{
throw handler.MissingDeclaration(stateNameContext.state, "state", stateName);
}
IPExpr payload = null;
PLanguageType expectedType =
state.Entry.Signature.ParameterTypes.ElementAtOrDefault(0) ?? PrimitiveType.Null;
if (context.rvalueList()?.rvalue() is PParser.RvalueContext[] rvalues)
{
if (rvalues.Length == 1)
{
payload = exprVisitor.Visit(rvalues[0]);
}
else
{
IPExpr[] tupleFields = rvalues.Select(exprVisitor.Visit).ToArray();
payload = new UnnamedTupleExpr(context, tupleFields,
new TupleType(tupleFields.Select(f => f.Type).ToList()));
}
}
PLanguageType payloadType = payload?.Type ?? PrimitiveType.Null;
if (!expectedType.IsAssignableFrom(payloadType))
{
throw handler.TypeMismatch(context, payloadType, expectedType);
}
return(new GotoStmt(context, state, payload));
}
public CategoryList()
{
_stateContainer = new AggregateStateContainer(
new CategoryListStateContainer(this),
_categoryStates);
// Setup the shared width container
_sharedWidthContainer = new SharedPropertyValueColumnWidthContainer();
SharedPropertyValueColumnWidthContainer.SetOwningSharedPropertyValueColumnWidthContainer(this, _sharedWidthContainer);
// When someone new gets focus, we may need to mess around with selected property, so listen to the event
this.AddHandler(FocusManager.GotFocusEvent, new RoutedEventHandler(OnSomeoneGotFocus));
// When editing is done in the value editor, shift focus back to the selected property
this.CommandBindings.Add(new CommandBinding(PropertyValueEditorCommands.FinishEditing, OnFinishEditing));
// Need to call this method from a UI thread because some of Sparkle's value editors rely on it
UIThreadDispatcher.InitializeInstance();
}
private void AddNeededNodes(IStateContainer stateContainer)
{
foreach (var category in stateContainer.Categories)
{
if (GetTreeNodeForTag(category) == null)
{
var treeNode = mTreeView.Nodes.Add(category.Name);
treeNode.Tag = category;
treeNode.ImageIndex = ElementTreeViewManager.FolderImageIndex;
}
}
foreach (var state in stateContainer.UncategorizedStates)
{
// uncategorized
if (GetTreeNodeForTag(state) == null)
{
var treeNode = mTreeView.Nodes.Add(state.Name);
treeNode.Tag = state;
treeNode.ImageIndex = ElementTreeViewManager.StateImageIndex;
}
}
foreach (var category in stateContainer.Categories)
{
foreach (var state in category.States)
{
// uncategorized
if (GetTreeNodeForTag(state) == null)
{
var toAddTo = GetTreeNodeForTag(category);
var treeNode = toAddTo.Nodes.Add(state.Name);
treeNode.ImageIndex = ElementTreeViewManager.StateImageIndex;
treeNode.Tag = state;
}
}
}
}
public void GenerateStateEnums(IStateContainer stateContainer, ICodeBlock currentBlock, string enumNamePrefix = null)
{
bool hasUncategorized = (stateContainer is BehaviorSave) == false;
currentBlock.Line("#region State Enums");
if (hasUncategorized)
{
string categoryName = "VariableState";
var states = stateContainer.UncategorizedStates;
GenerateEnumsForCategory(currentBlock, categoryName, states);
}
// loop through categories:
foreach (var category in stateContainer.Categories)
{
string categoryName = enumNamePrefix + category.Name;
var states = category.States;
GenerateEnumsForCategory(currentBlock, categoryName, states);
}
currentBlock.Line("#endregion");
}
internal void RenameState(StateSave stateSave, IStateContainer stateContainer)
{
var behaviorNeedingState = GetBehaviorsNeedingState(stateSave);
if (behaviorNeedingState.Any())
{
string message =
"This state cannot be removed because it is needed by the following behavior(s):";
foreach (var behavior in behaviorNeedingState)
{
message += "\n" + behavior.Name;
}
MessageBox.Show(message);
}
else
{
TextInputWindow tiw = new TextInputWindow();
tiw.Message = "Enter new state name";
tiw.Result = SelectedState.Self.SelectedStateSave.Name;
var result = tiw.ShowDialog();
if (result == DialogResult.OK)
{
string oldName = stateSave.Name;
stateSave.Name = tiw.Result;
GumCommands.Self.GuiCommands.RefreshStateTreeView();
// I don't think we need to save the project when renaming a state:
//GumCommands.Self.FileCommands.TryAutoSaveProject();
PluginManager.Self.StateRename(stateSave, oldName);
GumCommands.Self.FileCommands.TryAutoSaveCurrentElement();
}
}
}
protected override void DoGetHeader(IStateContainer state, HttpResponseMessage response)
{
var sw = state.GetState <Stopwatch>(StardustTimerKey);
if (sw == null)
{
return;
}
sw.Stop();
IEnumerable <string> values = response.Headers.GetValues("x-execution-timer");
string s = values != null?values.FirstOrDefault() : null;
if (string.IsNullOrWhiteSpace(s))
{
return;
}
long num1 = long.Parse(s);
long num2 = sw.ElapsedMilliseconds - num1;
state.Extras.Add("latency", (object)num2);
state.Extras.Add("serverTime", (object)num1);
state.Extras.Add("totalTime", (object)sw.ElapsedMilliseconds);
}
public void Apply(IStateContainer <IWeatherState> stateContainer)
{
stateContainer.LoadState();
stateContainer.State.Forecasts = this.forecasts;
}
protected override void DoGetServiceHeader(IStateContainer state, IDictionary <string, StringValues> headers)
{
state.Add(StardustTimerKey, Stopwatch.StartNew());
}
protected override void DoSetServiceHeaders(IStateContainer state, HttpResponseHeaders headers)
{
}
protected override void DoGetServiceHeader(IStateContainer state, HttpRequestHeaders headers)
{
state.Add(StardustTimerKey, Stopwatch.StartNew());
}
protected override void DoGetServiceHeader(IStateContainer state, HttpRequestHeaders headers)
{
}
protected GenericIngameGameHandler(IStateContainer <TPeer> state)
: base(state.Peer)
{
this.state = state;
}
protected void DoGetServiceHeaders(IStateContainer state, IDictionary <string, StringValues> headers)
{
}