Applies the operations.
431878
public function applyOperations()
    {
        // Renders the effects
        foreach ($this->operations as $operation) {
            call_user_func_array(array($this->adapter, $operation[0]), $operation[1]);
        }
    }
528195
public function applyFilters()
    {
        if ($this->filters) {
            foreach ($this->filters as $k => $filter) {
                if (
                    isset($_GET[$filter['field']]) &&
                    !empty($_GET[$filter['field']]) &&
                    $_GET[$filter['field']] != $this->filterEmpty &&
                    @$_GET['filter'] != $filter['field']
                ) {
                    $this->model->addCondition($filter['field'], $_GET[$filter['field']]);
                }
            }
        }
    }
1333471
public function apply()
	{
		foreach ($this->patches as $patch)
		{
			// Separate the input into lines
			$lines = self::splitLines($patch['udiff']);

			// Loop for each header
			while (self::findHeader($lines, $src, $dst))
			{
				$done = false;

				if ($patch['strip'] === null)
				{
					$src = $patch['root'] . preg_replace('#^([^/]*/)*#', '', $src);
					$dst = $patch['root'] . preg_replace('#^([^/]*/)*#', '', $dst);
				}
				else
				{
					$src = $patch['root'] . preg_replace('#^([^/]*/){' . (int) $patch['strip'] . '}#', '', $src);
					$dst = $patch['root'] . preg_replace('#^([^/]*/){' . (int) $patch['strip'] . '}#', '', $dst);
				}

				// Loop for each hunk of differences
				while (self::findHunk($lines, $srcLine, $srcSize, $dstLine, $dstSize))
				{
					$done = true;

					// Apply the hunk of differences
					$this->applyHunk($lines, $src, $dst, $srcLine, $srcSize, $dstLine, $dstSize);
				}

				// If no modifications were found, throw an exception
				if (!$done)
				{
					throw new \RuntimeException('Invalid Diff');
				}
			}
		}

		// Initialize the counter
		$done = 0;

		// Patch each destination file
		foreach ($this->destinations as $file => $content)
		{
			$content = implode("\n", $content);

			if (File::write($file, $content))
			{
				if (isset($this->sources[$file]))
				{
					$this->sources[$file] = $content;
				}

				$done++;
			}
		}

		// Remove each removed file
		foreach ($this->removals as $file)
		{
			if (File::delete($file))
			{
				if (isset($this->sources[$file]))
				{
					unset($this->sources[$file]);
				}

				$done++;
			}
		}

		// Clear the destinations cache
		$this->destinations = array();

		// Clear the removals
		$this->removals = array();

		// Clear the patches
		$this->patches = array();

		return $done;
	}
1104319
def apply(self, collection, ops, resource=None, **kwargs):
        """"""
        mfield = self.mfield or resource.meta.model._meta.fields.get(self.field.attribute)
        if mfield:
            collection = collection.where(*[op(mfield, val) for op, val in ops])
        return collection
782698
public function apply()
    {
        if ($this->canApply()) {
            $nodeName = $this->generateUniqueNodeName($this->getSiblingNode()->getParent());
            $node = $this->getSubject()->copyAfter($this->getSiblingNode(), $nodeName);
            $this->finish($node);
        }
    }
1310226
def _rewrite_applied_operations(self):
        
        self._rewrite_where(self.query.where)
        self._rewrite_order()
        self._rewrite_select_related()
1243085
def apply_patch(self):
        
        patch = self.patches.get(self.storage.__class__.__name__)
        if patch:
            patch.apply(self)
904773
public void applyToListeners (ListenerOp op)
    {
        for (int ii = 0, ll = occupants.size(); ii < ll; ii++) {
            op.apply(this, occupants.get(ii));
        }
    }
1033512
public function apply()
    {
        if ($this->canApply()) {
            $before = self::cloneNodeWithNodeData($this->getSubject());
            $parent = $before->getParent();

            if ($this->nodeNameAvailableBelowNode($this->getSiblingNode()->getParent(), $this->getSubject())) {
                $this->getSubject()->moveAfter($this->getSiblingNode());
            } else {
                $nodeName = $this->generateUniqueNodeName($this->getSiblingNode()->getParent());
                $this->getSubject()->moveAfter($this->getSiblingNode(), $nodeName);
            }

            $updateParentNodeInfo = new UpdateNodeInfo();
            $updateParentNodeInfo->setNode($parent);

            $this->feedbackCollection->add($updateParentNodeInfo);

            $this->finish($before);
        }
    }
37228
@TargetApi(Build.VERSION_CODES.GINGERBREAD)
    public void apply() {
        if (editing == null) {
            return;
        }
        try {
            editing.apply();
        } catch (Exception ex) {
            editing.commit(); // Fallback in case low api lever.
        }
        editing = null;
    }
406030
private function applyOperations($operations, &$target)
    {
        foreach ($operations as $key => $operation)
        {
            $oldValue = (isset($target[$key]) ? $target[$key] : null);
            $newValue = $operation->_apply($oldValue, $this, $key);
            if (empty($newValue) && !is_array($newValue) && $newValue !== null && !is_scalar($newValue)
            )
            {
                unset($target[$key]);
                unset($this->dataAvailability[$key]);
            } else
            {
                $target[$key] = $newValue;
                $this->dataAvailability[$key] = true;
            }
        }
    }
165423
public void setOperations(java.util.Collection<String> operations) {
        if (operations == null) {
            this.operations = null;
            return;
        }

        this.operations = new com.amazonaws.internal.SdkInternalList<String>(operations);
    }
1323661
public function apply()
    {
        global ${$this->name};

        $this->backup = ${$this->name};

        ${$this->name} = $this->value;
    }
109130
public function addOperation(Operation $operation) {
        $operations = $this->getOperations();
        $operations[] = $operation;
        $this->setOperations($operations);
    }
1341809
public function apply(ComponentInterface $component, $operations)
    {
        if (is_string($operations) || $operations instanceof Closure) {
            $operations = [$operations];
        }
        foreach ($operations as $operation) {
            if (is_string($operation)) {
                list($key, $value) = explode(':', $operation);
                $operation = [$key => $value];
            } elseif ($operation instanceof Closure) {
                $operation = [$operation];
            }
            $this->applyInternal($component, $operation);
        }

    }
855651
public function apply()
    {
        if ($this->canApply()) {
            $subject = $this->getSubject();
            $this->createNode($subject);
            $this->updateWorkspaceInfo();
        }
    }
181890
protected function processOperation()
    {
        if ($this->_operation!==null) {
            $value = $this->_operationArgument ? $this->_operationArgument : null;
            if ($value instanceof TmpFile) {
                $value = (string) $value;
            }
            $this->addArg($this->_operation, $value, $this->_escapeOperationArgument);
        }
    }