Get a double property
@param cls the class associated with the property
@param key the property key name
@return the double property value
325695
public static Double getPropertyDouble(Class<?> cls, String key)
	{
		return getSettings().getPropertyDouble(cls, key);

	}
997330
@SuppressWarnings("unchecked")
    public <T> T getObject(String key, Class<T> clazz) {
        EDBObjectEntry entry = get(key);
        return entry == null ? null : (T) entry.getValue();
    }
856156
public Double getDoubleProperty(String property, boolean required) {
		Double doubleValue = null;
		String value = getProperty(property, required);
		if (value != null) {
			try {
				doubleValue = Double.valueOf(value);
			} catch (NumberFormatException e) {
				throw new GeoPackageException(GEOPACKAGE_PROPERTIES_FILE
						+ " property file property '" + property
						+ "' must be a double");
			}
		}
		return doubleValue;
	}
1197892
@SuppressWarnings("unchecked")
	@Override
	public <T> T getProperty(Object key, Class<T> clazz) {
	    return (T)getProperty(key);
	}
548906
public double[] getDoubleArray(final String key, final double[] def) {
		try {
			final double[] result = getDoubleArray(key);
			return result != null ? result : def;
		} catch (final NumberFormatException nfe) {
			return def;
		}
	}
1357795
@Override
    public float getFloat(@NonNull String key) {
        if (key == null) { throw new IllegalArgumentException("key cannot be null."); }

        synchronized (lock) {
            return CBLConverter.asFloat(getMValue(internalDict, key), internalDict);
        }
    }
1349411
@Override
    public Double getDouble( final String     key,
                             final Double     defaultValue )
    {
        return formatDouble( key, getFormattedPropValue( key ), defaultValue );
    }
713153
@Override
	public String getProperty(final String key) {
		lock.readLock().lock();
		try {
			final boolean useLocalPrefixes = !mixDefaultAndLocalPrefixes && hasLocalPrefixConfigurations();
			final Object object = get(key, useLocalPrefixes);
			if (object instanceof String) {
				return (String) object;
			} else {
				if (object == null) {
					return null;
				}
				throw new IllegalStateException("The value of " + key + " is of type: " + object.getClass().getName());
			}
		} finally {
			lock.readLock().unlock();
		}
	}
26338
public Property get(String key) {
        for (Property property : properties) {
            if (property.getKey().equals(key)) {
                return property;
            }
        }
        return null;
    }
924334
private double getValue(HashMap m, String key) {
        try {
            return Double.parseDouble(getValueOr(m, key, ""));
        } catch (Exception e) {
            return Double.MIN_VALUE;
        }
    }
543771
public static Object getProperty(Scriptable obj, Symbol key)
    {
        Scriptable start = obj;
        Object result;
        do {
            result = ensureSymbolScriptable(obj).get(key, start);
            if (result != Scriptable.NOT_FOUND)
                break;
            obj = obj.getPrototype();
        } while (obj != null);
        return result;
    }
380040
public Object getProperty(PropertyKey key)
    {
        if (!isValidKey(key))
            throw new IllegalArgumentException("Key " + key + " is not valid for " + getMapClass());

        //
        // Check local properties first
        //
        if (_properties.containsKey(key))
            return _properties.get(key);

        //
        // Return the value of the annotation type instance (if any)
        //
        if (_annot != null)
            return key.extractValue(_annot);

        //
        // Call up to superclass, for delegation model / default value
        //
        return super.getProperty(key);
    }
1260512
public <V> V getObject(final String key, final Class<V> type) {
        final Object obj = this.values.get(key);
        return type.cast(obj);
    }
279359
public static <T> T get(String key, Class<T> clz) {
        return (T)m().get(key);
    }
1283163
public double getDouble(String key, double defaultValue) {
		addToDefaults(key, Double.toString(defaultValue));
		String value = get(key);
		if (value == null) {
			return defaultValue;
		} else {
			return Double.valueOf(value);
		}
	}
1226475
@SuppressWarnings("unchecked")
    @Override
	public <T> T getProperty(Object key) {
	    return (T) getZone().getProperty(key);
	}
429629
@SuppressWarnings("unchecked")
    public <T> T get(Class<T> cls) {
        T runtimeInstance = (T) runtimeServices.computeIfAbsent(cls, this::createRuntimeInstance);
        if (runtimeInstance == null) {
            throw new NoSuchElementException(cls.getName());
        } else {
            return runtimeInstance;
        }
    }