/// <summary>Add a NAMED record with a name of a next state record to link to</summary>
/// <param name="name">Record's name to be added to the name cross reference list</param>
/// <param name="record">Record to be saved</param>
/// <param name="linkToName">Name of record to link to</param>
public void AddNextStateRecord(string name, NextStateRec record, string linkToName)
{
//NextStateFunc.AddNextStateRecord(record, null);
m_recNameXRef.Add(name, record);
//m_unLnkdRecordList.Add(record, linkToName);
throw new NotImplementedException("Needs completing!");
}
internal void LinkAlternate(NextStateRec alt)
{
if (Alternate != null)
{
throw new InvalidOperationException($"Can only set Alternate State Once! Alternate has already been set.\n\tAlternate={Alternate}\n\tLinkNext={alt}");
}
Alternate = alt;
}
// Link the next NSRecord to the end of the list, returning the object that contains this next Record
internal void LinkNext(NextStateRec next)
{
if (Sequence != null)
{
throw new InvalidOperationException($"Can only set Next State Once! Sequence has already been set.\n\tSequence={Sequence}\n\tLinkNext={next}");
}
Sequence = next;
}
public NextStateBuilder(NextStateRec startState, NextStateFunc.ActionDelegte action)
: this(startState)
{
if (action is null)
{
throw new ArgumentNullException(nameof(action));
}
NextStateFunc.Action += action;
}
public NextStateBuilder(NextStateRec startState)
{
if (startState is null)
{
throw new ArgumentNullException(nameof(startState));
}
NextStateFunc = new NextStateFunc(startState);
m_recNameXRef.Add(startState.Name, startState);
}
/// <summary>Resolves those records that do not yet have a NextState recorded</summary>
/// <remarks>Where a record is added, but the NextState is not yet added, then its NestState's name is recorded.
/// This methods resolves these unlimked records after all records have been recorded and their objects created</remarks>
public void ResolveUnlinkedRecords()
{
foreach (KeyValuePair <NextStateRec, Link2Ref> item in m_unLnkdRecordList)
{
NextStateRec record = item.Key;
NextStateRec next = m_recNameXRef[item.Value.Name];
throw new NotImplementedException("Needs completing!");
// NextStateFunc.AddRecordNextLink(record, next);
}
}
/// <summary>Add a record with a name of a next state record to link to</summary>
/// <param name="record">Record to be saved</param>
/// <param name="linkToName">Name of record to link to</param>
public void AddNSRecordRef(NextStateRec record, string linkToName, bool isAlternate)
{
if (m_recNameXRef.ContainsKey(linkToName))
{
// gramma has been already defined -can be linked as required
NextStateRec link = m_recNameXRef[linkToName];
if (isAlternate)
{
record.LinkAlternate(link);
}
else
{
record.LinkNext(link);
}
}
else
{
m_unLnkdRecordList.Add(record, new Link2Ref(linkToName, isAlternate)); // Gramma not yet defined, add to list to be resovled later
}
}
public static NextStateRec CreateTokenRef(string name, TokenRef.Type type, ParseResponse response)
{
NextStateRec nsRec;
switch (type)
{
case TokenRef.Type.Null:
throw new FormatException($"SourceObject Type {type.ToString()} is valid BUT NOT in the context as a Next State Token Ref!");
case TokenRef.Type.Empty:
nsRec = new NextStateRec(Type.TokenRef, TokenRef.CreateEmpty(), null, response);
break;
case TokenRef.Type.Identifier:
if (!(name is null))
{
throw new ArgumentNullException(nameof(name), $"NextStateRecords can not contain Identifier Tokens with predefined names -{nameof(name)} must be set to 'null', not '{name}'!");
}
nsRec = new NextStateRec(Type.TokenRef, TokenRef.CreateIdentifier(), response);
break;
case TokenRef.Type.Keyword:
nsRec = new NextStateRec(Type.TokenRef, TokenRef.CreateKeyword(name), name, response);
break;
case TokenRef.Type.Operator:
nsRec = new NextStateRec(Type.TokenRef, TokenRef.CreateOperator(name), name, response);
break;
case TokenRef.Type.Error:
throw new NotImplementedException("Error types yet to be implemented!");
default:
throw InvalidEnumValueException.InvalidArgument(typeof(TokenRef.Type), type, nameof(name));
}
return(nsRec);
}
/// <summary>Add the Allternative NextState to an NS record</summary>
/// <param name="record">Record to receive link to the Alternative NS Record</param>
/// <param name="altNextState">The Next stae record to be linked as Alternative to record</param>
public void AddAlternativeNSRecord(NextStateRec record, NextStateRec altNextState)
{
record.LinkAlternate(altNextState);
}
/// <summary>Add the Sequence NextState to an NS record</summary>
/// <param name="record">Record to receive link to the Sequence NS Record</param>
/// <param name="nextState">The Next stae record to be linked to record</param>
public void AddSequenceNSRecord(NextStateRec record, NextStateRec nextState)
{
record.LinkNext(nextState);
}
public void SetNextStateStartRecord(NextStateRec startRec)
{
NextStateFunc.StartState = startRec;
m_recNameXRef.Add(startRec.Name, startRec);
}
/// <summary>Add a NAMED record with a next state record supplied</summary>
/// <param name="name">Record's name to be added to the name cross reference list</param>
/// <param name="record">Record to be saved</param>
/// <param name="nextState">The Next stae record to be linked to record</param>
public void AddNextStateRecord(string name, NextStateRec record, NextStateRec nextState)
{
//NextStateFunc.AddNextStateRecord(record, nextState);
m_recNameXRef.Add(name, record);
throw new NotImplementedException("Needs completing!");
}
public void AddNSRecordRef(string name, NextStateRec record)
{
m_recNameXRef.Add(name, record);
}
public ParseResponse GoToNextState(SourceObject next)
{
ParseResponse response = ParseResponse.Null;
NextStateRec state = CurrentState;
TokenRef token = TokenRef.Create(next.OfType, next.Text);
do
{
Debug.WriteIf(state != null, $"{{{token}}} against {{{state.Token}}}", "Check");
if (state == null)
{
response = ParseResponse.Reject;
Debug.WriteLine(" -Match! Response = Reject");
}
else if (token == state.Token)
{
response = state.Response;
Debug.WriteLine(" -Match! Response = " + response);
}
else if (state.Token.OfType == TokenRef.Type.Empty)
{
response = state.Response;
Debug.WriteLine(" -Match on Empty! Response = " + response);
}
else if (state.Token.OfType == TokenRef.Type.Null)
{
if (state.Response == ParseResponse.Next)
{
state = state.Sequence;
response = ParseResponse.Null;
}
else
{
response = state.Response;
}
Debug.WriteLine(" -Special Response = " + response);
}
else
{
Debug.WriteLine(" -NO Match! Check Next");
state = state.Sequence;
}
} while (response == ParseResponse.Null);
// Determine next state based on response
Debug.Write($"{{{state.Token }}} -> ", "Result");
switch (response)
{
case ParseResponse.Next:
CurrentState = state.Sequence;
break;
default:
throw new InvalidEnumValueException(typeof(ParseResponse), response);
}
Debug.WriteLine($"{{{CurrentState.Token}}} -Response {response}!");
return(response);
}
public NextStateFunc(NextStateRec startState)
{
StartState = startState ?? throw new ArgumentNullException(nameof(startState));
CurrentState = startState;
}
public NextStateFunc(NextStateRec startState, ActionDelegte action)
{
StartState = startState ?? throw new ArgumentNullException(nameof(startState));
CurrentState = startState;
Action = action ?? throw new ArgumentNullException(nameof(action));
}
