Actually adds the condition to the proper target.
548217
protected function addCondition($method, array $params)
    {
        $target = $this->getCurrentPredicate();
        
        # Set default operator if any.
        if ($operator = $this->getDefaultOperator()) {
            $target->$operator;
        }
        
        call_user_func_array([$target, $method], $params);
    }
356200
protected function applyConditions()
    {
        $attributes = ['id', 'handle', 'class', 'scope'];

        foreach ($attributes as $attribute) {
            if (null !== ($value = $this->{$attribute})) {
                $this->andWhere(Db::parseParam($attribute, $value));
            }
        }
    }
245366
@Override
    public T add(final Asset asset, final String target) throws IllegalArgumentException {
        // Precondition checks
        Validate.notNullOrEmpty(target, "target must be specified");
        Validate.notNull(asset, "asset must be specified");

        // Make a Path from the target
        final ArchivePath path = new BasicPath(target);

        // Delegate
        return this.add(asset, path);
    }
461919
def setPoint(self, targetTemp):
        """"""
        self.targetTemp = targetTemp
        self.Integrator = 0
        self.Derivator = 0
1235538
def _set_condition(self, condition):
        """"""
        assert isinstance(condition, CodeExpression.TYPES)
        self.condition = condition
1248497
def add_rule(self, rule_class, target_class=_Nothing):
        
        if isinstance(target_class, Iterable):
            for cls in target_class:
                self._rules[cls] = rule_class
        else:
            self._rules[target_class] = rule_class
1195911
public void addTarget(final AjaxTarget target) {
		AjaxControlModel model = getOrCreateComponentModel();

		if (model.targets == null) {
			model.targets = new ArrayList<>();
		}

		model.targets.add(target);
		MemoryUtil.checkSize(model.targets.size(), this.getClass().getSimpleName());
	}
1217953
function (target, src) {
	for (var key in src) {
		if (src.hasOwnProperty(key)) {
			target[key] = src[key];
		}
	}
}
906592
def bind_target(self, target, ctx=None):
        

        # process self _bind_target
        result = self._bind_target(target=target, ctx=ctx)

        # fire on bind target event
        self.on_bind_target(target=target, ctx=ctx)

        return result
982338
public void setTarget(String target)
    {
        ExtendedInfo info = getInfo(target);
        if (info != null)
            info._target = target;
    }
216526
def update_target(self, name, current, total):
        """"""
        self.refresh(self._bar(name, current, total))
1299811
public ConditionalMultibind<T> addBinding(TypeLiteral<T> target)
  {
    multibinder.addBinding().to(target);
    return this;
  }
1123370
function modifyTarget(target, source, sourceKeys, filters, overrideKeys) {

    // Arguments available to each filter.
    var filterContext = {
        target: target, // readonly
        source: source, // readonly
        sourceKey: null, // readonly
        targetKey: null,
        sourceValue: null
    };

    // For each property, send it through the filter pipeline and
    // then apply it to the target object.
    for (var sourceKey in sourceKeys) {
        filterContext.sourceKey = sourceKey;
        filterContext.targetKey = sourceKeys[sourceKey];

        // Throw an error if the source property name doesn't refer to a value.
        if (!(sourceKey in source)) {
            errorManager.propertyNotFound(sourceKey, source);
        }
        filterContext.sourceValue = source[sourceKey];

        // Apply the filters to the property.
        for (var i = 0; i < filters.length; i++) {
            if (!filters[i](filterContext)) {
                // Don't apply this property to the target.
                filterContext.targetKey = null;
                break;
            }
        }

        // Apply property to target.
        if (filterContext.targetKey !== null) {
            // Allow overwrite to take place. Developer can ignore error.
            var overwritten = filterContext.targetKey in target;

            target[filterContext.targetKey] = filterContext.sourceValue;

            if (overwritten && !overrideKeys[sourceKey]) {
                errorManager.propertyOverride(filterContext.targetKey, target);
            }
        }
    }
}
1245821
def add_for_targets(self, targets, classpath_elements):
    """"""
    for target in targets:
      self.add_for_target(target, classpath_elements)
778035
def add_condition(self, observed_arr):
        '''
        
        '''
        condition_arr = self.__image_true_sampler.draw()
        return np.concatenate((observed_arr, condition_arr), axis=1)
1161784
private void updateTargetDescription() {
		if( targetPt != null ) {
			TupleDesc feature = describe.createDescription();
			describe.process(targetPt.x,targetPt.y,targetOrientation,targetRadius,feature);
			tuplePanel.setDescription(feature);
		} else {
			tuplePanel.setDescription(null);
		}
		tuplePanel.repaint();
	}
1300795
function addTargetToContext(target, context) {
        context.target = target;

        var engine = context.engine;
        var name = target.name;

        if (engine.targets[name]) {
            switch (engine.options.namingConflict) {
                /* jshint ignore:start */
                case 'override':
                    engine.targets[name] = target;
                    context.targets.push(name);
                case 'ignore':
                    break;
                /* jshint ignore:end */
                default:
                    throw new Error('[ETPL_TARGET_EXISTS]' + name);
            }
        }
        else {
            engine.targets[name] = target;
            context.targets.push(name);
        }
    }