/// <summary>
/// 添加pattern，按照中序遍历的顺序添加，即先访问根节点，再访问子节点
/// </summary>
/// <param name="pattern"></param>
/// <param name="parentPattern">patttern所属的外层pattern</param>
/// <param name="origin">patttern原点</param>
/// <param name="level">pattern所处的层级，WorkPiece层级为1</param>
public void AddPattern(Pattern pattern, Pattern parentPattern, PointD origin, int level)
{
if (pattern == null)
{
throw new Exception("pattern can not be null.");
}
if (pattern is Workpiece)
{
if (root != null)
{
throw new Exception("Workpiece has already been added!");
}
root = new PatternNode(null, pattern, parentPattern, origin, level);
allNodesList.Add(root);
map.Add(pattern, root);
return;
}
if (parentPattern == null)
{
throw new Exception("Parent pattern of pattern " + pattern.Name + " can not be null.");
}
PatternNode parentNode = allNodesList.Find((obj) => { return(parentPattern == obj.Pattern); });
if (parentNode == null)
{
throw new Exception("Parent " + parentPattern.Name + "is not found in pattern tree.");
}
PatternNode node = new PatternNode(parentNode, pattern, parentPattern, origin, level);
parentNode.Children.Add(node);
allNodesList.Add(node);
map.Add(pattern, node);
}
private void Untruncate(PatternNode <Word, ShapeNode> patternNode, Shape output, bool optional, VariableBindings varBindings)
{
foreach (PatternNode <Word, ShapeNode> node in patternNode.Children)
{
var constraint = node as Constraint <Word, ShapeNode>;
if (constraint != null && constraint.Type() == HCFeatureSystem.Segment)
{
FeatureStruct fs = constraint.FeatureStruct.DeepClone();
fs.ReplaceVariables(varBindings);
output.Add(fs, optional);
}
else
{
var quantifier = node as Quantifier <Word, ShapeNode>;
if (quantifier != null)
{
for (int i = 0; i < quantifier.MaxOccur; i++)
{
Untruncate(quantifier, output, i >= quantifier.MinOccur, varBindings);
}
}
else
{
Untruncate(node, output, optional, varBindings);
}
}
}
}
private void RuleSpecsChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.OldStartingIndex > -1)
{
PatternNode <TData, TOffset> startNode = _pattern.Children.ElementAt(e.OldStartingIndex);
foreach (Pattern <TData, TOffset> node in startNode.GetNodes().Take(e.OldItems.Count).Cast <Pattern <TData, TOffset> >().ToArray())
{
_ruleIds.Remove(node.Name);
node.Remove();
}
}
if (e.NewStartingIndex > -1)
{
PatternNode <TData, TOffset> startNode = e.NewStartingIndex == 0 ? _pattern.Children.Begin : _pattern.Children.ElementAt(e.NewStartingIndex - 1);
foreach (IPatternRuleSpec <TData, TOffset> rs in e.NewItems)
{
IPatternRuleSpec <TData, TOffset> ruleSpec = rs;
string id = "rule" + _curRuleId++;
_ruleIds[id] = ruleSpec;
var subpattern = new Pattern <TData, TOffset>(id, ruleSpec.Pattern.Children.DeepClone())
{
Acceptable = match => ruleSpec.IsApplicable(match.Input) && ruleSpec.Pattern.Acceptable(match)
};
startNode.AddAfter(subpattern);
startNode = subpattern;
}
}
}
internal override bool MatchPattern(Node pattern, Dictionary <int, Node> matchings)
{
if (pattern is PatternNode)
{
PatternNode patternNode = pattern as PatternNode;
if (patternNode.Type == PatternType.Any || patternNode.Type == PatternType.Variable)
{
if (!matchings.ContainsKey(patternNode.Key))
{
matchings[patternNode.Key] = this;
return(true);
}
else
{
return(matchings[patternNode.Key].Equals(this));
}
}
else if (patternNode.Type == PatternType.Position)
{
matchings[patternNode.Key] = this;
return(true);
}
return(false);
}
else if (pattern is VariableNode)
{
return(pattern.Equals(this));
}
return(false);
}
private Rule_testRule()
{
PatternNode node_p2 = new PatternNode((int)NodeTypes.@Process, "node_p2", node_p2_AllowedTypes, node_p2_IsAllowedType, PatternElementType.Normal, -1);
PatternNode node_p1 = new PatternNode((int)NodeTypes.@Process, "node_p1", node_p1_AllowedTypes, node_p1_IsAllowedType, PatternElementType.Normal, -1);
PatternEdge edge__edge0 = new PatternEdge(node_p1, node_p2, (int)EdgeTypes.@connection, "edge__edge0", edge__edge0_AllowedTypes, edge__edge0_IsAllowedType, PatternElementType.Normal, -1);
patternGraph = new PatternGraph(
new PatternNode[] { node_p2, node_p1 },
new PatternEdge[] { edge__edge0 },
new Condition[] { },
new bool[2, 2] {
{ true, false, },
{ false, true, },
},
new bool[1, 1] {
{ true, },
},
new bool[] {
false, false,
},
new bool[] {
false,
}
);
negativePatternGraphs = new PatternGraph[] {};
inputs = new GrGenType[] { };
outputs = new GrGenType[] { };
}
public UstNode Deserialize(string data, LanguageFlags sourceLanguage)
{
if (string.IsNullOrEmpty(data))
{
throw new ParsingException("Pattern value can not be empty.")
{
IsPattern = true
};
}
Parser.Logger = Logger;
UstConverter.Logger = Logger;
DslParser.PatternContext patternContext = Parser.Parse(data);
UstConverter.SourceLanguage = sourceLanguage;
UstConverter.Data = data;
DslNode dslNode = UstConverter.Convert(patternContext);
UstNode result = dslNode.Collection.First();
ResultPatternVars = dslNode.PatternVarDefs;
var preprocessor = new UstPreprocessor();
preprocessor.Logger = Logger;
result = new PatternNode(result, dslNode.PatternVarDefs);
result = preprocessor.Preprocess(result);
return(result);
}
private PatternNode getTreeNode(string patternID)
{
if (string.IsNullOrEmpty(patternID))
{
return(null);
}
var pattern = db.Patterns.FirstOrDefault(x => x.ID == patternID);
if (null == pattern)
{
return(null);
}
PatternNode root = new PatternNode()
{
name = pattern.Name
};
IList <PatternNode> children = new List <PatternNode>();
var segments = db.PatternSegments.Where(x => x.ParentID == patternID).OrderBy(x => x.IndexInPattern);
foreach (PatternSegment segment in segments)
{
var patternNode = new PatternNode()
{
name = segment.Name,
parent = root
};
patternNode.children = getChildNodes(segment.ID, patternNode);
children.Add(patternNode);
}
root.children = children;
root.parent = null;
return(root);
}
internal override bool MatchPattern(Node pattern, Dictionary <int, Node> matchings)
{
if (pattern is PatternNode)
{
PatternNode patternNode = pattern as PatternNode;
if (patternNode.Type == PatternType.Any || patternNode.Type == PatternType.Constant)
{
if (!matchings.ContainsKey(patternNode.Key))
{
matchings[patternNode.Key] = this;
return(true);
}
else
{
return(matchings[patternNode.Key].Equals(this));
}
}
else if (patternNode.Type == PatternType.Position)
{
matchings[patternNode.Key] = this;
return(true);
}
return(false);
}
else if (pattern is NumberNode)
{
return(pattern.Equals(this));
}
else if (pattern is UniaryOperatorNode)
{
UniaryOperatorNode uniOp = pattern as UniaryOperatorNode;
return(new UniaryOperatorNode(UniaryOperator.Negate, -Value).MatchPattern(pattern, matchings));
}
return(false);
}
public override UstNode Visit(PatternNode patternVars)
{
UstNode data = Visit(patternVars.Node);
List <PatternVarDef> vars = patternVars.Vars.Select(v => (PatternVarDef)Visit(v)).ToList();
vars.Sort();
return(new PatternNode(data, vars));
}
protected void PopulateNode(PatternNode <TData, TOffset> node)
{
CheckEndAlternation();
foreach (PatternNode <TData, TOffset> child in _nodes)
{
node.Children.Add(child);
}
}
/// <summary>
/// Instantiates a node plan node.
/// </summary>
/// <param name="patNode">The pattern node for this plan node.</param>
/// <param name="elemID">The element ID for this plan node.</param>
/// <param name="isPreset">True, if this element is a known element.</param>
public PlanNode(PatternNode patNode, int elemID, bool isPreset)
{
NodeType = PlanNodeType.Node;
ElementID = elemID;
IsPreset = isPreset;
PatternElement = patNode;
}
/// <summary>
/// 计算各节点所在层级的index
/// </summary>
/// <param name="node"></param>
private void calculateIndex(PatternNode node, int index)
{
node.Index = index;
for (int i = 0; i < node.Children.Count; i++)
{
calculateIndex(node.Children[0], i + 1);
}
}
public PatternNode(PatternNode parent, Pattern pattern, Pattern parentPattern, PointD origin, int level)
{
this.parent = parent;
this.pattern = pattern;
this.parentPattern = parentPattern;
this.origin = origin;
this.level = level;
}
private void addCoordinateSystem(PatternNode node)
{
Log.Print("Add CordinateSystem, level=" + node.Level + ", index=" + node.Index + ", parentIndex=" + node.Parent.Index);
csm.AddCordinateSystem(new CordinateSystem(node.Level, node.Index, node.Parent.Index, node.Origin));
foreach (PatternNode n in node.Children)
{
addCoordinateSystem(n);
}
}
public void JsonSerialize_PatternWithVar_JsonEqualsToDsl()
{
var pwdVar = new PatternVarDef {
Id = "pwd", Values = new List <Expression>()
{
new PatternIdToken("password")
}
};
var patternNode = new PatternNode
{
Vars = new List <PatternVarDef>()
{
pwdVar
},
Node = new PatternStatements(
new ExpressionStatement
{
Expression = new AssignmentExpression
{
Left = new PatternVarRef(pwdVar),
Right = new PatternExpression()
}
},
new PatternMultipleStatements(),
new ExpressionStatement
{
Expression = new InvocationExpression
{
Target = new PatternExpression(),
Arguments = new PatternExpressions(
new PatternMultipleExpressions(),
new PatternVarRef(pwdVar),
new PatternMultipleExpressions())
}
}
)
};
var jsonSerializer = new JsonUstNodeSerializer(typeof(UstNode), typeof(PatternVarDef));
jsonSerializer.Indented = true;
jsonSerializer.IncludeTextSpans = false;
string json = jsonSerializer.Serialize(patternNode);
UstNode nodeFromJson = jsonSerializer.Deserialize(json, LanguageExt.AllPatternLanguages);
var dslSeializer = new DslProcessor()
{
PatternExpressionInsideStatement = false
};
var nodeFromDsl = dslSeializer.Deserialize("<[@pwd:password]> = #; ... #(#*, <[@pwd]>, #*);", LanguageExt.AllPatternLanguages);
Assert.IsTrue(nodeFromJson.Equals(patternNode));
Assert.IsTrue(nodeFromJson.Equals(nodeFromDsl));
}
private void AddNode(PatternNode <TData, TOffset> node)
{
if (_inAlternation)
{
_alternation.Add(node);
_inAlternation = false;
}
else
{
_nodes.Add(node);
}
}
private IList <PatternNode> getChildNodes(string parentID, PatternNode parentNode)
{
IList <PatternNode> children = null;
if (!string.IsNullOrEmpty(parentID))
{
var segments = db.PatternSegments.Where(x => x.ParentID == parentID).OrderBy(x => x.IndexInPattern);
if (segments.Any())
{
children = new List <PatternNode>();
foreach (PatternSegment segment in segments)
{
var patternNode = new PatternNode()
{
parent = parentNode,
name = segment.Name
};
patternNode.children = getChildNodes(segment.ID, patternNode);
children.Add(patternNode);
}
}
else
{
// if there is no child node for a pattern node, we should query log records from LogTable
var logRecords = db.PatternLogs.Where(x => x.SegmentID == parentID).OrderBy(x => x.IndexInSegment);
if (logRecords.Any())
{
children = new List <PatternNode>();
foreach (var log in logRecords)
{
var patterNode = new PatternNode()
{
name = log.Text,
traceline = log.LineNumInTraceFile,
debugging = log.IsForDebug,
breaking = log.IsBreakPoint,
parent = parentNode
};
if (patterNode.breaking)
{
breakingNodeList.Add(patterNode);
}
children.Add(patterNode);
}
}
}
}
return(children);
}
private bool CheckNeighbours(INode node, PatternNode patternNode)
{
foreach (var edge in patternNode.Edges)
{
PatternNode n = (PatternNode)edge.GetOtherNode(patternNode);
if (n.IsMatched && !n.MatchedNode.IsNeighbour(node).Success)
{
return(false);
}
}
return(true);
}
private void MarkBranch(List <PatternNode> list)
{
PatternNode tmpNode = null;
foreach (PatternNode node in list)
{
tmpNode = node;
while (null != tmpNode && null != tmpNode.parent)
{
tmpNode.parent.breaking = true;
tmpNode = tmpNode.parent;
}
}
}
TreeLocal?CreateAlias(PatternNode node)
{
if (!(node.Alias is PatternAliasNode alias))
{
return(null);
}
var sym = alias.GetAnnotation <SyntaxSymbol>("Symbol");
var local = _parent._context.CreateLocal(_parent._freezes.Contains(sym), sym.Name);
_parent.AddVariable(sym, local);
return(local);
}
public MatchNodeArg(INode node, PatternNode patternNode, Predicate <T> predicate, IMatchEdge incomingEdge)
: this(node, patternNode, predicate)
{
if (incomingEdge != null)
{
this.IsRemote = incomingEdge.IsRemote;
this.RemotePartitionId = incomingEdge.RemotePartitionId;
}
else
{
this.IsRemote = false;
this.RemotePartitionId = null;
}
}
public PrecedenceAltGroup(Source source, Precedence precedence,
List <IParseable> nodes)
{
this.nodes = nodes;
this.precedence = precedence;
if (nodes.Count == 1)
{
parseGraph = nodes[0];
}
else
{
parseGraph = new LongestAlt(source, nodes);
}
leftRecursiveNodes = new List <ParseGraphNode>();
foreach (IParseable node in (IEnumerable <IParseable>)nodes)
{
PatternNode patternNode = node as PatternNode;
if (patternNode != null)
{
ConcretePattern pattern = patternNode.Pattern as ConcretePattern;
if (pattern != null)
{
if (pattern.RecursionBehaviour == RecursionBehaviour.LeftRecursive)
{
leftRecursiveNodes.Add(new PatternNode(source, pattern, true));
}
}
}
}
if (leftRecursiveNodes.Count == 0)
{
leftRecursiveParseGraph = null;
}
else if (leftRecursiveNodes.Count == 1)
{
leftRecursiveParseGraph = leftRecursiveNodes[0];
}
else
{
leftRecursiveParseGraph = new AltNode(source, leftRecursiveNodes, true);
}
}
protected override bool FollowupOnRemoteNode(INode node, PatternNode patternNode, MatcherFunc next)
{
System.Diagnostics.Debug.Assert(node.Id.Equals(patternNode.MatchedNode.Id));
foreach (var edge in patternNode.RemoteEdges)
{
INode n = edge.GetOtherNode(patternNode.MatchedNode);
// do not double check nodes!
if (!model.HasNode(n) && next(n, edge))
{
logger.Trace("Matched node/subpattern in a third partition!");
return(true);
}
}
return(false);
}
public override PatternNode <ComplexConcParagraphData, ShapeNode> GeneratePattern(FeatureSystem featSys)
{
var group = new Group <ComplexConcParagraphData, ShapeNode>();
Alternation <ComplexConcParagraphData, ShapeNode> alternation = null;
bool inAlternation = false;
foreach (ComplexConcPatternNode child in Children)
{
if (child is ComplexConcOrNode)
{
if (alternation == null)
{
alternation = new Alternation <ComplexConcParagraphData, ShapeNode>();
alternation.Children.Add(group.Children.Last);
}
inAlternation = true;
}
else
{
if (!inAlternation && alternation != null)
{
group.Children.Add(alternation);
alternation = null;
}
PatternNode <ComplexConcParagraphData, ShapeNode> newNode = child.GeneratePattern(featSys);
if (inAlternation)
{
alternation.Children.Add(newNode);
inAlternation = false;
}
else
{
group.Children.Add(newNode);
}
}
}
if (alternation != null)
{
group.Children.Add(alternation.Children.Count == 1 ? alternation.Children.First : alternation);
}
return(AddQuantifier(group));
}
private bool TryMatchNodeWithNext <T>(INode node, PatternNode patternNode, Predicate <T> predicate, MatcherFunc next, IMatchEdge incomingEdge) where T : class, INode
{
var res = TryMatchNode(new MatchNodeArg <T>(node, patternNode, predicate, incomingEdge));
if (!res.IsMatched)
{
return(false);
}
// when already matched the whole subpattern, no need to look further
// this can happen if returning from a remote match
if (res.IsMatched && res.IsFullSubpatternMatched)
{
return(true);
}
bool isSubpatternMatch = false;
// patternNode.RemoteEdges is only populated when a
// remote node returns
foreach (var edge in node.Edges.Cast <IMatchEdge>())
{
INode neighbour = edge.GetOtherNode(node);
if (next(neighbour, edge))
{
isSubpatternMatch = true;
break;
}
}
// no match found in local partition -> check remotes as well
// but only if this is the initially started matching (not a remote one)
if (!isSubpatternMatch && !this.IsRemote)
{
isSubpatternMatch = FollowupOnRemoteNode(node, patternNode, next);
// when no match found clear the pattern node
if (!isSubpatternMatch)
{
patternNode.Reset();
}
}
return(isSubpatternMatch);
}
public bool Validate(
PatternNode pattern,
PatternCompilerErrorsSink errorsSink)
{
try
{
Validate <NoConsecutiveSegmentStartValidator>(pattern);
Validate <NoConsecutiveWildcardValidator>(pattern);
Validate <OneVariablePerSegmentValidator>(pattern);
Validate <NoVariableFollowedByWildcardValidator>(pattern);
Validate <VariableNameValidator>(pattern);
return(true);
}
catch (PatternException pe)
{
errorsSink.AddError(pe.Message);
return(false);
}
}
public Pattern[] Convert(IEnumerable <PatternDto> patternsDto)
{
var result = new List <Pattern>();
foreach (var patternDto in patternsDto)
{
var serializer = UstNodeSerializers[patternDto.DataFormat];
try
{
PatternNode data = (PatternNode)serializer.Deserialize(patternDto.Value, patternDto.Languages);
var pattern = new Pattern(patternDto, data);
result.Add(pattern);
}
catch (Exception ex)
{
Logger.LogError(new ConversionException($"Error while \"{patternDto.Key}\" pattern deserialising ({patternDto.Value}) ", ex));
}
}
return(result.ToArray());
}
internal override bool MatchPattern(Node pattern, Dictionary <int, Node> matchings)
{
if (pattern is BinaryOperatorNode)
{
BinaryOperatorNode binOp = pattern as BinaryOperatorNode;
if (binOp.Operator != Operator)
{
return(false);
}
if (!Left.MatchPattern(binOp.Left, matchings) || !Right.MatchPattern(binOp.Right, matchings))
{
return(false);
}
return(true);
}
else if (pattern is PatternNode)
{
PatternNode patternNode = pattern as PatternNode;
if (patternNode.Type == PatternType.Any)
{
if (!matchings.ContainsKey(patternNode.Key))
{
matchings[patternNode.Key] = this;
return(true);
}
else
{
return(matchings[patternNode.Key].Equals(this));
}
}
else if (patternNode.Type == PatternType.Position)
{
matchings[patternNode.Key] = this;
return(true);
}
}
return(false);
}
public override void Update(float deltaTime)
{
for (var iterator = _attackPattern.First; iterator != null; iterator = iterator.Next)
{
PatternNode pattern = iterator.Value;
pattern.Update(deltaTime);
if (pattern.time < 0f)
{
pattern.function();
_attackPattern.Remove(pattern);
}
}
Vector2 perlinValue = (new Vector2(Mathf.PerlinNoise(time * 0.2f, 0f), Mathf.PerlinNoise(0f, time * 0.2f)) * 2f - Vector2.one) * 8f;
Vector3 targetPosition = _player.worldPosition + new Vector3(perlinValue.x, 8f + Mathf.Sin(time * 5f), perlinValue.y);
velocity = Vector3.Lerp(velocity, targetPosition - worldPosition, deltaTime * 24f);
int holdRuneCount = GetRunesByState(RuneState.Hold).Count;
for (int i = 0; i < holdRuneCount; i++)
{
GetRunesByState(RuneState.Hold)[i]._targetPosition = worldPosition +
CustomMath.HorizontalRotate(Vector3.right * 12f, (i * 360f / holdRuneCount) + (time * 120f));
}
foreach (var rune in GetRunesByState(RuneState.ReadyDrop))
{
rune._targetPosition = world.player.worldPosition + Vector3.up * 6f;
}
_entityParts[0].worldPosition = worldPosition;
_entityParts[1].worldPosition = Vector3.Lerp(_entityParts[1].worldPosition, worldPosition, deltaTime * 10f);
base.Update(deltaTime);
}
public void Sort_PatternVars()
{
var unsortedExpressions = new List <Expression>()
{
new IntLiteral {
Value = 100
},
new IntLiteral {
Value = 42
},
new IntLiteral {
Value = 0
},
new StringLiteral {
Text = "42"
},
new StringLiteral {
Text = "Hello World!"
},
new IdToken {
Id = "testId"
},
new IdToken {
Id = "42"
},
new PatternExpression(new StringLiteral {
Text = "42"
}, true),
};
var expectedSortedExpressions = new List <Expression>
{
new StringLiteral {
Text = "42"
},
new PatternExpression(new StringLiteral {
Text = "42"
}, true),
new StringLiteral {
Text = "Hello World!"
},
new IdToken {
Id = "42"
},
new IdToken {
Id = "testId"
},
new IntLiteral {
Value = 0
},
new IntLiteral {
Value = 42
},
new IntLiteral {
Value = 100
},
};
var patternVarDef = new PatternVarDef
{
Id = "testVarDef",
Values = unsortedExpressions
};
var patternVars = new PatternNode
{
Vars = new List <PatternVarDef>()
{
patternVarDef
},
Node = new PatternVarRef(patternVarDef)
};
var logger = new LoggerMessageCounter();
var processor = new DslProcessor();
UstPreprocessor preprocessor = new UstPreprocessor()
{
Logger = logger
};
Expression[] resultSortedExpressions = ((PatternNode)preprocessor.Preprocess(patternVars))
.Vars.First().Values.ToArray();
Assert.AreEqual(expectedSortedExpressions.Count, resultSortedExpressions.Length);
for (int i = 0; i < expectedSortedExpressions.Count; i++)
{
Assert.IsTrue(expectedSortedExpressions[i].Equals(resultSortedExpressions[i]),
$"Not equal at {i} index: expected {expectedSortedExpressions[i]} not equals to {resultSortedExpressions[i]}");
}
}
private void Untruncate(PatternNode<Word, ShapeNode> patternNode, Shape output, bool optional, VariableBindings varBindings)
{
foreach (PatternNode<Word, ShapeNode> node in patternNode.Children)
{
var constraint = node as Constraint<Word, ShapeNode>;
if (constraint != null && constraint.Type() == HCFeatureSystem.Segment)
{
FeatureStruct fs = constraint.FeatureStruct.DeepClone();
fs.ReplaceVariables(varBindings);
output.Add(fs, optional);
}
else
{
var quantifier = node as Quantifier<Word, ShapeNode>;
if (quantifier != null)
{
for (int i = 0; i < quantifier.MaxOccur; i++)
Untruncate(quantifier, output, i >= quantifier.MinOccur, varBindings);
}
else
{
Untruncate(node, output, optional, varBindings);
}
}
}
}
public void ConnectTo(PatternNode node)
{
lineRenderer.SetPosition(1, node.transform.position - transform.position);
}
protected PatternNode<ComplexConcParagraphData, ShapeNode> AddQuantifier(PatternNode<ComplexConcParagraphData, ShapeNode> node)
{
return Minimum != 1 || Maximum != 1 ? new Quantifier<ComplexConcParagraphData, ShapeNode>(Minimum, Maximum, node) : node;
}
