Returns the list of KNX devices currently attached to the host, based on known KNX vendor IDs.

@return the list of found KNX devices
2080
public static List<UsbDevice> getKnxDevices()
	{
		final List<UsbDevice> knx = new ArrayList<>();
		for (final UsbDevice d : getDevices()) {
			final int vendor = d.getUsbDeviceDescriptor().idVendor() & 0xffff;
			for (final int v : vendorIds)
				if (v == vendor)
					knx.add(d);
		}
		return knx;
	}
49318
def devices(self):
        
        eax = self.attributes.get('devices')
        if eax is None:
            eax = self._all_devices
        if not isinstance(eax, list):
            eax = [eax]
        return [str(dev) for dev in eax]
1258525
public java.util.List<Host> getHosts() {
        if (hosts == null) {
            hosts = new com.amazonaws.internal.SdkInternalList<Host>();
        }
        return hosts;
    }
1052797
public java.util.List<String> getSupportedAddonList() {
        if (supportedAddonList == null) {
            supportedAddonList = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return supportedAddonList;
    }
146948
def get_all_hosting_devices(self, context):
        """"""
        cctxt = self.client.prepare()
        return cctxt.call(context,
                          'get_all_hosting_devices',
                          host=self.host)
411713
public java.util.List<String> getHostReservationIdSet() {
        if (hostReservationIdSet == null) {
            hostReservationIdSet = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return hostReservationIdSet;
    }
356345
public static host_device[] get_filtered(nitro_service service, String filter) throws Exception
	{
		host_device obj = new host_device();
		options option = new options();
		option.set_filter(filter);
		host_device[] response = (host_device[]) obj.getfiltered(service, option);
		return response;
	}
923362
def get_devices(self):
        """"""
        devices = []
        for element in self.get_device_elements():
            device = FritzhomeDevice(self, node=element)
            devices.append(device)
        return devices
1116554
static List<InetSocketAddress> getJournalHttpAddresses(Configuration conf) {
    String[] hosts = JournalConfigHelper.getJournalHttpHosts(conf);
    List<InetSocketAddress> addrs = new ArrayList<InetSocketAddress>();
    for (String host : hosts) {
      addrs.add(NetUtils.createSocketAddr(host));
    }
    return addrs;
  }
245814
protected function getDevices() {
        if (!$this->_devices) {
            $this->_devices = new DeviceList($this->version, $this->solution['sid']);
        }

        return $this->_devices;
    }
497202
def get_hosts_info(self):
        
        result = []
        index = 0
        while index < self.host_numbers:
            host = self.get_generic_host_entry(index)
            result.append({
                'ip': host['NewIPAddress'],
                'name': host['NewHostName'],
                'mac': host['NewMACAddress'],
                'status': host['NewActive']})
            index += 1
        return result
562269
def devices(self):
        
        if self._devices is None:
            self._devices = DeviceList(self._version, fleet_sid=self._solution['sid'], )
        return self._devices
11666
public java.util.List<SSHPublicKeyMetadata> getSSHPublicKeys() {
        if (sSHPublicKeys == null) {
            sSHPublicKeys = new com.amazonaws.internal.SdkInternalList<SSHPublicKeyMetadata>();
        }
        return sSHPublicKeys;
    }
1039918
async def async_get_connected_devices(self):
        
        devices = {}
        dev = await self.async_get_wl()
        devices.update(dev)
        dev = await self.async_get_arp()
        devices.update(dev)
        dev = await self.async_get_neigh(devices)
        devices.update(dev)
        if not self.mode == 'ap':
            dev = await self.async_get_leases(devices)
            devices.update(dev)

        ret_devices = {}
        for key in devices:
            if not self.require_ip or devices[key].ip is not None:
                ret_devices[key] = devices[key]
        return ret_devices
387805
def get_devices(self):
        """"""
        utils.pending_message('Fetching device list...')

        get_devices_task = self.client.devices(
            account=self.account
        )

        # We wait for device list info as this sample relies on it next.
        get_devices_task.wait_for_result(timeout=self.timeout)

        get_devices_result = json.loads(get_devices_task.result)
        self.devices = get_devices_result['devices']

        utils.info_message('Get devices successful')
220181
private ImmutableList<EndPoint> getEndPointsFromHostDiscovery() {
        Iterable<ServiceEndPoint> hosts = _hostDiscovery.getHosts();

        ImmutableList.Builder<EndPoint> endPoints = ImmutableList.builder();
        for (final ServiceEndPoint host : hosts) {
            if (host.equals(_self)) {
                continue;
            }
            endPoints.add(new EndPoint() {
                @Override
                public String getAddress() {
                    return _endPointAdapter.toEndPointAddress(host);
                }

                @Override
                public boolean isValid() {
                    return Iterables.contains(_hostDiscovery.getHosts(), host);
                }
            });
        }

        return endPoints.build();
    }
802277
@Override
    public Set<ProviderInfo> currentProviderList() {
        providerLock.lock();
        try {
            ConcurrentHashSet<ProviderInfo> providerInfos = new ConcurrentHashSet<ProviderInfo>();
            providerInfos.addAll(aliveConnections.keySet());
            providerInfos.addAll(subHealthConnections.keySet());
            providerInfos.addAll(retryConnections.keySet());
            return providerInfos;
        } finally {
            providerLock.unlock();
        }
    }