public static Dictionary<IEdge, SetValueType> Edges(IGraph graph, EdgeType edgeType, IActionExecutionEnvironment actionEnv, int threadId)
 {
     Dictionary<IEdge, SetValueType> edgesSet = new Dictionary<IEdge, SetValueType>();
     foreach(IEdge edge in graph.GetCompatibleEdges(edgeType))
     {
         ++actionEnv.PerformanceInfo.SearchStepsPerThread[threadId];
         edgesSet[edge] = null;
     }
     return edgesSet;
 }
 public static Dictionary<INode, SetValueType> Nodes(IGraph graph, NodeType nodeType, IActionExecutionEnvironment actionEnv, int threadId)
 {
     Dictionary<INode, SetValueType> nodesSet = new Dictionary<INode, SetValueType>();
     foreach(INode node in graph.GetCompatibleNodes(nodeType))
     {
         ++actionEnv.PerformanceInfo.SearchStepsPerThread[threadId];
         nodesSet[node] = null;
     }
     return nodesSet;
 }
 public static int CountEdges(IGraph graph, EdgeType edgeType, IActionExecutionEnvironment actionEnv, int threadId)
 {
     return graph.GetNumCompatibleEdges(edgeType);
 }
 public static Dictionary<IEdge, SetValueType> ReachableEdgesOutgoing(IGraph graph, INode startNode, EdgeType outgoingEdgeType, NodeType targetNodeType, IActionExecutionEnvironment actionEnv, int threadId)
 {
     Dictionary<IEdge, SetValueType> outgoingEdgesSet = new Dictionary<IEdge, SetValueType>();
     ReachableEdgesOutgoing(startNode, outgoingEdgeType, targetNodeType, outgoingEdgesSet, graph, actionEnv, threadId);
     foreach(KeyValuePair<IEdge, SetValueType> kvp in outgoingEdgesSet)
     {
         IEdge edge = kvp.Key;
         graph.SetInternallyVisited(edge.Source, false, threadId);
         graph.SetInternallyVisited(edge.Target, false, threadId);
     }
     return outgoingEdgesSet;
 }
 public static Dictionary<INode, SetValueType> ReachableIncoming(INode startNode, EdgeType incomingEdgeType, NodeType sourceNodeType, IActionExecutionEnvironment actionEnv, int threadId)
 {
     Dictionary<INode, SetValueType> sourceNodesSet = new Dictionary<INode, SetValueType>();
     ReachableIncoming(startNode, incomingEdgeType, sourceNodeType, sourceNodesSet, actionEnv, threadId);
     return sourceNodesSet;
 }
 /// <summary>
 /// Fills set of nodes reachable from the start node via incoming edges, under the type constraints given, in a depth-first walk
 /// </summary>
 private static void ReachableIncoming(INode startNode, EdgeType incomingEdgeType, NodeType sourceNodeType, Dictionary<INode, SetValueType> sourceNodesSet, IActionExecutionEnvironment actionEnv, int threadId)
 {
     foreach(IEdge edge in startNode.Incoming)
     {
         ++actionEnv.PerformanceInfo.SearchStepsPerThread[threadId];
         if(!edge.InstanceOf(incomingEdgeType))
             continue;
         INode adjacentNode = edge.Source;
         if(!adjacentNode.InstanceOf(sourceNodeType))
             continue;
         if(sourceNodesSet.ContainsKey(adjacentNode))
             continue;
         sourceNodesSet[adjacentNode] = null;
         ReachableIncoming(adjacentNode, incomingEdgeType, sourceNodeType, sourceNodesSet, actionEnv, threadId);
     }
 }
 public static Dictionary<IEdge, SetValueType> Incoming(INode startNode, EdgeType incomingEdgeType, NodeType sourceNodeType, IActionExecutionEnvironment actionEnv, int threadId)
 {
     Dictionary<IEdge, SetValueType> incomingEdgesSet = new Dictionary<IEdge, SetValueType>();
     foreach(IEdge edge in startNode.Incoming)
     {
         ++actionEnv.PerformanceInfo.SearchStepsPerThread[threadId];
         if(!edge.InstanceOf(incomingEdgeType))
             continue;
         INode adjacentNode = edge.Source;
         if(!adjacentNode.InstanceOf(sourceNodeType))
             continue;
         incomingEdgesSet[edge] = null;
     }
     return incomingEdgesSet;
 }
Beispiel #8
0
 public object ApplyFunctionMethod(IActionExecutionEnvironment actionEnv, IGraph graph, string name, object[] arguments)
 {
     throw new NotImplementedException("The method or operation is not implemented.");
 }
 public static bool IsBoundedReachableOutgoing(IGraph graph, INode startNode, INode endNode, int depth, EdgeType outgoingEdgeType, NodeType targetNodeType, IActionExecutionEnvironment actionEnv, int threadId)
 {
     Dictionary<INode, int> targetNodesToMinDepth = new Dictionary<INode, int>();
     bool result = IsBoundedReachableOutgoing(startNode, endNode, depth, outgoingEdgeType, targetNodeType, graph, targetNodesToMinDepth, actionEnv, threadId);
     return result;
 }
 public StatisticsSource(IGraph graph, IActionExecutionEnvironment actionEnv)
 {
     this.graph     = graph;
     this.actionEnv = actionEnv;
 }
        private static bool IsReachableEdgesIncoming(INode startNode, IEdge endEdge, EdgeType incomingEdgeType, NodeType sourceNodeType, IGraph graph, List<IGraphElement> visitedElems, IActionExecutionEnvironment actionEnv, int threadId)
        {
            bool result = false;

            foreach(IEdge edge in startNode.Incoming)
            {
                ++actionEnv.PerformanceInfo.SearchStepsPerThread[threadId];
                if(!edge.InstanceOf(incomingEdgeType))
                    continue;
                INode adjacentNode = edge.Source;
                if(!adjacentNode.InstanceOf(sourceNodeType))
                    continue;
                if(graph.IsInternallyVisited(edge, threadId))
                    continue;
                graph.SetInternallyVisited(edge, true, threadId);
                visitedElems.Add(edge);
                if(edge.Source == endEdge)
                    return true;

                if(graph.IsInternallyVisited(adjacentNode, threadId))
                    continue;
                graph.SetInternallyVisited(adjacentNode, true, threadId);
                visitedElems.Add(adjacentNode);
                result = IsReachableEdgesIncoming(adjacentNode, endEdge, incomingEdgeType, sourceNodeType, graph, visitedElems, actionEnv, threadId);
                if(result == true)
                    break;
            }

            return result;
        }
 public static bool IsBoundedReachable(IGraph graph, INode startNode, INode endNode, int depth, EdgeType incidentEdgeType, NodeType adjacentNodeType, IActionExecutionEnvironment actionEnv, int threadId)
 {
     Dictionary<INode, int> adjacentNodesToMinDepth = new Dictionary<INode, int>();
     bool result = IsBoundedReachable(startNode, endNode, depth, incidentEdgeType, adjacentNodeType, graph, adjacentNodesToMinDepth, actionEnv, threadId);
     return result;
 }
 public static bool IsReachableEdgesIncoming(IGraph graph, INode startNode, IEdge endEdge, EdgeType incomingEdgeType, NodeType sourceNodeType, IActionExecutionEnvironment actionEnv, int threadId)
 {
     List<IGraphElement> visitedElems = new List<IGraphElement>((int)Math.Sqrt(graph.NumNodes));
     bool result = IsReachableEdgesIncoming(startNode, endEdge, incomingEdgeType, sourceNodeType, graph, visitedElems, actionEnv, threadId);
     for(int i = 0; i < visitedElems.Count; ++i)
         graph.SetInternallyVisited(visitedElems[i], false, threadId);
     return result;
 }
 public static bool IsIncoming(INode startNode, IEdge endEdge, EdgeType incomingEdgeType, NodeType sourceNodeType, IActionExecutionEnvironment actionEnv, int threadId)
 {
     foreach(IEdge edge in startNode.Incoming)
     {
         ++actionEnv.PerformanceInfo.SearchStepsPerThread[threadId];
         if(!edge.InstanceOf(incomingEdgeType))
             continue;
         INode adjacentNode = edge.Source;
         if(!adjacentNode.InstanceOf(sourceNodeType))
             continue;
         if(edge == endEdge)
             return true;
     }
     return false;
 }
 public static bool IsAdjacentOutgoing(INode startNode, INode endNode, EdgeType outgoingEdgeType, NodeType targetNodeType, IActionExecutionEnvironment actionEnv, int threadId)
 {
     foreach(IEdge edge in startNode.Outgoing)
     {
         ++actionEnv.PerformanceInfo.SearchStepsPerThread[threadId];
         if(!edge.InstanceOf(outgoingEdgeType))
             continue;
         INode adjacentNode = edge.Target;
         if(!adjacentNode.InstanceOf(targetNodeType))
             continue;
         if(adjacentNode == endNode)
             return true;
     }
     return false;
 }
Beispiel #16
0
 /// <summary>
 /// Executes the procedure method given by its name.
 /// Throws an exception if the method does not exists or the parameters are of wrong types.
 /// </summary>
 /// <param name="actionEnv">The current action execution environment.</param>
 /// <param name="graph">The current graph.</param>
 /// <param name="name">The name of the procedure method to apply.</param>
 /// <param name="arguments">An array with the arguments to the method.</param>
 /// <returns>An array with the return values of procedure application. Only valid until the next call of this method.</returns>
 public abstract object[] ApplyProcedureMethod(IActionExecutionEnvironment actionEnv, IGraph graph, string name, object[] arguments);
 public static bool IsBoundedReachableEdgesIncoming(IGraph graph, INode startNode, IEdge endEdge, int depth, EdgeType incomingEdgeType, NodeType sourceNodeType, IActionExecutionEnvironment actionEnv, int threadId)
 {
     Dictionary<INode, int> sourceNodesToMinDepth = new Dictionary<INode, int>();
     bool result = IsBoundedReachableEdgesIncoming(startNode, endEdge, depth, incomingEdgeType, sourceNodeType, graph, sourceNodesToMinDepth, actionEnv, threadId);
     return result;
 }
 /// <summary>
 /// Applies this procedure with the given action environment on the given graph.
 /// Takes the arguments as inputs.
 /// Returns an array of output values.
 /// Attention: at the next call of Apply, the array returned from previous call is overwritten with the new return values.
 /// </summary>
 public abstract object[] Apply(IActionExecutionEnvironment actionEnv, IGraph graph, object[] argument);
 public static int CountIncoming(INode startNode, EdgeType incidentEdgeType, NodeType adjacentNodeType, IActionExecutionEnvironment actionEnv, int threadId)
 {
     int count = 0;
     foreach(IEdge edge in startNode.Incoming)
     {
         ++actionEnv.PerformanceInfo.SearchStepsPerThread[threadId];
         if(!edge.InstanceOf(incidentEdgeType))
             continue;
         INode adjacentNode = edge.Source;
         if(!adjacentNode.InstanceOf(adjacentNodeType))
             continue;
         ++count;
     }
     return count;
 }
 public static Dictionary<IEdge, SetValueType> Outgoing(INode startNode, EdgeType outgoingEdgeType, NodeType targetNodeType, IActionExecutionEnvironment actionEnv, int threadId)
 {
     Dictionary<IEdge, SetValueType> outgoingEdgesSet = new Dictionary<IEdge, SetValueType>();
     foreach(IEdge edge in startNode.Outgoing)
     {
         ++actionEnv.PerformanceInfo.SearchStepsPerThread[threadId];
         if(!edge.InstanceOf(outgoingEdgeType))
             continue;
         INode adjacentNode = edge.Target;
         if(!adjacentNode.InstanceOf(targetNodeType))
             continue;
         outgoingEdgesSet[edge] = null;
     }
     return outgoingEdgesSet;
 }
 public static Dictionary<INode, SetValueType> ReachableOutgoing(INode startNode, EdgeType outgoingEdgeType, NodeType targetNodeType, IActionExecutionEnvironment actionEnv, int threadId)
 {
     Dictionary<INode, SetValueType> targetNodesSet = new Dictionary<INode, SetValueType>();
     ReachableOutgoing(startNode, outgoingEdgeType, targetNodeType, targetNodesSet, actionEnv, threadId);
     return targetNodesSet;
 }
        /// <summary>
        /// Returns whether the end edge is reachable from the start node within the given depth, via incoming edges, under the type constraints given
        /// </summary>
        private static bool IsBoundedReachableEdgesIncoming(INode startNode, IEdge endEdge, int depth, EdgeType incomingEdgeType, NodeType sourceNodeType, IGraph graph, Dictionary<INode, int> adjacentNodesToMinDepth, IActionExecutionEnvironment actionEnv, int threadId)
        {
            if(depth <= 0)
                return false;

            bool result = false;

            foreach(IEdge edge in startNode.Incoming)
            {
                ++actionEnv.PerformanceInfo.SearchSteps;
                if(!edge.InstanceOf(incomingEdgeType))
                    continue;
                INode adjacentNode = edge.Source;
                if(!adjacentNode.InstanceOf(sourceNodeType))
                    continue;
                if(edge == endEdge)
                    return true;
                int nodeDepth;
                if(adjacentNodesToMinDepth.TryGetValue(adjacentNode, out nodeDepth) && nodeDepth >= depth - 1)
                    continue;
                adjacentNodesToMinDepth[adjacentNode] = depth - 1;
                result = IsBoundedReachableEdgesIncoming(adjacentNode, endEdge, depth - 1, incomingEdgeType, sourceNodeType, graph, adjacentNodesToMinDepth, actionEnv, threadId);
                if(result == true)
                    break;
            }

            return result;
        }
Beispiel #23
0
 /// <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).
 /// </summary>
 /// <param name="actionEnv">The action execution 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 filter to apply</param>
 public abstract void Filter(IActionExecutionEnvironment actionEnv, IList <IMatch> matches, FilterCallWithArguments filter);
 public static Dictionary<INode, SetValueType> Reachable(INode startNode, EdgeType incidentEdgeType, NodeType adjacentNodeType, IActionExecutionEnvironment actionEnv, int threadId)
 {
     Dictionary<INode, SetValueType> adjacentNodesSet = new Dictionary<INode, SetValueType>();
     Reachable(startNode, incidentEdgeType, adjacentNodeType, adjacentNodesSet, actionEnv, threadId);
     return adjacentNodesSet;
 }
 public static IEnumerable<IEdge> ReachableEdgesOutgoing(INode startNode, EdgeType incidentEdgeType, NodeType adjacentNodeType, IGraph graph, IActionExecutionEnvironment actionEnv, int threadId)
 {
     Dictionary<INode, SetValueType> visitedNodes = new Dictionary<INode, SetValueType>((int)Math.Sqrt(graph.NumNodes));
     visitedNodes.Add(startNode, null);
     foreach(IEdge edge in ReachableEdgesOutgoingRec(startNode, incidentEdgeType, adjacentNodeType, graph, visitedNodes, actionEnv, threadId))
         yield return edge;
 }
 /// <summary>
 /// Fills set of nodes reachable from the start node via outgoing edges, under the type constraints given, in a depth-first walk
 /// </summary>
 private static void ReachableOutgoing(INode startNode, EdgeType outgoingEdgeType, NodeType targetNodeType, IDictionary<INode, SetValueType> targetNodesSet, IActionExecutionEnvironment actionEnv, int threadId)
 {
     foreach(IEdge edge in startNode.Outgoing)
     {
         ++actionEnv.PerformanceInfo.SearchStepsPerThread[threadId];
         if(!edge.InstanceOf(outgoingEdgeType))
             continue;
         INode adjacentNode = edge.Target;
         if(!adjacentNode.InstanceOf(targetNodeType))
             continue;
         if(targetNodesSet.ContainsKey(adjacentNode))
             continue;
         targetNodesSet[adjacentNode] = null;
         ReachableOutgoing(adjacentNode, outgoingEdgeType, targetNodeType, targetNodesSet, actionEnv, threadId);
     }
 }
        private static IEnumerable<IEdge> ReachableEdgesOutgoingRec(INode startNode, EdgeType incidentEdgeType, NodeType adjacentNodeType, IGraph graph, Dictionary<INode, SetValueType> visitedNodes, IActionExecutionEnvironment actionEnv, int threadId)
        {
            foreach(IEdge edge in startNode.GetCompatibleOutgoing(incidentEdgeType))
            {
                ++actionEnv.PerformanceInfo.SearchStepsPerThread[threadId];
                INode adjacentNode = edge.Target;
                if(!adjacentNode.InstanceOf(adjacentNodeType))
                    continue;
                yield return edge;

                if(visitedNodes.ContainsKey(adjacentNode))
                    continue;
                visitedNodes.Add(adjacentNode, null);
                foreach(IEdge reachableEdge in ReachableEdgesOutgoingRec(adjacentNode, incidentEdgeType, adjacentNodeType, graph, visitedNodes, actionEnv, threadId))
                    yield return reachableEdge;
            }
        }
 public static int CountNodes(IGraph graph, NodeType nodeType, IActionExecutionEnvironment actionEnv, int threadId)
 {
     return graph.GetNumCompatibleNodes(nodeType);
 }
 private static IEnumerable<INode> BoundedReachableIncomingRec(INode startNode, int depth, EdgeType incidentEdgeType, NodeType adjacentNodeType, IGraph graph, Dictionary<INode, int> sourceNodesToMinDepth, IActionExecutionEnvironment actionEnv, int threadId)
 {
     if(depth <= 0)
         yield break;
     foreach(IEdge edge in startNode.GetCompatibleIncoming(incidentEdgeType))
     {
         ++actionEnv.PerformanceInfo.SearchStepsPerThread[threadId];
         INode adjacentNode = edge.Source;
         if(!adjacentNode.InstanceOf(adjacentNodeType))
             continue;
         int nodeDepth;
         if(!sourceNodesToMinDepth.TryGetValue(adjacentNode, out nodeDepth))
             yield return adjacentNode;
         if(sourceNodesToMinDepth.TryGetValue(adjacentNode, out nodeDepth) && nodeDepth >= depth - 1)
             continue;
         sourceNodesToMinDepth[adjacentNode] = depth - 1;
         foreach(INode node in BoundedReachableIncomingRec(adjacentNode, depth - 1, incidentEdgeType, adjacentNodeType, graph, sourceNodesToMinDepth, actionEnv, threadId))
             yield return node;
     }
 }
 public static int CountReachableIncoming(INode startNode, EdgeType incomingEdgeType, NodeType sourceNodeType, IActionExecutionEnvironment actionEnv, int threadId)
 {
     // todo: more performant implementation with internally visited used for marking and list for unmarking instead of hash set
     Dictionary<INode, SetValueType> sourceNodesSet = new Dictionary<INode, SetValueType>();
     ReachableIncoming(startNode, incomingEdgeType, sourceNodeType, sourceNodesSet, actionEnv, threadId);
     return sourceNodesSet.Count;
 }
 public static IEnumerable<INode> BoundedReachableOutgoing(INode startNode, int depth, EdgeType incidentEdgeType, NodeType adjacentNodeType, IGraph graph, IActionExecutionEnvironment actionEnv, int threadId)
 {
     Dictionary<INode, int> targetNodesToMinDepth = new Dictionary<INode, int>();
     foreach(INode node in BoundedReachableOutgoingRec(startNode, depth, incidentEdgeType, adjacentNodeType, graph, targetNodesToMinDepth, actionEnv, threadId))
         yield return node;
 }
 private static void ReachableEdges(INode startNode, EdgeType incidentEdgeType, NodeType adjacentNodeType, Dictionary<IEdge, SetValueType> incidentEdgesSet, IGraph graph, IActionExecutionEnvironment actionEnv, int threadId)
 {
     foreach(IEdge edge in startNode.Outgoing)
     {
         ++actionEnv.PerformanceInfo.SearchStepsPerThread[threadId];
         if(!edge.InstanceOf(incidentEdgeType))
             continue;
         INode adjacentNode = edge.Target;
         if(!adjacentNode.InstanceOf(adjacentNodeType))
             continue;
         incidentEdgesSet[edge] = null;
         if(graph.IsInternallyVisited(adjacentNode, threadId))
             continue;
         graph.SetInternallyVisited(adjacentNode, true, threadId);
         ReachableEdges(adjacentNode, incidentEdgeType, adjacentNodeType, incidentEdgesSet, graph, actionEnv, threadId);
     }
     foreach(IEdge edge in startNode.Incoming)
     {
         ++actionEnv.PerformanceInfo.SearchStepsPerThread[threadId];
         if(!edge.InstanceOf(incidentEdgeType))
             continue;
         INode adjacentNode = edge.Source;
         if(!adjacentNode.InstanceOf(adjacentNodeType))
             continue;
         incidentEdgesSet[edge] = null;
         if(graph.IsInternallyVisited(adjacentNode, threadId))
             continue;
         graph.SetInternallyVisited(adjacentNode, true, threadId);
         ReachableEdges(adjacentNode, incidentEdgeType, adjacentNodeType, incidentEdgesSet, graph, actionEnv, threadId);
     }
 }
 public static IEnumerable<IEdge> BoundedReachableEdgesOutgoing(INode startNode, int depth, EdgeType incidentEdgeType, NodeType adjacentNodeType, IGraph graph, IActionExecutionEnvironment actionEnv, int threadId)
 {
     Dictionary<IEdge, SetValueType> visitedEdges = new Dictionary<IEdge, SetValueType>();
     Dictionary<INode, int> targetNodesToMinDepth = new Dictionary<INode, int>();
     foreach(IEdge edge in BoundedReachableEdgesOutgoingRec(startNode, depth, incidentEdgeType, adjacentNodeType, graph, visitedEdges, targetNodesToMinDepth, actionEnv, threadId))
         yield return edge;
 }
Beispiel #34
0
 /// <summary>
 /// Executes the function method given by its name.
 /// Throws an exception if the method does not exists or the parameters are of wrong types.
 /// </summary>
 /// <param name="actionEnv">The current action execution environment.</param>
 /// <param name="graph">The current graph.</param>
 /// <param name="name">The name of the function method to apply.</param>
 /// <param name="arguments">An array with the arguments to the method.</param>
 /// <returns>The return value of function application.</returns>
 public abstract object ApplyFunctionMethod(IActionExecutionEnvironment actionEnv, IGraph graph, string name, object[] arguments);
 private static IEnumerable<IEdge> BoundedReachableEdgesOutgoingRec(INode startNode, int depth, EdgeType incidentEdgeType, NodeType adjacentNodeType, IGraph graph, Dictionary<IEdge, SetValueType> visitedEdges, Dictionary<INode, int> targetNodesToMinDepth, IActionExecutionEnvironment actionEnv, int threadId)
 {
     if(depth <= 0)
         yield break;
     foreach(IEdge edge in startNode.GetCompatibleOutgoing(incidentEdgeType))
     {
         ++actionEnv.PerformanceInfo.SearchStepsPerThread[threadId];
         INode adjacentNode = edge.Target;
         if(!adjacentNode.InstanceOf(adjacentNodeType))
             continue;
         if(!visitedEdges.ContainsKey(edge))
         {
             visitedEdges[edge] = null;
             yield return edge;
         }
         int nodeDepth;
         if(targetNodesToMinDepth.TryGetValue(adjacentNode, out nodeDepth) && nodeDepth >= depth - 1)
             continue;
         targetNodesToMinDepth[adjacentNode] = depth - 1;
         foreach(IEdge reachableEdge in BoundedReachableEdgesOutgoingRec(adjacentNode, depth - 1, incidentEdgeType, adjacentNodeType, graph, visitedEdges, targetNodesToMinDepth, actionEnv, threadId))
             yield return reachableEdge;
     }
 }
Beispiel #36
0
 public override object[] ApplyProcedureMethod(IActionExecutionEnvironment actionEnv, IGraph graph, string name, object[] arguments)
 {
     throw new Exception("The method or operation is not implemented.");
 }
 public static int CountAdjacentIncoming(IGraph graph, INode startNode, EdgeType incidentEdgeType, NodeType adjacentNodeType, IActionExecutionEnvironment actionEnv, int threadId)
 {
     int count = 0;
     foreach(IEdge edge in startNode.Incoming)
     {
         ++actionEnv.PerformanceInfo.SearchStepsPerThread[threadId];
         if(!edge.InstanceOf(incidentEdgeType))
             continue;
         INode adjacentNode = edge.Source;
         if(!adjacentNode.InstanceOf(adjacentNodeType))
             continue;
         if(graph.IsInternallyVisited(adjacentNode, threadId))
             continue;
         graph.SetInternallyVisited(adjacentNode, true, threadId);
         ++count;
     }
     foreach(IEdge edge in startNode.GetCompatibleIncoming(incidentEdgeType))
     {
         INode adjacentNode = edge.Source;
         if(!adjacentNode.InstanceOf(adjacentNodeType))
             continue;
         graph.SetInternallyVisited(adjacentNode, false, threadId);
     }
     return count;
 }
Beispiel #38
0
 /// <summary>
 /// Applies this procedure with the given action environment on the given graph.
 /// Takes the parameters from paramBindings as inputs.
 /// Returns an array of output values.
 /// Attention: at the next call of Apply, the array returned from previous call is overwritten with the new return values.
 /// </summary>
 public abstract object[] Apply(IActionExecutionEnvironment actionEnv, IGraph graph, ProcedureInvocationParameterBindings paramBindings);
Beispiel #39
0
 /// <summary>
 /// Applies this function with the given action environment on the given graph.
 /// Takes the parameters from paramBindings as inputs.
 /// Returns the one output value.
 /// </summary>
 public abstract object Apply(IActionExecutionEnvironment actionEnv, IGraph graph, FunctionInvocationParameterBindings paramBindings);