获得条件的绑定参数映射

@param conditions
424048
public static Map<String, Object> getParamMap(final Collection<Condition> conditions) {
    final Map<String, Object> params = new HashMap<String, Object>();
    for (final Condition con : conditions) {
      params.putAll(getParamMap(con));
    }
    return params;
  }
308400
public void fillAllConditions(Condition condition) {
        if (_valueColumns != null) {
            final Condition[] conditions = new Condition[_valueColumns.length];
            Arrays.fill(conditions, condition);
            _conditions = conditions;
        }
    }
506960
protected function applyFieldConditions()
    {
        if ($this->field !== null) {
            $this->andWhere(Db::parseParam('fieldId', $this->parseFieldValue($this->field)));
        }
    }
118439
private boolean conditionsEqual(Collection<Condition> conditions) {
        if (conditions.size() != _conditions.size()) {
            return false;
        }
        List<Condition> unvalidatedConditions = new ArrayList<>(conditions);
        for (Condition condition : _conditions) {
            if (!unvalidatedConditions.remove(condition)) {
                return false;
            }
        }
        return true;
    }
693124
public static <S, D> Condition<S, D> not(Condition<S, D> condition) {
    Assert.notNull(condition, "condition");
    return new Not<S, D>(condition);
  }
529361
static void waitForCondition(final StartConditionCheck condition, int timeoutSeconds, final String containerDescription) throws TimeoutException {
        try {
            log.info("wait for {} started", condition.describe());
            new WaitForUnit(TimeUnit.SECONDS, timeoutSeconds, TimeUnit.SECONDS, 1, new WaitForUnit.WaitForCondition() {
                @Override
                public boolean isConditionMet() {
                    return condition.check();
                }
                @Override
                public String timeoutMessage() {
                    return String.format("timeout waiting for %s in container %s", condition.describe(), containerDescription);
                }
            }).startWaiting();
            log.info("wait for {} - condition met", condition.describe());
        } catch (InterruptedException e) {
            throw new IllegalStateException(String.format("Interrupted while waiting for %s", condition.describe()), e);
        }
    }
502827
public function setConditions($conditions)
    {
        $this->conditions = [];
        if (!is_array($conditions)) {
            $conditions = [$conditions];
        }
        foreach ($conditions as $condition) {
            $this->addCondition($condition);
        }

        return $this;
    }
794020
private static void checkPreconditions(final Set<Object> possibleValues) {
		if( possibleValues == null ) {
			throw new NullPointerException("possibleValues Set should not be null");
		} else if( possibleValues.isEmpty() ) {
			throw new IllegalArgumentException("possibleValues Set should not be empty");
		}
	}
989415
public function addCondition($condition)
    {
        if (!$this->conditions->contains($condition)) {
            $this->conditions[] = $condition;
        }

        return $this;
    }
1073481
protected void invokePreconditions() {
    MethodContractHandle h =
        contracts.getMethodHandle(ContractKind.PRE, methodName, methodDesc, 0);
    if (h == null) {
      return;
    }

    MethodNode contractMethod = injectContractMethod(h);
    if (!statik) {
      loadThis();
    }
    loadArgs();
    invokeContractMethod(contractMethod);
  }
1266784
public void add(Collection<AlertCondition> conditions)
    {
        for(AlertCondition condition : conditions)
            this.conditions.put(condition.getId(), condition);
    }
540492
public function destroy($conditions = array())
    {
        $conditions[$this->_property] = $this->_root;
        $this->getRepository()->destroy($conditions);
    }
675001
public function andWhere($conditions, array $bindParams = null, array $bindTypes = null) {
        if(!is_null($bindParams)) {
            $tmpBindParams = array();
            foreach($bindParams as $key => $value) {
                if(is_int($key)) {
                    $param = 'criteriaHelper' . $this->incrementLocalParamCount();
                    $tmpBindParams[$param] = $value;
                    $conditions = str_replace('?' . $key, ':' . $param . ':', $conditions);
                } else {
                    $tmpBindParams[$key] = $value;
                }
            }
            $bindParams = $tmpBindParams;
        }
        $this->getCriteria()->andWhere($conditions, $bindParams, $bindTypes);
        return $this;
    }
878695
public BooleanConditionBuilder should(ConditionBuilder... conditionBuilders) {
        if (should == null) {
            should = new ArrayList<>(conditionBuilders.length);
        }
        for (ConditionBuilder conditionBuilder : conditionBuilders) {
            should.add(conditionBuilder.build());
        }
        return this;
    }
196252
public function registerDefaultConditions()
    {
        if (false === $this->defaultConditionsWereRegistered) {
            $this->defaultConditionsWereRegistered = true;

            $this->registerCondition(
                FieldHasValueCondition::CONDITION_NAME,
                FieldHasValueCondition::class
            )->registerCondition(
                FieldHasErrorCondition::CONDITION_NAME,
                FieldHasErrorCondition::class
            )->registerCondition(
                FieldIsValidCondition::CONDITION_NAME,
                FieldIsValidCondition::class
            )->registerCondition(
                FieldIsEmptyCondition::CONDITION_NAME,
                FieldIsEmptyCondition::class
            )->registerCondition(
                FieldIsFilledCondition::CONDITION_IDENTIFIER,
                FieldIsFilledCondition::class
            )->registerCondition(
                FieldCountValuesCondition::CONDITION_IDENTIFIER,
                FieldCountValuesCondition::class
            );
        }
    }
365595
public static Rule conditionsRule(final Condition condition, StateObj result) {
        HashSet<Condition> conditions = new HashSet<>();
        conditions.add(condition);
        return conditionsRule(conditions, result);
    }
491521
public Condition[] wrap(Condition... conditions){
		final Condition[] clonedConditions = new Condition[conditions.length];
		if(ArrayUtil.isNotEmpty(conditions)) {
			Condition clonedCondition;
			for(int i = 0; i < conditions.length; i++) {
				clonedCondition = conditions[i].clone();
				clonedCondition.setField(wrap(clonedCondition.getField()));
				clonedConditions[i] = clonedCondition;
			}
		}
		
		return clonedConditions;
	}