`URLSearchParams.prototype.getAll` method https://url.spec.whatwg.org/#dom-urlsearchparams-getall
976048
function getAll(name) {
    validateArgumentsLength(arguments.length, 1);
    var entries = getInternalParamsState(this).entries;
    var key = name + '';
    var result = [];
    var i = 0;
    for (; i < entries.length; i++) if (entries[i].key === key) result.push(entries[i].value);
    return result;
  }
718989
function getAllPathParamNames () {
    let params = [];

    function addParam (param) {
      if (param.in === "path") {
        params.push(param.name);
      }
    }

    if (context.api) {
      _.each(context.api.paths, (path) => {
        // Add each path parameter
        _.each(path.parameters, addParam);

        // Add each operation parameter
        _.each(path, (operation) => {
          _.each(operation.parameters, addParam);
        });
      });
    }

    return _.uniq(params);
  }
531160
function getQueryParam(name) {
  if (!isBrowser()) {
    _logger2.default.error({
      description: 'Browser is required to get query params.',
      func: 'asyncLoadJs', obj: 'dom'
    });
    throw new Error('Query parameters are only available within browsers.');
  }
  name = name.replace(/[\[]/, '\\[').replace(/[\]]/, '\\]');
  var regex = new RegExp('[\\?&]' + name + '=([^&#]*)');
  var results = regex.exec(window.location.search);
  return results === null ? '' : decodeURIComponent(results[1].replace(/\+/g, ' '));
}
127774
def all_as_href(self):
        
        if not self.is_any and not self.is_none:
            return [element for element in self.get(self.typeof)]
        return []
980848
def all(self):
        
        return self.pages(self.url.page, self.url.max_page)
711977
def getAll(self):
        ''''''

        if not bool(len(self.ATTRIBUTES)):
            self.load_attributes()
        return eval(str(self.ATTRIBUTES))
1224331
def get_uris(self, base_uri, filter_list=None):
        """"""
        return {
            re.sub(r'^/', base_uri, link.attrib['href'])
            for link in self.parsedpage.get_nodes_by_selector('a')
            if 'href' in link.attrib and (
                link.attrib['href'].startswith(base_uri) or
                link.attrib['href'].startswith('/')
            ) and
            not is_uri_to_be_filtered(link.attrib['href'], filter_list)
        }
588813
def all(path, options = {}, &block)
      all = []
      list_type, list_item = get_list_types(path)

      result = request('GET', path, options)
      raise RequestError.new result.status if result.status_code != 200 or result.parsed[list_type].nil?

      total = result.parsed[list_type]['totalItems'].to_i
      items = result.parsed[list_type]['itemsInPage'].to_i
      return all if total == 0

      pages = (total / config.page_size) + 1
      (0 .. pages - 1).each do |i|
        options[:query][:pgNum] = i
        result     = request('GET', path, options)
        raise RequestError.new result.status if result.status_code != 200
        list_items = result.parsed[list_type][list_item]
        list_items = [ list_items ] if items == 1
        list_items.each { |item| yield item if block_given? }
        all.concat list_items
      end
      all
    end
721512
public List<ParamValueType<WebFragmentDescriptor>> getAllContextParam()
   {
      List<ParamValueType<WebFragmentDescriptor>> list = new ArrayList<ParamValueType<WebFragmentDescriptor>>();
      List<Node> nodeList = model.get("context-param");
      for(Node node: nodeList)
      {
         ParamValueType<WebFragmentDescriptor>  type = new ParamValueTypeImpl<WebFragmentDescriptor>(this, "context-param", model, node);
         list.add(type);
      }
      return list;
   }
618167
def search_all(self, template: str) -> _Result:
        
        return [r for r in findall(template, self.html)]
962910
def _get_all(cls, parent_id=None, grandparent_id=None):
        """"""
        client = cls._get_client()
        endpoint = cls._endpoint.format(resource_id="",
                                        parent_id=parent_id or "",
                                        grandparent_id=grandparent_id or "")
        resources = []
        while True:
            response = client.get_resource(endpoint)
            for raw_data in response.get("value", []):
                raw_data["parentResourceID"] = parent_id
                raw_data["grandParentResourceID"] = grandparent_id
                resources.append(cls.from_raw_data(raw_data))
            endpoint = response.get("nextLink")
            if not endpoint:
                break
        return resources
731671
public List<T> all(Map<String, ?> params) throws AuthenticationException, ApiException, InvalidRequestException {
		return all(params, getAuthenticatedClient());
	}
897414
public void getAll(BoundingBox bounds, Handler<Note> handler, int limit, int hideClosedNoteAfter)
	{
		getAll(bounds, null, handler, limit, hideClosedNoteAfter);
	}
718559
def get_all(self, qry, tpl):
        '''  '''
        self.cur.execute(qry, tpl)
        result = self.cur.fetchall()
        return result
930301
public static Map<String,String> getQueryParams(String s) throws MalformedURLException {
        Map<String,String> params = new HashMap<String, String>();

        for (String kv : s.split("&")) {
            String[] parts = kv.split("=");
            if (parts.length != 2) {
                throw new MalformedURLException();
            }
            try {
                String k = URLDecoder.decode(parts[0], "UTF-8");
                String v = URLDecoder.decode(parts[1], "UTF-8");
                params.put(k, v);
            } catch (UnsupportedEncodingException ex) {
                throw new MalformedURLException(ex.getMessage());
            }
        }
        return params;
    }
657953
public static ListMultimap<String, Link> getAllLinks(HalResource hal, Predicate<Pair<String, Link>> predicate) {
    return getAllLinks(hal, "self", predicate);
  }
1114096
public List<Parameter> getAllParameters() {
        List<Parameter> ret = new ArrayList<Parameter>();

        if (parameters != null)
            ret.addAll(parameters);

        if (terms != null) {
            for (final Term t : terms) {
                ret.addAll(t.getAllParameters());
            }
        }

        return ret;
    }