Called when all device's services and characteristics got resolved.
347258
def services_resolved(self):
        
        self._disconnect_service_signals()

        services_regex = re.compile(self._device_path + '/service[0-9abcdef]{4}$')
        managed_services = [
            service for service in self._object_manager.GetManagedObjects().items()
            if services_regex.match(service[0])]
        self.services = [Service(
            device=self,
            path=service[0],
            uuid=service[1]['org.bluez.GattService1']['UUID']) for service in managed_services]

        self._connect_service_signals()
153956
def _sync_and_resolve(self, config, resolver):
        ''''''
        resolved = set()
        for key, theirs in config.items(self._name):
            theirs = self._real_value_of(theirs)
            if key in self:
                mine = self[key]
                value = resolver(self._name, key, mine, theirs)
            else:
                value = theirs
            self._set_value(config, key, value)
            resolved.add(key)
        return resolved
188884
def _check_all_devices_in_sync(self):
        '''
        '''

        if len(self._get_devices_by_failover_status('In Sync')) != \
                len(self.devices):
            msg = "Expected all devices in group to have 'In Sync' status."
            raise UnexpectedDeviceGroupState(msg)
796780
void resolveFeatures(ResolutionMode mode) {
        boolean allowMultipleVersions = mode == ResolutionMode.IGNORE_CONFLICTS ? true : false;
        FeatureResolver resolver = new FeatureResolverImpl();
        Result result = resolver.resolveFeatures(resolverRepository, featureNamesToResolve, Collections.<String> emptySet(), allowMultipleVersions);
        for (String name : result.getResolvedFeatures()) {
            ProvisioningFeatureDefinition feature = resolverRepository.getFeature(name);
            resolvedFeatures.put(feature.getSymbolicName(), feature);
        }

        for (String missingFeature : result.getMissing()) {
            Collection<ApplicableToProduct> featureOtherProducts = resolverRepository.getNonApplicableResourcesForName(missingFeature);
            if (featureOtherProducts.isEmpty()) {
                featuresMissing.add(missingFeature);
            } else {
                requirementsFoundForOtherProducts.add(missingFeature);
                for (ApplicableToProduct feature : featureOtherProducts) {
                    resourcesWrongProduct.add(feature);
                }
            }
        }
    }
868713
function() {
        registerDeviceTimeoutId && clearTimeout(registerDeviceTimeoutId);
        registerServerTimeoutId && clearTimeout(registerServerTimeoutId);
        checkIfSocketHasOpennedTimeoutId && clearTimeout(checkIfSocketHasOpennedTimeoutId);
        socketReconnectCheck && clearTimeout(socketReconnectCheck);
      }
496923
async def resolve(self, client):
        """"""
        if self.resolved:
            return

        if not self._resolve_lock:
            self._resolve_lock = asyncio.Lock(loop=client.loop)

        async with self._resolve_lock:
            if not self.resolved:
                await self._resolve(client)
                self.resolved = True
290767
protected function resolve()
    {
        $extensionsManager = $this->getServiceLocator()->get(\common_ext_ExtensionsManager::SERVICE_ID);
        $installed = $extensionsManager->getInstalledExtensionsIds();
        foreach ($installed as $extId) {
            $extension = $extensionsManager->getExtensionById($extId);
            foreach ($this->getRoutes($extension) as $entry) {
                /** @var Route $route */
                $route = $entry['route'];
                $called = $route->resolve($this->getRequest());
                if ($called !== null) {
                    list($controller, $action) = explode('@', $called);
                    $this->controller = $controller;
                    $this->action = $action;
                    $this->extensionId = $entry['extId'];

                    return true;
                }
            }
        }

        throw new \ResolverException('Unable to resolve '.$this->request->getUri()->getPath());
    }
954764
def list_all(dev: Device):
    """"""
    for name, service in dev.services.items():
        click.echo(click.style("\nService %s" % name, bold=True))
        for method in service.methods:
            click.echo("  %s" % method.name)
761574
def update(self, data):
        """"""
        if data is None:
            for device in self.devices:
                device.clear_info()
        else:
            for device, device_info in zip(self.devices, data):
                device.device_info = device_info
                self.connection.log("Device information updated -> [{}]".format(device))
23186
async def resolve(self, host: str,
                      port: int, family: int) -> List[Dict[str, Any]]:
        """"""
403117
function resolveWhen() {
          var dfd = pendings[handle];
          if (dfd) {
            dfd.forEach(function (promise) {
              promise.resolve(instance);
            });
            delete pendings[handle];
          }
        }
616846
def update(self):
        """"""

        if self.device_time_check():

            if not self.in_process:
                outlets, switches, fans = self.get_devices()

                self.outlets = helpers.resolve_updates(self.outlets, outlets)
                self.switches = helpers.resolve_updates(
                    self.switches, switches)
                self.fans = helpers.resolve_updates(self.fans, fans)

                self.last_update_ts = time.time()
299301
function(finishedCallback){
      self.getHardwareVersion(function(data,error){
        self.deviceData.hardwareVersion = data;
        finishedCallback(error);
      });
    }
1351601
async def Resolved(self, retry, unit_name):
        '''
        
        '''
        # map input types to rpc msg
        _params = dict()
        msg = dict(type='Client',
                   request='Resolved',
                   version=1,
                   params=_params)
        _params['retry'] = retry
        _params['unit-name'] = unit_name
        reply = await self.rpc(msg)
        return reply
177704
public function resolve()
    {
        $this->data = [
            'environment' => php_sapi_name(),
            'process-id' => $this->process->getId(),
            'parent-process-id' => $this->process->getParentId(),
            'date' => date('Y-m-d'),
            'time' => date('H:m:s'),
            'timestamp' => time()
        ];
    }
1368023
function(devices)
			{
				for (var i in devices)
				{
					var d = devices[i];
					if (d.address == device.address)
					{
						success("bonded");
						return; // bonded device found
					}
				}
				success("unbonded")
			}
944412
function (successCallback, errorCallback, deviceHandle) {

			// Find the requested device in our list of discovered devices
			var device = winble.deviceManager.getDeviceFromHandle(deviceHandle, "getDeviceServices", errorCallback);
			if (device == null)
				return;

			// Enumerate the services
			winble.bleDevice.fromIdAsync(device.gattDevice.id).done(
				function (bleDevice) {
					winble.logger.logDebug("getDeviceServices", "BluetoothLEDevice.fromIdAsync completed with success");

					// Store the services and return an API-specified list to the caller
					var serviceListOut = [];
					for (var i = 0; i < bleDevice.gattServices.length; i++) {

						// Add service internally to the device so we can retrieve it later by its handle
						winble.logger.logDebug("getDeviceServices", "Found " + device.gattDevice.name + " service '" + bleDevice.gattServices[i].uuid + "'");
						var serviceStore = {
							"gattService": bleDevice.gattServices[i],
							"handle": winble.nextGattHandle++
						};
						device.serviceList[serviceStore.handle] = serviceStore;

						// Add service to return list
						var serviceOut = {
							"handle": serviceStore.handle,
							"uuid": serviceStore.gattService.uuid,
							"type": 0 // 0 = Primary, 1 = Secondary (Windows only returns primary services in the ble.gattServices list)
						};
						serviceListOut.push(serviceOut);
					}

					// Report the list of services back to the caller
					successCallback(serviceListOut);
				},
				function (error) {
					var msg = "BluetoothLEDevice.fromIdAsync('" + device.gattDevice.id + "') failed: " + error;
					winble.logger.logError("getDeviceServices", msg);
					errorCallback(msg);
				});
		}