Own parameters for this state. state.url.params is already built at this point. Create and add non-url params
161964
function(state) {
      var params = state.url && state.url.params || new $$UMFP.ParamSet();
      forEach(state.params || {}, function(config, id) {
        if (!params[id]) params[id] = new $$UMFP.Param(id, null, config, "config");
      });
      return params;
    }
978502
def insert_param(self, param):
        
        self._current_params = tuple([param] + list(self._current_params))
76885
def build_params(self, params={}):
        
        z = params.copy()
        z.update({'editId': self.edit_id, 'packageName': self.package_name})
        return z
479727
function(name, url, params, options) {
        OpenLayers.Layer.prototype.initialize.apply(this, [name, options]);
        this.url = url;
        if (!this.params) {
            this.params = OpenLayers.Util.extend({}, params);
        }
    }
52259
def _init_event_data(params)
      # set state
      @state = {
        reloaded: !params[:evnt].nil?,
        saved: true
      }

      # set options
      initial_options = {
        exceptions: false,
        silent: false
      }
      default_options = _safe_default_options || {}
      params_options = params[:_options] || {}
      @options = initial_options.merge(default_options)
                                .merge(params_options)

      # set name and attributes
      @name = _safe_name
      @attributes = _safe_attributes

      # set payload
      payload = params.reject { |k, _v| k[0] == '_' }
      @payload = @state[:reloaded] ? payload : _generate_payload(payload)

      # set extras
      @extras = {}
      extras = params.select { |k, _v| k[0] == '_' }
      extras.each { |k, v| @extras[k[1..-1].to_sym] = v }
    end
775540
function (url) {
		var current = this.current, params = current.params;

		var state = find(url);

		if (state.is_changed(current.name, params)) {
			this.current = state;
			this.trigger_event("state_changed", state);
			this.trigger_event("state_changed_success", url);
		}
	}
672632
def submit_url(self, url, params={}, _extra_params={}):
        
        self._check_user_parameters(params)
        params = copy.copy(params)
        params['url'] = url
        return self._submit(params, _extra_params=_extra_params)
310419
function initParams(uri, options, callback) {
  if ((typeof options === 'function') && !callback) callback = options
  if (options && typeof options === 'object') {
    options.uri = uri
  } else if (typeof uri === 'string') {
    options = {uri:uri}
  } else {
    options = uri
    uri = options.uri
  }
  return { uri: uri, options: options, callback: callback }
}
576799
def authorize_url(params = {})
      params = (params || {}).merge(redirection_params)
      connection.build_url(options[:authorize_url], params).to_s
    end
1126220
function mergeUrlWithParams(url, params) {
        params = params || {};
        return _.isEmpty(params) ? url : url + "?" + qs.stringify(params);
    }
1023597
function() {
  var args = Array.from(arguments)
  var url = _.get(args, '[0]', '')
  var params = _.get(args, '[1]', {})

  // if we specify all of the options as a param object, we're basically done
  // and we can skip all of the parameterization checks below
  if (_.isPlainObject(_.get(args, '[0]', {})))
  {
    params = _.get(args, '[0]', {})
  }
   else
  {
    params = _.assign({}, { url }, params)
  }

  return _.assign({}, params, { op: 'request' })
}
49329
function(state) {
      return state.parent && state.parent.params ? extend(state.parent.params.$$new(), state.ownParams) : new $$UMFP.ParamSet();
    }
1138840
function(params) {

                corbel.validate.value('id', this.id);

                var options = params ? corbel.utils.clone(params) : {};

                var args = corbel.utils.extend(options, {
                    url: this._buildUriWithDomain(this.id),
                    method: corbel.request.method.GET,
                    query: params ? corbel.utils.serializeParams(params) : null
                });

                return this.request(args);

            }
1179000
public static String newUrl(final String baseUrl, 
        final Collection<Pair<String, String>> params)
        {
        final StringBuilder sb = new StringBuilder();
        sb.append(baseUrl);
        sb.append(getUrlParameters(params, true));
        return sb.toString();
        }
1325521
function appendParams(url, specificParams) {
    // Assign default and specific parameters
    var params = Object.assign({}, defaultParams, specificParams);

    // Stringify the querystring params
    var paramsString = qs.stringify(params);

    // Empty params
    if (paramsString === '') {
      return url;
    }

    // Does url contain parameters already?
    var delim = url.includes('?') ? '&' : '?';

    return url + delim + paramsString;
  }
206280
function _createRequestParams(params){
  var resourcePath = params.resourcePath;

  resourcePath = resourcePath.replace(":domain", params.domain)
    .replace(":projectid", params.projectid)
    .replace(":guid", params.appid);

  log.logger.debug("Creating Request Params For Core ", params);
  var coreHost = params.appMbaasModel.coreHost;
  if(coreHost.indexOf("http") !== 0){
    // We do not know protocol so using https as default one.
    coreHost = "https://" + coreHost;
  }
  return {
    url: url.format(coreHost + resourcePath),
    method: params.method,
    headers: {
      'x-fh-auth-app' : params.apiKey
    },
    json: true,
    body: params.data || {}
  };
}
730603
def build_uri(method, params = {})
      uri = URI(api_server)
      uri.path  = '/api/' + method.sub('.', '/')
      uri.query = URI.encode_www_form(sign(params))

      SchoolFriend.logger.debug "API Request: #{uri}"

      uri
    end