public static void Test()
{
var machine = new Region( "history" );
var initial = new PseudoState( "initial", PseudoStateKind.Initial, machine );
var shallow = new CompositeState( "shallow", machine );
var deep = new SimpleState( "deep", machine );
var final = new FinalState( "final", machine );
var s1 = new SimpleState( "s1", shallow );
var s2 = new SimpleState( "s2", shallow );
new Transition( initial, shallow );
new Transition( new PseudoState( "shallow", PseudoStateKind.ShallowHistory, shallow ), s1 );
new Transition<String>( s1, s2, c => c.Equals( "move" ) );
new Transition<String>( shallow, deep, c => c.Equals( "go deep" ) );
new Transition<String>( deep, shallow, c => c.Equals( "go shallow" ) );
new Transition<String>( s2, final, c => c.Equals( "end" ) );
var state = new State();
machine.Initialise( state );
Trace.Assert( machine.Process( state, "move" ) );
Trace.Assert( machine.Process( state, "go deep" ) );
Trace.Assert( machine.Process( state, "go shallow" ) );
Trace.Assert( !machine.Process( state, "go shallow" ) );
Trace.Assert( machine.Process( state, "end" ) );
Trace.Assert( machine.IsComplete( state ) );
}
/// <inheritdoc />
public override IDictionary <char, State> NextStates()
{
if (this.nextstates == null)
{
Charset context = this.Context;
// we are at the end of the word
// look into parent context for continuation
IDictionary <char, State> parentStates = this.ContextWordEnd ? context.Parent?.GetInitialState(context)?.NextStates() : null;
// if the context can be repeated
// look into next character
IDictionary <char, State> nextStates = null;
int repeatCount = this.RepeatCount + 1;
if (repeatCount <= context.MaxRepeatCount)
{
nextStates = CharsetState.NextStates(this.Char, context, repeatCount);
}
// combine next and parent states
this.nextstates = CompositeState.Merge(nextStates, parentStates);
}
return(this.nextstates);
}
protected virtual void NotifyPropertyChanged(string propertyName)
{
var property = GetType().GetProperty(propertyName);
if (property == null)
{
throw new ArgumentException(propertyName);
}
State = State == CompositeState.New ? CompositeState.New : CompositeState.Modified;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
public void Execute_Corresponding_Inner_States_Methods_In_Its_Own_Methods()
{
var state = Substitute.For <IState>();
var compositeState = new CompositeState(state);
compositeState.Enter();
compositeState.Update();
compositeState.Exit();
state.Received(1).Enter();
state.Received(1).Update();
state.Received(1).Exit();
}
async Task <object> IScorable <Score> .PrepareAsync <Item>(Item item, CancellationToken token)
{
CompositeState maximum = null;
foreach (var scorable in this.scorables)
{
var state = await scorable.PrepareAsync(item, token);
Score score;
if (scorable.TryScore(state, out score))
{
if (this.comparer.Compare(score, this.traits.Minimum) < 0)
{
throw new ArgumentOutOfRangeException(nameof(score));
}
if (this.comparer.Compare(score, this.traits.Maximum) > 0)
{
throw new ArgumentOutOfRangeException(nameof(score));
}
if (maximum == null)
{
maximum = new CompositeState();
}
var compare = this.comparer.Compare(score, maximum.Score);
if (maximum.Scorable == null || compare > 0)
{
maximum.Score = score;
maximum.State = state;
maximum.Scorable = scorable;
if (this.comparer.Compare(score, this.traits.Maximum) == 0)
{
break;
}
}
}
}
return(maximum);
}
protected CompositeInstanceImpl(
CompositeInstanceStructureOwner structureOwner,
CompositeModel model,
IEnumerable <Type> publicCompositeTypes,
UsesContainerQuery usesContainer,
MainCompositeConstructorArguments publicCtorArgsObject
)
{
ArgumentValidator.ValidateNotNull("Structure owner", structureOwner);
ArgumentValidator.ValidateNotNull("Composite model", model);
ArgumentValidator.ValidateNotEmpty("Composite type", publicCompositeTypes);
ArgumentValidator.ValidateNotNull("Container for objects to be used in fragment creation", usesContainer);
this._structureOwner = structureOwner;
var application = this._structureOwner.Application;
this._modelInfo = this._structureOwner.ModelInfoContainer.GetCompositeModelInfo(model);
if (publicCompositeTypes.Any(pcType => pcType.ContainsGenericParameters()))
{
throw new InternalException("With given public composite types {" + String.Join(", ", publicCompositeTypes) + "} and public composite type in model being [" + String.Join(", ", model.PublicTypes) + "], the public composite types contained non-closed generic parameters.");
}
this._usesContainer = usesContainer;
this._isPrototype = (Int32)PrototypeState.PROTOTYPE;
this._invocationInfos = new Lazy <ThreadLocal <Stack <InvocationInfo> > >(() => new ThreadLocal <Stack <InvocationInfo> >(() => new Stack <InvocationInfo>()), LazyThreadSafetyMode.PublicationOnly);
var composites = application.CollectionsFactory.NewDictionaryProxy <Type, Object>();
var cProps = application.CollectionsFactory.NewListProxy(new List <CompositeProperty>(model.Methods.Count * 2));
var cEvents = application.CollectionsFactory.NewListProxy(new List <CompositeEvent>(model.Methods.Count * 2));
var publicTypeGenResult = this._modelInfo.Types;
var factory = publicTypeGenResult.CompositeFactory;
var gArgs = publicTypeGenResult.PublicCompositeGenericArguments.Count == 0 ? null : new Type[publicTypeGenResult.GeneratedMainPublicType.GetGenericArguments().Length];
this._gArgs = gArgs;
foreach (var pType in publicCompositeTypes)
{
ListQuery <Int32> gArgInfo = null;
if (publicTypeGenResult.PublicCompositeGenericArguments.TryGetValue(pType.GetGenericDefinitionIfGenericType(), out gArgInfo))
{
var declaredGArgs = pType.GetGenericArguments();
for (Int32 i = 0; i < declaredGArgs.Length; ++i)
{
gArgs[gArgInfo[i]] = declaredGArgs[i];
}
}
}
if (gArgs != null && gArgs.Any(gArg => gArg == null))
{
throw new InvalidCompositeTypeException(publicCompositeTypes, "Could not find suitable generic argument for all public types of composite " + this._modelInfo.Model + ".");
}
Action prePrototypeAction = null;
var publicCtorArgs = new Object[publicTypeGenResult.MaxParamCountForCtors];
Object[] compositeCtorParams = null;
foreach (var genType in publicTypeGenResult.GeneratedPublicTypes)
{
var isMainType = genType.GeneratedType.Equals(this._modelInfo.Types.GeneratedMainPublicType);
var curCtorArgs = isMainType ? publicCtorArgs : compositeCtorParams;
this.SetCompositeCtorArgs(ref curCtorArgs, cProps.AO, cEvents.AO);
var publicComposite = factory.CreateInstance(genType.GeneratedTypeID, gArgs, curCtorArgs);
foreach (var cType in this.GetTypeKeysForGeneratedType(publicComposite.GetType(), true, isMainType))
{
composites[cType] = publicComposite;
}
if (isMainType)
{
if (publicCtorArgsObject != null)
{
publicCtorArgsObject.Arguments = curCtorArgs;
}
prePrototypeAction = (Action)publicCtorArgs[COMPOSITE_CTOR_FIRST_ADDITIONAL_PARAM_IDX];
this._prototypeAction = (Action)publicCtorArgs[COMPOSITE_CTOR_FIRST_ADDITIONAL_PARAM_IDX + 1];
this._checkStateFunc = (Action <IDictionary <QualifiedName, IList <ConstraintViolationInfo> > >)publicCtorArgs[COMPOSITE_CTOR_FIRST_ADDITIONAL_PARAM_IDX + 2];
this._compositeMethods = new Lazy <MethodInfo[]>(() => ((CompositeCallbacks)publicComposite).GetCompositeMethods(), LazyThreadSafetyMode.ExecutionAndPublication);
}
}
this._isPrototypeTransitionInProgress = null;
this.SetCompositeCtorArgs(ref compositeCtorParams, cProps.AO, cEvents.AO);
foreach (var typeGenResult in publicTypeGenResult.PrivateCompositeGenerationResults)
{
var privateComposite = factory.CreateInstance(typeGenResult.GeneratedTypeID, gArgs, compositeCtorParams);
foreach (var cTypeOrParent in this.GetTypeKeysForGeneratedType(privateComposite.GetType(), false, false))
{
composites.Add(cTypeOrParent, privateComposite);
}
}
this._composites = composites.CQ;
this._methodsToModels = new Lazy <DictionaryQuery <MethodInfo, CompositeMethodModel> >(() =>
{
var retVal = new Dictionary <MethodInfo, CompositeMethodModel>();
var cMethods = this._compositeMethods.Value;
for (var i = 0; i < cMethods.Length; ++i)
{
var cm = cMethods[i];
retVal.Add(cm, this._modelInfo.Model.Methods[i]);
}
return(application.CollectionsFactory.NewDictionaryProxy(retVal).CQ);
}, LazyThreadSafetyMode.ExecutionAndPublication);
this._state = new CompositeStateImpl(this._structureOwner.Application.CollectionsFactory, cProps.CQ, cEvents.CQ);
this._fragmentInstancePools = this.CreatePoolDictionary <FragmentTypeGenerationResult, FragmentInstance>(
gArgs,
this._modelInfo.Types.FragmentGenerationResults.Where(fGenResult => fGenResult.InstancePoolRequired),
application.CollectionsFactory);
var fInstances = application.CollectionsFactory.NewDictionaryProxy(new Dictionary <Type, FragmentInstance>());
foreach (var genResult in publicTypeGenResult.FragmentGenerationResults.Where(val => !val.InstancePoolRequired))
{
var genType = genResult.GeneratedType;
if (gArgs != null)
{
genType = genType.MakeGenericType(gArgs);
}
else if (genType.ContainsGenericParameters())
{
throw new InternalException("Could not find generic arguments for fragment type " + genResult.DeclaredType + ".");
}
fInstances.Add(genType, new FragmentInstanceImpl());
}
this._fragmentInstances = fInstances.CQ;
this._concernInvocationInstances = this.CreatePoolDictionary <TypeGenerationResult, FragmentDependant>(gArgs, publicTypeGenResult.ConcernInvocationGenerationResults, application.CollectionsFactory);
this._sideEffectInvocationInstances = this.CreatePoolDictionary <TypeGenerationResult, FragmentDependant>(gArgs, publicTypeGenResult.SideEffectGenerationResults, application.CollectionsFactory);
this._constructorsForFragments = application.CollectionsFactory.NewDictionaryProxy <Type, ListQuery <FragmentConstructorInfo> >(this._fragmentInstancePools.Keys.Concat(this._fragmentInstances.Keys)
.ToDictionary(
fType => fType,
fType => application.CollectionsFactory.NewListProxy(fType
.GetAllInstanceConstructors()
.Select(fCtor =>
{
Int32 idx;
return(fCtor.TryGetConstructorModelIndex(out idx) ?
new FragmentConstructorInfo(model.Constructors[idx], fCtor) :
null);
})
.Where(i => i != null)
.ToList()
).CQ
)).CQ;
if (prePrototypeAction != null)
{
prePrototypeAction();
}
}
public override IDictionary <char, State> NextStates()
{
if (this.nextstates == null)
{
Vocabulary context = this.Context;
int repeatCount = this.RepeatCount;
IDictionary <char, State> parentStates = null;
if (this.ContextWordEnd)
{
parentStates = context.Parent?.GetInitialState(context)?.NextStates();
}
IDictionary <char, State> repeatStates = null;
if (this.RepeatWordEnd && repeatCount < context.MaxRepeatCount)
{
/*if (Vocabulary.Separator != (char)0)
* {*/
VocabularyState state = new VocabularyState(
Vocabulary.Separator,
false,
false,
1.0f,
0.0f,
false,
repeatCount + 1,
context,
Vocabulary.SeekToBegin);
repeatStates = new Dictionary <char, State>();
repeatStates.Add(Vocabulary.Separator, state);
/*}
* else
* {
* repeatStates = new VocabularyState(
* (char)0,
* false,
* false,
* 0.0f,
* 0.0f,
* false,
* repeatCount + 1,
* context,
* Vocabulary.SeekToBegin).NextStates();
* }*/
}
// if the state does not point to the end
// look into next character
IDictionary <char, State> nextStates = null;
int seek = this.Seek;
if (seek != Vocabulary.SeekToEnd)
{
nextStates = VocabularyState.NextStates(seek, context, repeatCount);
}
// combine next and parent states
this.nextstates = CompositeState.Merge(nextStates, repeatStates, parentStates);
}
return(this.nextstates);
}
