Ejemplo n.º 1
0
 protected override bool ApplyImpl(IGraphProcessingEnvironment procEnv)
 {
     long i = 0;
     while(Seq.Apply(procEnv))
     {
         procEnv.EndOfIteration(true, this);
         Seq.ResetExecutionState();
         i++;
     }
     procEnv.EndOfIteration(false, this);
     return i >= Min;
 }
Ejemplo n.º 2
0
 protected override bool ApplyImpl(IGraphProcessingEnvironment procEnv)
 {
     long i;
     bool first = true;
     for(i = 0; i < Max; i++)
     {
         if(!first) procEnv.EndOfIteration(true, this);
         Seq.ResetExecutionState();
         if(!Seq.Apply(procEnv)) break;
         first = false;
     }
     procEnv.EndOfIteration(false, this);
     return i >= Min;
 }
Ejemplo n.º 3
0
        protected override bool ApplyImpl(IGraphProcessingEnvironment procEnv)
        {
            bool res = true;

            // first get all matches of the rule
            object[] parameters;
            if(Rule.ParamBindings.ArgumentExpressions.Length > 0)
            {
                parameters = Rule.ParamBindings.Arguments;
                for(int j = 0; j < Rule.ParamBindings.ArgumentExpressions.Length; j++)
                {
                    if(Rule.ParamBindings.ArgumentExpressions[j] != null)
                        parameters[j] = Rule.ParamBindings.ArgumentExpressions[j].Evaluate(procEnv);
                }
            }
            else parameters = null;

#if LOG_SEQUENCE_EXECUTION
            procEnv.Recorder.WriteLine("Matching for rule " + Rule.GetRuleCallString(procEnv));
#endif

#if DEBUGACTIONS || MATCHREWRITEDETAIL
            procEnv.PerformanceInfo.StartLocal();
#endif
            IMatches matches = Rule.ParamBindings.Action.Match(procEnv, procEnv.MaxMatches, parameters);
            for(int i=0; i<Rule.Filters.Count; ++i)
                Rule.ParamBindings.Action.Filter(procEnv, matches, Rule.Filters[i]);
#if DEBUGACTIONS || MATCHREWRITEDETAIL
            procEnv.PerformanceInfo.StopMatch(); // total match time does NOT include listeners anymore
#endif
            procEnv.PerformanceInfo.MatchesFound += matches.Count;

            if(matches.Count == 0)
            {
                procEnv.EndOfIteration(false, this);
                Rule.executionState = SequenceExecutionState.Fail;
                return res;
            }

#if LOG_SEQUENCE_EXECUTION
            procEnv.Recorder.WriteLine("Rule " + Rule.GetRuleCallString(procEnv) + " matched " + matches.Count + " times");
#endif

            // the rule might be called again in the sequence, overwriting the matches object of the action
            // normally it's safe to assume the rule is not called again until its matches were processed,
            // allowing for the one matches object memory optimization, but here we must clone to prevent bad side effect
            // TODO: optimization; if it's ensured the sequence doesn't call this action again, we can omit this, requires call analysis
            matches = matches.Clone();

            // apply the sequence for every match found
            bool first = true;
            foreach(IMatch match in matches)
            {
                if(!first) procEnv.EndOfIteration(true, this);
                Var.SetVariableValue(match, procEnv);
#if LOG_SEQUENCE_EXECUTION
                procEnv.Recorder.WriteLine("Iterating match: " + MatchPrinter.ToString(match, procEnv.Graph, ""));
#endif

                procEnv.EnteringSequence(Rule);
                Rule.executionState = SequenceExecutionState.Underway;
                procEnv.Matched(matches, match, Rule.Special);
                Rule.executionState = SequenceExecutionState.Success;
                procEnv.ExitingSequence(Rule);

                // rule matching simulated so it can be shown in the debugger, now execute the sequence
                Seq.ResetExecutionState();
                res &= Seq.Apply(procEnv);
                first = false;
            }
            procEnv.EndOfIteration(false, this);
            return res;
        }
Ejemplo n.º 4
0
        public override bool Apply(SequenceInvocationParameterBindings sequenceInvocation,
            IGraphProcessingEnvironment procEnv)
        {
            // If this sequence definition is currently executed
            // we must copy it and use the copy in its place
            // to prevent state corruption.
            if(executionState == SequenceExecutionState.Underway)
            {
                return ApplyCopy(sequenceInvocation, procEnv);
            }

            procEnv.EnteringSequence(this);
            executionState = SequenceExecutionState.Underway;
#if LOG_SEQUENCE_EXECUTION
            procEnv.Recorder.WriteLine("Before executing sequence definition " + Id + ": " + Symbol);
#endif
            bool res = ApplyImpl(sequenceInvocation, procEnv);
#if LOG_SEQUENCE_EXECUTION
            procEnv.Recorder.WriteLine("After executing sequence definition " + Id + ": " + Symbol + " result " + res);
#endif
            executionState = res ? SequenceExecutionState.Success : SequenceExecutionState.Fail;

            procEnv.EndOfIteration(false, this);

            procEnv.ExitingSequence(this);

            ResetExecutionState(); // state is shown by call, we don't exist any more for the debugger

            return res;
        }
Ejemplo n.º 5
0
        protected bool ApplyImplProfiling(IGraphProcessingEnvironment procEnv)
        {
            bool res = true;

            INode node = (INode)ArgExprs[0].Evaluate(procEnv);
            int depth = -1;
            EdgeType edgeType;
            NodeType nodeType;

            if(SequenceType == SequenceType.ForBoundedReachableNodes
                || SequenceType == SequenceType.ForBoundedReachableNodesViaIncoming
                || SequenceType == SequenceType.ForBoundedReachableNodesViaOutgoing
                || SequenceType == SequenceType.ForBoundedReachableEdges
                || SequenceType == SequenceType.ForBoundedReachableEdgesViaIncoming
                || SequenceType == SequenceType.ForBoundedReachableEdgesViaOutgoing)
            {
                depth = (int)ArgExprs[1].Evaluate(procEnv);
                edgeType = GetEdgeType(procEnv, ArgExprs.Count >= 3 ? ArgExprs[2] : null);
                nodeType = GetNodeType(procEnv, ArgExprs.Count >= 4 ? ArgExprs[3] : null);
            }
            else
            {
                edgeType = GetEdgeType(procEnv, ArgExprs.Count >= 2 ? ArgExprs[1] : null);
                nodeType = GetNodeType(procEnv, ArgExprs.Count >= 3 ? ArgExprs[2] : null);
            }

            switch(SequenceType)
            {
                case SequenceType.ForAdjacentNodes:
                {
                    bool first = true;
                    foreach(IEdge edge in node.Incident)
                    {
                        ++procEnv.PerformanceInfo.SearchSteps;
                        if(!edge.InstanceOf(edgeType))
                            continue;
                        if(!edge.Opposite(node).InstanceOf(nodeType))
                            continue;

                        if(!first) procEnv.EndOfIteration(true, this);
                        Var.SetVariableValue(edge.Opposite(node), procEnv);
                        Seq.ResetExecutionState();
                        res &= Seq.Apply(procEnv);
                        first = false;
                    }
                    break;
                }
                case SequenceType.ForAdjacentNodesViaIncoming:
                {
                    bool first = true;
                    foreach(IEdge edge in node.Incoming)
                    {
                        ++procEnv.PerformanceInfo.SearchSteps;
                        if(!edge.InstanceOf(edgeType))
                            continue;
                        if(!edge.Source.InstanceOf(nodeType))
                            continue;

                        if(!first) procEnv.EndOfIteration(true, this);
                        Var.SetVariableValue(edge.Source, procEnv);
                        Seq.ResetExecutionState();
                        res &= Seq.Apply(procEnv);
                        first = false;
                    }
                    break;
                }
                case SequenceType.ForAdjacentNodesViaOutgoing:
                {
                    bool first = true;
                    foreach(IEdge edge in node.Outgoing)
                    {
                        ++procEnv.PerformanceInfo.SearchSteps;
                        if(!edge.InstanceOf(edgeType))
                            continue;
                        if(!edge.Target.InstanceOf(nodeType))
                            continue;

                        if(!first) procEnv.EndOfIteration(true, this);
                        Var.SetVariableValue(edge.Target, procEnv);
                        Seq.ResetExecutionState();
                        res &= Seq.Apply(procEnv);
                        first = false;
                    }
                    break;
                }
                case SequenceType.ForIncidentEdges:
                {
                    bool first = true;
                    foreach(IEdge edge in node.Incident)
                    {
                        ++procEnv.PerformanceInfo.SearchSteps;
                        if(!edge.InstanceOf(edgeType))
                            continue;
                        if(!edge.Opposite(node).InstanceOf(nodeType))
                            continue;

                        if(!first) procEnv.EndOfIteration(true, this);
                        Var.SetVariableValue(edge, procEnv);
                        Seq.ResetExecutionState();
                        res &= Seq.Apply(procEnv);
                        first = false;
                    }
                    break;
                }
                case SequenceType.ForIncomingEdges:
                {
                    bool first = true;
                    foreach(IEdge edge in node.Incoming)
                    {
                        ++procEnv.PerformanceInfo.SearchSteps;
                        if(!edge.InstanceOf(edgeType))
                            continue;
                        if(!edge.Source.InstanceOf(nodeType))
                            continue;

                        if(!first) procEnv.EndOfIteration(true, this);
                        Var.SetVariableValue(edge, procEnv);
                        Seq.ResetExecutionState();
                        res &= Seq.Apply(procEnv);
                        first = false;
                    }
                    break;
                }
                case SequenceType.ForOutgoingEdges:
                {
                    bool first = true;
                    foreach(IEdge edge in node.Outgoing)
                    {
                        ++procEnv.PerformanceInfo.SearchSteps;
                        if(!edge.InstanceOf(edgeType))
                            continue;
                        if(!edge.Target.InstanceOf(nodeType))
                            continue;

                        if(!first) procEnv.EndOfIteration(true, this);
                        Var.SetVariableValue(edge, procEnv);
                        Seq.ResetExecutionState();
                        res &= Seq.Apply(procEnv);
                        first = false;
                    }
                    break;
                }
                case SequenceType.ForReachableNodes:
                {
                    bool first = true;
                    foreach(INode iter in GraphHelper.Reachable(node, edgeType, nodeType, procEnv.Graph, procEnv))
                    {
                        if(!first) procEnv.EndOfIteration(true, this);
                        Var.SetVariableValue(iter, procEnv);
                        Seq.ResetExecutionState();
                        res &= Seq.Apply(procEnv);
                        first = false;
                    }
                    break;
                }
                case SequenceType.ForReachableNodesViaIncoming:
                {
                    bool first = true;
                    foreach(INode iter in GraphHelper.ReachableIncoming(node, edgeType, nodeType, procEnv.Graph, procEnv))
                    {
                        if(!first) procEnv.EndOfIteration(true, this);
                        Var.SetVariableValue(iter, procEnv);
                        Seq.ResetExecutionState();
                        res &= Seq.Apply(procEnv);
                        first = false;
                    }
                    break;
                }
                case SequenceType.ForReachableNodesViaOutgoing:
                {
                    bool first = true;
                    foreach(INode iter in GraphHelper.ReachableOutgoing(node, edgeType, nodeType, procEnv.Graph, procEnv))
                    {
                        if(!first) procEnv.EndOfIteration(true, this);
                        Var.SetVariableValue(iter, procEnv);
                        Seq.ResetExecutionState();
                        res &= Seq.Apply(procEnv);
                        first = false;
                    }
                    break;
                }
                case SequenceType.ForReachableEdges:
                {
                    bool first = true;
                    foreach(IEdge edge in GraphHelper.ReachableEdges(node, edgeType, nodeType, procEnv.Graph, procEnv))
                    {
                        if(!first) procEnv.EndOfIteration(true, this);
                        Var.SetVariableValue(edge, procEnv);
                        Seq.ResetExecutionState();
                        res &= Seq.Apply(procEnv);
                        first = false;
                    }
                    break;
                }
                case SequenceType.ForReachableEdgesViaIncoming:
                {
                    bool first = true;
                    foreach(IEdge edge in GraphHelper.ReachableEdgesIncoming(node, edgeType, nodeType, procEnv.Graph, procEnv))
                    {
                        if(!first) procEnv.EndOfIteration(true, this);
                        Var.SetVariableValue(edge, procEnv);
                        Seq.ResetExecutionState();
                        res &= Seq.Apply(procEnv);
                        first = false;
                    }
                    break;
                }
                case SequenceType.ForReachableEdgesViaOutgoing:
                {
                    bool first = true;
                    foreach(IEdge edge in GraphHelper.ReachableEdgesOutgoing(node, edgeType, nodeType, procEnv.Graph, procEnv))
                    {
                        if(!first) procEnv.EndOfIteration(true, this);
                        Var.SetVariableValue(edge, procEnv);
                        Seq.ResetExecutionState();
                        res &= Seq.Apply(procEnv);
                        first = false;
                    }
                    break;
                }
                case SequenceType.ForBoundedReachableNodes:
                {
                    bool first = true;
                    foreach(INode iter in GraphHelper.BoundedReachable(node, depth, edgeType, nodeType, procEnv.Graph, procEnv))
                    {
                        if(!first) procEnv.EndOfIteration(true, this);
                        Var.SetVariableValue(iter, procEnv);
                        Seq.ResetExecutionState();
                        res &= Seq.Apply(procEnv);
                        first = false;
                    }
                    break;
                }
                case SequenceType.ForBoundedReachableNodesViaIncoming:
                {
                    bool first = true;
                    foreach(INode iter in GraphHelper.BoundedReachableIncoming(node, depth, edgeType, nodeType, procEnv.Graph, procEnv))
                    {
                        if(!first) procEnv.EndOfIteration(true, this);
                        Var.SetVariableValue(iter, procEnv);
                        Seq.ResetExecutionState();
                        res &= Seq.Apply(procEnv);
                        first = false;
                    }
                    break;
                }
                case SequenceType.ForBoundedReachableNodesViaOutgoing:
                {
                    bool first = true;
                    foreach(INode iter in GraphHelper.BoundedReachableOutgoing(node, depth, edgeType, nodeType, procEnv.Graph, procEnv))
                    {
                        if(!first) procEnv.EndOfIteration(true, this);
                        Var.SetVariableValue(iter, procEnv);
                        Seq.ResetExecutionState();
                        res &= Seq.Apply(procEnv);
                        first = false;
                    }
                    break;
                }
                case SequenceType.ForBoundedReachableEdges:
                {
                    bool first = true;
                    foreach(IEdge edge in GraphHelper.BoundedReachableEdges(node, depth, edgeType, nodeType, procEnv.Graph, procEnv))
                    {
                        if(!first) procEnv.EndOfIteration(true, this);
                        Var.SetVariableValue(edge, procEnv);
                        Seq.ResetExecutionState();
                        res &= Seq.Apply(procEnv);
                        first = false;
                    }
                    break;
                }
                case SequenceType.ForBoundedReachableEdgesViaIncoming:
                {
                    bool first = true;
                    foreach(IEdge edge in GraphHelper.BoundedReachableEdgesIncoming(node, depth, edgeType, nodeType, procEnv.Graph, procEnv))
                    {
                        if(!first) procEnv.EndOfIteration(true, this);
                        Var.SetVariableValue(edge, procEnv);
                        Seq.ResetExecutionState();
                        res &= Seq.Apply(procEnv);
                        first = false;
                    }
                    break;
                }
                case SequenceType.ForBoundedReachableEdgesViaOutgoing:
                {
                    bool first = true;
                    foreach(IEdge edge in GraphHelper.BoundedReachableEdgesOutgoing(node, depth, edgeType, nodeType, procEnv.Graph, procEnv))
                    {
                        if(!first) procEnv.EndOfIteration(true, this);
                        Var.SetVariableValue(edge, procEnv);
                        Seq.ResetExecutionState();
                        res &= Seq.Apply(procEnv);
                        first = false;
                    }
                    break;
                }
            }

            procEnv.EndOfIteration(false, this);
            return res;
        }
Ejemplo n.º 6
0
        protected bool ApplyImplNodesEdgesProfiling(IGraphProcessingEnvironment procEnv)
        {
            bool res = true;

            switch(SequenceType)
            {
                case SequenceType.ForNodes:
                {
                    NodeType nodeType = GetNodeType(procEnv, ArgExprs.Count >= 1 ? ArgExprs[0] : null);
                    bool first = true;
                    foreach(INode node in procEnv.Graph.GetCompatibleNodes(nodeType))
                    {
                        ++procEnv.PerformanceInfo.SearchSteps;
                        if(!first) procEnv.EndOfIteration(true, this);
                        Var.SetVariableValue(node, procEnv);
                        Seq.ResetExecutionState();
                        res &= Seq.Apply(procEnv);
                        first = false;
                    }
                    break;
                }
                case SequenceType.ForEdges:
                {
                    EdgeType edgeType = GetEdgeType(procEnv, ArgExprs.Count >= 1 ? ArgExprs[0] : null);
                    bool first = true;
                    foreach(IEdge edge in procEnv.Graph.GetCompatibleEdges(edgeType))
                    {
                        ++procEnv.PerformanceInfo.SearchSteps;
                        if(!first) procEnv.EndOfIteration(true, this);
                        Var.SetVariableValue(edge, procEnv);
                        Seq.ResetExecutionState();
                        res &= Seq.Apply(procEnv);
                        first = false;
                    }
                    break;
                }
            }

            procEnv.EndOfIteration(false, this);
            return res;
        }
Ejemplo n.º 7
0
 protected override bool ApplyImpl(IGraphProcessingEnvironment procEnv)
 {
     bool res = true;
     IAttributeIndex index = (IAttributeIndex)procEnv.Graph.Indices.GetIndex(IndexName);
     if(Ascending)
     {
         if(From() != null && To() != null)
         {
             if(IncludingFrom())
             {
                 if(IncludingTo())
                 {
                     bool first = true;
                     foreach(IGraphElement elem in index.LookupElementsAscendingFromInclusiveToInclusive(From().Evaluate(procEnv), To().Evaluate(procEnv)))
                     {
                         if(EmitProfiling)
                             ++procEnv.PerformanceInfo.SearchSteps;
                         if(!first) procEnv.EndOfIteration(true, this);
                         Var.SetVariableValue(elem, procEnv);
                         Seq.ResetExecutionState();
                         res &= Seq.Apply(procEnv);
                         first = false;
                     }
                     procEnv.EndOfIteration(false, this);
                 }
                 else
                 {
                     bool first = true;
                     foreach(IGraphElement elem in index.LookupElementsAscendingFromInclusiveToExclusive(From().Evaluate(procEnv), To().Evaluate(procEnv)))
                     {
                         if(EmitProfiling)
                             ++procEnv.PerformanceInfo.SearchSteps;
                         if(!first) procEnv.EndOfIteration(true, this);
                         Var.SetVariableValue(elem, procEnv);
                         Seq.ResetExecutionState();
                         res &= Seq.Apply(procEnv);
                         first = false;
                     }
                     procEnv.EndOfIteration(false, this);
                 }
             }
             else
             {
                 if(IncludingTo())
                 {
                     bool first = true;
                     foreach(IGraphElement elem in index.LookupElementsAscendingFromExclusiveToInclusive(From().Evaluate(procEnv), To().Evaluate(procEnv)))
                     {
                         if(EmitProfiling)
                             ++procEnv.PerformanceInfo.SearchSteps;
                         if(!first) procEnv.EndOfIteration(true, this);
                         Var.SetVariableValue(elem, procEnv);
                         Seq.ResetExecutionState();
                         res &= Seq.Apply(procEnv);
                         first = false;
                     }
                     procEnv.EndOfIteration(false, this);
                 }
                 else
                 {
                     bool first = true;
                     foreach(IGraphElement elem in index.LookupElementsAscendingFromExclusiveToExclusive(From().Evaluate(procEnv), To().Evaluate(procEnv)))
                     {
                         if(EmitProfiling)
                             ++procEnv.PerformanceInfo.SearchSteps;
                         if(!first) procEnv.EndOfIteration(true, this);
                         Var.SetVariableValue(elem, procEnv);
                         Seq.ResetExecutionState();
                         res &= Seq.Apply(procEnv);
                         first = false;
                     }
                     procEnv.EndOfIteration(false, this);
                 }
             }
         }
         else if(From() != null)
         {
             if(IncludingFrom())
             {
                 bool first = true;
                 foreach(IGraphElement elem in index.LookupElementsAscendingFromInclusive(From().Evaluate(procEnv)))
                 {
                     if(EmitProfiling)
                         ++procEnv.PerformanceInfo.SearchSteps;
                     if(!first) procEnv.EndOfIteration(true, this);
                     Var.SetVariableValue(elem, procEnv);
                     Seq.ResetExecutionState();
                     res &= Seq.Apply(procEnv);
                     first = false;
                 }
                 procEnv.EndOfIteration(false, this);
             }
             else
             {
                 bool first = true;
                 foreach(IGraphElement elem in index.LookupElementsAscendingFromExclusive(From().Evaluate(procEnv)))
                 {
                     if(EmitProfiling)
                         ++procEnv.PerformanceInfo.SearchSteps;
                     if(!first) procEnv.EndOfIteration(true, this);
                     Var.SetVariableValue(elem, procEnv);
                     Seq.ResetExecutionState();
                     res &= Seq.Apply(procEnv);
                     first = false;
                 }
                 procEnv.EndOfIteration(false, this);
             }
         }
         else if(To() != null)
         {
             if(IncludingTo())
             {
                 bool first = true;
                 foreach(IGraphElement elem in index.LookupElementsAscendingToInclusive(To().Evaluate(procEnv)))
                 {
                     if(EmitProfiling)
                         ++procEnv.PerformanceInfo.SearchSteps;
                     if(!first) procEnv.EndOfIteration(true, this);
                     Var.SetVariableValue(elem, procEnv);
                     Seq.ResetExecutionState();
                     res &= Seq.Apply(procEnv);
                     first = false;
                 }
                 procEnv.EndOfIteration(false, this);
             }
             else
             {
                 bool first = true;
                 foreach(IGraphElement elem in index.LookupElementsAscendingToExclusive(To().Evaluate(procEnv)))
                 {
                     if(EmitProfiling)
                         ++procEnv.PerformanceInfo.SearchSteps;
                     if(!first) procEnv.EndOfIteration(true, this);
                     Var.SetVariableValue(elem, procEnv);
                     Seq.ResetExecutionState();
                     res &= Seq.Apply(procEnv);
                     first = false;
                 }
                 procEnv.EndOfIteration(false, this);
             }
         }
         else
         {
             bool first = true;
             foreach(IGraphElement elem in index.LookupElementsAscending())
             {
                 if(EmitProfiling)
                     ++procEnv.PerformanceInfo.SearchSteps;
                 if(!first) procEnv.EndOfIteration(true, this);
                 Var.SetVariableValue(elem, procEnv);
                 Seq.ResetExecutionState();
                 res &= Seq.Apply(procEnv);
                 first = false;
             }
             procEnv.EndOfIteration(false, this);
         }
     }
     else
     {
         if(From() != null && To() != null)
         {
             if(IncludingFrom())
             {
                 if(IncludingTo())
                 {
                     bool first = true;
                     foreach(IGraphElement elem in index.LookupElementsDescendingFromInclusiveToInclusive(From().Evaluate(procEnv), To().Evaluate(procEnv)))
                     {
                         if(EmitProfiling)
                             ++procEnv.PerformanceInfo.SearchSteps;
                         if(!first) procEnv.EndOfIteration(true, this);
                         Var.SetVariableValue(elem, procEnv);
                         Seq.ResetExecutionState();
                         res &= Seq.Apply(procEnv);
                         first = false;
                     }
                     procEnv.EndOfIteration(false, this);
                 }
                 else
                 {
                     bool first = true;
                     foreach(IGraphElement elem in index.LookupElementsDescendingFromInclusiveToExclusive(From().Evaluate(procEnv), To().Evaluate(procEnv)))
                     {
                         if(EmitProfiling)
                             ++procEnv.PerformanceInfo.SearchSteps;
                         if(!first) procEnv.EndOfIteration(true, this);
                         Var.SetVariableValue(elem, procEnv);
                         Seq.ResetExecutionState();
                         res &= Seq.Apply(procEnv);
                         first = false;
                     }
                     procEnv.EndOfIteration(false, this);
                 }
             }
             else
             {
                 if(IncludingTo())
                 {
                     bool first = true;
                     foreach(IGraphElement elem in index.LookupElementsDescendingFromExclusiveToInclusive(From().Evaluate(procEnv), To().Evaluate(procEnv)))
                     {
                         if(EmitProfiling)
                             ++procEnv.PerformanceInfo.SearchSteps;
                         if(!first) procEnv.EndOfIteration(true, this);
                         Var.SetVariableValue(elem, procEnv);
                         Seq.ResetExecutionState();
                         res &= Seq.Apply(procEnv);
                         first = false;
                     }
                     procEnv.EndOfIteration(false, this);
                 }
                 else
                 {
                     bool first = true;
                     foreach(IGraphElement elem in index.LookupElementsDescendingFromExclusiveToExclusive(From().Evaluate(procEnv), To().Evaluate(procEnv)))
                     {
                         if(EmitProfiling)
                             ++procEnv.PerformanceInfo.SearchSteps;
                         if(!first) procEnv.EndOfIteration(true, this);
                         Var.SetVariableValue(elem, procEnv);
                         Seq.ResetExecutionState();
                         res &= Seq.Apply(procEnv);
                         first = false;
                     }
                     procEnv.EndOfIteration(false, this);
                 }
             }
         }
         else if(From() != null)
         {
             if(IncludingFrom())
             {
                 bool first = true;
                 foreach(IGraphElement elem in index.LookupElementsDescendingFromInclusive(From().Evaluate(procEnv)))
                 {
                     if(EmitProfiling)
                         ++procEnv.PerformanceInfo.SearchSteps;
                     if(!first) procEnv.EndOfIteration(true, this);
                     Var.SetVariableValue(elem, procEnv);
                     Seq.ResetExecutionState();
                     res &= Seq.Apply(procEnv);
                     first = false;
                 }
                 procEnv.EndOfIteration(false, this);
             }
             else
             {
                 bool first = true;
                 foreach(IGraphElement elem in index.LookupElementsDescendingFromExclusive(From().Evaluate(procEnv)))
                 {
                     if(EmitProfiling)
                         ++procEnv.PerformanceInfo.SearchSteps;
                     if(!first) procEnv.EndOfIteration(true, this);
                     Var.SetVariableValue(elem, procEnv);
                     Seq.ResetExecutionState();
                     res &= Seq.Apply(procEnv);
                     first = false;
                 }
                 procEnv.EndOfIteration(false, this);
             }
         }
         else if(To() != null)
         {
             if(IncludingTo())
             {
                 bool first = true;
                 foreach(IGraphElement elem in index.LookupElementsDescendingToInclusive(To().Evaluate(procEnv)))
                 {
                     if(EmitProfiling)
                         ++procEnv.PerformanceInfo.SearchSteps;
                     if(!first) procEnv.EndOfIteration(true, this);
                     Var.SetVariableValue(elem, procEnv);
                     Seq.ResetExecutionState();
                     res &= Seq.Apply(procEnv);
                     first = false;
                 }
                 procEnv.EndOfIteration(false, this);
             }
             else
             {
                 bool first = true;
                 foreach(IGraphElement elem in index.LookupElementsDescendingToExclusive(To().Evaluate(procEnv)))
                 {
                     if(EmitProfiling)
                         ++procEnv.PerformanceInfo.SearchSteps;
                     if(!first) procEnv.EndOfIteration(true, this);
                     Var.SetVariableValue(elem, procEnv);
                     Seq.ResetExecutionState();
                     res &= Seq.Apply(procEnv);
                     first = false;
                 }
                 procEnv.EndOfIteration(false, this);
             }
         }
         else
         {
             bool first = true;
             foreach(IGraphElement elem in index.LookupElementsDescending())
             {
                 if(EmitProfiling)
                     ++procEnv.PerformanceInfo.SearchSteps;
                 if(!first) procEnv.EndOfIteration(true, this);
                 Var.SetVariableValue(elem, procEnv);
                 Seq.ResetExecutionState();
                 res &= Seq.Apply(procEnv);
                 first = false;
             }
             procEnv.EndOfIteration(false, this);
         }
     }
     return res;
 }
Ejemplo n.º 8
0
 protected override bool ApplyImpl(IGraphProcessingEnvironment procEnv)
 {
     bool res = true;
     IAttributeIndex index = (IAttributeIndex)procEnv.Graph.Indices.GetIndex(IndexName);
     bool first = true;
     foreach(IGraphElement elem in index.LookupElements(Expr.Evaluate(procEnv)))
     {
         if(EmitProfiling)
             ++procEnv.PerformanceInfo.SearchSteps;
         if(!first) procEnv.EndOfIteration(true, this);
         Var.SetVariableValue(elem, procEnv);
         Seq.ResetExecutionState();
         res &= Seq.Apply(procEnv);
         first = false;
     }
     procEnv.EndOfIteration(false, this);
     return res;
 }
Ejemplo n.º 9
0
        protected override bool ApplyImpl(IGraphProcessingEnvironment procEnv)
        {
            bool res = true;

            int entry = (int)Left.Evaluate(procEnv);
            int limit = (int)Right.Evaluate(procEnv);
            bool ascending = entry <= limit;

            bool first = true;
            while(ascending ? entry <= limit : entry >= limit)
            {
                if(!first) procEnv.EndOfIteration(true, this);
                Var.SetVariableValue(entry, procEnv);
                Seq.ResetExecutionState();
                res &= Seq.Apply(procEnv);
                if(ascending) ++entry; else --entry;;
                first = false;
            }
            procEnv.EndOfIteration(false, this);

            return res;
        }
Ejemplo n.º 10
0
 protected override bool ApplyImpl(IGraphProcessingEnvironment procEnv)
 {
     bool res = true;
     if(Container.GetVariableValue(procEnv) is IList)
     {
         IList array = (IList)Container.GetVariableValue(procEnv);
         bool first = true;
         for(int i = 0; i < array.Count; ++i)
         {
             if(!first) procEnv.EndOfIteration(true, this);
             if(VarDst != null)
             {
                 Var.SetVariableValue(i, procEnv);
                 VarDst.SetVariableValue(array[i], procEnv);
             }
             else
             {
                 Var.SetVariableValue(array[i], procEnv);
             }
             Seq.ResetExecutionState();
             res &= Seq.Apply(procEnv);
             first = false;
         }
         procEnv.EndOfIteration(false, this);
     }
     else if(Container.GetVariableValue(procEnv) is IDeque)
     {
         IDeque deque = (IDeque)Container.GetVariableValue(procEnv);
         bool first = true;
         for(int i = 0; i < deque.Count; ++i)
         {
             if(!first) procEnv.EndOfIteration(true, this);
             if(VarDst != null)
             {
                 Var.SetVariableValue(i, procEnv);
                 VarDst.SetVariableValue(deque[i], procEnv);
             }
             else
             {
                 Var.SetVariableValue(deque[i], procEnv);
             }
             Seq.ResetExecutionState();
             res &= Seq.Apply(procEnv);
             first = false;
         }
         procEnv.EndOfIteration(false, this);
     }
     else
     {
         IDictionary setmap = (IDictionary)Container.GetVariableValue(procEnv);
         bool first = true;
         foreach(DictionaryEntry entry in setmap)
         {
             if(!first) procEnv.EndOfIteration(true, this);
             Var.SetVariableValue(entry.Key, procEnv);
             if(VarDst != null)
                 VarDst.SetVariableValue(entry.Value, procEnv);
             Seq.ResetExecutionState();
             res &= Seq.Apply(procEnv);
             first = false;
         }
         procEnv.EndOfIteration(false, this);
     }
     return res;
 }
Ejemplo n.º 11
0
        protected override bool ApplyImpl(IGraphProcessingEnvironment procEnv)
        {
            // first get all matches of the rule
            object[] parameters;
            if(Rule.ParamBindings.ArgumentExpressions.Length > 0)
            {
                parameters = Rule.ParamBindings.Arguments;
                for(int j = 0; j < Rule.ParamBindings.ArgumentExpressions.Length; j++)
                {
                    if(Rule.ParamBindings.ArgumentExpressions[j] != null)
                        parameters[j] = Rule.ParamBindings.ArgumentExpressions[j].Evaluate(procEnv);
                }
            }
            else parameters = null;

#if LOG_SEQUENCE_EXECUTION
            procEnv.Recorder.WriteLine("Matching backtrack all " + Rule.GetRuleCallString(procEnv));
#endif

#if DEBUGACTIONS || MATCHREWRITEDETAIL
            procEnv.PerformanceInfo.StartLocal();
#endif
            IMatches matches = Rule.ParamBindings.Action.Match(procEnv, procEnv.MaxMatches, parameters);
            for(int i=0; i<Rule.Filters.Count; ++i)
                Rule.ParamBindings.Action.Filter(procEnv, matches, Rule.Filters[i]);

#if DEBUGACTIONS || MATCHREWRITEDETAIL
            procEnv.PerformanceInfo.StopMatch(); // total match time does NOT include listeners anymore
#endif
            procEnv.PerformanceInfo.MatchesFound += matches.Count;

            if(matches.Count == 0)
            {
                Rule.executionState = SequenceExecutionState.Fail;
                return false;
            }

#if LOG_SEQUENCE_EXECUTION
            for(int i = 0; i < matches.Count; ++i)
            {
                procEnv.Recorder.WriteLine("match " + i + ": " + MatchPrinter.ToString(matches.GetMatch(i), procEnv.Graph, ""));
            }
#endif

            // the rule might be called again in the sequence, overwriting the matches object of the action
            // normally it's safe to assume the rule is not called again until its matches were processed,
            // allowing for the one matches object memory optimization, but here we must clone to prevent bad side effect
            // TODO: optimization; if it's ensured the sequence doesn't call this action again, we can omit this, requires call analysis
            matches = matches.Clone();

#if LOG_SEQUENCE_EXECUTION
            for(int i = 0; i < matches.Count; ++i)
            {
                procEnv.Recorder.WriteLine("cloned match " + i + ": " + MatchPrinter.ToString(matches.GetMatch(i), procEnv.Graph, ""));
            }
#endif

            // apply the rule and the following sequence for every match found,
            // until the first rule and sequence execution succeeded
            // rolling back the changes of failing executions until then
            int matchesTried = 0;
            foreach(IMatch match in matches)
            {
                ++matchesTried;
#if LOG_SEQUENCE_EXECUTION
                procEnv.Recorder.WriteLine("Applying backtrack match " + matchesTried + "/" + matches.Count + " of " + Rule.GetRuleCallString(procEnv));
                procEnv.Recorder.WriteLine("match: " + MatchPrinter.ToString(match, procEnv.Graph, ""));
#endif

                // start a transaction
                int transactionID = procEnv.TransactionManager.Start();
                int oldRewritesPerformed = procEnv.PerformanceInfo.RewritesPerformed;

                procEnv.EnteringSequence(Rule);
                Rule.executionState = SequenceExecutionState.Underway;
#if LOG_SEQUENCE_EXECUTION
                procEnv.Recorder.WriteLine("Before executing sequence " + Rule.Id + ": " + Rule.Symbol);
#endif
                procEnv.Matched(matches, match, Rule.Special);
                bool result = Rule.Rewrite(procEnv, matches, match);
#if LOG_SEQUENCE_EXECUTION
                procEnv.Recorder.WriteLine("After executing sequence " + Rule.Id + ": " + Rule.Symbol + " result " + result);
#endif
                Rule.executionState = result ? SequenceExecutionState.Success : SequenceExecutionState.Fail;
                procEnv.ExitingSequence(Rule);

                // rule applied, now execute the sequence
                result = Seq.Apply(procEnv);

                // if sequence execution failed, roll the changes back and try the next match of the rule
                if(!result)
                {
                    procEnv.TransactionManager.Rollback(transactionID);
                    procEnv.PerformanceInfo.RewritesPerformed = oldRewritesPerformed;
                    if(matchesTried < matches.Count)
                    {
                        procEnv.EndOfIteration(true, this);
                        Rule.ResetExecutionState();
                        Seq.ResetExecutionState();
                        continue;
                    }
                    else
                    {
                        // all matches tried, all failed later on -> end in fail
#if LOG_SEQUENCE_EXECUTION
                        procEnv.Recorder.WriteLine("Applying backtrack match exhausted " + Rule.GetRuleCallString(procEnv));
#endif
                        procEnv.EndOfIteration(false, this);
                        return false;
                    }
                }

                // if sequence execution succeeded, commit the changes so far and succeed
                procEnv.TransactionManager.Commit(transactionID);
                procEnv.EndOfIteration(false, this);
                return true;
            }

            return false; // to satisfy the compiler, we return from inside the loop
        }