Adds a list of predicates to the current predicates using AND conjunctions

@param newPredicates predicates to be added
342220
private void addPredicates(List<Predicate> newPredicates) {
    for(Predicate newPredicate : newPredicates) {
      if(this.predicates == null) {
        this.predicates = newPredicate;
      } else {
        this.predicates = new And(this.predicates, newPredicate);
      }
    }
  }
253200
public void add(Collection<PluginsAlertCondition> conditions)
    {
        for(PluginsAlertCondition condition : conditions)
            this.conditions.put(condition.getId(), condition);
    }
54202
@SafeVarargs
    public static final <T> Predicate<T> or(Predicate<T>... predicates) {
        return Seq.of(predicates).reduce(t -> false, (t1, t2) -> t1.or(t2));
    }
202865
public void add(@Nonnull  Boolean...booleans) {
        for (Boolean b : booleans) {
            add(primitive(b));
        }
    }
841486
private void addModels(final Key<Model>[] newModels) {
    int before = leaderboard().getModelCount();
    leaderboard().addModels(newModels);
    int after = leaderboard().getModelCount();
    modelCount.addAndGet(after - before);
  }
330432
private static void addPredecessors(Block start) {
    Set<Block> visited = Sets.newIdentityHashSet();
    addPredecessors(start, visited);
  }
1214170
@NonNull
  public BatchStatementBuilder addStatements(@NonNull Iterable<BatchableStatement<?>> statements) {
    int delta = Iterables.size(statements);
    if (statementsCount + delta > 0xFFFF) {
      throw new IllegalStateException(
          "Batch statement cannot contain more than " + 0xFFFF + " statements.");
    }
    statementsCount += delta;
    statementsBuilder.addAll(statements);
    return this;
  }
869947
private void applyPredicatesForRegisteredItems(final List<PredicateHandler> predicates) {
        ImmutableList.builder()
                .addAll(getEnabledModules())
                .addAll(getEnabledBundles())
                .addAll(getEnabledExtensions())
                .addAll(getEnabledInstallers())
                .build()
                .stream()
                .<ItemInfo>map(this::getInfo)
                .forEach(item -> applyDisablePredicates(predicates, item));
    }
96791
public void addAll(String[] strings) {
		if (strings == null) {
			return;
		}
		for (String string : strings) {
			add(string);
		}
	}
886528
private static Predicate join(final String joinWord, final List<Predicate> preds) {
        return new Predicate() {
            public void init(AbstractSqlCreator creator) {
                for (Predicate p : preds) {
                    p.init(creator);
                }
            }
            public String toSql() {
                StringBuilder sb = new StringBuilder()
                .append("(");
                boolean first = true;
                for (Predicate p : preds) {
                    if (!first) {
                        sb.append(" ").append(joinWord).append(" ");
                    }
                    sb.append(p.toSql());
                    first = false;
                }
                return sb.append(")").toString();
            }
        };
    }
42994
public void combine(Vector new_filters, int op) throws DBException
    {
        for (Enumeration elems = new_filters.elements(); elems.hasMoreElements();)
        {
            SearchFilter filter = (SearchFilter) elems.nextElement();

            combine(filter, op);
        }
    }
420147
public void addAll(final Iterable<String> strings) {
    checkNotNull(strings);
    for (String string : strings) {
      add(string);
    }
  }
336100
public void addClause(final Literal... literals) {
    if (this.miniSat == null && this.cleaneLing == null)
      this.result.add(this.f.clause(literals));
    else if (this.miniSat != null) {
      final LNGIntVector clauseVec = new LNGIntVector(literals.length);
      for (final Literal lit : literals) {
        int index = this.miniSat.underlyingSolver().idxForName(lit.name());
        if (index == -1) {
          index = this.miniSat.underlyingSolver().newVar(!this.miniSat.initialPhase(), true);
          this.miniSat.underlyingSolver().addName(lit.name(), index);
        }
        final int litNum;
        if (lit instanceof EncodingAuxiliaryVariable)
          litNum = !((EncodingAuxiliaryVariable) lit).negated ? index * 2 : (index * 2) ^ 1;
        else
          litNum = lit.phase() ? index * 2 : (index * 2) ^ 1;
        clauseVec.push(litNum);
      }
      this.miniSat.underlyingSolver().addClause(clauseVec, null);
      this.miniSat.setSolverToUndef();
    } else {
      for (final Literal lit : literals) {
        final int index = this.cleaneLing.getOrCreateVarIndex(lit.variable());
        if (lit instanceof EncodingAuxiliaryVariable)
          this.cleaneLing.underlyingSolver().addlit(!((EncodingAuxiliaryVariable) lit).negated ? index : -index);
        else
          this.cleaneLing.underlyingSolver().addlit(lit.phase() ? index : -index);
      }
      this.cleaneLing.underlyingSolver().addlit(CleaneLing.CLAUSE_TERMINATOR);
      this.cleaneLing.setSolverToUndef();
    }
  }
572515
@Override
  protected void addSiblingConditions(List<String> conditions, QueryNode node,
    QueryNode target, Sibling join, QueryData queryData)
  {
    Sibling sibling = (Sibling) join;
    String componentName = sibling.getName();
    
    // "parent" column is unique over all component IDs, thus don't add an extra join
    addComponentPredicates(conditions, node, target, componentName, "d", false);

    conditions.add(join("=", tables(node).aliasedColumn(RANK_TABLE, "parent"),
      tables(target).aliasedColumn(RANK_TABLE, "parent")));

    if (!allowIdenticalSibling)
    {
      joinOnNode(conditions, node, target, "<>", "id", "id");
    }
  }
693407
public static <T> Predicate<T> AND(final Predicate<T> a, final Predicate<T> b) {
	return new Predicate<T>() {
	    public boolean check(T obj) {
		return a.check(obj) && b.check(obj);
	    }
	};
    }
121305
def add_predicate(self, predicate_obj):
        
        if self.srl_layer is None:
            self.srl_layer = Csrl()
            self.root.append(self.srl_layer.get_node())
        self.srl_layer.add_predicate(predicate_obj)
661263
public static <T> Predicate<T> and(Predicate<? super T>... components) {
        return and(Arrays.asList(components));
    }