Get runtime value of specified resource it
           The returned value will be boolean, integer or float
           Return None if resource cannot be found or on error
512302
def get_runtime_value(self, resourceid: int):
        
        payload = """<getRuntimeValue1 xmlns="utcs">{id}</getRuntimeValue1>
                  """.format(id=resourceid)
        xdoc = self.connection.soap_action('/ws/ResourceInteractionService',
                                           'getResourceValue',
                                           payload)
        if not xdoc:
            return False
        boolresult = xdoc.find(
            './SOAP-ENV:Body/ns1:getRuntimeValue2/ns1:value/ns2:value',
            IHCSoapClient.ihcns)
        if boolresult is not None:
            return boolresult.text == "true"
        intresult = xdoc.find(
            './SOAP-ENV:Body/ns1:getRuntimeValue2/ns1:value/ns2:integer',
            IHCSoapClient.ihcns)
        if intresult is not None:
            return int(intresult.text)
        floatresult = xdoc.find(
            ('./SOAP-ENV:Body/ns1:getRuntimeValue2/'
             'ns1:value/ns2:floatingPointValue'),
            IHCSoapClient.ihcns)
        if floatresult is not None:
            return float(floatresult.text)
        enumNameResut = xdoc.find(
            ('./SOAP-ENV:Body/ns1:getRuntimeValue2/'
             'ns1:value/ns2:enumName'),
            IHCSoapClient.ihcns)
        if enumNameResut is not None:
            return enumNameResut.text
        return False
1280258
def get_runtime_value(self, ihcid: int):
        
        if self.client.get_runtime_value(ihcid):
            return True
        self.re_authenticate()
        return self.client.get_runtime_value(ihcid)
280115
def get_property(self, name):
        
        for prop in self.resource.properties:
            if prop.name == name:
                return prop

        raise AttributeError(name)
250245
def wait_for_resource_value_changes(self, wait: int=10):
        
        changes = {}
        payload = """<waitForResourceValueChanges1
                     xmlns=\"utcs\">{timeout}</waitForResourceValueChanges1>
                  """.format(timeout=wait)
        xdoc = self.connection.soap_action('/ws/ResourceInteractionService',
                                           'getResourceValue', payload)
        if not xdoc:
            return False
        result = xdoc.findall(
            './SOAP-ENV:Body/ns1:waitForResourceValueChanges2/ns1:arrayItem',
            IHCSoapClient.ihcns)
        for item in result:
            ihcid = item.find('ns1:resourceID', IHCSoapClient.ihcns)
            if ihcid is None:
                continue
            bvalue = item.find('./ns1:value/ns2:value', IHCSoapClient.ihcns)
            if bvalue is not None:
                changes[int(ihcid.text)] = bvalue.text == 'true'
                continue
            ivalue = item.find('./ns1:value/ns3:integer', IHCSoapClient.ihcns)
            if ivalue is not None:
                changes[int(ihcid.text)] = int(ivalue.text)
            fvalue = item.find('./ns1:value/ns2:floatingPointValue',
                               IHCSoapClient.ihcns)
            if fvalue is not None:
                changes[int(ihcid.text)] = float(fvalue.text)
                continue
            
            enumName = item.find('./ns1:value/ns2:enumName',
                               IHCSoapClient.ihcns)
            if enumName is not None:
                changes[int(ihcid.text)] = enumName.text
        return changes
406939
def get(self, timeout=None):
        # type: (float) -> T
        """"""
        self.wait(timeout)
        if isinstance(self._result, Exception):
            raise self._result
        return self._result
1325673
private DataSource getDataSource(ComponentHelper cmp, Resource resource) {
    try {
      /*
       * by default the path is read from request "path" parameter
       * here we overwrite it via a synthetic resource because the path may be overwritten by validation logic
       * to ensure the path is not beyond the configured root path
       */
      ValueMap overwriteProperties = new ValueMapDecorator(ImmutableMap.<String, Object>of("path", resource.getPath()));
      Resource dataSourceResourceWrapper = GraniteUiSyntheticResource.wrapMerge(request.getResource(), overwriteProperties);
      return cmp.getItemDataSource(dataSourceResourceWrapper);
    }
    catch (ServletException | IOException ex) {
      throw new RuntimeException("Unable to get data source.", ex);
    }
  }
614785
function get(key) {

    let val = process.env[key];

    return val in types ? types[val] : util.isNumeric(val) ? parseFloat(val) : val;

}
613210
def get_int(self, key, default=None):
        
        value = self.get(key, default)
        return None if value is None else int(value)
1271224
public T get(V value) {
		T found = find(value);
		if (found != null) {
			return found;
		}

		synchronized (runtimeDefined) {
			for (T obj : runtimeDefined) {
				if (matches(obj, value)) {
					return obj;
				}
			}

			T created = create(value);
			runtimeDefined.add(created);
			return created;
		}
	}
1050068
private Runtime getRuntime(int runtimeID) {
    ListRuntimesArg.Builder builder = ListRuntimesArg.newBuilder();
    builder.addRuntimeIDList(runtimeID);
    builder.setCreate(true);

    Response response = executeMessage(EcmascriptMessage.LIST_RUNTIMES, builder);
    RuntimeList.Builder runtimeListBuilder = RuntimeList.newBuilder();
    buildPayload(response, runtimeListBuilder);
    List<Runtime> runtimes = runtimeListBuilder.build().getRuntimeListList();
    return (runtimes.isEmpty()) ? null : runtimes.get(0);
  }
271318
def running_time(self):
        
        if not self.is_done():
            raise ValueError("Cannot get running time for a program that isn't completed.")
        try:
            running_time = float(self._raw['running_time'].split()[0])
        except (ValueError, KeyError, IndexError):
            raise UnknownApiError(str(self._raw))
        return running_time
805147
def _GetValueAsObject(self, property_value):
    
    if property_value.type == pyolecf.value_types.BOOLEAN:
      return property_value.data_as_boolean

    if property_value.type in self._INTEGER_TYPES:
      return property_value.data_as_integer

    if property_value.type in self._STRING_TYPES:
      return property_value.data_as_string

    try:
      data = property_value.data
    except IOError:
      data = None

    return data
329284
def __get_value(self, bundleId, languageId, resourceKey, fallback=False):
        
        resourceEntryData = self.__get_resource_entry_data(bundleId=bundleId,
            languageId=languageId, resourceKey=resourceKey, fallback=fallback)

        if not resourceEntryData:
            return None

        value = resourceEntryData.get(self.__RESPONSE_TRANSLATION_KEY)

        return value
729989
private T loadResourceValue(final URL resource)
	{
		try (final InputStream is = resource.openStream())
		{
			cached = null; // Prevent the old value from being used

			return setCached(clazz.cast(factory.getInstance(clazz).deserialise(is)));
		}
		catch (IOException e)
		{
			throw new RuntimeException("Error loading JAXB resource " + name + " " + clazz + " from " + resource, e);
		}
	}
625450
def get_resources(self):
        
        if self.retrieved:
            raise errors.IllegalState('List has already been retrieved.')
        self.retrieved = True
        return objects.ResourceList(self._results, runtime=self._runtime)
673491
def set_runtime_value_float(self, resourceid: int, floatvalue: float):
        """"""
        payload = """
            <setResourceValue1 xmlns=\"utcs\"
            xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\">
            <value i:type=\"a:WSFloatingPointValue\" xmlns:a=\"utcs.values\">
            <a:floatingPointValue>{value}</a:floatingPointValue></value>
            <typeString/>
            <resourceID>{id}</resourceID>
            <isValueRuntime>true</isValueRuntime>
            </setResourceValue1>
            </s:Body>
            """.format(id=resourceid, value=floatvalue)
        xdoc = self.connection.soap_action('/ws/ResourceInteractionService',
                                           'setResourceValue', payload)
        if xdoc:
            result = xdoc.find('./SOAP-ENV:Body/ns1:setResourceValue2',
                               IHCSoapClient.ihcns).text
            return result == "true"
        return False
345337
synchronized Object getValue() {
        while (value == NULL) {
            try {
                wait();
            } catch (InterruptedException ex) {
                throw new RuntimeException(ex);
            }
        }
        return value;
    }