Get int type of property value by name.

@param propertyName
name of the property to get
@return int type of value
553536
public static int getIntFromProperty(final String propertyName) {
        try {
            return Integer.parseInt(properties.getProperty(propertyName));
        } catch (NumberFormatException e) {
            log.error("NumberFormatException caught during reading property from properties file: "
                    + e.getMessage());
            return 0;
        }
    }
299555
public Type getPropertyType(String property) {
    Type type = (Type) propertyTypes.get(property);
    if (null == type) {
      Class<?> propertyType = PropertyUtils.getPropertyType(entityClass, property);
      if (null != propertyType) {
        if (Entity.class.isAssignableFrom(propertyType)) type = new EntityType(propertyType);
        if (propertyType.isInterface()) type = Model.getType(propertyType.getName());
        if (null == type) type = new IdentifierType(propertyType);
      }
    }
    if (null == type) logger.error("{} doesn't contains property {}", entityName, property);
    return type;
  }
90160
public int getInt(String name) {

		Object value = super.get(name);

		if (value instanceof Integer) {
			return (Integer) value;
		}

		if (value == null) {
			throw new IllegalArgumentException("Setting: '" + name + "', not found!");
		}

		try {
			return Integer.parseInt(value.toString());
		}
		catch (NumberFormatException e) {
			throw new IllegalArgumentException("Setting: '" + name + "', can't be converted to integer: '" + value + "'!");
		}
	}
113775
public static int getInt(Properties props, String key, int defaultValue) {
    String value = props.getProperty(key);
    if (value != null) {
      return Integer.parseInt(value);
    } else {
      return defaultValue;
    }
  }
1193172
public String getValue(String name) {
	    	Properties properties = loadProperties();
	    	return (String) properties.getProperty(name);
    }
21866
private Integer getIntegerPropertyOverrideValue(String name, String key) {
        if (properties != null) {
            String propertyName = getPropertyName(name, key);

            String propertyOverrideValue = properties.getProperty(propertyName);

            if (propertyOverrideValue != null) {
                try {
                    return Integer.parseInt(propertyOverrideValue);
                }
                catch (NumberFormatException e) {
                    logger.error("Could not parse property override key={}, value={}",
                            key, propertyOverrideValue);
                }
            }
        }
        return null;
    }
234256
public final HasPropertyKind getOwnPropertyKind(String propertyName) {
    return getOwnSlot(propertyName) != null
        ? HasPropertyKind.KNOWN_PRESENT
        : HasPropertyKind.ABSENT;
  }
849612
protected final int getIntValue(final String propertyName, int defaultValue) {
        int result;
        String property = this.properties.getProperty(propertyName);
        try {
            result = Integer.parseInt(property);
        } catch (NumberFormatException e) {
            LOGGER.warn("Invalid integer property in configuration: {}",
                    propertyName);
            result = defaultValue;
        }
        return result;
    }
518233
public static <Q> Object getPropertyValue(Q bean, String propertyName) {

        return ObjectUtils.getPropertyValue(bean, propertyName, Object.class);
    }
1270822
@SuppressWarnings( "unchecked" )
    public <T> T get( final String propertyName )
    {
        return (T) m_properties.get( propertyName );
    }
214546
public final ObjectType getTopMostDefiningType(String propertyName) {
    checkState(isConstructor() || isInterface());
    checkArgument(getInstanceType().hasProperty(propertyName));
    FunctionType ctor = this;

    if (isInterface()) {
      return getInstanceType().getTopDefiningInterface(propertyName);
    }

    ObjectType topInstanceType = null;
    do {
      topInstanceType = ctor.getInstanceType();
      ctor = ctor.getSuperClassConstructor();
    } while (ctor != null && ctor.getPrototype().hasProperty(propertyName));

    return topInstanceType;
  }
1135303
public String getColumnNameForProperty(final String propertyName)
   {
     return Optional.ofNullable(propertyToField.get(propertyName))
                    .map(fcInfo -> fcInfo.getDelimitedColumnName())
                    .orElse(null);
   }
676081
public static int getInt(java.util.Properties properties,
                             String prop, int defaultVal) {
        String propVal = properties.getProperty(prop);
        return  (propVal != null)
            ? Integer.parseInt(propVal)
            : defaultVal;
    }
315648
public int getInt(final String key) {
		final String value = getProperty(key);
		if (value == null) {
			throw new NumberFormatException("Couldn't parse property to int.");
		}
		return Integer.parseInt(value);
	}
251034
protected String getRootPropertyName(String propertyName) {
		int location = propertyName.indexOf(PROPERTY_KEY_PREFIX);
		return location == -1 ? propertyName : propertyName.substring(0, location);
	}
371513
public String getString(String propertyName) {
        Object obj = get(propertyName);
        return obj != null ? obj.toString() : null;
    }
1207242
public int getIntProperty( String key , int defaultValue )
    {
        String value = SystemTools.replaceSystemProperties(settings.getProperty(key));
        if (value == null)
            return defaultValue;
        try
        {
            return Integer.parseInt(value);
        }
        catch (Exception e)
        {
            return defaultValue;
        }
    }