Set the system-level disabled functions.

@return string[]
502062
public function getDisabledFunctions()
    {
        if ($this->disabledFunctions === null) {
            $iniValue = @ini_get('disable_functions');
            $this->setDisabledFunctions(is_string($iniValue) ? explode(',', $iniValue) : []);
        }

        return $this->disabledFunctions;
    }
199414
public static function getStatusesArray() : array
    {
        return [
            self::STATUS_BLOCKED => Yii::t('setrun/user', 'Blocked'),
            self::STATUS_ACTIVE  => Yii::t('setrun/user', 'Active'),
            self::STATUS_WAIT    => Yii::t('setrun/user', 'Wait')
        ];
    }
847496
public function defaultSettings()
    {
        $handler = $this->get('handler');
        if (class_exists($handler)) {
            $handler = new $handler();

            return $handler->defaultSettings($this);
        }

        return [];
    }
733430
public function isEnabled()
    {
        return isset($this->config->enable->value) && $this->config->enable->value;
    }
951353
public function setDisabledFunctions($functionNames)
    {
        $normalized = [];
        if (is_array($functionNames) || $functionNames instanceof Traversable) {
            foreach ($functionNames as $functionName) {
                if (is_string($functionName)) {
                    $functionName = trim($functionName);
                    if ($functionName !== '') {
                        $normalized[] = strtolower($functionName);
                    }
                }
            }
        }
        $this->disabledFunctions = $normalized;

        return $this;
    }
435114
protected function populateDisabledPluginsFromDb()
    {
        if (!App::hasDatabase()) {
            return;
        }

        if (!Schema::hasTable('system_plugin_versions')) {
            return;
        }

        $disabled = Db::table('system_plugin_versions')->where('is_disabled', 1)->lists('code');

        foreach ($disabled as $code) {
            $this->disabledPlugins[$code] = true;
        }
    }
758276
public static function enable()
    {
        self::$startValues = array(
            'time' => microtime(true),
            'realmem' => memory_get_usage(true),
            // 'emalloc' => memory_get_usage(false)
        );
        self::$_enabled = true;
    }
1367393
protected function allowedTypes()
    {
        return [
            self::TYPE_DEFAULT_MESSAGE,
            self::TYPE_REGISTRATION_MESSAGE,
            self::TYPE_RESET_PASSWORD_MESSAGE,
            self::TYPE_LOGIN_MESSAGE,
            self::TYPE_NOTIFICATION_MESSAGE,
        ];
    }
827891
def get_disabled():
    '''
    
    '''
    (enabled_services, disabled_services) = _get_service_list(include_enabled=False,
                                                              include_disabled=True)
    return sorted(disabled_services)
218931
protected function getAvailableDrivers()
    {
        $supportedDrivers = [
            'pdo_mysql' => 'MySQL/MariaDB via PDO',
            'mysqli' => 'MySQL/MariaDB via mysqli',
            'pdo_pgsql' => 'PostgreSQL via PDO'
        ];

        $availableDrivers = [];
        foreach ($supportedDrivers as $driver => $label) {
            if (extension_loaded($driver)) {
                $availableDrivers[$driver] = $label;
            }
        }

        return $availableDrivers;
    }
769433
private function disableAll()
    {
        // set all non-error endpoints to disabled
        $this->getEndpoints()->map(function (Endpoint $endpoint) {
            if ($endpoint->isError() === false) {
                $endpoint->setStatus(Endpoint::STATUS_DISABLED);
            }
        });
    }
294538
public static function disable()
    {
        if (!\is_array($functions = spl_autoload_functions())) {
            return;
        }

        foreach ($functions as $function) {
            spl_autoload_unregister($function);
        }

        foreach ($functions as $function) {
            if (\is_array($function) && $function[0] instanceof self) {
                $function = $function[0]->getClassLoader();
            }

            spl_autoload_register($function);
        }
    }
928912
public function getOperationsAllowed()
    {
        if ($this->_getField(self::$OPERATIONS_ALLOWED) == '') {
            return Array();
        } else {
            return explode(',', $this->_getField(self::$OPERATIONS_ALLOWED));
        }
    }
545314
public static function get_enabled_plugins() {
        global $DB, $CFG;
        require_once("$CFG->libdir/filterlib.php");

        $enabled = array();
        $filters = $DB->get_records_select('filter_active', "active <> :disabled AND contextid = :contextid", array(
            'disabled' => TEXTFILTER_DISABLED, 'contextid' => \context_system::instance()->id), 'filter ASC', 'id, filter');
        foreach ($filters as $filter) {
            $enabled[$filter->filter] = $filter->filter;
        }

        return $enabled;
    }
507085
public function addDisableFunctions($disabledFunction) {
        if ($this->searchParams->disableFunctions == null) {
            $this->searchParams->disableFunctions = array();
        }

        $this->searchParams->disableFunctions[] = $disabledFunction;
    }
1287616
protected function _enable()
    {
        $disabledPlugins = plugin()
            ->filter(function ($plugin) {
                return !$plugin->status && !$plugin->isTheme;
            })
            ->toArray();

        if (!count($disabledPlugins)) {
            $this->err(__d('installer', '<info>There are no disabled plugins!</info>'));
            $this->out();

            return;
        }

        $index = 1;
        $this->out();
        foreach ($disabledPlugins as $plugin) {
            $disabledPlugins[$index] = $plugin;
            $this->out(__d('installer', '[{0, number, integer}] {1}', [$index, $plugin->humanName]));
            $index++;
        }
        $this->out();

        $message = __d('installer', "Which plugin would you like to activate?\n[Q]uit");
        while (true) {
            $in = $this->in($message);
            if (strtoupper($in) === 'Q') {
                $this->err(__d('installer', 'Operation aborted'));
                break;
            } elseif (intval($in) < 1 || !isset($disabledPlugins[intval($in)])) {
                $this->err(__d('installer', 'Invalid option'));
            } else {
                $task = $this->dispatchShell("Installer.plugins toggle -p {$disabledPlugins[$in]->name} -s enable");

                if ($task === 0) {
                    $this->out(__d('installer', 'Plugin enabled!'));
                    Plugin::dropCache();
                } else {
                    $this->err(__d('installer', 'Plugin could not be enabled.'), 2);
                    $this->out();
                }
                break;
            }
        }

        $this->out();
    }
842124
public static function all()
    {
        return array(
            self::ENABLED,
            self::DISABLED,
            self::TYPE_NOT_FOUND,
            self::TYPE_NOT_ENABLED,
            self::INVALID,
        );
    }