Add condition to the dependence map
        :param condition: The condition that is to be added to the dependence map
974484
def add_condition(self, condition: z3.BoolRef) -> None:
        
        variables = set(_get_expr_variables(condition))
        relevant_buckets = set()
        for variable in variables:
            try:
                bucket = self.variable_map[str(variable)]
                relevant_buckets.add(bucket)
            except KeyError:
                continue

        new_bucket = DependenceBucket(variables, [condition])
        self.buckets.append(new_bucket)

        if relevant_buckets:
            # Merge buckets, and rewrite variable map accordingly
            relevant_buckets.add(new_bucket)
            new_bucket = self._merge_buckets(relevant_buckets)

        for variable in new_bucket.variables:
            self.variable_map[str(variable)] = new_bucket
1044160
def condition(*args, **kwds):
  
  if len(args) == 1 and len(kwds) == 0 and callable(args[0]):
    # used as `@decorator`
    func = args[0]
    return wraps(func)(FontBakeryCondition(func))
  else:
    # used as `@decorator()` maybe with args
    def wrapper(func):
      return wraps(func)(FontBakeryCondition(func, *args, **kwds))
  return wrapper
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);
  }
687216
def merge_conditions(conditions)
      @conditions = Conditions::Operation.new(:and) << @conditions unless @conditions.nil?

      conditions.compact!
      conditions.each do |condition|
        case condition
          when Conditions::AbstractOperation, Conditions::AbstractComparison
            add_condition(condition)

          when Hash
            condition.each { |key, value| append_condition(key, value) }

          when Array
            statement, *bind_values = *condition
            raw_condition = [ statement ]
            raw_condition << bind_values if bind_values.size > 0
            add_condition(raw_condition)
            @raw = true
        end
      end
    end
28272
def stop_condition(self, condition):
        

        # Try to parse this into a stop condition with each of our registered
        # condition types
        for cond_format in self._known_conditions:
            try:
                cond = cond_format.FromString(condition)
                self.stop_conditions.append(cond)
                return
            except ArgumentError:
                continue

        raise ArgumentError("Stop condition could not be processed by any known StopCondition type", condition=condition, suggestion="It may be mistyped or otherwise invalid.")
1210705
private function addCondition($key, $condition, $value)
    {
        if (!isset($this->where[$key]))
        {
            $this->where[$key] = array();
        }
        $this->where[$key][$condition] = AVClient::_encode($value, true);
    }
342483
public static void parseConditionToJunction(Condition condition,
			Junction junction, Class<?> persistentClass) {
		// 子条件
		List<Condition> subConditions = condition.getSubConditions();

		// 有子条件则进行遍历获取最终的条件
		if (null != subConditions && !subConditions.isEmpty()) {
			// 子条件当中的and条件集合
			List<Condition> andConditions = condition.getAndConditions();
			if (null != andConditions && !andConditions.isEmpty()) {
				// 创建一个and条件集合
				Conjunction conj = Restrictions.conjunction();
				// 添加到父条件中
				junction.add(conj);
				for (Condition andCondition : andConditions) {
					/*
					 * 把每个条件看做是一个大的条件(包含 and 和 or 2个部分),
					 * 然后使用disjunction连接条件集合来组合这个大条件的(and项 和 or项);
					 * 因为and项和or项都已经被分为2个部分
					 * ,而且又是用disjunction来组合,所以可以保证一个大条件只会被or连接符分隔成2个部分
					 */
					Disjunction dj = Restrictions.disjunction();
					conj.add(dj);
					parseConditionToJunction(andCondition, dj, persistentClass);
				}
			}

			// 子条件当中的or条件集合
			List<Condition> orConditions = condition.getOrConditions();
			if (null != orConditions && !orConditions.isEmpty()) {
				// 创建一个or条件集合
				Disjunction disj = Restrictions.disjunction();
				// 添加到父条件中
				junction.add(disj);
				for (Condition orCondition : orConditions) {
					// 这里的实现原理与上面的andCondition的处理相同
					Disjunction dj = Restrictions.disjunction();
					disj.add(dj);
					parseConditionToJunction(orCondition, dj, persistentClass);
				}
			}
		} else {
			// 条件为最终条件，转换为符合Hibernate的条件，然后条件到条件集合中
			junction.add(condition.getCriterion(persistentClass));
		}
	}
262423
private function addCondition($property, $condition)
    {
        $currentCondition = $property->getVisibleCondition();
        if ((!($currentCondition instanceof ConditionChainInterface))
            || ($currentCondition->getConjunction() != ConditionChainInterface::OR_CONJUNCTION)
        ) {
            if ($currentCondition === null) {
                $currentCondition = new PropertyConditionChain([$condition]);
            } else {
                $currentCondition = new PropertyConditionChain([$currentCondition, $condition]);
            }
            $currentCondition->setConjunction(ConditionChainInterface::OR_CONJUNCTION);
            $property->setVisibleCondition($currentCondition);
        } else {
            $currentCondition->addCondition($condition);
        }
    }
1143141
def add_clause(self, clause, no_return=True):
        

        if self.lingeling:
            pysolvers.lingeling_add_cl(self.lingeling, clause)
1166184
def add_obligation_condition_for( path, expression )
      raise "invalid expression #{expression.inspect}" unless expression.is_a?( Array ) && expression.length == 3
      add_obligation_join_for( path )
      obligation_conditions[@current_obligation] ||= {}
      ( obligation_conditions[@current_obligation][path] ||= Set.new ) << expression
    end
337582
def fuse(criteria_conditions = {})
      criteria_conditions.inject(self) do |criteria, (key, value)|
        criteria.send(key, value)
      end
    end
407655
def condition(proc)
      return unless block_given?
      @template.add_node Nodes::Condition.new(proc, sub_compile(nil, true) { yield })
    end
1359256
def with_condition(self, condition: Callable[[MonitorContext], bool]) -> 'MonitorTask':
        
        self._condition = condition
        return self
1068963
void addIndexCondition(Expression[] exprList, Index index, int colCount,
                           boolean isJoin) {
// VoltDB extension
        if (rangeIndex == index && isJoinIndex && (!isJoin) &&
                (multiColumnCount > 0) && (colCount == 0)) {
            // This is one particular set of conditions which broke the classification of
            // ON and WHERE clauses.
            return;
        }
// End of VoltDB extension
        rangeIndex  = index;
        isJoinIndex = isJoin;

        for (int i = 0; i < colCount; i++) {
            Expression e = exprList[i];

            indexEndCondition =
                ExpressionLogical.andExpressions(indexEndCondition, e);
        }

        if (colCount == 1) {
            indexCondition = exprList[0];
        } else {
            findFirstExpressions = exprList;
            isMultiFindFirst     = true;
            multiColumnCount     = colCount;
        }
    }
1120857
public function setCondition($condition)
    {
        $this->condition = (string) $condition;
        $this->compiled = null;

        return $this;
    }
1094833
def select(self, condition):
        
        return self.__class__([p for p in self if condition(p)])
1300119
public AnnotationTypeCondition addCondition(String element, AnnotationCondition condition)
    {
        this.conditions.put(element, condition);
        return this;
    }