Force the values of the criterion to be evolved.

 @api private

 @example Force values to booleans.
   selectable.force_typing(criterion) do |val|
     Boolean.evolve(val)
   end

 @param [ Hash ] criterion The criterion.

 @since 1.0.0
198597
def typed_override(criterion, operator)
      if criterion
        criterion.update_values do |value|
          yield(value)
        end
      end
      __override__(criterion, operator)
    end
816217
@ObjectiveCName("changeWithValue:")
    public boolean change(@Nullable T value) {
        if (this.value != null && value != null && value.equals(this.value)) {
            return false;
        }

        // No need in sync. We are not expected complex sync of value models
        this.value = value;

        notify(value);

        return true;
    }
1048834
function (val, condition, options) {
      enforceType(val, "array");
      return this.define("minimum", val[0], condition, options)
                 .define("maximum", val[1], condition, options);
    }
128791
private void addCriterionsToCriteria(Criteria criteria, Criterion... criterion) {
        if (criteria != null) {
            for (Criterion c : criterion) {
                if (c != null) {
                    criteria.add(c);
                }
            }
        }
    }
844678
def []=(key,val)
      change_type = keys.include?(key) ? :modified : :added
      changes = changes_for(change_type,:[]=,key,val)
      changing(change_type,:trigger=>:[]=, :changes=>changes) {super}
    end
563292
def set?
      case value.class
      when Array
        value.size == 0 ? false : true
      else
        value.nil? ? false : true
      end
    end
935891
public Event evolution(Evolution... values) {
        if (values == null || values.length == 0) {
            return this;
        }
        this.evolution().addAll(Arrays.asList(values));
        return this;
    }
1009571
def take_over_management=(new_val)
      return nil if new_val == @take_over_management
      raise JSS::InvalidDataError, 'New value must be true or false' unless new_val.jss_boolean?
      @take_over_management = new_val
      @need_to_update = true
    end
587937
def make_available_after_install=(new_val)
      return nil if new_val == @make_available_after_install
      raise JSS::InvalidDataError, 'New value must be true or false' unless new_val.jss_boolean?
      @make_available_after_install = new_val
      @need_to_update = true
    end
388448
protected function compileCriterion(Criterion $criterion, array &$bindings): string
    {
        if ($criterion instanceof ValueCriterion) {
            $sql = sprintf(
                '%s %s %s',
                $this->compileIdentifier($criterion->column, $bindings),
                $criterion->rule,
                $this->compileValue($criterion->value, $bindings)
            );

            if ($criterion->rule === 'LIKE' && is_string($criterion->value)) {
                $sql .= ' ESCAPE ?';
                $this->mergeBindings($bindings, ['\\']);
            }

            return $sql;
        }

        if ($criterion instanceof ColumnsCriterion) {
            return sprintf(
                '%s %s %s',
                $this->compileIdentifier($criterion->column1, $bindings),
                $criterion->rule,
                $this->compileIdentifier($criterion->column2, $bindings)
            );
        }

        if ($criterion instanceof BetweenCriterion) {
            return sprintf(
                '(%s %sBETWEEN %s AND %s)',
                $this->compileIdentifier($criterion->column, $bindings),
                $criterion->not ? 'NOT ' : '',
                $this->compileValue($criterion->min, $bindings),
                $this->compileValue($criterion->max, $bindings)
            );
        }

        if ($criterion instanceof CriteriaCriterion) {
            $groupBindings = [];
            $groupSQL = $this->compileCriteria($criterion->criteria, $groupBindings);

            if ($groupSQL === '') {
                return '';
            } else {
                $this->mergeBindings($bindings, $groupBindings);

                return sprintf(
                    '%s(%s)',
                    $criterion->not ? 'NOT ' : '',
                    $groupSQL
                );
            }
        }

        if ($criterion instanceof ExistsCriterion) {
            return sprintf(
                '%sEXISTS %s',
                $criterion->not ? 'NOT ' : '',
                $this->compileSubQuery($criterion->subQuery, $bindings)
            );
        }

        if ($criterion instanceof InCriterion) {
            if (is_array($criterion->values)) {
                if (empty($criterion->values)) {
                    return $this->compileEmptyInCriterion($criterion, $bindings);
                }

                $subQuery = '';
                foreach ($criterion->values as $value) {
                    $subQuery .= ($subQuery ? ', ' : '(') . $this->compileValue($value, $bindings);
                }
                $subQuery .= ')';
            } else {
                $subQuery = $this->compileSubQuery($criterion->values, $bindings);
            }

            return sprintf(
                '%s %sIN %s',
                $this->compileIdentifier($criterion->column, $bindings),
                $criterion->not ? 'NOT ' : '',
                $subQuery
            );
        }

        if ($criterion instanceof NullCriterion) {
            return sprintf(
                '%s IS %sNULL',
                $this->compileIdentifier($criterion->column, $bindings),
                $criterion->isNull ? '' : 'NOT '
            );
        }

        if ($criterion instanceof RawCriterion) {
            return $this->compileSubQuery($criterion->raw, $bindings);
        }

        throw new InvalidQueryException('The given criterion '.get_class($criterion).' is unknown');
    }
1333998
def keyword(text = nil, match = nil, &block)
      biddable_criterion = BiddableAdGroupCriterion.new(self)
      criterion = CriterionKeyword.new(self, text, match, &block)
      biddable_criterion.criterion = criterion
      @criterions ||= []
      @criterions.push( biddable_criterion )
      biddable_criterion
    end
274254
function (actual, message) {
        YUITest.Assert._increment();
        if (true !== actual) {
            throw new YUITest.ComparisonFailure(YUITest.Assert._formatMessage(message, "Value should be true."), true, actual);
        }

    }
897617
function (selector, expected, hash) {
    this.actionQueue.push(this.webdriverClient.element.bind(this.webdriverClient, selector));
    this.actionQueue.push(this.webdriverClient.getAttribute.bind(this.webdriverClient, 'value'));
    this.actionQueue.push(this._valCb.bind(this, selector, hash, expected));
    return this;
  }
1310983
def _force_on_change(self):
        
        for layout in self.force_on_change:
            if layout in self.available_combinations:
                if self.active_layout != layout:
                    self.displayed = layout
                    self._apply(force=True)
                    self.py3.update()
                    break
                else:
                    break
65970
def invalidate(strategy, value = nil)
      (value = strategy; strategy = :id) unless strategy.is_a?(Symbol)
      # call the invalidate method of the chosen strategy
      @strategy_by_attribute[strategy].invalidate(value) if @strategy_by_attribute[strategy]
    end
496980
def notify_preference=(value)
      if value
        translated_value = "1"
      else
        translated_value = "0"
      end
      xml = Builder::XmlMarkup.new
      xml.instruct!
      xml.Request(:xmlns => "urn:sbx:apis:SbxBaseComponents") do |xml|
        connection.requester_credentials_block(xml)
        xml.SetBusinessCardNotifyPreferenceCall do |xml|
          xml.BusinessCardNotifyPreference(translated_value)
        end
      end
      response = connection.post_xml(xml)
      # TODO: Retrieve the new value to make sure it worked?
      value
    end
90879
def sync=(sync)
      validator = EnumAttributeValidator.new('String', ["true", "false"])
      unless validator.valid?(sync)
        fail ArgumentError, "invalid value for 'sync', must be one of #{validator.allowable_values}."
      end
      @sync = sync
    end