Binding for {@link java.lang.Math#toIntExact(long)}

@param value the long value
@return the argument as an int
@throws ArithmeticException if the {@code argument} overflows an int
190841
public static IntegerBinding toIntExact(final ObservableLongValue value) {
        return createIntegerBinding(() -> Math.toIntExact(value.get()), value);
    }
18512
public static int toInteger(Object value, int defaultValue) {
		if (value == null || value.toString().trim().equals("")) {
			return defaultValue;
		}
		if (value instanceof Integer) {
			return (Integer) value;
		}
		return (int) JKConversionUtil.toDouble(value);
	}
61087
public IntegerConstant addInteger(int value)
  {
    IntegerConstant entry = getIntegerByValue(value);

    if (entry != null)
      return entry;

    entry = new IntegerConstant(this, _entries.size(), value);

    addConstant(entry);

    return entry;
  }
189884
public static Integer parseInteger(String value) throws ParseException
   {
      Integer result = null;

      if (value.length() > 0 && value.indexOf(' ') == -1)
      {
         if (value.indexOf('.') == -1)
         {
            result = Integer.valueOf(value);
         }
         else
         {
            Number n = DatatypeConverter.parseDouble(value);
            result = Integer.valueOf(n.intValue());
         }
      }

      return result;
   }
1062671
public static <T extends Number & Comparable<?>> NumberExpression<T> asNumber(T value) {
        return asNumber(constant(value));
    }
294903
public static final Integer getInteger(String value)
   {
      Integer result;

      try
      {
         result = Integer.valueOf(Integer.parseInt(value));
      }

      catch (Exception ex)
      {
         result = null;
      }

      return (result);
   }
957353
public void put(Long value) {
		if (value == null) {
			this.compiledStatement.bindNull(compiledStatementBindIndex++);
		} else {
			compiledStatement.bindLong(compiledStatementBindIndex++, (long) value);
		}
	}
1071004
public static int toIntWithDefault(String value, int defaultValue) {

        int result = defaultValue;
        try {
            result = Integer.parseInt(value);
        } catch (@SuppressWarnings("unused") Exception e) {
            // Do nothing, return default.
        }
        return result;
    }
949056
protected void addToLong(String key, long value) {
        synchronized (this.stepExecution) {
            long currentValue = getLongValue(key);
            getExecutionContext().putLong(key, currentValue + value);
        }

    }
443102
public Object execute(final Object value, final CsvContext context) {
		validateInputNotNull(value, context);
		
		final Long result;
		if( value instanceof Long ) {
			result = (Long) value;
		} else if( value instanceof String ) {
			try {
				result = Long.parseLong((String) value);
			}
			catch(final NumberFormatException e) {
				throw new SuperCsvCellProcessorException(String.format("'%s' could not be parsed as an Long", value),
					context, this, e);
			}
		} else {
			final String actualClassName = value.getClass().getName();
			throw new SuperCsvCellProcessorException(String.format(
				"the input value should be of type Long or String but is of type %s", actualClassName), context, this);
		}
		
		return next.execute(result, context);
	}
631863
public int intValue() throws OtpErlangRangeException {
        final long l = longValue();
        final int i = (int) l;

        if (i != l) {
            throw new OtpErlangRangeException("Value too large for int: " + val);
        }

        return i;
    }
1341517
public Expression<Integer> lt(int value) {
		String valueString = "'" + value + "'";
		return new Expression<Integer>(this, Operation.lt, valueString);
	}
55510
@Pure
	@Inline(value = "$2.valueOf($1.longValue())", imported = Long.class)
	@Deprecated
	public static Long toLongInteger(AtomicLong number) {
		return Long.valueOf(number.longValue());
	}
1160033
public JBBPOut Long(final long... value) throws IOException {
    assertNotEnded();
    assertArrayNotNull(value);
    if (this.processCommands) {
      for (final long l : value) {
        _writeLong(l);
      }
    }
    return this;
  }
363622
@Override
    public Byte convert(Object value) {
        if (value instanceof Number) {
            double d = ((Number)value).doubleValue();
            if (Double.isNaN(d) || Math.round(d)!=d) throw new IllegalArgumentException("Not a valid byte: " + value);
            long l = ((Number)value).longValue();
            if (l>=Byte.MIN_VALUE && l<=Byte.MAX_VALUE) return Byte.valueOf((byte)l);
            else throw new IllegalArgumentException("Value too large for byte: " + value);
        } else if (value instanceof String) {
            return Byte.parseByte((String)value);
        } else return null;
    }
796687
public void put(Integer value) {
		if (value == null) {
			this.compiledStatement.bindNull(compiledStatementBindIndex++);
		} else {
			compiledStatement.bindLong(compiledStatementBindIndex++, value);
		}
	}
176121
public static long getLong(JSONValue value) {
        if (value == null)
            return 0;
        if (!(value instanceof Number))
            throw new JSONException(NOT_A_NUMBER);
        return ((Number)value).longValue();
    }