Gets all the options from the warning plugins and collects them
 with overriding rules. The later the declaration is run, the higher the
 priority the option has.
173153
def get_warning_options
      all_options = Warning.all_warnings.inject({}) do |result, warning|
        options = warning.options
        options = [options] if options.any? && !options[0].is_a?(Array)
        options.each do |option|
          result[option.first] = option
        end
        result
      end
      all_options.values
    end
23905
def get_override_configuration(self):
        
        res = {}
        properties = self.__class__.properties
        for prop, entry in list(properties.items()):
            if entry.override:
                res[prop] = getattr(self, prop)
        return res
399742
private void tryRegisterJava8Optionals() {
        try {
            loadType("java.util.OptionalInt");
            @SuppressWarnings("unchecked")
            Class<?> cls1 = (Class<TypedStringConverter<?>>) loadType("org.joda.convert.OptionalIntStringConverter");
            TypedStringConverter<?> conv1 = (TypedStringConverter<?>) cls1.getDeclaredConstructor().newInstance();
            registered.put(conv1.getEffectiveType(), conv1);

            @SuppressWarnings("unchecked")
            Class<?> cls2 = (Class<TypedStringConverter<?>>) loadType("org.joda.convert.OptionalLongStringConverter");
            TypedStringConverter<?> conv2 = (TypedStringConverter<?>) cls2.getDeclaredConstructor().newInstance();
            registered.put(conv2.getEffectiveType(), conv2);

            @SuppressWarnings("unchecked")
            Class<?> cls3 = (Class<TypedStringConverter<?>>) loadType("org.joda.convert.OptionalDoubleStringConverter");
            TypedStringConverter<?> conv3 = (TypedStringConverter<?>) cls3.getDeclaredConstructor().newInstance();
            registered.put(conv3.getEffectiveType(), conv3);

        } catch (Throwable ex) {
            if (LOG) {
                System.err.println("tryRegisterOptionals: " + ex);
            }
        }
    }
320254
function getOptions(loaderContext) {
  const options = {
    plugins: [],
    relativeUrls: true,
    ...clone(loaderUtils.getOptions(loaderContext)),
  };

  // We need to set the filename because otherwise our WebpackFileManager will receive an undefined path for the entry
  options.filename = loaderContext.resource;

  // When no paths are given, we use the webpack resolver
  if ('paths' in options === false) {
    // It's safe to mutate the array now because it has already been cloned
    options.plugins.push(createWebpackLessPlugin(loaderContext));
  }

  if (options.sourceMap) {
    if (typeof options.sourceMap === 'boolean') {
      options.sourceMap = {};
    }
    if ('outputSourceFiles' in options.sourceMap === false) {
      // Include source files as `sourceContents` as sane default since this makes source maps "just work" in most cases
      options.sourceMap.outputSourceFiles = true;
    }
  }

  return options;
}
838940
function getPlugins(){
    var plugins = $p.plugins,
      f = function(){};
    f.prototype = plugins;

    // do not overwrite functions if external definition
    f.prototype.compile    = plugins.compile || compile;
    f.prototype.render     = plugins.render || render;
    f.prototype.autoRender = plugins.autoRender || autoRender;
    f.prototype.find       = plugins.find || find;

    // give the compiler and the error handling to the plugin context
    f.prototype._compiler  = compiler;
    f.prototype._error     = error;

    return new f();
  }
1171895
public Set<List<String>> getPluginOpts() {
        String plugins = options.get(Option.PLUGIN);
        if (plugins == null)
            return Collections.emptySet();

        Set<List<String>> pluginOpts = new LinkedHashSet<>();
        for (String plugin: plugins.split("\\x00")) {
            pluginOpts.add(List.from(plugin.split("\\s+")));
        }
        return Collections.unmodifiableSet(pluginOpts);
    }
610540
public List<Option> getOptions(boolean includeDisabled) {
        List<Option> result = new ArrayList<>(); //Keep order

        if (!includeDisabled && !enabled) {
            return result;//This group is disabled entirely
        }

        for (Option option : options.values()) {
            if (includeDisabled || option.isEnabled()) {
                result.add(option);
            }
        }

        return result;
    }
480123
function defaultOptions(options) {
	options = extend({}, pa11y.defaults, options);
	options.ignore = options.ignore.map(ignored => ignored.toLowerCase());
	if (!options.includeNotices) {
		options.ignore.push('notice');
	}
	if (!options.includeWarnings) {
		options.ignore.push('warning');
	}
	return options;
}
162617
public function getOptionsList() {
    $options = [];
    foreach ($this->getDefinitions() as $plugin_id => $plugin_definition) {
      $options[$plugin_id] = Html::escape($plugin_definition['label']);
    }
    return $options;
  }
384427
function(pluginName, defaultOptions) {
		
		var self = this,
			options = $.extend(true, {}, defaultOptions);
		
		// if the plugin options were isolated in a property named after the
		// plugin, use them (prevents conflicts with other plugins)
		var pluginOptions = self.__options[pluginName];
		
		// if not, try to get them as regular options
		if (!pluginOptions){
			
			pluginOptions = {};
			
			$.each(defaultOptions, function(optionName, value) {
				
				var o = self.__options[optionName];
				
				if (o !== undefined) {
					pluginOptions[optionName] = o;
				}
			});
		}
		
		// let's merge the default options and the ones that were provided. We'd want
		// to do a deep copy but not let jQuery merge arrays, so we'll do a shallow
		// extend on two levels, that will be enough if options are not more than 1
		// level deep
		$.each(options, function(optionName, value) {
			
			if (pluginOptions[optionName] !== undefined) {
				
				if ((		typeof value == 'object'
						&&	!(value instanceof Array)
						&&	value != null
					)
					&&
					(		typeof pluginOptions[optionName] == 'object'
						&&	!(pluginOptions[optionName] instanceof Array)
						&&	pluginOptions[optionName] != null
					)
				) {
					$.extend(options[optionName], pluginOptions[optionName]);
				}
				else {
					options[optionName] = pluginOptions[optionName];
				}
			}
		});
		
		return options;
	}
1133954
def for_scope(self, scope, inherit_from_enclosing_scope=True):
    

    # First get enclosing scope's option values, if any.
    if scope == GLOBAL_SCOPE or not inherit_from_enclosing_scope:
      values = OptionValueContainer()
    else:
      values = copy.copy(self.for_scope(enclosing_scope(scope)))

    # Now add our values.
    flags_in_scope = self._scope_to_flags.get(scope, [])
    self._parser_hierarchy.get_parser_by_scope(scope).parse_args(flags_in_scope, values)

    # Check for any deprecation conditions, which are evaluated using `self._flag_matchers`.
    if inherit_from_enclosing_scope:
      self._check_and_apply_deprecations(scope, values)

    return values
746720
protected Options getOptions() throws MojoExecutionException {
        File persistence = ensurePersistenceXml();

        Options opts = new Options();
        if (toolProperties != null) {
            opts.putAll(toolProperties);
        }
        opts.put(OPTION_PROPERTIES_FILE, persistence.getAbsolutePath());

        if (connectionDriverName != null) {
            opts.put(OPTION_CONNECTION_DRIVER_NAME, connectionDriverName);
        }

        if (connectionProperties != null) {
            opts.put(OPTION_CONNECTION_PROPERTIES, connectionProperties);
        }

        // put the standard options into the list also
        opts.put(OPTION_ADD_DEFAULT_CONSTRUCTOR, Boolean.toString(addDefaultConstructor));
        opts.put(OPTION_ENFORCE_PROPERTY_RESTRICTION, Boolean.toString(enforcePropertyRestrictions));
        opts.put(OPTION_USE_TEMP_CLASSLOADER, Boolean.toString(tmpClassLoader));

        return opts;
    }
432945
@Override
	public List<CPDefinitionOptionRel> findAll() {
		return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
	}
408079
def _ParseAnalysisPluginOptions(self, options):
    
    # Get a list of all available plugins.
    analysis_plugin_info = self._analysis_manager.GetAllPluginInformation()
    # Use set-comprehension to create a set of the analysis plugin names.
    analysis_plugin_names = {
        name.lower() for name, _, _ in analysis_plugin_info}

    analysis_plugins = self.ParseStringOption(options, 'analysis_plugins')
    if not analysis_plugins:
      return

    # Use set-comprehension to create a set of the requested plugin names.
    requested_plugin_names = {
        name.strip().lower() for name in analysis_plugins.split(',')}

    # Check to see if we are trying to load plugins that do not exist.
    difference = requested_plugin_names.difference(analysis_plugin_names)
    if difference:
      raise errors.BadConfigOption(
          'Non-existent analysis plugins specified: {0:s}'.format(
              ' '.join(difference)))

    self._analysis_plugins = self._GetAnalysisPlugins(analysis_plugins)

    for analysis_plugin in self._analysis_plugins:
      helpers_manager.ArgumentHelperManager.ParseOptions(
          options, analysis_plugin)
285835
function processOptions(options) {
  // Parse preset names
  const presets = (options.presets || []).map(presetName => {
    const preset = loadBuiltin(availablePresets, presetName);

    if (preset) {
      // workaround for babel issue
      // at some point, babel copies the preset, losing the non-enumerable
      // buildPreset key; convert it into an enumerable key.
      if (
        isArray(preset) &&
        typeof preset[0] === "object" &&
        preset[0].hasOwnProperty("buildPreset")
      ) {
        preset[0] = { ...preset[0], buildPreset: preset[0].buildPreset };
      }
    } else {
      throw new Error(
        `Invalid preset specified in Babel options: "${presetName}"`,
      );
    }
    return preset;
  });

  // Parse plugin names
  const plugins = (options.plugins || []).map(pluginName => {
    const plugin = loadBuiltin(availablePlugins, pluginName);

    if (!plugin) {
      throw new Error(
        `Invalid plugin specified in Babel options: "${pluginName}"`,
      );
    }
    return plugin;
  });

  return {
    babelrc: false,
    ...options,
    presets,
    plugins,
  };
}
318752
def getPlugins():
		
		
		# Retrieve the list of detected entry points in the ue4cli.plugins group
		plugins = {
			entry_point.name: entry_point.load()
			for entry_point
			in pkg_resources.iter_entry_points('ue4cli.plugins')
		}
		
		# Filter out any invalid plugins
		plugins = {
			name: plugins[name]
			for name in plugins
			if
				'action' in plugins[name] and
				'description' in plugins[name] and
				'args' in plugins[name] and
				callable(plugins[name]['action']) == True and
				len(signature(plugins[name]['action']).parameters) == 2
		}
		
		return plugins
180734
@Override
	public Options getOptions() {
		Options opts = super.getOptions();
		opts.addOption(null, "name", true, "tenant name");
		opts.addOption(null, "description", true, "tenant description");
		opts.addOption(null, "enabled", false, "enabled");
		return opts;
	}