Updates the {@link #predicateDependencyGraph} by the input rule.

It adds all the edges <rule.head.pred, p> to
{@link #predicateDependencyGraph}, for all the p in the predicates of the
rule body


@param rule
428525
private void updatePredicateDependencyGraph(CQIE rule) {

		List<Predicate> dependencyList = new LinkedList<>();

		for (Function bodyAtom : rule.getBody()) {

			if (bodyAtom.isDataFunction()) {
				dependencyList.add(bodyAtom.getFunctionSymbol());
			} else if (bodyAtom.isAlgebraFunction() || bodyAtom.isOperation()) {
				updatePredicateDependencyGraph_traverseBodyAtom(dependencyList, bodyAtom);
				//} else if (bodyAtom.isArithmeticFunction() || bodyAtom.isDataTypeFunction() {
			} else if (bodyAtom.isDataTypeFunction()) {
					continue;
				} else {
					throw new IllegalStateException("Unknown Function");
				}
		}

		Predicate headPred = rule.getHead().getFunctionSymbol();
		predicateDependencyGraph.addVertex(headPred);

		for (Predicate dependentPred : dependencyList) {
			predicateDependencyGraph.addVertex(dependentPred);
			predicateDependencyGraph.addEdge(headPred, dependentPred);
		}
	}
784254
public RuleImpl buildRule(VertexElement vertex, Rule type, Pattern when, Pattern then) {
        return getOrBuildConcept(vertex, (v) -> RuleImpl.create(v, type, when, then));
    }
180078
private void add(final PathEdge edge) {
        int u = edge.either();
        int v = edge.other(u);
        if (rank[u] < rank[v])
            graph[u].add(edge);
        else
            graph[v].add(edge);
    }
855388
public static <T> RuleRouter<T> of(final Iterable<Rule<T>> rules) {
    return new RuleRouter<>(ImmutableList.copyOf(rules));
  }
283592
public synchronized ValidationRuleStore addRule(ValidationRule rule) {
        rule.setOrderIdx(this.rules.size());
        this.rules.add(rule);
        this.checkHashMap.put(rule.getRuleName(), rule.getValidationCheck());
        return this;
    }
310545
public synchronized void addRule(final RuleImpl rule) throws InvalidPatternException {
        final List<TerminalNode> terminals = this.ruleBuilder.addRule( rule,
                                                                       this.kBase );

        BaseNode[] nodes = terminals.toArray( new BaseNode[terminals.size()] );
        this.rules.put( rule.getFullyQualifiedName(), nodes );
        if (rule.isQuery()) {
            this.queries.put( rule.getName(), nodes );
        }
    }
1085404
public void addVertex(JobVertex vertex) {
		final JobVertexID id = vertex.getID();
		JobVertex previous = taskVertices.put(id, vertex);

		// if we had a prior association, restore and throw an exception
		if (previous != null) {
			taskVertices.put(id, previous);
			throw new IllegalArgumentException("The JobGraph already contains a vertex with that id.");
		}
	}
965775
public final void entryRulePredicatedGroup() throws RecognitionException {
        try {
            // InternalXtext.g:1071:1: ( rulePredicatedGroup EOF )
            // InternalXtext.g:1072:1: rulePredicatedGroup EOF
            {
             before(grammarAccess.getPredicatedGroupRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            rulePredicatedGroup();

            state._fsp--;

             after(grammarAccess.getPredicatedGroupRule()); 
            match(input,EOF,FollowSets000.FOLLOW_2); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
273898
public void setRuleDependency(){		
		ruleDependencyFinder();
		VariableOrderingH varOH = new VariableOrderingH() {
			
			@Override
			public int compare(ConstraintNetwork arg0, ConstraintNetwork arg1) {
				// TODO Auto-generated method stub
				//System.out.println(toSkip.indexOf(ruleHeads.get(((FuzzyActivity)arg0.getVariables()[0]))));
				//System.out.println(toSkip.indexOf(ruleHeads.get(((FuzzyActivity)arg1.getVariables()[0]))));
				return toSkip.indexOf(ruleHeads.get(((FuzzyActivity)arg0.getVariables()[0]))) - toSkip.indexOf(ruleHeads.get(((FuzzyActivity)arg1.getVariables()[0])));
			}
			
			@Override
			public void collectData(ConstraintNetwork[] allMetaVariables) {
				// TODO Auto-generated method stub
				
			}
		};//// variable ordering should be implemented
		
		this.varOH = varOH;
		

	}
432327
public void addRule( RuleWrapper addRule ) {
        Rule rule = addRule.getRule();
        featureTypeStyle.rules().add(rule);
        rulesWrapperList.add(addRule);
    }
908465
void addRuleRootNodes(List<RBBINode> dest, RBBINode node) {
           if (node == null) {
               return;
           }
           if (node.fRuleRoot) {
               dest.add(node);
               // Note: rules cannot nest. If we found a rule start node,
               //       no child node can also be a start node.
               return;
           }
           addRuleRootNodes(dest, node.fLeftChild);
           addRuleRootNodes(dest, node.fRightChild);
       }
97191
static Set<String> validateRuleOntologically(TransactionOLTP graph, Rule rule) {
        Set<String> errors = new HashSet<>();

        //both body and head refer to the same graph and have to be valid with respect to the schema that governs it
        //as a result the rule can be ontologically validated by combining them into a conjunction
        //this additionally allows to cross check body-head references
        ReasonerQuery combinedQuery = combinedRuleQuery(graph, rule);
        errors.addAll(combinedQuery.validateOntologically(rule.label()));
        return errors;
    }
721272
public void addEdge(DiEdge e) {
        if (edges.add(e)) {
            int s = e.get1();
            int t = e.get2();
            addNode(s);
            addNode(t);
            predecessors.get(t).add(s);
            successors.get(s).add(t);
        }
    }
1114569
public void addRule(TransliterationRule rule) {
        ruleVector.add(rule);
        int len;
        if ((len = rule.getAnteContextLength()) > maxContextLength) {
            maxContextLength = len;
        }

        rules = null;
    }
1014467
private AtlasEdge addOrUpdateStruct(AtlasVertex instanceVertex, AttributeInfo attributeInfo,
            ITypedStruct newAttributeValue, AtlasEdge currentEdge,
            String edgeLabel, Operation operation) throws AtlasException {
        AtlasEdge newEdge = null;
        if (GraphHelper.elementExists(currentEdge) && newAttributeValue != null) {
            //update
            updateStructVertex(newAttributeValue, currentEdge, operation);
            newEdge = currentEdge;
        } else if (! GraphHelper.elementExists(currentEdge) && newAttributeValue != null) {
            //add
            newEdge = addStructVertex(newAttributeValue, instanceVertex, attributeInfo, edgeLabel);
        }
        return newEdge;
    }
758436
public void updateRuleBasicInfo(ValidationRule rule) {
        this.orderIdx = rule.orderIdx;
        this.parentDependency = rule.parentDependency;
        this.standardValueType = rule.standardValueType;
        this.validationCheck = rule.validationCheck;
        this.overlapBanRuleName = rule.overlapBanRuleName;
        this.assistType = rule.assistType;
    }
233915
public void addRule(IntDependency dependency, double count) {
    if ( ! directional) {
      dependency = new IntDependency(dependency.head, dependency.arg, false, dependency.distance);
    }
    if (verbose) System.err.println("Adding dep " + dependency);
    //    coreDependencies.incrementCount(dependency, count);
    /*new IntDependency(dependency.head.word,
                                        dependency.head.tag,
                                        dependency.arg.word,
                                        dependency.arg.tag,
                                        dependency.leftHeaded,
                                        dependency.distance), count);
    */
    expandDependency(dependency, count);
    // System.err.println("stopCounter: " + stopCounter);
    // System.err.println("argCounter: " + argCounter);
  }