Public: Get all the gates used to determine enabled/disabled for the feature.

 Returns an array of gates
171487
def gates
      @gates ||= [
        Gates::Boolean.new,
        Gates::Actor.new,
        Gates::PercentageOfActors.new,
        Gates::PercentageOfTime.new,
        Gates::Group.new,
      ]
    end
827891
def get_disabled():
    '''
    
    '''
    (enabled_services, disabled_services) = _get_service_list(include_enabled=False,
                                                              include_disabled=True)
    return sorted(disabled_services)
58697
public function getStateAllowableValues()
    {
        return [
            self::STATE_OFFLINE,
            self::STATE_ONLINE,
            self::STATE_ONLINING,
            self::STATE_REINFORCED,
            self::STATE_UNANCHORING,
        ];
    }
58493
public function getEnabledPluginActions()
    {
        $enabledActionsList = array();

        $configValues = $this->config->toArray();

        // find all settings that start with "enable_" in the config-value-name and collect all active ones
        $searchKeyPart = 'enable_';
        foreach ($configValues as $key => $val) {
            if (substr($key, 0, strlen($searchKeyPart)) == $searchKeyPart) {
                if ($val) {
                    $enabledActionsList[$key] = $val;
                }
            }
        }

        return $enabledActionsList;
    }
543158
def _get_enabled_disabled(enabled_prop="true"):
    '''
    
    '''
    ret = set()
    cmd = '/usr/bin/svcprop -c -p general/enabled "*"'
    lines = __salt__['cmd.run_stdout'](cmd, python_shell=False).splitlines()
    for line in lines:
        comps = line.split()
        if not comps:
            continue
        if comps[2] == enabled_prop:
            ret.add(comps[0].split("/:properties")[0])
    return sorted(ret)
878965
def get_all(self):
    
    return [{'label': x[0], 'timing': x[1], 'is_tool': x[0] in self._tool_labels}
            for x in sorted(self._timings_by_path.items(), key=lambda x: x[1], reverse=True)]
1306572
def get_all_handleable_roots(self):
        
        nodes = self.get_device_tree()
        return [node.device
                for node in sorted(nodes.values(), key=DevNode._sort_key)
                if not node.ignored and node.device
                and (node.root == '/' or nodes[node.root].ignored)]
980563
public static function get_enabled_plugins() {
        global $CFG;

        $order = (!empty($CFG->converter_plugins_sortorder)) ? explode(',', $CFG->converter_plugins_sortorder) : [];
        if ($order) {
            $plugins = \core_plugin_manager::instance()->get_installed_plugins('fileconverter');
            $order = array_intersect($order, array_keys($plugins));
        }

        return array_combine($order, $order);
    }
784157
def getAllowedTransitions(instance):
    
    wftool = getToolByName(instance, "portal_workflow")
    transitions = wftool.getTransitionsFor(instance)
    return [trans['id'] for trans in transitions]
1063942
public static function get_enabled_plugins() {
        $enabled = array();
        $plugins = core_plugin_manager::instance()->get_installed_plugins('dataformat');

        if (!$plugins) {
            return array();
        }

        $enabled = array();
        foreach ($plugins as $plugin => $version) {
            $disabled = get_config('dataformat_' . $plugin, 'disabled');
            if (empty($disabled)) {
                $enabled[$plugin] = $plugin;
            }
        }
        return $enabled;
    }
128897
public function getPluginsLoadedAndActivated()
    {
        if (is_null($this->pluginsLoadedAndActivated)) {
            $enabled = $this->getActivatedPlugins();

            if (empty($enabled)) {
                return array();
            }

            $plugins = $this->getLoadedPlugins();
            $enabled = array_combine($enabled, $enabled);
            $plugins = array_intersect_key($plugins, $enabled);

            $this->pluginsLoadedAndActivated = $plugins;
        }

        return $this->pluginsLoadedAndActivated;
    }
1353590
def get_all():
    '''
    
    '''
    (enabled_services, disabled_services) = _get_service_list(include_enabled=True,
                                                              include_disabled=True)
    enabled_services.update(dict([(s, []) for s in disabled_services]))
    return odict.OrderedDict(enabled_services)
887119
def all(cls, include_deactivated=False):
        
        if include_deactivated:
            resources = yield cls.view.get(include_docs=True)
        else:
            resources = yield cls.active_view.get(include_docs=True)
        raise Return([cls(**resource['doc']) for resource in resources['rows']])
276706
def get_enabled():
    '''
    
    '''
    raw_services = _get_services()
    services = set()
    for service in raw_services:
        if info(service['ServiceName'])['StartType'] in ['Auto']:
            services.add(service['ServiceName'])

    return sorted(services)
1108541
def _get_enabled():
    """"""
    providers = Provider.objects.all()
    return [p for p in providers if p.enabled()]
1056157
def get_enabled_plugins():
    '''
    
    '''
    plugins = entrypoints.get_enabled('udata.preview', current_app).values()
    valid = [p for p in plugins if issubclass(p, PreviewPlugin)]
    for plugin in plugins:
        if plugin not in valid:
            clsname = plugin.__name__
            msg = '{0} is not a valid preview plugin'.format(clsname)
            warnings.warn(msg, PreviewWarning)
    return [p() for p in sorted(valid, key=lambda p: 1 if p.fallback else 0)]
205799
def get_enabled():
    '''
    
    '''
    ret = []
    for rconf in ('/etc/rc.conf', '/etc/rc.conf.local'):
        if os.access(rconf, os.R_OK):
            with salt.utils.files.fopen(rconf, 'r') as _fp:
                for line in _fp:
                    line = salt.utils.stringutils.to_unicode(line)
                    if not line.strip():
                        continue
                    if not line.startswith('jail_list='):
                        continue
                    jails = line.split('"')[1].split()
                    for j in jails:
                        ret.append(j)
    return ret