Gets the default command loop listeners.

@return array An array of Execution Loop Listener instances
163041
protected function getDefaultLoopListeners()
    {
        $listeners = [];

        if (ProcessForker::isSupported() && $this->config->usePcntl()) {
            $listeners[] = new ProcessForker();
        }

        if (RunkitReloader::isSupported()) {
            $listeners[] = new RunkitReloader();
        }

        return $listeners;
    }
1072828
public function getCommands(): array
    {
        $commands           = [
            $this->container->get(GenerateRelationsCommand::class),
            $this->container->get(GenerateEntityCommand::class),
            $this->container->get(SetRelationCommand::class),
            $this->container->get(GenerateFieldCommand::class),
            $this->container->get(SetFieldCommand::class),
            $this->container->get(SetEmbeddableCommand::class),
            $this->container->get(GenerateEmbeddableFromArchetypeCommand::class),
            $this->container->get(GenerateEmbeddableSkeletonCommand::class),
            $this->container->get(RemoveUnusedRelationsCommand::class),
            $this->container->get(OverrideCreateCommand::class),
            $this->container->get(OverridesUpdateCommand::class),
            $this->container->get(CreateConstraintCommand::class),
            $this->container->get(FinaliseBuildCommand::class),
            $this->container->get(CreateConstraintCommand::class),
        ];
        $migrationsCommands = [
            $this->container->get(ExecuteCommand::class),
            $this->container->get(GenerateCommand::class),
            $this->container->get(LatestCommand::class),
            $this->container->get(MigrateCommand::class),
            $this->container->get(DiffCommand::class),
            $this->container->get(UpToDateCommand::class),
            $this->container->get(StatusCommand::class),
            $this->container->get(VersionCommand::class),
        ];
        foreach ($migrationsCommands as $command) {
            $commands[] = $this->addMigrationsConfig($command);
        }

        return $commands;
    }
307722
public function getCalledListeners(/* Request $request = null */)
    {
        if (null === $this->callStack) {
            return [];
        }

        $hash = 1 <= \func_num_args() && null !== ($request = \func_get_arg(0)) ? spl_object_hash($request) : null;
        $called = [];
        foreach ($this->callStack as $listener) {
            list($eventName, $requestHash) = $this->callStack->getInfo();
            if (null === $hash || $hash === $requestHash) {
                $called[] = $listener->getInfo($eventName);
            }
        }

        return $called;
    }
1117494
public function get_instance_defaults() {
        $expirynotify = $this->get_config('expirynotify');
        if ($expirynotify == 2) {
            $expirynotify = 1;
            $notifyall = 1;
        } else {
            $notifyall = 0;
        }

        $fields = array();
        $fields['status']          = $this->get_config('status');
        $fields['roleid']          = $this->get_config('roleid');
        $fields['enrolperiod']     = $this->get_config('enrolperiod');
        $fields['expirynotify']    = $expirynotify;
        $fields['notifyall']       = $notifyall;
        $fields['expirythreshold'] = $this->get_config('expirythreshold');
        $fields['customint1']      = $this->get_config('groupkey');
        $fields['customint2']      = $this->get_config('longtimenosee');
        $fields['customint3']      = $this->get_config('maxenrolled');
        $fields['customint4']      = $this->get_config('sendcoursewelcomemessage');
        $fields['customint5']      = 0;
        $fields['customint6']      = $this->get_config('newenrols');

        return $fields;
    }
854368
public function getScheduledCommands()
    {
        $scheduledCommands = [];
        foreach ($this->console->all() as $command) {
            if ($command instanceof ScheduledCommandInterface) {
                $scheduledCommands[] = $command;
            }
        }

        return $scheduledCommands;
    }
364897
protected function getCommandNames()
    {
        // Command::Hidden isn't supported before Symfony Console 3.2.0
        // We don't complete hidden command names as these are intended to be private
        if (method_exists('\Symfony\Component\Console\Command\Command', 'isHidden')) {
            $commands = array();

            foreach ($this->application->all() as $name => $command) {
                if (!$command->isHidden()) {
                    $commands[] = $name;
                }
            }

            return $commands;

        } else {

            // Fallback for compatibility with Symfony Console < 3.2.0
            // This was the behaviour prior to pull #75
            $commands = $this->application->all();
            unset($commands['_completion']);

            return array_keys($commands);
        }
    }
1269890
protected function getDefaultCommands()
    {

        $shell = new Shell(dirname(VENDOR_PATH));

        $handlers = [
            'source' => new Handler\Source($shell),
            'coverage' => new Handler\Coverage(),
            'pdepend' => new Handler\PDepend($shell),
            'dependencies' => new Handler\Dependencies($shell),
            'phpmd' => new Handler\PHPMD($shell),
            'checkstyle' => new Handler\Checkstyle($shell),
            'tests' => new Handler\Tests(),
            'cpd' => new Handler\CPD($shell),
            'phploc' => new Handler\Phploc($shell),
            'git' => new Handler\Git($shell),
            'gitDetailed' => new Handler\GitDetailed($shell),
        ];

        return array_merge(
            parent::getDefaultCommands(),
            [
                new Command\Serve(),
                new Command\Bundle(),
                new Command\Analyze($handlers),
                new Command\Analyzers($handlers),
            ]
        );
    }
82177
private function getEventLoop()
    {
        if (! $this->eventLoop instanceof LoopInterface) {
            $this->eventLoop = EventLoop::create();
        }

        return $this->eventLoop;
    }
1219131
protected List<SebListener> getDefaultListeners() {
		return new ArrayList<>(Arrays.asList(new ConfigListener(), new LoggingListener(), new SebLogListener(),
				new WebDriverLogListener(), new PageSourceListener(), new ScreenshotListener()));
	}
523642
public function getCommandline(): array
    {
        $args = $this->getArguments();
        if ($this->executable !== null && $this->executable !== '') {
            array_unshift($args, $this->executable);
        }

        return $args;
    }
445036
protected function defaultCommandVariables()
    {
        $this->type     = NULL;
        $this->path     = NULL;
        $this->command  = NULL;
        $this->debug    = false;
    }
185678
protected function getCommands(): array
	{
		$info = [];

		foreach($this->commands as $name => $class)
		{
			$command = $this->instantiateCommandWithoutConstructor($class);

			$info[$name] = [$name, $command->getCommandDescription()];
		}

		ksort($info);

		return $info;
	}
15820
public function getDefaultValues()
    {
        $values = [];
        foreach ($this->getColumns() as $column) {
            $values[$column->getName()] = $column->getDefaultValue();
        }
        return $values;
    }
188979
public function attachDefaultListeners()
    {
        parent::attachDefaultListeners();

        $serviceLocator  = $this->serviceLocator;
        $defaultServices = $serviceLocator->get('DefaultListeners');
        $events          = $this->getEventManager();
        $events->attach($defaultServices);

        return $this;
    }
1190104
public function getListeners($eventName = NULL)
	{
		if($eventName === NULL)
		{
			$listeners = [];
			
			foreach(array_keys($this->listeners) as $k)
			{
				$listeners[$k] = [];
				
				foreach(clone $this->listeners[$k] as $listener)
				{
					$listeners[$k][] = $listener;
				}
			}
			
			ksort($listeners);
			
			return $listeners;
		}
		
		if($eventName instanceof \ReflectionClass)
		{
			$eventName = $eventName->name;
		}
		
		if(empty($this->listeners[$eventName]))
		{
			return [];
		}
		
		$listeners = [];
		
		foreach(clone $this->listeners[$eventName] as $listener)
		{
			$listeners[] = $listener;
		}
		
		return $listeners;
	}
909217
protected static function _list()
    {
        if (empty(static::$_listeners)) {
            $manager = EventDispatcher::instance('Shortcode')->eventManager();
            static::$_listeners = listeners($manager);
        }

        return static::$_listeners;
    }
1311785
public function requestCommands(): array
    {
        if ($this->_requestCommands === null) {
            $reflection = new ReflectionClass($this);

            $commands = [];
            foreach ($reflection->getConstants() as $name => $value) {
                if (strpos($name, 'RC_') === 0) {
                    $commands[] = $value;
                }
            }

            return $this->_requestCommands = $commands;
        } else {
            return $this->_requestCommands;
        }
    }