=> find locations
761041
def locations(parameters)
      allowed_parameters = %w(query x y type)

      query = create_query(parameters, allowed_parameters)
      locations = perform('locations', query)

      locations['stations']
    end
613054
def _places(client, url_part, query=None, location=None, radius=None,
            keyword=None, language=None, min_price=0, max_price=4, name=None,
            open_now=False, rank_by=None, type=None, region=None, page_token=None):
    

    params = {"minprice": min_price, "maxprice": max_price}

    if query:
        params["query"] = query
    if location:
        params["location"] = convert.latlng(location)
    if radius:
        params["radius"] = radius
    if keyword:
        params["keyword"] = keyword
    if language:
        params["language"] = language
    if name:
        params["name"] = convert.join_list(" ", name)
    if open_now:
        params["opennow"] = "true"
    if rank_by:
        params["rankby"] = rank_by
    if type:
        params["type"] = type
    if region:
        params["region"] = region
    if page_token:
        params["pagetoken"] = page_token

    url = "/maps/api/place/%ssearch/json" % url_part
    return client._request(url, params)
876632
function _find(collection, query, opts) {
  if (Tyr.logging.trace) {
    Tyr.trace({ e: 'db', c: collection.id, m: 'find', q: query });
    const cursor = collection.db.find(query, opts);
    //Tyr.Log.updateDuration(logPromise);
    return cursor;
  } else {
    return collection.db.find(query, opts);
  }
}
1223851
function locate(fn, location) {
    try {
        return fn();
    } catch (e) {
        if (e instanceof JuttleError && !e.info.location) {
            e.info.location = location;
        }

        throw e;
    }
}
97581
function equalsLocation(a, b) {
    return a.range[0] === b.range[0] && a.range[1] === b.range[1]
}
888935
@Override
  public void findAllLocal(String sql, Result<Iterable<Cursor>> result, Object ...args)
  {
    _kraken.findAllLocal(sql, args, result);
  }
371554
def findAllByBiSearch(self, strSeq) :
		""""""
		arr = self.encode(strSeq)
		lst = []
		self._dichFind(arr[0], self, 0, lst)
		return lst
977743
def locate(name, **kwargs):
    
    ctx = Context(**kwargs)
    ctx.execute_action('locate', **{
        'name': name,
        'locator': ctx.locator,
    })
286047
def _get_locations(self, calc):
        """"""
        return (self._location_in(calc.profile),
                self._location_out(calc.profile))
750500
function locate (methods) {
  var found = []
  var i = -1

  while (++i < methods.length) {
    if (methods[i] && methods[i].match(/FrontMatter$/)) {
      found.push(methods[i])
    }
  }

  return found
}
360249
def get_locations(self, filter_to_my_group=False):
        """"""
        resp = self._post('general-retrievelocations', 'locations')
        groups = {}
        if resp['groupinfo']:
            for group in resp['groupinfo']:
                groups[group['id']] = Group(
                                            name=group.get('name'),
                                            inventory_id=group.get('id')
                                            )
        final_resp = []
        if resp['data']:
            if filter_to_my_group:
                resp['data'] = {self.groupid: resp['data'][self.groupid]}
            for groupid, sublocation in resp['data'].items():
                if type(sublocation) is dict:
                    sublocation = [loc for _, loc in sublocation.items()]
                    sublocation = flatten_list(sublocation)
                if type(sublocation) is list:
                    sublocation = flatten_list(sublocation)
                for location in sublocation:
                    group = groups[groupid]
                    final_resp.append(Location(
                                            name=location.get('name'),
                                            inventory_id=location.get('id'),
                                            parent=location.get('parent'),
                                            group=group,
                                            barcode=location.get('barcode')
                                      ))
        return final_resp
1067920
def locations(params={})
      args = [ :query, :lat, :lon, :count ]
      params.each do |k,v|
        if !args.include?(k)
          raise ArgumentError.new 'Search term not allowed: ' + k.to_s
        end
      end

      if !params.include?(:query)
        raise ArgumentError.new '"query" term with location name is required'
      end

      results = get('locations', params)
      if results.key?("location_suggestions")
        results["location_suggestions"].map { |l| Location.new(self, l) }
      else
        nil
      end
    end
938837
def findWhere(self, attrs=None):
        
        return self._wrap(self._clean.where(attrs, True))
560844
function() {
                    var hash = window.location.hash.substring(1),
                        params = {};

                    if (hash.length < 5) {
                        return params;
                    }

                    var vars = hash.split('&');
                    for (var i = 0; i < vars.length; i++) {
                        if (!vars[i]) {
                            continue;
                        }
                        var pair = vars[i].split('=');
                        if (pair.length < 2) {
                            continue;
                        }
                        params[pair[0]] = pair[1];
                    }

                    if (params.gid) {
                        params.gid = parseInt(params.gid, 10);
                    }

                    return params;
                }
614542
def GetLocation(location=None,alias=None,session=None):
		
		if not location:  location = clc.v2.Account.GetLocation(session=session)

		return(AntiAffinity.GetAll(alias=alias,location=location,session=session))
18148
function getCoordinates(location) {
  var tile_width = 40;
  var x = location.r * tile_width;
  var y = location.c * tile_width;
  return {x: x, y: y};
}
1121932
function locator(value, fromIndex) {
    var result
    var prev

    regex.lastIndex = fromIndex

    result = regex.exec(value)

    if (result) {
      result = regex.lastIndex - result[0].length
      prev = value.charCodeAt(result - 1)

      if (usernameCharacter(prev) || prev === CC_HASH || prev === CC_AT) {
        /* Find the next possible value. */
        return locator(value, regex.lastIndex)
      }

      return result
    }

    return -1
  }