Set the class you want to load from the raw option array
764887
protected function setClass()
    {
        if (!isset($this->rawOptions['class'])) {
            $this->rawOptions['class'] = static::DEFAULT_CLASS;
        }

        $this->class = $this->rawOptions['class'];
        unset($this->rawOptions['class']);
    }
1094589
private void loadOptions(final P6LoadableOptions options) {
		// make sure to load defaults first
		options.load(options.getDefaults());

		// load the rest in the right order then
		for (P6OptionsSource optionsSource : optionsSources) {
			Map<String, String> toLoad = optionsSource.getOptions();
			if (null != toLoad) {
				options.load(toLoad);
			}
		}

		// register to all the props then
		allOptions.put(options.getClass(), options);
	}
536757
public static function select($name,
                           $class,
                           $id,
                           array $options,
                           $opt_value = NULL,
                           $label = NULL,
                           $attrs = array())
    {
        $attrs['name'] = $name;
        
        $opts = array();
        foreach($options as $value => $msg)
        {
            $opt_attr = array(
              'value' => $value 
            );
            
            if(($opt_value) && $value == $opt_value)
                $opt_attr['selected'] = 'selected';
            
            $opts[] = self::tag('option', $msg, NULL, NULL, $opt_attr);
            
        }
        
        $opts = self::parseBreak(implode(PHP_EOL, $opts));
        $ret = NULL;
        if($label)
            $ret = PHP_EOL . self::formatLabel($label, $id);
            
        $ret .= self::parseBreak(self::tag('select', $opts, $class, $id, $attrs));
        return $ret;
    }
357227
function loadArrayOptGroups($arr, $values=null)
    {
        if (!is_array($arr)) {
            return self::raiseError('Argument 1 of HTML_Select::loadArrayOptGroups is not a valid array');
        }
        if (isset($values)) {
            $this->setSelected($values);
        }
        foreach ($arr as $key => $val) {
            // Warning: new API since release 2.3
            $this->addOptGroup($key, $val);
        }
        return true;
    }
1083627
protected function getRawOptions()
    {
        global $argv;

        if (!is_array($this->rawOptions)) {
            $this->setRawOptions($argv);
        }

        return $this->rawOptions;
    }
740687
private function loadOptionValues(): void
	{
		$this->optionValues = array_merge(
			Option::getDefaults($this->moduleId),
			Option::getForModule($this->moduleId)
		);
	}
716406
def load_from_args(active_relation_or_array,*args)
      options = args.extract_options!
      @name = (options[:name] || Time.now.strftime("%Y_%m_%d_%H_%M_%S")).to_sym
      if active_relation_or_array.kind_of? String
        @extract_code = active_relation_or_array
      else
        raise "Extract code must be a string, so .rebuild can be called"
      end
    end
208861
function initArrays(optlist, parsedOptions){
	Object.keys(optlist).forEach(function(key) {
		if (optlist[key].type === Array && !(key in parsedOptions)) {
			parsedOptions[key] = [];
		}
	});
}
163922
function(class_datas) {

		for (var i = 0, count = class_datas.length; i <count; i++) {

			this.loadClass(class_datas[i]);

		}

	}
1065604
def load(json_src, save=False):
    """"""
    if isinstance(json_src, six.string_types):
        json_src = json_lib.loads(json_src)

    if isinstance(json_src, list):
        return [getattr(objects, obj['class']).load(obj, save)
                for obj in json_src]

    return getattr(objects, json_src['class']).load(json_src, save)
645314
function(options) {
      inputEx.Field.superclass.setOptions.call(this, options);
      
      this.options.wirable = lang.isUndefined(options.wirable) ? false : options.wirable;
      this.options.container = options.container;
      options.container = null;
   }
378964
function _setRaw(raw: Object, key: string, value: any, columnSchema: ColumnSchema): void {
  const { type, isOptional } = columnSchema

  // If the value is wrong type or invalid, it's set to `null` (if optional) or empty value ('', 0, false)
  if (type === 'string') {
    if (typeof value === 'string') {
      raw[key] = value
    } else {
      raw[key] = isOptional ? null : ''
    }
  } else if (type === 'boolean') {
    if (typeof value === 'boolean') {
      raw[key] = value
    } else if (value === 1 || value === 0) {
      // Exception to the standard rule — because SQLite turns true/false into 1/0
      raw[key] = Boolean(value)
    } else {
      raw[key] = isOptional ? null : false
    }
  } else {
    // type = number
    // Treat NaN and Infinity as null
    if (isValidNumber(value)) {
      raw[key] = value
    } else {
      raw[key] = isOptional ? null : 0
    }
  }
}
512623
def load(self, raw):
        
        try:
            self._load(raw)
        except (KeyError, ValueError) as e:
            raise_from(exception.ParseException('Parse error in %s' % (type(self)), raw), e)
124772
def load(self, rawdata):
        
        if isinstance(rawdata, str):
            self.__parse_string(rawdata)
        else:
            # self.update() wouldn't call our custom __setitem__
            for key, value in rawdata.items():
                self[key] = value
        return
1183052
def from_array(cls, arr, index=None, name=None, copy=False,
                   fill_value=None, fastpath=False):
        
        warnings.warn("'from_array' is deprecated and will be removed in a "
                      "future version. Please use the pd.SparseSeries(..) "
                      "constructor instead.", FutureWarning, stacklevel=2)
        return cls(arr, index=index, name=name, copy=copy,
                   fill_value=fill_value, fastpath=fastpath)
94923
def load(self, _override=True, _allow_undeclared=False, **kwargs):
    """"""
    self.load_from_dict(
        kwargs, _override=_override, _allow_undeclared=_allow_undeclared)
691940
def _get_render_prepared_object(cls, context, **option_values):
        
        ctx_vals = cls._create_contextualvals_obj_from_context(context)
        opt_vals = cls._create_optionvals_obj_from_values(**option_values)

        if issubclass(cls, models.Model):
            instance = cls.get_from_collected_values(ctx_vals, opt_vals)
        else:
            instance = cls.create_from_collected_values(ctx_vals, opt_vals)
        if not instance:
            return None

        instance.prepare_to_render(context['request'], ctx_vals, opt_vals)
        return instance