private String parseNode(Queue <IXamlElement> token)
{
if (token.Peek().QName.Equals(createQName("FlowStep")))
{
return(parseStep(token));
}
else if (token.Peek().QName.Equals(createQName("FlowDecision")))
{
return(parseDecision(token));
}
else if (token.Peek().QName.Equals(createQName("FlowSwitch")))
{
return(parseSwitch(token));
}
else if (token.Peek().QName.Equals(createQName("Reference", ns_x)))
{
IXamlElement elem = token.Dequeue();
// Reference
String reference;
elem.Attributes.TryGetValue("Reference", out reference);
// Optional <x:Key>
if (token.Peek().QName.Equals(createQName("Key", ns_x)))
{
token.Dequeue();
token.Dequeue();
}
token.Dequeue();
return(reference);
}
else
{
throw new ParseException(String.Format("Unknown tag found in activity '{0}'", QName), initialTokenCount - token.Count, QName);
}
}
public IActivity Parse(Queue <IXamlElement> token)
{
log.Debug(String.Format("Calling parse in activity '{0}'", name));
// Start Element
IXamlElement element = token.Dequeue();
// Naming
operation = element.Attributes["OperationName"];
string[] cArr = element.Attributes["ServiceContractName"].Split(':');
if (cArr.Length > 1)
{
contract = cArr[1];
}
else
{
contract = cArr[0];
}
// Ignore inner structure
while (!token.Peek().QName.Equals(this.QName))
{
token.Dequeue();
}
// End Element
token.Dequeue();
return(this);
}
public RenderContext(IXamlElement root, RenderInfo ri)
{
Writer = ri.Writer;
_root = root;
_dataModel = ri.DataModel;
_localizer = ri.Localizer;
_currentLocale = ri.CurrentLocale;
_typeChecker = ri.TypeChecker;
IsDebugConfiguration = ri.IsDebugConfiguration;
}
private String parseStep(Queue <IXamlElement> token)
{
FlowStep step = new FlowStep();
// [Start] FlowStep
IXamlElement elem = token.Dequeue();
// Reference
String reference;
elem.Attributes.TryGetValue("x:Name", out reference);
step.Id = reference;
while (!token.Peek().QName.Equals(createQName("FlowStep")))
{
// Optional Key Tag in Switch
if (token.Peek().QName.Equals(createQName("Key", ns_x)))
{
token.Dequeue();
while (!token.Peek().QName.Equals(createQName("Key", ns_x)))
{
token.Dequeue();
}
token.Dequeue();
}
// Activity
IActivity activity = moduleFactory.CreateActivity(token.Peek().QName);
if (activity != null)
{
IActivity inner = activity.Parse(token);
step.Action = inner;
}
else
{
throw new ParseException(String.Format("No Module found for activity '{0}'", QName), initialTokenCount - token.Count, QName);
}
// Optional FlowStep.Next
if (token.Peek().QName.Equals(createQName("FlowStep.Next")))
{
// [Start] FlowStep.Next
token.Dequeue();
step.Next = parseNode(token);
// [End] FlowStep.Next
token.Dequeue();
}
}
// [End] FlowStep
token.Dequeue();
steps.Add(step);
return(step.Id);
}
public IActivity Parse(Queue <IXamlElement> token)
{
log.Debug(String.Format("Calling parse in activity '{0}'", name));
// Debug
initialTokenCount = token.Count;
// [Start] StateMachine
IXamlElement root = token.Dequeue();
// Initial State
if (root.Attributes.TryGetValue("InitialState", out initialState))
{
initialState = extractReference(initialState);
while (!token.Peek().QName.Equals(this.QName))
{
// Parse State
parseState(token);
}
}
else
{
while (!token.Peek().QName.Equals(this.QName))
{
if (token.Peek().QName.Equals(createQName("StateMachine.InitialState", ns)))
{
// [Start] InitialState
token.Dequeue();
String reference = token.Peek().Attributes["x:Name"];
initialState = reference;
while (!token.Peek().QName.Equals(createQName("StateMachine.InitialState", ns)))
{
// Parse State
parseState(token);
}
// [End] InitialState
token.Dequeue();
}
else
{
// Parse State
parseState(token);
}
}
}
// [End] StateMachine
token.Dequeue();
return(this);
}
private String parseDecision(Queue <IXamlElement> token)
{
FlowDecision dec = new FlowDecision();
// [Start] FlowDecision
IXamlElement elem = token.Dequeue();
// Reference
String reference;
elem.Attributes.TryGetValue("x:Name", out reference);
dec.Id = reference;
// True
String right;
if (elem.Attributes.TryGetValue("True", out right))
{
dec.Right = extractReference(right);
}
// False
String wrong;
if (elem.Attributes.TryGetValue("False", out wrong))
{
dec.Wrong = extractReference(wrong);
}
while (!token.Peek().QName.Equals(createQName("FlowDecision")))
{
if (token.Peek().QName.Equals(createQName("FlowDecision.True")))
{
token.Dequeue();
dec.Right = parseNode(token);
token.Dequeue();
}
else if (token.Peek().QName.Equals(createQName("FlowDecision.False")))
{
token.Dequeue();
dec.Wrong = parseNode(token);
token.Dequeue();
}
else
{
throw new ParseException(String.Format("Unknown tag found in activity '{0}'", QName), initialTokenCount - token.Count, QName);
}
}
// [End] FlowDecision
token.Dequeue();
steps.Add(dec);
return(dec.Id);
}
public IActivity Parse(Queue <IXamlElement> token)
{
log.Debug(String.Format("Calling parse in activity '{0}'", name));
// Start Element
IXamlElement element = token.Dequeue();
// Ignore inner structure
while (!token.Peek().QName.Equals(this.QName))
{
token.Dequeue();
}
// End Element
token.Dequeue();
return(this);
}
private String parseSwitch(Queue <IXamlElement> token)
{
FlowSwitch swtch = new FlowSwitch();
// [Start] FlowDecision
IXamlElement elem = token.Dequeue();
// Reference
String reference;
elem.Attributes.TryGetValue("x:Name", out reference);
swtch.Id = reference;
// Default
String def;
if (elem.Attributes.TryGetValue("Default", out def))
{
swtch.Default = extractReference(def);
}
while (!token.Peek().QName.Equals(createQName("FlowSwitch")))
{
if (token.Peek().QName.Equals(createQName("FlowSwitch.Default")))
{
token.Dequeue();
swtch.Default = parseNode(token);
token.Dequeue();
}
else
{
swtch.Branches.Add(parseNode(token));
}
}
// [End] FlowDecision
token.Dequeue();
steps.Add(swtch);
return(swtch.Id);
}
private SMTransition parseTransition(Queue <IXamlElement> token)
{
// Transition
SMTransition transition = new SMTransition();
// Trigger
SMTrigger trigger;
// Reference
String reference;
String refTrigger;
String condition;
// [Start] Transition
IXamlElement element = token.Dequeue();
bool attRef = element.Attributes.TryGetValue("To", out reference);
bool attTrigger = element.Attributes.TryGetValue("Trigger", out refTrigger);
bool attCondition = element.Attributes.TryGetValue("Condition", out condition);
// To
if (attRef)
{
transition.To = extractReference(reference);
}
// Trigger
if (attTrigger)
{
String id = extractReference(refTrigger);
if (triggers.ContainsKey(id))
{
triggers[id].Transitions.Add(transition);
}
else
{
// Warning
log.Warn("Warning Trigger created before IActivity was found!");
trigger = new SMTrigger();
trigger.Transitions.Add(transition);
triggers.Add(id, trigger);
}
}
// Condition
if (attCondition)
{
transition.Condition = true;
}
while (!token.Peek().QName.Equals(createQName("Transition")))
{
if (token.Peek().QName.Equals(createQName("Transition.Trigger")))
{
// [Start] Transition.Trigger
token.Dequeue();
// Trigger Reference
String triggerRef;
if (token.Peek().Attributes.TryGetValue("x:Name", out triggerRef))
{
// Activity
IActivity activity = moduleFactory.CreateActivity(token.Peek().QName);
IActivity triggerActivity;
if (activity != null)
{
triggerActivity = activity.Parse(token);
}
else
{
throw new ParseException(String.Format("No Module found for activity '{0}'", QName), initialTokenCount - token.Count, QName);
}
if (triggers.ContainsKey(triggerRef))
{
log.Warn("Warning trigger existent!");
triggers[triggerRef].Trigger = triggerActivity;
triggers[triggerRef].Transitions.Add(transition);
}
else
{
trigger = new SMTrigger();
trigger.Trigger = triggerActivity;
trigger.Transitions.Add(transition);
triggers.Add(triggerRef, trigger);
}
}
else
{
// Activity
IActivity activity = moduleFactory.CreateActivity(token.Peek().QName);
IActivity triggerActivity;
if (activity != null)
{
triggerActivity = activity.Parse(token);
}
else
{
throw new ParseException(String.Format("No Module found for activity '{0}'", QName), initialTokenCount - token.Count, QName);
}
trigger = new SMTrigger();
trigger.Trigger = triggerActivity;
trigger.Transitions.Add(transition);
triggerKey++;
triggers.Add(triggerKey.ToString(), trigger);
}
// [End] Transition.Trigger
token.Dequeue();
}
else if (token.Peek().QName.Equals(createQName("Transition.Condition")))
{
// [Start] Transition.Condition
token.Dequeue();
transition.Condition = true;
// [End] Transition.Condition
token.Dequeue();
}
else if (token.Peek().QName.Equals(createQName("Transition.Action")))
{
// [Start] Transition.Action
token.Dequeue();
// Activity
IActivity activity = moduleFactory.CreateActivity(token.Peek().QName);
if (activity != null)
{
transition.Action = activity.Parse(token);
}
else
{
throw new ParseException(String.Format("No Module found for activity '{0}'", QName), initialTokenCount - token.Count, QName);
}
// [End] Transition.Action
token.Dequeue();
}
else if (token.Peek().QName.Equals(createQName("Transition.To")))
{
// [Start] Transition.To
token.Dequeue();
if (token.Peek().QName.Equals(createQName("State")))
{
transition.To = token.Peek().Attributes["x:Name"];
// Recursion
parseState(token);
}
else if (token.Peek().QName.Equals(createQName("Reference", ns_x)))
{
// [Start] Reference
element = token.Dequeue();
reference = element.Attributes["Reference"];
transition.To = reference;
// [End] Reference
token.Dequeue();
}
else
{
throw new ParseException(String.Format("Unknown tag found in activity '{0}'", QName), initialTokenCount - token.Count, QName);
}
// [End] Transition.To
token.Dequeue();
}
else
{
throw new ParseException(String.Format("Unknown tag found in activity '{0}'", QName), initialTokenCount - token.Count, QName);
}
}
// [End] Transition
token.Dequeue();
return(transition);
}
private void parseState(Queue <IXamlElement> token)
{
if (token.Peek().QName.Equals(createQName("State")))
{
// State
SMState state = new SMState();
states.Add(state);
// [Start] State
IXamlElement element = token.Dequeue();
// Reference
String reference = element.Attributes["x:Name"];
state.Id = reference;
// Final State
String att;
if (element.Attributes.TryGetValue("IsFinal", out att))
{
if (att.Equals("True"))
{
state.Final = true;
}
}
while (!token.Peek().QName.Equals(createQName("State")))
{
if (token.Peek().QName.Equals(createQName("State.Entry")))
{
// [Start] State.Entry
token.Dequeue();
// Activity
IActivity activity = moduleFactory.CreateActivity(token.Peek().QName);
if (activity != null)
{
state.Entry = activity.Parse(token);
}
else
{
throw new ParseException(String.Format("No Module found for activity '{0}'", QName), initialTokenCount - token.Count, QName);
}
// [End] State.Entry
token.Dequeue();
}
else if (token.Peek().QName.Equals(createQName("State.Exit")))
{
// [Start] State.Exit
token.Dequeue();
// Activity
IActivity activity = moduleFactory.CreateActivity(token.Peek().QName);
if (activity != null)
{
state.Exit = activity.Parse(token);
}
else
{
throw new ParseException(String.Format("No Module found for activity '{0}'", QName), initialTokenCount - token.Count, QName);
}
// [End] State.Exit
token.Dequeue();
}
else if (token.Peek().QName.Equals(createQName("State.Transitions")))
{
// [Start] State.Transitions
token.Dequeue();
// Transitions
while (!token.Peek().QName.Equals(createQName("State.Transitions")))
{
// Transition
state.Transitions.Add(parseTransition(token));
}
// [End] State.Transitions
token.Dequeue();
}
else
{
throw new ParseException(String.Format("Unknown tag found in activity '{0}'", QName), initialTokenCount - token.Count, QName);
}
}
// [End] State
token.Dequeue();
}
else if (token.Peek().QName.Equals(createQName("Reference", ns_x)))
{
// [Start][End] Reference
token.Dequeue();
token.Dequeue();
}
else
{
throw new ParseException(String.Format("Unknown tag found in activity '{0}'", QName), initialTokenCount - token.Count, QName);
}
}
/// <summary>
/// Parses the Token-Queue and returns an equivalent IActivity representation
/// </summary>
/// <exception cref="System.NullReferenceException">Thrown when ModuleFactory or Token-Queue is null</exception>
/// <exception cref="System.InvalidOperationException">Thrown when Token-Queue is empty, but another token was expected</exception>
/// <exception cref="WF2oWFN.API.ParseException">Thrown when an error occurs while parsing the Xaml tokens</exception>
/// <returns>IActivity containing all parsed Activities</returns>
public IActivity Parse()
{
// Activity AST
IActivity activity = null;
if (this.moduleFactory == null)
{
throw new NullReferenceException("No ModuleFactory was found");
}
if (this.tokens == null)
{
throw new NullReferenceException("No Token-Queue was found");
}
try
{
// [Start] Root Element
IXamlElement startRoot = tokens.Dequeue();
if (!RootTags.Contains(startRoot.QName))
{
ParseException e = new ParseException(String.Format("No {0} or {1} was found", this.xaml, this.xamlx));
e.ElementNumber = initialTokenCount - tokens.Count;
e.Activity = "Root";
throw e;
}
else
{
// Inner activity
activity = moduleFactory.CreateActivity(tokens.Peek().QName);
if (activity == null)
{
ParseException e = new ParseException(String.Format("No Module found for activity '{0}'", tokens.Peek().QName));
e.ElementNumber = initialTokenCount - tokens.Count;
throw e;
}
else
{
// Parse inner activity
activity = activity.Parse(tokens);
}
}
// [End] Root Element
if (tokens.Count == 1)
{
IXamlElement endRoot = tokens.Dequeue();
if (!RootTags.Contains(endRoot.QName))
{
throw new ParseException(String.Format("No {0} or {1} end tag was found", this.xaml, this.xamlx), initialTokenCount, "Root");
}
}
else
{
throw new ParseException(String.Format("Expected end tag, but still too many tokens in queue '{0}'", tokens.Count), initialTokenCount - tokens.Count, "Root");
}
return(activity);
}
catch (InvalidOperationException)
{
throw new ParseException("Expected token, but queue is empty", 1, "Root");
}
}
/// <summary>
/// Transforms the xml data of the <code>inputFile</code> to a token queue
/// </summary>
/// <exception cref="System.Xml.XmlException">If the Xaml is not well-formed XML</exception>
/// <exception cref="System.IO.FileNotFoundException">If the <code>inputFile</code> was not found</exception>
/// <returns>The token queue generated from the <code>inputFile</code></returns>
public Queue <IXamlElement> Scan()
{
// Validate Xml
ValidateXml();
// Try to validate Xaml
ValidateXaml();
// Screener
Screener screener = new Screener(inputFile);
screener.ScreenXaml();
// Scan tokens
XmlTextReader reader = new XmlTextReader(inputFile);
// Current token
IXamlElement element = null;
String name;
String ns;
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
// Enqueue last element
if (element != null)
{
tokens.Enqueue(element);
}
// Element
name = reader.LocalName;
ns = reader.NamespaceURI;
element = new XamlElement();
element.Namespace = ns;
element.LocalName = name;
bool empty = reader.IsEmptyElement;
// Attributes
if (reader.HasAttributes)
{
IDictionary <string, string> dic = element.Attributes;
while (reader.MoveToNextAttribute())
{
// Add Attributes
String value = reader.Value;
String attname = reader.Name;
dic.Add(attname, value);
}
element.Attributes = dic;
if (empty)
{
tokens.Enqueue(element);
}
}
else
{
if (empty)
{
tokens.Enqueue(element);
}
}
// Closing Element
if (empty)
{
element = new XamlElement();
element.Namespace = ns;
element.LocalName = name;
element.IsClosingElement = true;
}
break;
case XmlNodeType.EndElement:
// Enqueue last element
if (element != null)
{
tokens.Enqueue(element);
}
name = reader.LocalName;
ns = reader.NamespaceURI;
element = new XamlElement();
element.Namespace = ns;
element.LocalName = name;
element.IsClosingElement = true;
break;
case XmlNodeType.Text:
// Add inner text as self-titled attribute
// e.g. <x:Reference>__REFERENCEID1</x:Reference> -> Reference="__REFERENCEID1"
String inner = reader.Value;
element.Attributes.Add(element.LocalName, inner);
break;
default:
// Nothing to handle
break;
}
}
// Last Element
tokens.Enqueue(element);
// Cleanup
reader.Close();
return(tokens);
}
public void Render(RenderInfo info)
{
if (String.IsNullOrEmpty(info.FileName))
{
throw new XamlException("No source for render");
}
IProfileRequest request = _profile.CurrentRequest;
String fileName = String.Empty;
IXamlElement uiElem = null;
using (request.Start(ProfileAction.Render, $"load: {info.FileTitle}"))
{
try
{
// XamlServices.Load sets IUriContext
if (!String.IsNullOrEmpty(info.FileName))
{
using (var fileStream = _host.ApplicationReader.FileStreamFullPathRO(info.FileName))
{
RootFileName = info.FileName;
ApplicationReader = _host.ApplicationReader;
uiElem = XamlServices.Load(fileStream) as IXamlElement;
}
}
else if (!String.IsNullOrEmpty(info.Text))
{
uiElem = XamlServices.Parse(info.Text) as IXamlElement;
}
else
{
throw new XamlException("Xaml. There must be either a 'FileName' or a 'Text' property");
}
if (uiElem == null)
{
throw new XamlException("Xaml. Root is not 'UIElement'");
}
var stylesPath = _host.ApplicationReader.MakeFullPath(String.Empty, "styles.xaml");
if (_host.ApplicationReader.FileExists(stylesPath))
{
using (var stylesStream = _host.ApplicationReader.FileStreamFullPathRO(stylesPath))
{
if (stylesStream != null)
{
if (!(XamlServices.Load(stylesStream) is Styles styles))
{
throw new XamlException("Xaml. Styles is not 'Styles'");
}
if (uiElem is IRootContainer root)
{
root.SetStyles(styles);
}
}
}
}
}
finally
{
RootFileName = null;
ApplicationReader = null;
}
}
using (request.Start(ProfileAction.Render, $"render: {info.FileTitle}"))
{
RenderContext ctx = new RenderContext(uiElem, info)
{
RootId = info.RootId,
Path = info.Path
};
if (info.SecondPhase)
{
if (!(uiElem is ISupportTwoPhaseRendering twoPhaseRender))
{
throw new XamlException("The two-phase rendering is not available");
}
twoPhaseRender.RenderSecondPhase(ctx);
}
else
{
uiElem.RenderElement(ctx);
}
Grid.ClearAttached();
Splitter.ClearAttached();
FullHeightPanel.ClearAttached();
Toolbar.ClearAttached();
}
if (uiElem is IDisposable disp)
{
disp.Dispose();
}
}
public IActivity Parse(Queue <IXamlElement> token)
{
log.Debug(String.Format("Calling parse in activity '{0}'", name));
// Debug
initialTokenCount = token.Count;
// [Start] FlowChart
IXamlElement root = token.Dequeue();
// [Attr] StartNode
String start;
if (root.Attributes.TryGetValue("StartNode", out start))
{
startNode = extractReference(start);
}
while (!token.Peek().QName.Equals(this.QName) || !token.Peek().IsClosingElement)
{
if (token.Peek().QName.Equals(createQName("Flowchart.StartNode")))
{
// [Start] StartNode
token.Dequeue();
while (!token.Peek().QName.Equals(createQName("Flowchart.StartNode")))
{
if (token.Peek().QName.Equals(createQName("Reference", ns_x)))
{
IXamlElement elem = token.Dequeue();
String reference;
elem.Attributes.TryGetValue("Reference", out reference);
startNode = reference;
token.Dequeue();
}
else
{
if (startNode == null)
{
if (token.Peek().QName.Equals(createQName("Null", ns_x)))
{
token.Dequeue();
token.Dequeue();
}
else
{
startNode = token.Peek().Attributes["x:Name"];
parseNode(token);
}
}
}
}
// [End] StartNode
token.Dequeue();
}
else
{
parseNode(token);
}
}
// [End] FlowChart
token.Dequeue();
return(this);
}
