internal static IEnumerable <ParsedStatenode> GetDescendants(
this ParsedStatenode stateNode)
=> stateNode.CataFold(
atomic => atomic.Yield() as IEnumerable <ParsedStatenode>,
final => final.Yield() as IEnumerable <ParsedStatenode>,
(compound, subStates) =>
compound.Append(subStates.SelectMany(a => a)),
(orthogonal, subStates) =>
orthogonal.Append(subStates.SelectMany(a => a))).Except(stateNode.Yield());
private static Transition Convert(this TransitionDefinition definition, ParsedStatenode source, Func <OneOf <StatenodeId, string>, ParsedStatenode> getStatenode, ServiceDefinition serviceDefinition, int serviceIndex) =>
definition.Match(
forbidden => new Transition(forbidden.Event, source, Enumerable.Empty <ParsedStatenode>(), Actionblock.Empty(), Option.None <Guard>(), true),
unguarded => new Transition(unguarded.Event.Convert(source, serviceDefinition, serviceIndex), source, unguarded.Targets.GetTargetStatenodes(source.Id, getStatenode), unguarded.Actions.Convert(), Option.None <Guard>(), false),
unguarded => new Transition(unguarded.Event.Convert(source, serviceDefinition, serviceIndex), source, unguarded.Targets.GetTargetStatenodes(source.Id, getStatenode), unguarded.Actions.Convert(), Option.None <Guard>(), false),
unguarded => new Transition(unguarded.Event.Convert(source, serviceDefinition, serviceIndex), source, unguarded.Targets.GetTargetStatenodes(source.Id, getStatenode), unguarded.Actions.Convert(), Option.None <Guard>(), false),
guarded => new Transition(guarded.Event.Convert(source, serviceDefinition, serviceIndex), source, guarded.Targets.GetTargetStatenodes(source.Id, getStatenode), guarded.Actions.Convert(), (guarded.Guard as Guard).ToOption(), false),
guarded => new Transition(guarded.Event.Convert(source, serviceDefinition, serviceIndex), source, guarded.Targets.GetTargetStatenodes(source.Id, getStatenode), guarded.Actions.Convert(), guarded.Guard.AsBase().ToOption(), false),
guarded => new Transition(guarded.Event.Convert(source, serviceDefinition, serviceIndex), source, guarded.Targets.GetTargetStatenodes(source.Id, getStatenode), guarded.Actions.Convert(), guarded.Guard.AsBase().ToOption(), false));
public ParsedOrthogonalStatenode(
ParsedStatenode parent,
string name,
Option <string> uniqueIdentifier,
int documentIndex,
Actionblock entryActions,
Actionblock exitActions) : base(parent, name, uniqueIdentifier, documentIndex, entryActions, exitActions)
{
}
protected ParsedNonFinalStatenode(
ParsedStatenode parent,
string name,
Option <string> uniqueIdentifier,
int documentIndex,
Actionblock entryActions,
Actionblock exitActions) : base(parent, name, uniqueIdentifier, documentIndex, entryActions, exitActions)
{
}
internal static IEvent Convert(this IEventDefinition eventDefinition, ParsedStatenode source, ServiceDefinition serviceDefinition, int serviceIndex)
{
switch (eventDefinition)
{
case INamedDataEvent definition: return(new NamedDataEvent <object>(definition.Name, definition.Data)); // TODO: check this
case INamedEvent definition: return(new NamedEvent(definition.Name));
case ImmediateEventDefinition _: return(new ImmediateEvent());
case DelayedEventDefinition definition: return(new DelayedEvent(source.Id, definition.Delay));
case ServiceSuccessEventDefinition _: return(new ServiceSuccessEvent(serviceDefinition.GetId(source.Id, serviceIndex), null));
case ServiceErrorEventDefinition _: return(new ServiceErrorEvent(serviceDefinition.GetId(source.Id, serviceIndex), null));
case DoneEventDefinition _: return(new DoneEvent(source.Id));
default: throw new Exception("it would be easier to interpret a Statechart if a proper event mapping is defined ;)");
}
}
internal static IEnumerable <Transition> GetTransitions(this ParsedStatenode statenode) => statenode.Match(final => Enumerable.Empty <Transition>(), nonFinal => nonFinal.Transitions);
internal static IEnumerable <ParsedStatenode> AncestorsUntil(
this ParsedStatenode stateNode, ParsedStatenode until)
=> stateNode.GetParents().TakeWhile(parentStateNode => !parentStateNode.Equals(until));
internal static ParsedStatenode OneBeneath(
this ParsedStatenode statenode, ParsedStatenode beneath)
=> statenode.Append(statenode.GetParents())
.FirstOrDefault(parentStateNode => parentStateNode.Parent.Equals(beneath.ToOption()));
internal static IEnumerable <ParsedStatenode> GetParents(
this ParsedStatenode statenode) =>
statenode.Parent
.Map(parent => parent.Append(parent.GetParents()))
.ValueOr(Enumerable.Empty <ParsedStatenode>());
private static IEnumerable <Transition> GetNonFinalStatenodeTransitions(this NonFinalStatenodeDefinition definition, ParsedStatenode source, Func <OneOf <StatenodeId, string>, ParsedStatenode> getStatenode)
{
IEnumerable <(ServiceDefinition serviceDefinition, TransitionDefinition transitionDefinition, int serviceIndex)> GetServiceTransitionDefinitions(IEnumerable <ServiceDefinition> serviceDefinitions) =>
serviceDefinitions?.SelectMany((serviceDefinition, index) =>
serviceDefinition.Match <IEnumerable <(ServiceDefinition, TransitionDefinition, int)> >(
activity => activity.OnErrorTransition.Map(transitionDefinition => transitionDefinition.AsBase())
.Yield().WhereSome().Select(transitionDefinition => (serviceDefinition, transitionDefinition, index)),
task => new[] { task.OnSuccessDefinition, task.OnErrorTransition }.WhereSome()
.Select(transitionDefinition => (serviceDefinition, transitionDefinition.AsBase(), index)),
dataTask => new[]
{
dataTask.OnSuccessDefinition.Map(_ => _.AsBase()),
dataTask.OnErrorTransition.Map(_ => _.AsBase())
}.WhereSome().Select(transitionDefinition => (serviceDefinition, transitionDefinition, index))))
?? Enumerable.Empty <(ServiceDefinition, TransitionDefinition, int)>();
var serviceTransitions = GetServiceTransitionDefinitions(definition.Services)
.Select(mapped => mapped.transitionDefinition.Convert(source, getStatenode, mapped.serviceDefinition, mapped.serviceIndex));
var regularTransitions = (definition.Transitions ?? Enumerable.Empty <TransitionDefinition>()).Select(transitionDefinition =>
transitionDefinition.Convert(source, getStatenode, null, 0)); // TODO, hate this `null`
return(regularTransitions.Concat(serviceTransitions));
}
private static Transition Convert(this DoneTransitionDefinition definition, ParsedStatenode source, Func <OneOf <StatenodeId, string>, ParsedStatenode> getStatenode) => new Transition(new DoneEvent(source.Id), source, definition.Targets.GetTargetStatenodes(source.Id, getStatenode), definition.Actions.Convert(), definition.Guard.Map(guard => guard.AsBase()), false);
private static Transition Convert(this InitialCompoundTransitionDefinition definition, ParsedStatenode source, Func <OneOf <StatenodeId, string>, ParsedStatenode> getStatenode) => new Transition(new InitializeEvent(source.Id), source, definition.Target.GetTargetStatenode(source.Id, getStatenode).Yield(), definition.Actions.Convert(), Option.None <Guard>(), false);
private static IDictionary <StatenodeId, (StatenodeDefinition definition, ParsedStatenode statenode)> CreateLookup(
ParsedStatenode rootnode,
IDictionary <StatenodeId, StatenodeDefinition> definitions) =>
private static (ParsedStatenode root, IDictionary <StatenodeId, StatenodeDefinition> definitions) ParseStatenode(
StatenodeDefinition definition,
ParsedStatenode parent,
IDictionary <StatenodeId, StatenodeDefinition> definitions,
int documentIndex)
{
IEnumerable <(ParsedStatenode statenode, StatenodeDefinition definition)> ParseChildren(
IEnumerable <StatenodeDefinition> substateNodeDefinitions,
ParsedStatenode recursedParent) =>
substateNodeDefinitions.Select((substateDefinition, index) =>
(ParseStatenode(substateDefinition, recursedParent, definitions, index).root, substateDefinition));
var name = definition.Name;
var uniqueIdentifier = definition.UniqueIdentifier;
var entryActions = definition.EntryActions.Convert();
var exitActions = definition.ExitActions.Convert();
(ParsedStatenode root, IDictionary <StatenodeId, StatenodeDefinition> definitions) CreateAtomicStatenode(AtomicStatenodeDefinition atomicDefinition)
{
var statenode = new ParsedAtomicStatenode(parent, name, uniqueIdentifier, documentIndex, entryActions, exitActions);
statenode.Services = atomicDefinition.Services.Convert(statenode);
definitions.Add(statenode.Id, atomicDefinition);
return(statenode, definitions);
}
(ParsedStatenode root, IDictionary <StatenodeId, StatenodeDefinition> definitions) CreateFinalStatenode(FinalStatenodeDefinition finalDefinition)
{
var statenode = new ParsedFinalStatenode(parent, name, uniqueIdentifier, documentIndex, entryActions, exitActions);
definitions.Add(statenode.Id, finalDefinition);
return(statenode, definitions);
}
(ParsedStatenode root, IDictionary <StatenodeId, StatenodeDefinition> definitions) CreateCompoundStatenode(CompoundStatenodeDefinition compoundDefinition)
{
var statenode = new ParsedCompoundStatenode(parent, name, uniqueIdentifier, documentIndex, entryActions, exitActions);
var children = ParseChildren(compoundDefinition.Statenodes, statenode).ToList();
var statenodes = children.Select(child => child.statenode);
statenode.Statenodes = statenodes;
statenode.Services = compoundDefinition.Services.Convert(statenode);
definitions.Add(statenode.Id, compoundDefinition);
return(statenode, definitions);
}
(ParsedStatenode root, IDictionary <StatenodeId, StatenodeDefinition> definitions) CreateOrthogonalStatenode(OrthogonalStatenodeDefinition orthogonalDefinition)
{
var statenode = new ParsedOrthogonalStatenode(parent, name, uniqueIdentifier, documentIndex, entryActions, exitActions);
var children = ParseChildren(orthogonalDefinition.Statenodes, statenode).ToList();
var statenodes = children.Select(child => child.statenode);
statenode.Statenodes = statenodes;
statenode.Services = orthogonalDefinition.Services.Convert(statenode);
definitions.Add(statenode.Id, orthogonalDefinition);
return(statenode, definitions);
}
return(definition.Match(
CreateAtomicStatenode,
CreateFinalStatenode,
CreateCompoundStatenode,
CreateOrthogonalStatenode));
}
internal static IEnumerable <Transition> ConvertTransitions(this OrthogonalStatenodeDefinition definition, ParsedStatenode source, Func <OneOf <StatenodeId, string>, ParsedStatenode> getStatenode)
{
var done = definition.DoneTransition.Map(doneTransitionDefinition => doneTransitionDefinition.Convert(source, getStatenode)).Yield().WhereSome();
var transitions = definition.GetNonFinalStatenodeTransitions(source, getStatenode);
return(done.Concat(transitions));
}
internal static IEnumerable <Transition> ConvertTransitions(this AtomicStatenodeDefinition definition, ParsedStatenode source, Func <OneOf <StatenodeId, string>, ParsedStatenode> getStatenode) => definition.GetNonFinalStatenodeTransitions(source, getStatenode);
