Adds data contained in the `extra` parameter if it has been specified
436286
function addExtra(properties, extra) {
    for(var key in extra){
      if(extra.hasOwnProperty(key)) {
        properties[key] = extra[key];
      }
    }

    return properties;
  }
1087107
def addValue(self, source, data):
    """"""
    self.__result[self._dataFormat.getValue(data)].append(source)
207107
function addParameter(data, parameter) {
            var regex = '(' + parameter + '=[a-z0-9-]+)';
            var search = window.location.search.match(regex);
            if (search) {
                data.push(search[1]);
            }
            var hash = window.location.hash.match(regex);
            if (hash) {
                data.push(hash[1]);
            }
        }
1139055
def insertData(self, offset: int, string: str) -> None:
        """"""
        self._insert_data(offset, string)
43188
def additional_data(data = '')

      # abort data.inspect

      if !data.blank?
        data.each do |key, value|
          data[key.to_sym] = value[0] if value.size < 2
        end
        self.post_additional_data = ActiveSupport::JSON.encode(data)
      else
        self.post_additional_data = ''
      end

    end
603672
def load_extra_data(cls, data):
    
    try:
      cls._extra_config.update(json.loads(data))
    except ValueError as exception:
      sys.stderr.write('Could convert to JSON. {0:s}'.format(exception))
      exit(-1)
80892
def _copyValues(self, to, extra=None):
        
        paramMap = self._paramMap.copy()
        if extra is not None:
            paramMap.update(extra)
        for param in self.params:
            # copy default params
            if param in self._defaultParamMap and to.hasParam(param.name):
                to._defaultParamMap[to.getParam(param.name)] = self._defaultParamMap[param]
            # copy explicitly set params
            if param in paramMap and to.hasParam(param.name):
                to._set(**{param.name: paramMap[param]})
        return to
1192068
public void prepareParameters(Map<String, Object> extra) {
        if (paramConfig == null) return;
        for (ParamConfig param : paramConfig)
        {
            param.prepareParameter(extra);
        }
    }
708425
def extra_from_record(self, record):
        
        return {
            attr_name: record.__dict__[attr_name]
            for attr_name in record.__dict__
            if attr_name not in BUILTIN_ATTRS
        }
220367
def add(self, header, data) :
		""""""
		if header[0] != '>' :
			self.data.append(('>'+header, data))
		else :
			self.data.append((header, data))
358644
def _filter_extras(dm):
        
        for extra in list(filter(None, dm)):
            new_extra = extra
            reqs = dm.pop(extra)
            new_extra, _, marker = extra.partition(':')
            fails_marker = marker and (
                invalid_marker(marker)
                or not evaluate_marker(marker)
            )
            if fails_marker:
                reqs = []
            new_extra = safe_extra(new_extra) or None

            dm.setdefault(new_extra, []).extend(reqs)
        return dm
1244606
def add_param(self, group=None, type_='', field='', description=''):
        """"""
        group = group or '(Parameter)'
        group = group.lower()[1:-1]
        p = Param(type_, field, description)
        self.params[group][p.field] = p
1016578
def add_external_parameter(self, parameter):
        

        assert isinstance(parameter, Parameter), "Variable must be an instance of IndependentVariable"

        if self._has_child(parameter.name):

            # Remove it from the children only if it is a Parameter instance, otherwise don't, which will
            # make the _add_child call fail (which is the expected behaviour! You shouldn't call two children
            # with the same name)

            if isinstance(self._get_child(parameter.name), Parameter):

                warnings.warn("External parameter %s already exist in the model. Overwriting it..." % parameter.name,
                              RuntimeWarning)

                self._remove_child(parameter.name)

        # This will fail if another node with the same name is already in the model

        self._add_child(parameter)
19241
def include_extra_kwargs(self, kwargs, extra_kwargs):
        
        if extra_kwargs.get('read_only', False):
            for attr in [
                'required', 'default', 'allow_blank', 'allow_null',
                'min_length', 'max_length', 'min_value', 'max_value',
                'validators', 'queryset'
            ]:
                kwargs.pop(attr, None)

        if extra_kwargs.get('default') and kwargs.get('required') is False:
            kwargs.pop('required')

        if extra_kwargs.get('read_only', kwargs.get('read_only', False)):
            extra_kwargs.pop('required', None)  # Read only fields should always omit the 'required' argument.

        kwargs.update(extra_kwargs)

        return kwargs
258525
private void updateMethodParameters(final Set<MethodParameter> parameters, final Set<MethodParameter> additional) {
        additional.forEach(a -> {
            // remove preexisting parameters with identical names
            final Optional<MethodParameter> existingParameter = parameters.stream().filter(p -> p.getName().equals(a.getName())).findAny();
            existingParameter.ifPresent(parameters::remove);
            parameters.add(a);
        });
    }
379672
public function appendAdditionalParams(): void
    {
        if (!empty($this->additionalSearchFields)) {
            $this->normalSearchFields = array_merge_recursive($this->normalSearchFields, $this->additionalSearchFields);
        }

        if (!empty($this->additionalCustomSearchFields)) {
            $this->customSearchFields = array_merge_recursive($this->customSearchFields, $this->additionalCustomSearchFields);
        }

        if (!empty($this->additionalRelationSearchFields)) {
            $this->relationSearchFields = array_merge_recursive($this->relationSearchFields, $this->additionalRelationSearchFields);
        }
    }
566117
def write_extra_data(self, stream: WriteStream) -> None:
        """"""
        if self.params:
            stream.align(8)
            if self._params_offset_writer:
                self._params_offset_writer.write_current_offset(stream)
            else:
                self._params_offset = stream.tell()
            self.params.write(stream)

        if self.actions:
            stream.align(8)
            if self._actions_offset_writer:
                self._actions_offset_writer.write_current_offset(stream)
            else:
                self._actions_offset = stream.tell()
            for s in self.actions:
                stream.write_string_ref(s.v)

        if self.queries:
            stream.align(8)
            if self._queries_offset_writer:
                self._queries_offset_writer.write_current_offset(stream)
            else:
                self._queries_offset = stream.tell()
            for s in self.queries:
                stream.write_string_ref(s.v)