Get the runnable for the process.

@return callable
542074
protected function runnableRetriever()
    {
        $runnable = $this->getRunnable();

        if ($runnable && is_callable($runnable)) {
            return $runnable;
        }

        return function ($server, $process) {
            $this->dispatchEvent('Run', $server, $process);
        };
    }
492406
public function getProcessor()
    {
        if (null === $this->processor) {
            if (null !== $this->width) {
                return self::PROCESSOR_FIXED;
            }

            return self::PROCESSOR_DYNAMIC;
        }

        return $this->processor;
    }
477150
protected function runCallable()
    {
        $callable = $this->action['uses'];

        return $callable(...array_values($this->resolveMethodDependencies(
            $this->parametersWithoutNulls(), new ReflectionFunction($this->action['uses'])
        )));
    }
1308270
public function getNextCallable()
    {
        if(!$this->initiated)
        {
            reset($this->callables);

            $this->initiated = true;

            return current($this->callables);
        }

        return next($this->callables);
    }
321914
public function run()
    {
        if ($this->opts->error !== null) {
            if ($this->opts->error !== '') {
                $top = '{cmd}: ' . $this->opts->error;
            } else {
                $top = '';
            }
            $this->usage($top);
            return $this->io;
        }
        if (!$this->loadOpts()) {
            return $this->io;
        }
        $this->process();
        return $this->io;
    }
513767
protected function runClosure()
    {
        $closure = $this->getCommand()->getAction();
        return $closure(
            $this->getCommand()->getRequest(),
            new Response()
        );
    }
1042389
public function run()
    {
        $this->container = $this->container ?: new Container;

        try {
            if ($this->isControllerAction()) {
                return $this->runController();
            }

            return $this->runCallable();
        } catch (HttpResponseException $e) {
            return $e->getResponse();
        }
    }
915664
public function run()
	{
		if ( $this->description )
			touch( $this->mutexPath() );

		try
		{
			UniversalBuilder::call( $this->callback, $this->parameters )
		}
		finally
		{
			$this->removeMutex();
		}

		parent::callAfterCallbacks();

		return $response;
	}
516913
public function run()
    {
        // check if cron instances is defined
        if (!isset($this->configs['instances']) || !Any::isArray($this->configs['instances'])) {
            return null;
        }

        // get timestamp
        $time = time();
        $log = [];

        // each every one instance
        foreach ($this->configs['instances'] as $callback => $delay) {
            if (((int)$this->configs['log'][$callback] + $delay) <= $time) {
                // prepare cron initializing
                list($class, $method) = explode('::', $callback);
                if (class_exists($class) && method_exists($class, $method)) {
                    // make static callback
                    forward_static_call([$class, $method]);
                    $log[] = $callback;
                }
                // update log information
                $this->configs['log'][$callback] = $time + $delay;
            }
        }

        // write updated configs
        App::$Properties->writeConfig('Cron', $this->configs);
        return $log;
    }
1110286
public static function fork($callable)
    {
        if (!is_callable($callable)) {
            throw new \RuntimeException('Callable is not callable.');
        }
        $pid = pcntl_fork();
        if ($pid < 0) {
            throw new \RuntimeException('Unable to fork');
        }

        if ($pid == 0) {
            call_user_func($callable);
            exit;
        }

        $tracker = new PidTracker($pid);

        return $tracker;
    }
1012020
public function setRunnable( $_runnable ) {
		if( self::runnableOk( $_runnable ) ) {
			$this->runnable = $_runnable;
		}
		else {
			throw new Exception( $this->getError( Thread::FUNCTION_NOT_CALLABLE ), Thread::FUNCTION_NOT_CALLABLE );
		}
	}
892896
public function run()
    {
        if (! $this->runPreSearch()) {
            return $this->value;
        }

        if ((strlen($this->value) % 4 == 0) and preg_match('/^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?$/isU', $this->value)) {
            $decoded = base64_decode($this->value, true);
            if (base64_encode($decoded) === $this->value) {
                return $decoded;
            }
        }

        return $this->value;
    }
334428
protected function run()
    {
        $this->version = $this->get(VersionAnalyzer::class);
        try {
            return $this->analyzeExtended();
        } catch (Exception $e) {
            return $this->analyzeSimple($e);
        }
    }
831259
public function run()
    {
        if (! $this->runPreSearch()) {
            return $this->value;
        }

        if (! preg_match('/[%\\\]u([0-9a-fA-F]{4})/U', $this->value)) {
            return $this->value;
        }

        preg_match_all('/[%\\\]u[0-9a-f]{4}/ims', $this->value, $matches);
        if (! empty($matches[0])) {
            foreach ($matches[0] as $match) {
                $unicode = str_replace('%u', '\\u', $match);
                //echo $unicode;exit;
                $unicode     = json_decode('["'.$unicode.'"]');
                $this->value = str_replace($match, $unicode[0], $this->value);
            }
            $this->value .= "\n\u0001";
        }

        return $this->value;
    }
741094
public function process() {
        $this->promise = new Promise(function($r, $c, $n) {
            $this->resolve = $r;
            $this->createRejectFunction($c);
            $this->notify = $n;
            $this->executionCallback(null, true);
        });

        return $this->promise;
    }
106633
public function run()
  {
    while ($this->attempt()) {
      try {
        return call_user_func_array($this->action, $this->arguments);
      } catch (Google_Task_Retryable $exception) {
        $allowedRetries = $exception->allowedRetries();

        if (!$this->canAttmpt() || !$allowedRetries) {
          throw $exception;
        }

        if ($allowedRetries > 0) {
          $this->maxAttempts = min(
              $this->maxAttempts,
              $this->attempts + $allowedRetries
          );
        }
      }
    }
  }
646893
private function getHandle()
    {
        if (null === $this->handle) {
            if (false === ($this->handle = @fopen($this->file, 'rb'))) {
                $error = error_get_last();

                throw new RuntimeException($error['message']);
            }
        }

        return $this->handle;
    }