Return a list of all locations of all objects.
353647
def _allLocations(self):
        
        l = []
        for locationTuple in self.keys():
            l.append(Location(locationTuple))
        return l
971144
def get_maps():
  """"""
  maps = {}
  for mp in Map.all_subclasses():
    if mp.filename:
      map_name = mp.__name__
      if map_name in maps:
        raise DuplicateMapException("Duplicate map found: " + map_name)
      maps[map_name] = mp
  return maps
637929
def get_all(self):
        """"""
        logger.debug('Fetching items. Path: {data_file}'.format(
            data_file=self.data_file
        ))

        return load_file(self.data_file)
1237304
def _list_locators(self):
        
        with _handle_client_exception():
            response = self.client.get_account()

        for container in response[1]:
            yield container.pop('name'), container
626704
def GetRandomLocationsNearStops(schedule):
  """"""
  locations = []
  for s in schedule.GetStopList():
    locations.append(AddNoiseToLatLng(s.stop_lat, s.stop_lon))
  return locations
266121
function allNodesAtLocation(location) {
        var nodes = [];
        exports.root.each(function each(n) {
            if (n.type === DOMNode.TYPE_ELEMENT && n.isAtLocation(location)) {
                nodes.push(n);
            }
        });
        return nodes;
    }
1224098
def subcellular_locations(self):
        
        return [x[0] for x in self.session.query(models.SubcellularLocation.location).all()]
1132938
def listDatabases(self):
        """"""
        iter = self._jcatalog.listDatabases().toLocalIterator()
        databases = []
        while iter.hasNext():
            jdb = iter.next()
            databases.append(Database(
                name=jdb.name(),
                description=jdb.description(),
                locationUri=jdb.locationUri()))
        return databases
499249
def get_all(self, path, data=None, limit=100):
        """"""
        return ListResultSet(path=path, data=data or {}, limit=limit)
14481
def fetchall(self):
        """"""
        self._check_executed()
        if self._rows is None:
            return ()
        if self.rownumber:
            result = self._rows[self.rownumber:]
        else:
            result = self._rows
        self.rownumber = len(self._rows)
        return result
293807
def get_name_locations(self, name):
        """"""
        result = []
        for module in self.names:
            if name in self.names[module]:
                try:
                    pymodule = self.project.get_module(module)
                    if name in pymodule:
                        pyname = pymodule[name]
                        module, lineno = pyname.get_definition_location()
                        if module is not None:
                            resource = module.get_module().get_resource()
                            if resource is not None and lineno is not None:
                                result.append((resource, lineno))
                except exceptions.ModuleNotFoundError:
                    pass
        return result
579837
def fetch_all(self, R, depth=1, **kwargs):
        ""
        d, e = self._fetcher.fetch_all(R, depth, kwargs)
        if e: raise e
        return d
1152836
def all(self):
        
        return {
            key: value
            for key, value in chain(self.entry_points.items(), self.factories.items())
        }
648281
def fetch_all_objects_from_db(self,
                                  cls: Type[T],
                                  table: str,
                                  fieldlist: Sequence[str],
                                  construct_with_pk: bool,
                                  *args) -> List[T]:
        """"""
        return self.fetch_all_objects_from_db_where(
            cls, table, fieldlist, construct_with_pk, None, *args)
641708
def get_buildings(self):
        """"""
        resp = self._request("GET", "/1.1/space/locations").json()
        out = []
        for x in resp:
            if x["lid"] in LOCATION_BLACKLIST:
                continue
            if x["public"] == 1:
                del x["public"]
                x["service"] = "libcal"
                out.append(x)
        return out
1073926
def findAll(haystack, needle) :
	""""""
	
	h = haystack
	res = []
	f = haystack.find(needle)
	offset = 0
	while (f >= 0) :
		#print h, needle, f, offset
		res.append(f+offset)
		offset += f+len(needle)
		h = h[f+len(needle):]
		f = h.find(needle)

	return res
136540
def all(cls, start_position="", max_results=100, qb=None):
        
        return cls.where("", start_position=start_position, max_results=max_results, qb=qb)