function run()
Run the task.

@param Not-Required Mixed $sendValue

@return The return value of the task.
978915
public function run($sendValue=null){
            
            if($sendValue!==null) $this->sendValue = $sendValue;
            
            //Compatible the first item.
            
            if($this->beforeFirstYield){
                
                //Make the flag false.
                $this->beforeFirstYield = false;
                
                //Return the current return value.
                return $this->Generator->current();
                
            }else{
                
                /**
                 * Var $return
                 * The return value.
                 * 
                 */
                $return = $this->Generator->send($this->sendValue);
                
                //Clear the sendValue
                $this->sendValue = null;
                
                //Return the Return value
                return $return;
                
            }
            
        }
445629
function exportValue(&$submitValues, $assoc = false)
    {
        $value = $this->_findValue($submitValues);
        if (null === $value) {
            $value = $this->getChecked()? $this->getValue(): null;
        } elseif ($value != $this->getValue()) {
            $value = null;
        }
        return $this->_prepareValue($value, $assoc);
    }
16038
public function isTransaction($newValue = null)
    {
        if (null !== $newValue) {
            $this->isTransaction = (bool) $newValue;
        }
        return $this->isTransaction;
    }
862352
public function run( $field, $value, $message = null ) {

        $this->field   = $field;
        $this->message = $message;

        if ( ! $this->fieldKey || ! $this->fields ) {
            return false;
        }

        if ( $this->fields[ $this->fieldKey ] == $value ) {
            return true;
        }

        return false;
    }
123245
public function run()
    {
        if (! $this->runPreSearch()) {
            return $this->value;
        }

        $decoded = json_decode($this->value, 1);
        $result  = (json_last_error() == JSON_ERROR_NONE) && is_array($decoded);
        if ($result) {
            /* decoded is array */
            if (is_array($decoded)) {
                $arrayValue = '';
                array_walk_recursive($decoded, function ($value, $key) use (&$arrayValue) {
                    $arrayValue .= $key.' '.$value;
                });
                $this->value = $arrayValue;
            }
        }

        return $this->value;
    }
177116
public function run()
    {
        //check sub controller
        foreach ($this->controllers as $controller) {
            if ($result = $controller->run()) {
                return $result;
            }
        }

        $requestedUrl = $this->getClient()->getUrl();
        $this->normalizeUrl($requestedUrl);
        //check if its in our area
        if (strpos($requestedUrl, $this->triggerUrl) !== 0) return;

        $endPos = $this->triggerUrl === '/' ? 1 : strlen($this->triggerUrl) + 1;
        $uri = substr($requestedUrl, $endPos);

        if (!$uri) $uri = '';

        $route = false;
        $arguments = array();
        $requiredMethod = $this->getClient()->getMethod();

        //does the requested uri exist?
        list($callableMethod, $regexArguments, $method, $routeUri) = $this->findRoute($uri, $requiredMethod);

        if ((!$callableMethod || $method != 'options') && $requiredMethod == 'options') {
            $description = $this->describe($uri);
            $this->send($description);
        }

        if (!$callableMethod) {
            if (!$this->getParentController()) {
                if ($this->fallbackMethod) {
                    $m = $this->fallbackMethod;
                    $this->send($this->controller->$m());
                } else {
                    return $this->sendBadRequest('RouteNotFoundException', "There is no route for '$uri'.");
                }
            } else {
                return false;
            }
        }

        if ($method == '_all_')
            $arguments[] = $method;

        if (is_array($regexArguments)) {
            $arguments = array_merge($arguments, $regexArguments);
        }

        //open class and scan method
        if ($this->controller && is_string($callableMethod)) {
            $ref = new \ReflectionClass($this->controller);

            if (!method_exists($this->controller, $callableMethod)) {
                $this->sendBadRequest('MethodNotFoundException', "There is no method '$callableMethod' in ".
                    get_class($this->controller).".");
            }

            $reflectionMethod = $ref->getMethod($callableMethod);
        } else if (is_callable($callableMethod)) {
            $reflectionMethod = new \ReflectionFunction($callableMethod);
        }

        $params = $reflectionMethod->getParameters();

        if ($method == '_all_') {
            //first parameter is $pMethod
            array_shift($params);
        }

        //remove regex arguments
        for ($i=0; $i<count($regexArguments); $i++) {
            array_shift($params);
        }

        //collect arguments
        foreach ($params as $param) {
            $name = $this->argumentName($param->getName());

            if ($name == '_') {
                $thisArgs = array();
                foreach ($_GET as $k => $v) {
                    if (substr($k, 0, 1) == '_' && $k != '_suppress_status_code')
                        $thisArgs[$k] = $v;
                }
                $arguments[] = $thisArgs;
            } else {

                if (!$param->isOptional() && !isset($_GET[$name]) && !isset($_POST[$name])) {
                    return $this->sendBadRequest('MissingRequiredArgumentException', sprintf("Argument '%s' is missing.", $name));
                }

                $arguments[] = isset($_GET[$name]) ? $_GET[$name] : (isset($_POST[$name]) ? $_POST[$name] : $param->getDefaultValue());
            }
        }

        if ($this->checkAccessFn) {
            $args[] = $this->getClient()->getUrl();
            $args[] = $route;
            $args[] = $arguments;
            try {
                call_user_func_array($this->checkAccessFn, $args);
            } catch (\Exception $e) {
                $this->sendException($e);
            }
        }

        //fire method
        $object = $this->controller;

        return $this->fireMethod($callableMethod, $object, $arguments);

    }
1352843
function exportValue(&$submitValues, $notused = false) {
        // Get the values from all the child elements.
        $valuearray = array();
        foreach ($this->_elements as $element) {
            $thisexport = $element->exportValue($submitValues[$this->getName()], true);
            if (!is_null($thisexport)) {
                $valuearray += $thisexport;
            }
        }

        // Convert the value to an integer number of seconds.
        if (empty($valuearray)) {
            return null;
        }
        if ($this->_options['optional'] && empty($valuearray['enabled'])) {
            return array($this->getName() => 0);
        }
        return array($this->getName() => $valuearray['number'] * $valuearray['timeunit']);
    }
895850
public function run()
	{
		// Trigger event!
		$this->dispatch($this->listeners[self::LISTENER_STARTUP], [$this]);

		// Create initial request & response (PSR7!)
		$request = $this->createInitialRequest();
		$response = $this->createInitialResponse();

		try {
			// Trigger event!
			$this->dispatch($this->listeners[self::LISTENER_REQUEST], [$this, $request, $response]);

			// Right to the cycle
			$response = call_user_func(
				$this->chain,
				$request,
				$response,
				function (ServerRequestInterface $request, ResponseInterface $response): ResponseInterface {
					return $response;
				}
			);

			// Response validation check
			if (!isset($response) || $response === null) {
				throw new RuntimeException('Final response cannot be NULL or unset');
			}
		} catch (Throwable $e) {
			// Trigger event! In case of manual handling error, returned object is passed.
			$res = $this->dispatch($this->listeners[self::LISTENER_ERROR], [$this, $e, $request, $response]);
			if ($res !== null && $res !== false) {
				return $res;
			}

			// Throw exception again if it's not caught
			if ($this->catchExceptions !== true) {
				throw $e;
			}
		}

		// Trigger event! In case of manual finalizing, returned object is passed.
		$res = $this->dispatch($this->listeners[self::LISTENER_RESPONSE], [$this, $request, $response]);
		if ($res !== null && $res !== false) {
			return $res;
		}

		// Send to finalizer (simple send response)
		return $this->finalize($request, $response);
	}
1307471
public function run()
    {
        if (! $this->runPreSearch()) {
            return $this->value;
        }

        if (preg_match_all('/(?:\%23.*?\%0a)/im', $this->value, $matches)) {
            $converted = $this->value;
            foreach ($matches[0] as $match) {
                $converted = str_replace($match, ' ', $converted);
            }
            $this->value .= "\n".$converted;
        }

        return $this->value;
    }
64076
public function run()
    {
        if (! $this->runPreSearch()) {
            return $this->value;
        }
        $pattern = ['\'', '`', '´', '’', '‘', '"'];
        // normalize different quotes to "
        $this->value = str_replace($pattern, '"', $this->value);
        //make sure harmless quoted strings don't generate false alerts
        $this->value = preg_replace('/^"([^"=\\!><~]+)"$/', '$1', $this->value);

        return $this->value;
    }
1287092
public function run($data)
   {
      $this->task->addValues($data);
      if ($this->task->validate() === true) {
         return $this->task->run();
      }
      
      $errors = $this->task->getErrors();
      Env::error($this->formatErrors($errors));
   }
665550
public function run($url = null, $method = null)
    {
        $request = new Request($method, $url);
        try {
//            foreach ($this->modules as $module) {
//
//            }

            Profiler::start('router');
            if ($match = $this->router->match($url, $method)) {
                if ($match['name'] === 'handleFilesystem') {
                    Profiler::stop('router');
                    return $this->handleFilesystem($match['params'], $request);
                } else {
                    $target = $match['target'];
                    $module = $target[0];
                    if ($module instanceof Module) {
                        if ($this->isEnabled($module->title)) {
                            $this->runningModule = $module;
                            $controller = $target[1];
                            $request->setParams($match['params']);
                            Profiler::stop('router');
                            return $module->run($controller, $request);
                        } else {
                            Profiler::stop('router');
                            return $this->mainModule->run(new ErrorController("This module is disabled by your 
                            policy"),
                                $request);
                        }
                    }
                }
            }
            Profiler::stop('router');


            return $this->mainModule->run(new ErrorController("Controller for '$url' not found. " .
                $this->getRoutes()),
                $request);
        } catch (\Exception $ex) {
            Events::dispatch('onException', $ex);
            return $this->mainModule->run(new ExceptionController($ex), $request);
        } catch (\Throwable $ex) {
            Events::dispatch('onError', $ex);
            return $this->mainModule->run(new ExceptionController($ex), $request);
        }
    }
67117
public function run()
    {
        if ($job = $this->pop()) {
            list($route, $payload, $execution) = $job;
            $result = $this->runJob($route, $payload);
            if ($result === false) {
                if ($execution > 1) {
                    $this->push($route, $payload, 0, $execution - 1);
                } else {
                    $this->trigger(self::EVENT_FAIL, new Event(['route' => $route, 'payload' => $payload]));
                }
            }
            return $result !== false;
        }
    }
251799
public function run($request)
    {
        $this->request = $request;
        $args = $request->getVar('args');

        // The "cleanup" task has a different argument signature. Because it doesn't require the specification of a class.
        // This block normalizes that.
        if ($args[0] == "cleanup") {
            if (!isset($args[1])) {
                $args[1] = "__all__";
            }
            if ($args[1] != "__all__") {
                if (!class_exists($args[1]) || !is_subclass_of($args[1], "DataObject")) {
                    $this->showError("Please specify a valid DataObject descendant class.");
                }
            }

            return $this->cleanup($args[1]);
        } else {
            if (count($args) < 2) {
                $this->showError("Usage: MockDataTask <generate|populate|cleanup> <classname> [options]");
            }

            list($operation, $className) = $args;

            if (!class_exists($className) || !is_subclass_of($className, "DataObject")) {
                $this->showError("Please specify a valid DataObject descendant class.");
            }

            if (!in_array($operation, array('generate', 'populate', 'cleanup'))) {
                $this->showError("Please specify a valid operation (\"generate\", \"populate\", or \"cleanup\")");
            }


            $this->runBuilderCommand($operation, $className);
        }
    }
241030
public function run()
    {
        if (is_null($this->compiledResult)) {
            $this->compiledResult = \preg_replace_callback(static::$rxp_token, array($this, 'formatCallback'), $this->format);
        }

        return $this->compiledResult;
    }
139083
public function run()
    {
        // Catch all errors and convert to exceptions
        set_error_handler(array('\Diarmuidie\ImageRack\Server', 'handleErrors'));

        // Catch all uncaught exceptions
        set_exception_handler(array($this, 'error'));

        // Send a not found response if the request is not valid
        if (!$this->validRequest()) {
            $this->notFound();

            return $this->response;
        }

        // First try and load the image from the cache
        $cachePath = $this->getCachePath();
        if ($this->serveFromCache($cachePath)) {
            return $this->response;
        }

        // Secondly try load the source image
        $sourcePath = $this->getSourcePath();
        if ($this->serveFromSource($sourcePath)) {
            return $this->response;
        }

        // Finally default to returning a not found response
        $this->notFound();

        return $this->response;
    }
1078297
protected function runTaskOverSSH(Task $task)
    {
        // If the pretending option has been set, we'll simply dump the script out to the command
        // line so the developer can inspect it which is useful for just inspecting the script
        // before it is actually run against these servers. Allows checking for errors, etc.
        if ($this->pretending()) {
            echo $task->script.PHP_EOL;

            return 1;
        } else {
            return $this->passToRemoteProcessor($task);
        }
    }