public override void Assign(object value, IGraphProcessingEnvironment procEnv) { object container = DestVar.GetVariableValue(procEnv); object key = KeyExpression.Evaluate(procEnv); if (container is IList) { IList array = (IList)container; if (array.Count > (int)key) { array[(int)key] = value; } } else if (container is IDeque) { IDeque deque = (IDeque)container; if (deque.Count > (int)key) { deque[(int)key] = value; } } else { IDictionary map = (IDictionary)container; if (map.Contains(key)) { map[key] = value; } } }
/// <summary> /// Returns a string representation of the given Deque /// </summary> /// <param name="deque">The Deque of which to get the string representation</param> /// <param name="type">The type as string, e.g deque<int></param> /// <param name="content">The content as string, e.g. ] 42, 43 [</param> /// <param name="attrType">The attribute type of the deque if available, otherwise null</param> /// <param name="graph">The graph with the model and the element names if available, otherwise null</param> /// <param name="firstLevelObjectEmitted">Prevents emitting of further objects and thus infinite regressions</param> /// <param name="nameToObject">If not null, the names of visited objects are added</param> /// <param name="procEnv">If not null, the processing environment is used for transient object unique id emitting and fetching</param> public static void ToString(IDeque deque, out string type, out string content, AttributeType attrType, IGraph graph, bool firstLevelObjectEmitted, IDictionary <string, IObject> nameToObject, IGraphProcessingEnvironment procEnv) { Type valueType; ContainerHelper.GetDequeType(deque, out valueType); StringBuilder sb = new StringBuilder(256); sb.Append("]"); AttributeType attrValueType = attrType != null ? attrType.ValueType : null; if (deque != null) { type = "deque<" + valueType.Name + ">"; AppendDeque(sb, deque, attrValueType, graph, firstLevelObjectEmitted, nameToObject, procEnv); } else { type = "<INVALID>"; } sb.Append("["); content = sb.ToString(); }
public override void Assign(object value, IGraphProcessingEnvironment procEnv) { IGraphElement elem = (IGraphElement)DestVar.GetVariableValue(procEnv); AttributeType attrType; value = ContainerHelper.IfAttributeOfElementIsContainerThenCloneContainer( elem, AttributeName, value, out attrType); AttributeChangeType changeType = AttributeChangeType.Assign; if (elem is INode) { procEnv.Graph.ChangingNodeAttribute((INode)elem, attrType, changeType, value, null); } else { procEnv.Graph.ChangingEdgeAttribute((IEdge)elem, attrType, changeType, value, null); } elem.SetAttribute(AttributeName, value); if (elem is INode) { procEnv.Graph.ChangedNodeAttribute((INode)elem, attrType); } else { procEnv.Graph.ChangedEdgeAttribute((IEdge)elem, attrType); } }
public override void Assign(object value, IGraphProcessingEnvironment procEnv) { IGraphElement elem = (IGraphElement)GraphElementVar.GetVariableValue(procEnv); int visitedFlag = VisitedFlagExpression != null ? (int)VisitedFlagExpression.Evaluate(procEnv) : 0; procEnv.Graph.SetVisited(elem, visitedFlag, (bool)value); }
public void DoUndo(IGraphProcessingEnvironment procEnv) { // nothing to do, this is only needed to distinguish the outermost transaction // from the nested transactions to know when to remove the rollback information // if nothing happened from opening the first transaction to opening the transaction of interest, // they would be indistinguishable as the number of undo items did not change }
public void DoUndo(IGraphProcessingEnvironment procEnv) { LGSPGraphProcessingEnvironment procEnv_ = (LGSPGraphProcessingEnvironment)procEnv; if (procEnv.Graph is LGSPNamedGraph) { if (_elem is LGSPNode) { ((LGSPNamedGraph)procEnv_.graph).AddNode((LGSPNode)_elem, _name); } else { ((LGSPNamedGraph)procEnv_.graph).AddEdge((LGSPEdge)_elem, _name); } } else { if (_elem is LGSPNode) { procEnv_.graph.AddNode((LGSPNode)_elem); } else { procEnv_.graph.AddEdge((LGSPEdge)_elem); } } if (_vars != null) { foreach (Variable var in _vars) { procEnv_.SetVariableValue(var.Name, _elem); } } }
protected static EdgeType GetEdgeType(IGraphProcessingEnvironment procEnv, SequenceExpression edgeTypeExpr, string functionName) { EdgeType edgeType = null; if (edgeTypeExpr != null) // often incident edge { object tmp = edgeTypeExpr.Evaluate(procEnv); if (tmp is string) { edgeType = procEnv.Graph.Model.EdgeModel.GetType((string)tmp); } else if (tmp is EdgeType) { edgeType = (EdgeType)tmp; } if (edgeType == null) { throw new Exception("edge type argument to " + functionName + " is not an edge type"); } } else { edgeType = procEnv.Graph.Model.EdgeModel.RootType; } return(edgeType); }
private static string ToString(IObject value, IGraph graph, bool firstLevelObjectEmitted, IDictionary <string, IObject> nameToObject, IGraphProcessingEnvironment procEnv) { StringBuilder sb = new StringBuilder(); string objectType = value.Type.PackagePrefixedName; sb.Append(objectType); sb.Append("{"); sb.Append("%:" + value.GetObjectName()); if (nameToObject != null) { if (!nameToObject.ContainsKey(value.GetObjectName())) { nameToObject.Add(value.GetObjectName(), value); } } if (!firstLevelObjectEmitted) { foreach (AttributeType attrType in value.Type.AttributeTypes) { sb.Append(","); sb.Append(attrType.Name); sb.Append(":"); sb.Append(EmitHelper.ToStringAutomatic(value.GetAttribute(attrType.Name), graph, true, nameToObject, procEnv)); } } sb.Append("}"); return(sb.ToString()); }
protected static NodeType GetNodeType(IGraphProcessingEnvironment procEnv, SequenceExpression nodeTypeExpr, string functionName) { NodeType nodeType = null; if (nodeTypeExpr != null) // often adjacent node { object tmp = nodeTypeExpr.Evaluate(procEnv); if (tmp is string) { nodeType = procEnv.Graph.Model.NodeModel.GetType((string)tmp); } else if (tmp is NodeType) { nodeType = (NodeType)tmp; } if (nodeType == null) { throw new Exception("node type argument to " + functionName + " is not a node type"); } } else { nodeType = procEnv.Graph.Model.NodeModel.RootType; } return(nodeType); }
public override void Assign(object value, IGraphProcessingEnvironment procEnv) { IGraphElement elem = (IGraphElement)DestVar.GetVariableValue(procEnv); object container = elem.GetAttribute(AttributeName); object key = KeyExpression.Evaluate(procEnv); AttributeType attrType = elem.Type.GetAttributeType(AttributeName); BaseGraph.ChangingAttributeAssignElement(procEnv.Graph, elem, attrType, value, key); if(container is IList) { IList array = (IList)container; array[(int)key] = value; } else if(container is IDeque) { IDeque deque = (IDeque)container; deque[(int)key] = value; } else { IDictionary map = (IDictionary)container; map[key] = value; } BaseGraph.ChangedAttribute(procEnv.Graph, elem, attrType); }
/// <summary> /// Returns a string representation of the given scalar value /// </summary> /// <param name="value">The scalar value of which to get the string representation</param> /// <param name="graph">The graph with the model and the element names if available, otherwise null</param> /// <param name="firstLevelObjectEmitted">Prevents emitting of further objects and thus infinite regressions</param> /// <param name="nameToObject">If not null, the names of visited objects are added</param> /// <param name="procEnv">If not null, the processing environment is used for transient object unique id emitting and fetching</param> /// <returns>string representation of scalar value</returns> public static string ToString(object value, IGraph graph, bool firstLevelObjectEmitted, IDictionary <string, IObject> nameToObject, IGraphProcessingEnvironment procEnv) { string type; string content; ToString(value, out type, out content, null, graph, firstLevelObjectEmitted, nameToObject, procEnv); return(content); }
public void DoUndo(IGraphProcessingEnvironment procEnv) { if (_elem is INode) { procEnv.Graph.Remove((INode)_elem); } else { procEnv.Graph.Remove((IEdge)_elem); } }
// gets the variable value, decides whether to query the graph-global or the sequence-lokal variables public object GetVariableValue(IGraphProcessingEnvironment procEnv) { if(Type == "") { return procEnv.GetVariableValue(name); } else { #if LOG_VARIABLE_OPERATIONS procEnv.Recorder.Write(name + "==" + EmitHelper.ToStringAutomatic(value, procEnv.Graph) + "\n"); #endif return value; } }
public static IList GroupBy(object container, string memberOrAttribute, IGraphProcessingEnvironment procEnv) { IList array = (IList)container; IList resultingArray = procEnv.Actions.ArrayGroupBy(array, memberOrAttribute); if (resultingArray != null) { return(resultingArray); } return(procEnv.Graph.Model.ArrayGroupBy(array, memberOrAttribute)); }
private bool If(IGraphElement element, IGraphProcessingEnvironment procEnv) { if (ifClause != null) { object oldThis = procEnv.GetVariableValue("this"); procEnv.SetVariableValue("this", element); bool result = (bool)ifClause.Evaluate(procEnv); procEnv.SetVariableValue("this", oldThis); return(result); } return(true); }
public ShellGraphProcessingEnvironment(INamedGraph graph, String backendFilename, String[] backendParameters, String modelFilename) { LGSPNamedGraph Graph = (LGSPNamedGraph)graph; DumpInfo = new DumpInfo(Graph.GetElementName); SubruleDebugConfig = new SubruleDebuggingConfiguration(); BackendFilename = backendFilename; BackendParameters = backendParameters; ModelFilename = modelFilename; ProcEnv = new LGSPGraphProcessingEnvironment(Graph, null); NameToSubgraph.Add(Graph.Name, Graph); }
public override void Assign(object value, IGraphProcessingEnvironment procEnv) { IGraphElement elem = (IGraphElement)DestVar.GetVariableValue(procEnv); AttributeType attrType; value = ContainerHelper.IfAttributeOfElementIsContainerThenCloneContainer( elem, AttributeName, value, out attrType); BaseGraph.ChangingAttributeAssign(procEnv.Graph, elem, attrType, value); elem.SetAttribute(AttributeName, value); BaseGraph.ChangedAttribute(procEnv.Graph, elem, attrType); }
// gets the variable value, decides whether to query the graph-global or the sequence-lokal variables public object GetVariableValue(IGraphProcessingEnvironment procEnv) { if (Type == "") { return(procEnv.GetVariableValue(name)); } else { #if LOG_VARIABLE_OPERATIONS procEnv.Recorder.Write(name + "==" + EmitHelper.ToStringAutomatic(value, procEnv.Graph) + "\n"); #endif return(value); } }
// sets the variable value, decides whether to update the graph-global or the sequence-lokal variables public void SetVariableValue(object value, IGraphProcessingEnvironment procEnv) { if (Type == "") { procEnv.SetVariableValue(name, value); } else { #if LOG_VARIABLE_OPERATIONS procEnv.Recorder.Write(name + " = " + EmitHelper.ToStringAutomatic(value, procEnv.Graph) + "\n"); #endif this.value = value; } }
/// <summary> /// Returns type object for type name string /// </summary> /// <param name="typeName">Name of the type we want some type object for</param> /// <param name="procEnv">Graph processing environment to search the types in</param> /// <returns>The type object corresponding to the given string, null if type was not found</returns> public static Type GetType(String typeName, IGraphProcessingEnvironment procEnv) { if (typeName == null) { return(null); } if (procEnv == null) { return(null); } Type typeFromModel = GetType(typeName, procEnv.Graph.Model); if (typeFromModel != null) { return(typeFromModel); } IActions actions = procEnv.Actions; Assembly assembly = Assembly.GetAssembly(actions.GetType()); typeName = typeName.Substring(6); // remove "match<" typeName = typeName.Substring(0, typeName.Length - 1); // remove ">" if (typeName.StartsWith("class ")) { typeName = typeName.Substring(6); // remove "class " } foreach (IAction action in actions.Actions) { if (action.PackagePrefixedName == typeName) { Type type = Type.GetType(action.RulePattern.MatchInterfaceName + "," + assembly.FullName); // search actions assembly return(type); } } foreach (MatchClassFilterer matchClassFilterer in actions.MatchClasses) { MatchClassInfo info = matchClassFilterer.info; if (info.PackagePrefixedName == typeName) { Type type = Type.GetType(info.matchInterfaceName + "," + assembly.FullName); // search actions assembly return(type); } } return(null); }
public void DoUndo(IGraphProcessingEnvironment procEnv) { String name; if (procEnv.Graph is LGSPNamedGraph && ((LGSPNamedGraph)procEnv.Graph).ElemToName.TryGetValue(_newElem, out name)) { LGSPNamedGraph lgspGraph = (LGSPNamedGraph)procEnv.Graph; if (_newElem is INode) { LGSPNode newNode = (LGSPNode)_newElem; LGSPNode oldNode = (LGSPNode)_oldElem; lgspGraph.ElemToName[oldNode] = name; lgspGraph.RetypingNode(newNode, oldNode); // this will switch the variables lgspGraph.ReplaceNode(newNode, oldNode); lgspGraph.ElemToName.Remove(newNode); lgspGraph.NameToElem[name] = oldNode; } else { LGSPEdge newEdge = (LGSPEdge)_newElem; LGSPEdge oldEdge = (LGSPEdge)_oldElem; lgspGraph.ElemToName[oldEdge] = name; lgspGraph.RetypingEdge(newEdge, oldEdge); // this will switch the variables lgspGraph.ReplaceEdge(newEdge, oldEdge); lgspGraph.ElemToName.Remove(newEdge); lgspGraph.NameToElem[name] = oldEdge; } } else { LGSPGraph lgspGraph = (LGSPGraph)procEnv.Graph; if (_newElem is INode) { LGSPNode newNode = (LGSPNode)_newElem; LGSPNode oldNode = (LGSPNode)_oldElem; lgspGraph.RetypingNode(newNode, oldNode); // this will switch the variables lgspGraph.ReplaceNode(newNode, oldNode); } else { LGSPEdge newEdge = (LGSPEdge)_newElem; LGSPEdge oldEdge = (LGSPEdge)_oldElem; lgspGraph.RetypingEdge(newEdge, oldEdge); // this will switch the variables lgspGraph.ReplaceEdge(newEdge, oldEdge); } } }
public static object InContainer(IGraphProcessingEnvironment procEnv, object container, object value) { if (container is IList) { IList array = (IList)container; return(array.Contains(value)); } else if (container is IDeque) { IDeque deque = (IDeque)container; return(deque.Contains(value)); } else { IDictionary setmap = (IDictionary)container; return(setmap.Contains(value)); } }
public static bool ContainerEmpty(IGraphProcessingEnvironment procEnv, object container) { if (container is IList) { IList array = (IList)container; return(array.Count == 0); } else if (container is IDeque) { IDeque deque = (IDeque)container; return(deque.Count == 0); } else { IDictionary setmap = (IDictionary)container; return(setmap.Count == 0); } }
public static object ContainerAccess(IGraphProcessingEnvironment procEnv, object container, object key) { if (container is IList) { IList array = (IList)container; return(array[(int)key]); } else if (container is IDeque) { IDeque deque = (IDeque)container; return(deque[(int)key]); } else { IDictionary setmap = (IDictionary)container; return(setmap[key]); } }
/// <summary> /// Filters the matches of a multi rule all call or multi rule backtracking construct /// (i.e. matches obtained from different rules, that implement a match class) /// with a lambda expression filter (call). /// </summary> /// <param name="procEnv">The graph processing environment, required by the filter implementation.</param> /// <param name="matches">The combined list of all matches of all rules (implementing the same match class; to inspect and filter)</param> /// <param name="filter">The lambda expression filter to apply</param> public void Filter(IGraphProcessingEnvironment procEnv, IList <IMatch> matches, FilterCallWithLambdaExpression filter) { if (filter.PlainName == "assign") { FilterAssign(procEnv, matches, filter); } else if (filter.PlainName == "removeIf") { FilterRemoveIf(procEnv, matches, filter); } else if (filter.PlainName == "assignStartWithAccumulateBy") { FilterAssignStartWithAccumulateBy(procEnv, matches, filter); } else { throw new Exception("Unknown lambda expression filter call (available are assign, removeIf, assignStartWithAccumulateBy)"); } }
private static string ToString(ITransientObject value, IGraph graph, bool firstLevelObjectEmitted, IDictionary <string, IObject> nameToObject, IGraphProcessingEnvironment procEnv) { StringBuilder sb = new StringBuilder(); string transientObjectType = value.Type.PackagePrefixedName; sb.Append(transientObjectType); if (procEnv != null || !firstLevelObjectEmitted) { sb.Append("{"); } bool first = true; if (procEnv != null) { sb.Append("&:" + procEnv.GetUniqueId(value)); first = false; } if (!firstLevelObjectEmitted) { foreach (AttributeType attrType in value.Type.AttributeTypes) { if (first) { first = false; } else { sb.Append(","); } sb.Append(attrType.Name); sb.Append(":"); sb.Append(EmitHelper.ToStringAutomatic(value.GetAttribute(attrType.Name), graph, true, nameToObject, procEnv)); } } if (procEnv != null || !firstLevelObjectEmitted) { sb.Append("}"); } return(sb.ToString()); }
public SequenceVariable Copy(Dictionary<SequenceVariable, SequenceVariable> originalToCopy, IGraphProcessingEnvironment procEnv) { // ensure that every instance of a variable is mapped to the same copy if(originalToCopy.ContainsKey(this)) return originalToCopy[this]; // local variables must be cloned when a defined sequence gets copied // global variables stay the same if(Type == "") { originalToCopy.Add(this, this); return this; } else { originalToCopy.Add(this, new SequenceVariable(name, prefix, type)); #if LOG_VARIABLE_OPERATIONS procEnv.Recorder.Write(name + " = " + name + "; " + name + "==" + EmitHelper.ToStringAutomatic(value, procEnv.Graph) + "\n"); #endif return originalToCopy[this]; } }
/// <summary> /// Returns a string representation of the given non-container value /// </summary> /// <param name="value">The scalar value of which to get the string representation</param> /// <param name="type">The type as string, e.g int,string,Foo </param> /// <param name="content">The content as string, e.g. 42,"foo",bar } </param> /// <param name="attrType">The attribute type of the value (may be null)</param> /// <param name="graph">The graph with the model and the element names</param> /// <param name="firstLevelObjectEmitted">Prevents emitting of further objects and thus infinite regressions</param> /// <param name="nameToObject">If not null, the names of visited objects are added</param> /// <param name="procEnv">If not null, the processing environment is used for transient object unique id emitting and fetching</param> public static void ToString(object value, out string type, out string content, AttributeType attrType, IGraph graph, bool firstLevelObjectEmitted, IDictionary <string, IObject> nameToObject, IGraphProcessingEnvironment procEnv) { if (attrType == null) { ToString(value, out type, out content, graph, firstLevelObjectEmitted, nameToObject, procEnv); return; } Debug.Assert(attrType.Kind != AttributeKind.SetAttr && attrType.Kind != AttributeKind.MapAttr && attrType.Kind != AttributeKind.ArrayAttr && attrType.Kind != AttributeKind.DequeAttr); type = TypesHelper.AttributeTypeToXgrsType(attrType); if (type == "object") { content = ToStringObject(value, attrType, graph); } else { content = ToString(value, attrType, graph, firstLevelObjectEmitted, nameToObject, procEnv); } }
public void FilterAssign(IGraphProcessingEnvironment procEnv, IList <IMatch> matchList, FilterCallWithLambdaExpression filterCall) { if (filterCall.arrayAccess != null) { List <IMatch> matchListCopy = new List <IMatch>(); foreach (IMatch match in matchList) { matchListCopy.Add(match.Clone()); } filterCall.arrayAccess.SetVariableValue(matchListCopy, procEnv); } for (int index = 0; index < matchList.Count; ++index) { if (filterCall.index != null) { filterCall.index.SetVariableValue(index, procEnv); } IMatch match = matchList[index]; filterCall.element.SetVariableValue(match, procEnv); object result = filterCall.lambdaExpression.Evaluate(procEnv); match.SetMember(filterCall.Entity, result); } }
/// <summary> /// Returns a string representation of the given dictionary /// </summary> /// <param name="setmap">The dictionary of which to get the string representation</param> /// <param name="type">The type as string, e.g set<int> or map<string,boolean> </param> /// <param name="content">The content as string, e.g. { 42, 43 } or { "foo"->true, "bar"->false } </param> /// <param name="attrType">The attribute type of the dictionary if available, otherwise null</param> /// <param name="graph">The graph with the model and the element names if available, otherwise null</param> /// <param name="firstLevelObjectEmitted">Prevents emitting of further objects and thus infinite regressions</param> /// <param name="nameToObject">If not null, the names of visited objects are added</param> /// <param name="procEnv">If not null, the processing environment is used for transient object unique id emitting and fetching</param> public static void ToString(IDictionary setmap, out string type, out string content, AttributeType attrType, IGraph graph, bool firstLevelObjectEmitted, IDictionary <string, IObject> nameToObject, IGraphProcessingEnvironment procEnv) { Type keyType; Type valueType; ContainerHelper.GetDictionaryTypes(setmap, out keyType, out valueType); StringBuilder sb = new StringBuilder(256); sb.Append("{"); AttributeType attrValueType = attrType != null ? attrType.ValueType : null; AttributeType attrKeyType = attrType != null ? attrType.KeyType : null; if (setmap != null) { if (valueType == typeof(SetValueType)) { type = "set<" + keyType.Name + ">"; AppendSet(sb, setmap, attrValueType, graph, firstLevelObjectEmitted, nameToObject, procEnv); } else { type = "map<" + keyType.Name + "," + valueType.Name + ">"; AppendMap(sb, setmap, attrKeyType, attrValueType, graph, firstLevelObjectEmitted, nameToObject, procEnv); } } else { type = "<INVALID>"; } sb.Append("}"); content = sb.ToString(); }
public void FilterRemoveIf(IGraphProcessingEnvironment procEnv, IList <IMatch> matchList, FilterCallWithLambdaExpression filterCall) { List <IMatch> matchListCopy = new List <IMatch>(matchList); if (filterCall.arrayAccess != null) { filterCall.arrayAccess.SetVariableValue(matchListCopy, procEnv); } matchList.Clear(); for (int index = 0; index < matchListCopy.Count; ++index) { if (filterCall.index != null) { filterCall.index.SetVariableValue(index, procEnv); } IMatch match = matchListCopy[index]; filterCall.element.SetVariableValue(match, procEnv); object result = filterCall.lambdaExpression.Evaluate(procEnv); if (!(bool)result) { matchList.Add(match); } } }
internal override SequenceExpression CopyExpression(Dictionary<SequenceVariable, SequenceVariable> originalToCopy, IGraphProcessingEnvironment procEnv) { SequenceExpressionFunctionMethodCall copy = (SequenceExpressionFunctionMethodCall)MemberwiseClone(); copy.TargetExpr = TargetExpr.CopyExpression(originalToCopy, procEnv); copy.ParamBindings = ParamBindings.Copy(originalToCopy, procEnv); return copy; }
public override object Execute(IGraphProcessingEnvironment procEnv) { object subgraph = Subgraph.Evaluate(procEnv); object subgraphSet = SubgraphSet.Evaluate(procEnv); return GraphHelper.EqualsAny((IGraph)subgraph, (IDictionary<IGraph, SetValueType>)subgraphSet, IncludingAttributes); }
internal override SequenceExpression CopyExpression(Dictionary<SequenceVariable, SequenceVariable> originalToCopy, IGraphProcessingEnvironment procEnv) { SequenceExpressionCountBoundedReachable copy = (SequenceExpressionCountBoundedReachable)MemberwiseClone(); copy.SourceNode = SourceNode.CopyExpression(originalToCopy, procEnv); copy.Depth = Depth.CopyExpression(originalToCopy, procEnv); if(EdgeType != null) copy.EdgeType = EdgeType.CopyExpression(originalToCopy, procEnv); if(OppositeNodeType!=null)copy.OppositeNodeType = OppositeNodeType.CopyExpression(originalToCopy, procEnv); return copy; }
internal override SequenceExpression CopyExpression(Dictionary<SequenceVariable, SequenceVariable> originalToCopy, IGraphProcessingEnvironment procEnv) { SequenceExpressionIsAdjacentIncident copy = (SequenceExpressionIsAdjacentIncident)MemberwiseClone(); copy.SourceNode = SourceNode.CopyExpression(originalToCopy, procEnv); copy.EndElement = EndElement.CopyExpression(originalToCopy, procEnv); if(EdgeType != null) copy.EdgeType = EdgeType.CopyExpression(originalToCopy, procEnv); if(OppositeNodeType!=null)copy.OppositeNodeType = OppositeNodeType.CopyExpression(originalToCopy, procEnv); return copy; }
// sets the variable value, decides whether to update the graph-global or the sequence-lokal variables public void SetVariableValue(object value, IGraphProcessingEnvironment procEnv) { if(Type == "") { procEnv.SetVariableValue(name, value); } else { #if LOG_VARIABLE_OPERATIONS procEnv.Recorder.Write(name + " = " + EmitHelper.ToStringAutomatic(value, procEnv.Graph) + "\n"); #endif this.value = value; } }
public override object Execute(IGraphProcessingEnvironment procEnv) { object leftValue = Left.Evaluate(procEnv); object rightValue = Right.Evaluate(procEnv); try { return SequenceExpressionHelper.StructuralEqualObjects(leftValue, rightValue); } catch(Exception) { throw new SequenceParserException(Operator, TypesHelper.XgrsTypeOfConstant(leftValue, procEnv.Graph.Model), TypesHelper.XgrsTypeOfConstant(rightValue, procEnv.Graph.Model), Symbol); } }
public override object Execute(IGraphProcessingEnvironment procEnv) { object nodeSet = NodeSet.Evaluate(procEnv); return GraphHelper.InducedSubgraph((IDictionary<INode, SetValueType>)nodeSet, procEnv.Graph); }
internal override SequenceExpression CopyExpression(Dictionary<SequenceVariable, SequenceVariable> originalToCopy, IGraphProcessingEnvironment procEnv) { SequenceExpressionTypeof copy = (SequenceExpressionTypeof)MemberwiseClone(); copy.Entity = Entity.CopyExpression(originalToCopy, procEnv); return copy; }
public override object Execute(IGraphProcessingEnvironment procEnv) { object entity = Entity.Evaluate(procEnv); return TypesHelper.XgrsTypeOfConstant(entity, procEnv.Graph.Model); }
public override object Execute(IGraphProcessingEnvironment procEnv) { if(UniquelyIdentifiedEntity != null) return GraphHelper.Uniqueof(UniquelyIdentifiedEntity.Evaluate(procEnv), procEnv.Graph); else return GraphHelper.Uniqueof(null, procEnv.Graph); }
internal override SequenceExpression CopyExpression(Dictionary<SequenceVariable, SequenceVariable> originalToCopy, IGraphProcessingEnvironment procEnv) { SequenceExpressionUniqueof copy = (SequenceExpressionUniqueof)MemberwiseClone(); if(UniquelyIdentifiedEntity != null) copy.UniquelyIdentifiedEntity = UniquelyIdentifiedEntity.CopyExpression(originalToCopy, procEnv); return copy; }
public override object Execute(IGraphProcessingEnvironment procEnv) { object graph = Graph.Evaluate(procEnv); return ((IGraph)graph).Canonize(); }
public override object Execute(IGraphProcessingEnvironment procEnv) { IGraphElement owner = (IGraphElement)TargetExpr.Evaluate(procEnv); for(int i = 0; i < ParamBindings.ArgumentExpressions.Length; i++) { if(ParamBindings.ArgumentExpressions[i] != null) ParamBindings.Arguments[i] = ParamBindings.ArgumentExpressions[i].Evaluate(procEnv); } return owner.ApplyFunctionMethod(procEnv, procEnv.Graph, ParamBindings.Name, ParamBindings.Arguments); }
public override object Execute(IGraphProcessingEnvironment procEnv) { object path = Path.Evaluate(procEnv); return File.Exists((string)path); }
public override object Execute(IGraphProcessingEnvironment procEnv) { object leftValue = Left.Evaluate(procEnv); object rightValue = Right.Evaluate(procEnv); string balancedType = BalancedTypeStatic; string leftType = LeftTypeStatic; string rightType = RightTypeStatic; if(balancedType == "") { leftType = TypesHelper.XgrsTypeOfConstant(leftValue, procEnv.Graph.Model); rightType = TypesHelper.XgrsTypeOfConstant(rightValue, procEnv.Graph.Model); balancedType = SequenceExpressionHelper.Balance(SequenceExpressionType, leftType, rightType, procEnv.Graph.Model); if(balancedType == "-") { throw new SequenceParserException(Operator, leftType, rightType, Symbol); } } try { return SequenceExpressionHelper.ModObjects(leftValue, rightValue, balancedType, leftType, rightType, procEnv.Graph); } catch(Exception) { throw new SequenceParserException(Operator, TypesHelper.XgrsTypeOfConstant(leftValue, procEnv.Graph.Model), TypesHelper.XgrsTypeOfConstant(rightValue, procEnv.Graph.Model), Symbol); } }
internal override SequenceExpression CopyExpression(Dictionary<SequenceVariable, SequenceVariable> originalToCopy, IGraphProcessingEnvironment procEnv) { SequenceExpressionImport copy = (SequenceExpressionImport)MemberwiseClone(); copy.Path = Path.CopyExpression(originalToCopy, procEnv); return copy; }
public override object Execute(IGraphProcessingEnvironment procEnv) { INode sourceNode = (INode)SourceNode.Evaluate(procEnv); IGraphElement endElement = (IGraphElement)EndElement.Evaluate(procEnv); EdgeType edgeType = null; if(EdgeType != null) { object tmp = EdgeType.Evaluate(procEnv); if(tmp is string) edgeType = procEnv.Graph.Model.EdgeModel.GetType((string)tmp); else if(tmp is EdgeType) edgeType = (EdgeType)tmp; if(edgeType == null) throw new Exception("edge type argument to " + FunctionSymbol + " is not an edge type"); } else { edgeType = procEnv.Graph.Model.EdgeModel.RootType; } NodeType nodeType = null; if(OppositeNodeType != null) { object tmp = OppositeNodeType.Evaluate(procEnv); if(tmp is string) nodeType = procEnv.Graph.Model.NodeModel.GetType((string)tmp); else if(tmp is NodeType) nodeType = (NodeType)tmp; if(nodeType == null) throw new Exception("node type argument to " + FunctionSymbol + " is not a node type"); } else { nodeType = procEnv.Graph.Model.NodeModel.RootType; } switch(SequenceExpressionType) { case SequenceExpressionType.IsReachableNodes: if(EmitProfiling) return GraphHelper.IsReachable(procEnv.Graph, sourceNode, (INode)endElement, edgeType, nodeType, procEnv); else return GraphHelper.IsReachable(procEnv.Graph, sourceNode, (INode)endElement, edgeType, nodeType); case SequenceExpressionType.IsReachableNodesViaIncoming: if(EmitProfiling) return GraphHelper.IsReachableIncoming(procEnv.Graph, sourceNode, (INode)endElement, edgeType, nodeType, procEnv); else return GraphHelper.IsReachableIncoming(procEnv.Graph, sourceNode, (INode)endElement, edgeType, nodeType); case SequenceExpressionType.IsReachableNodesViaOutgoing: if(EmitProfiling) return GraphHelper.IsReachableOutgoing(procEnv.Graph, sourceNode, (INode)endElement, edgeType, nodeType, procEnv); else return GraphHelper.IsReachableOutgoing(procEnv.Graph, sourceNode, (INode)endElement, edgeType, nodeType); case SequenceExpressionType.IsReachableEdges: if(EmitProfiling) return GraphHelper.IsReachableEdges(procEnv.Graph, sourceNode, (IEdge)endElement, edgeType, nodeType, procEnv); else return GraphHelper.IsReachableEdges(procEnv.Graph, sourceNode, (IEdge)endElement, edgeType, nodeType); case SequenceExpressionType.IsReachableEdgesViaIncoming: if(EmitProfiling) return GraphHelper.IsReachableEdgesIncoming(procEnv.Graph, sourceNode, (IEdge)endElement, edgeType, nodeType, procEnv); else return GraphHelper.IsReachableEdgesIncoming(procEnv.Graph, sourceNode, (IEdge)endElement, edgeType, nodeType); case SequenceExpressionType.IsReachableEdgesViaOutgoing: if(EmitProfiling) return GraphHelper.IsReachableEdgesOutgoing(procEnv.Graph, sourceNode, (IEdge)endElement, edgeType, nodeType, procEnv); else return GraphHelper.IsReachableEdgesOutgoing(procEnv.Graph, sourceNode, (IEdge)endElement, edgeType, nodeType); default: return null; // internal failure } }
public override object Execute(IGraphProcessingEnvironment procEnv) { object path = Path.Evaluate(procEnv); return GraphHelper.Import(path, procEnv.Graph); }
public override object Execute(IGraphProcessingEnvironment procEnv) { return Operand.Evaluate(procEnv); }
internal override SequenceExpression CopyExpression(Dictionary<SequenceVariable, SequenceVariable> originalToCopy, IGraphProcessingEnvironment procEnv) { SequenceExpressionCopy copy = (SequenceExpressionCopy)MemberwiseClone(); copy.ObjectToBeCopied = ObjectToBeCopied.CopyExpression(originalToCopy, procEnv); return copy; }
internal override sealed SequenceExpression CopyExpression(Dictionary<SequenceVariable, SequenceVariable> originalToCopy, IGraphProcessingEnvironment procEnv) { SequenceExpressionCast copy = (SequenceExpressionCast)MemberwiseClone(); copy.Operand = Operand.CopyExpression(originalToCopy, procEnv); copy.TargetType = TargetType; return copy; }
public override object Execute(IGraphProcessingEnvironment procEnv) { object toBeCloned = ObjectToBeCopied.Evaluate(procEnv); if(toBeCloned is IGraph) return GraphHelper.Copy((IGraph)toBeCloned); else if(toBeCloned is IMatch) return ((IMatch)toBeCloned).Clone(); else return ContainerHelper.Clone(toBeCloned); }
public override object Execute(IGraphProcessingEnvironment procEnv) { INode sourceNode = (INode)SourceNode.Evaluate(procEnv); int depth = (int)Depth.Evaluate(procEnv); EdgeType edgeType = null; if(EdgeType != null) { object tmp = EdgeType.Evaluate(procEnv); if(tmp is string) edgeType = procEnv.Graph.Model.EdgeModel.GetType((string)tmp); else if(tmp is EdgeType) edgeType = (EdgeType)tmp; if(edgeType == null) throw new Exception("edge type argument to " + FunctionSymbol + " is not an edge type"); } else { edgeType = procEnv.Graph.Model.EdgeModel.RootType; } NodeType nodeType = null; if(OppositeNodeType != null) { object tmp = OppositeNodeType.Evaluate(procEnv); if(tmp is string) nodeType = procEnv.Graph.Model.NodeModel.GetType((string)tmp); else if(tmp is NodeType) nodeType = (NodeType)tmp; if(nodeType == null) throw new Exception("node type argument to " + FunctionSymbol + " is not a node type"); } else { nodeType = procEnv.Graph.Model.NodeModel.RootType; } switch(SequenceExpressionType) { case SequenceExpressionType.BoundedReachableNodesWithRemainingDepth: if(EmitProfiling) return GraphHelper.BoundedReachableWithRemainingDepth(sourceNode, depth, edgeType, nodeType, procEnv); else return GraphHelper.BoundedReachableWithRemainingDepth(sourceNode, depth, edgeType, nodeType); case SequenceExpressionType.BoundedReachableNodesWithRemainingDepthViaIncoming: if(EmitProfiling) return GraphHelper.BoundedReachableWithRemainingDepthIncoming(sourceNode, depth, edgeType, nodeType, procEnv); else return GraphHelper.BoundedReachableWithRemainingDepthIncoming(sourceNode, depth, edgeType, nodeType); case SequenceExpressionType.BoundedReachableNodesWithRemainingDepthViaOutgoing: if(EmitProfiling) return GraphHelper.BoundedReachableWithRemainingDepthOutgoing(sourceNode, depth, edgeType, nodeType, procEnv); else return GraphHelper.BoundedReachableWithRemainingDepthOutgoing(sourceNode, depth, edgeType, nodeType); default: return null; // internal failure } }
public override object Execute(IGraphProcessingEnvironment procEnv) { IFunctionDefinition funcDef = ParamBindings.FunctionDef; for(int i = 0; i < ParamBindings.ArgumentExpressions.Length; i++) { if(ParamBindings.ArgumentExpressions[i] != null) ParamBindings.Arguments[i] = ParamBindings.ArgumentExpressions[i].Evaluate(procEnv); } object res = funcDef.Apply(procEnv, procEnv.Graph, ParamBindings); return res; }
internal override SequenceExpression CopyExpression(Dictionary<SequenceVariable, SequenceVariable> originalToCopy, IGraphProcessingEnvironment procEnv) { SequenceExpressionDefinedSubgraph copy = (SequenceExpressionDefinedSubgraph)MemberwiseClone(); copy.EdgeSet = EdgeSet.CopyExpression(originalToCopy, procEnv); return copy; }
internal override SequenceExpression CopyExpression(Dictionary<SequenceVariable, SequenceVariable> originalToCopy, IGraphProcessingEnvironment procEnv) { SequenceExpressionEqualsAny copy = (SequenceExpressionEqualsAny)MemberwiseClone(); copy.Subgraph = Subgraph.CopyExpression(originalToCopy, procEnv); copy.SubgraphSet = SubgraphSet.CopyExpression(originalToCopy, procEnv); return copy; }
public override sealed object Execute(IGraphProcessingEnvironment procEnv) { throw new Exception("Internal error! AssignmentTarget executed as SequenceComputation."); }
public override object Execute(IGraphProcessingEnvironment procEnv) { object edgeSet = EdgeSet.Evaluate(procEnv); return GraphHelper.DefinedSubgraph((IDictionary<IEdge, SetValueType>)edgeSet, procEnv.Graph); }