Get the options that have been set.

        Called after the user has added all their own options
        and is ready to use the variables.
327558
def get_options(self):
        
        (options, args) = self.parser.parse_args()

        # Set values from .visdkrc, but only if they haven't already been set
        visdkrc_opts = self.read_visdkrc()
        for opt in self.config_vars:
            if not getattr(options, opt):
                # Try and use value from visdkrc
                if visdkrc_opts:
                    if opt in visdkrc_opts:
                        setattr(options, opt, visdkrc_opts[opt])

        # Ensure all the required options are set
        for opt in self.required_opts:
            if opt not in dir(options) or getattr(options, opt) == None:
                self.parser.error('%s must be set!' % opt)

        return options
122617
public function prepareVars()
    {
        $this->vars['placeholder'] = $this->placeholder;
        $this->vars['useKey'] = $this->useKey;
        $this->vars['field'] = $this->formField;
        $this->vars['fieldOptions'] = $this->getFieldOptions();
        $this->vars['selectedValues'] = $this->getLoadValue();
        $this->vars['customSeparators'] = $this->getCustomSeparators();
    }
53231
public Set<String> getOptionsValues() {
        Set<String> result = new HashSet<>();
        for (OptionGroup group : optionGroups.values()) {
            result.addAll(group.getOptionValues());
        }

        return result;
    }
318905
protected function initOptions()
    {
        $reflectedClient = new \ReflectionObject($this);
        $constants       = $reflectedClient->getConstants();

        foreach ($constants as $constant => $value) {
            if (strpos($constant, 'OPTION_') === 0) {
                $this->availableOptions[] = $value;
            }
        }
    }
923650
def GetOptions(self):
    
    values = [c.GetValue()
              for c in chain(*self.widgets)
              if c.GetValue() is not None]
    return ' '.join(values)
991251
protected function getOptions()
	{
		// Initialize variables.
		$options = array();

		if ($this->element['option_blank'])
		{
			$options[] = Dropdown::option('', App::get('language')->txt('- Select -'), 'value', 'text');
		}

		foreach ($this->element->children() as $option)
		{
			// Only add <option /> elements.
			if ($option->getName() != 'option')
			{
				continue;
			}

			$label = (isset($option[0]) ? $option[0] : $option['label']);

			// Create a new option object based on the <option /> element.
			$tmp = Dropdown::option((string) $option['value'],
				App::get('language')->alt(trim((string) $label), preg_replace('/[^a-zA-Z0-9_\-]/', '_', $this->fieldname)), 'value', 'text',
				((string) $option['disabled'] == 'true')
			);
			foreach ($option->attributes() as $index => $value)
			{
				$dataCheck = strtolower(substr($index, 0, 4));
				if ($dataCheck == 'data')
				{
					$tmp->$index = (string) $value;
				}
			}

			// Set some option attributes.
			$tmp->class = (string) $option['class'];

			// Set some JavaScript option attributes.
			$tmp->onclick = (string) $option['onclick'];

			// Add the option object to the result set.
			$options[] = $tmp;
		}

		reset($options);

		return $options;
	}
1116761
def options(self, new):
        
        options = self._create_options(new)
        if self.widget.value:
            self.widget.set_param(options=options, value=list(options.values())[:1])
        else:
            self.widget.options = options
            self.widget.value = list(options.values())[:1]
90488
private function populateOptions()
    {
        $flatOptions = $this->getRawOptions();

        $this->parser->parseInput($flatOptions);

        $parsed = $this->parser->getOptions();

        foreach ($parsed as $optionName => $optionValue) {
            //ignores any options the user sent which were not defined
            $this->options->setValueIfExists($optionName, $optionValue);
        }
    }
594168
def _option(self):
        
        class Options(object):
            def __getitem__(_self, name):
                return self.getOption(name)

            def __setitem__(_self, name, value):
                self.setOption(name, value)

        return Options()
408126
@Override
    public List<String> getValues() throws WidgetException {
        List<String> options = new ArrayList<String>();
        List<WebElement> elements = findElements();
        for (WebElement we : elements) {
            options.add(we.getAttribute("value"));
        }
        return options;
    }
1124177
def parse_options(self, option_values):
        
        self.set_options_values(option_values, parse=True)
        return self.get_options_values(hidden=False)
184607
def load(**options):
    
    log.msg("Hello!, I am a dummy, so I won't do a thing!")
    if len(options):
        log.msg_debug("I have received a bunch of options, here they come ...")
        for o, v in options.items():
            log.msg_debug("Option: name={name}, value={value}"
                          .format(name=o, value=v))
108041
def _calculate_options(self):
        """"""
        _options = self._default_options.copy()
        _options.update(self.options)
        if self.options_param:
            _options.update(self.options_param)
        return _options
46345
public Map<String, ? extends Object> getOptionValues()
    {
        Map<String, Object> opts = new HashMap<String, Object>();
        for (Option opt : options)
        {
            if (opt.wasGiven()) opts.put( opt.getName(), opt.getValue() );
        }

        return opts;
    }
478504
def view_variables
      instance_variables
        .select { |var| additional_var?(var) }
        .map { |var| fetch_ivar_value(var) }
    end
1237264
function() {
    var allOptions = this.dropdown.options;
    
    // Look for multiple selections
    if(this.multiple) {
        var values = [],
            i=0, j=allOptions.length;
        for(; i<j; i++) {
            if(allOptions[i].selected) {
                values.push(allOptions[i].value);
            }
        }
        return values;
    }
    // Only need to look for single selection
    else {
        return allOptions[allOptions.selectedIndex].value;
    }
}
1019431
def options(self):
        
        if self._option_view is None:
            self._option_view = Option.View(self)
        return self._option_view