Returns an iterator over the target(s) the given address points to.
193527
def resolve(self, spec):
    """"""
    address = Address.parse(spec)
    # NB: This is an idempotent, short-circuiting call.
    self.inject_address_closure(address)
    return self.transitive_subgraph_of_addresses([address])
73271
def _roots_to_targets(self, build_graph, target_roots):
    """"""
    with self._run_tracker.new_workunit(name='parse', labels=[WorkUnitLabel.SETUP]):
      return [
        build_graph.get_target(address)
        for address
        in build_graph.inject_roots_closure(target_roots, self._fail_fast)
      ]
654308
def transitive_dependents_of_addresses(self, addresses):
    """"""
    closure = set()
    result = []
    to_visit = deque(addresses)

    while to_visit:
      address = to_visit.popleft()
      if address in closure:
        continue

      closure.add(address)
      result.append(address)
      to_visit.extend(self._dependent_address_map[address])
      to_visit.extend(self._implicit_dependent_address_map[address])

    return result
1298428
function eachEndpoint(iterator) {
	for (var namespace in endpoints) {
		var methods = endpoints[namespace];

		for (var name in methods) {
			var method = methods[name];

			iterator(namespace, name, method);
		}
	}

	return endpoints;
}
580685
protected CompletableFuture<List<String>> remoteWebSocketAddresses(@RpcTargetAddress InetSocketAddress targetAddress, Serializable userid) {
        if (remoteNode == null) return CompletableFuture.completedFuture(null);
        try {
            return remoteNode.getWebSocketAddresses(targetAddress, userid);
        } catch (Exception e) {
            logger.log(Level.WARNING, "remote " + targetAddress + " websocket getOnlineRemoteAddresses error", e);
            return CompletableFuture.completedFuture(null);
        }
    }
320473
def address(self):
        
        pattern = self.random_element(self.address_formats)
        return self.generator.parse(pattern)
344086
public Iterable<DUser> queryByAddress2(java.lang.String address2) {
    return queryByField(null, DUserMapper.Field.ADDRESS2.getFieldName(), address2);
  }
257228
def getalignedtarget(self, index):
        """"""
        targetindices = []
        target = None
        foundindex = -1
        for sourceindex, targetindex in self.alignment:
            if sourceindex == index:
                targetindices.append(targetindex)
        if len(targetindices) > 1:
            for i in range(1,len(targetindices)):
                if abs(targetindices[i] - targetindices[i-1]) != 1:
                    break  # not consecutive
            foundindex = (min(targetindices), max(targetindices))
            target = ' '.join(self.target[min(targetindices):max(targetindices)+1])
        elif targetindices:
            foundindex = targetindices[0]
            target = self.target[foundindex]

        return target, foundindex
793086
def get_targets(conn=None):
    
    targets = RBT
    results = targets.run(conn)
    for item in results:
        yield item
645871
public Iterator targetMappings() {
        // System.out.println("TargetMappings called");
        // return vHostTable.values().iterator(); 316624
        Collection vHosts = vHostTable.values(); // 316624
        List l = new ArrayList(); // 316624
        l.addAll(vHosts); // 316624
        return l.listIterator(); // 316624
    }
1118647
def _addr(self):
        
        group_by = self._config['address_group_by']

        assert not self._flags['address'], "{} address already assigned".format(self._name)
        assert group_by in ('element', 'variable')

        m0 = self.system.dae.m
        n0 = self.system.dae.n
        mend = m0 + len(self._algebs) * self.n
        nend = n0 + len(self._states) * self.n

        if group_by == 'variable':
            for idx, item in enumerate(self._algebs):
                self.__dict__[item] = list(
                    range(m0 + idx * self.n, m0 + (idx + 1) * self.n))
            for idx, item in enumerate(self._states):
                self.__dict__[item] = list(
                    range(n0 + idx * self.n, n0 + (idx + 1) * self.n))
        elif group_by == 'element':
            for idx, item in enumerate(self._algebs):
                self.__dict__[item] = list(
                    range(m0 + idx, mend, len(self._algebs)))
            for idx, item in enumerate(self._states):
                self.__dict__[item] = list(
                    range(n0 + idx, nend, len(self._states)))

        self.system.dae.m = mend
        self.system.dae.n = nend

        self._flags['address'] = True
1225482
private ServerTarget findTargetServer(String address,
                                        int port)
  {
    for (ServerTarget target : _targets) {
      ServerBartender server = target.getServer();
      
      if (address.equals(server.getAddress()) && port == server.port()) {
        return target;
      }
    }
    
    return null;
  }
1199747
def next_address_avoid_collision(self, start_addr):
        """"""
        i = 1
        while self.is_address_in_use(next_addr(start_addr, i)):
            i += 1
        return next_addr(start_addr, i)
676403
def GetIPAddresses(self):
    """"""
    results = []
    for address in self.addresses:
      human_readable_address = address.human_readable_address
      if human_readable_address is not None:
        results.append(human_readable_address)

    return results
969989
def get_grid_point_from_address(grid_address, mesh):
    """"""
    _set_no_error()

    return spg.grid_point_from_address(np.array(grid_address, dtype='intc'),
                                       np.array(mesh, dtype='intc'))
1128110
def getaddress(self, address: str) -> dict:
        ''''''

        return cast(dict, self.ext_fetch('getaddress/' + address))
1130095
def _forward_iterator(self):
        ""
        path = [(self, 0, Bits())]
        while path:
            node, idx, prefix = path.pop()
            if idx==0 and node.value is not None and not node.prune_value:
                yield (self._unpickle_key(prefix), self._unpickle_value(node.value))
            if idx<len(node.children):
                path.append((node, idx+1, prefix))
                link = node.children[idx]
                if not link.pruned:
                    path.append((link.node, 0, prefix + link.prefix))