Public

<init>

ScheduledThreadPoolExecutor

Reactive rest calls using spring rest template

Thrown to indicate that a malformed URL has occurred. Either no legal protocol
could be found in a s

java.net.MalformedURLException

Represents a Uniform Resource Identifier (URI) reference. Aside from some minor
deviations noted bel

java.net.URI

A Java representation of the SQL TIMESTAMP type. It provides the capability of
representing the SQL 

java.sql.Timestamp

 JarFile is used to read jar entries and their associated data from jar files.

java.util.jar.JarFile

A Handler object accepts a logging request and exports the desired messages to a
target, for example

java.util.logging.Handler

org.hamcrest.core.IsNull

startActivity

onRequestPermissionsResult

Schedules the specified task for repeated fixed-rate execution, beginning after
the specified delay.

scheduleAtFixedRate

/**
 * Attaches the lowest alternative number type to the parameter number via {@link NumberWithFallbackType}, if
 * that's useful according the possible target number types. This transformation is applied on the method call
 * argument list before overloaded method selection.
 * 
 * Note that as of this writing, this method is only used when
 * {@link BeansWrapper#getIncompatibleImprovements()} >= 2.3.21.
 * 
 * Why's this needed, how it works: Overloaded method selection only selects methods where the type
 * (not the value!) of the argument is "smaller" or the same as the parameter type. This is similar to how it's in
 * the Java language. That it only decides based on the parameter type is important because this way
 * {@link OverloadedMethodsSubset} can cache method lookup decisions using the types as the cache key. Problem is,
 * since you don't declare the exact numerical types in FTL, and FTL has only a single generic numeric type
 * anyway, what Java type a {@link TemplateNumberModel} uses internally is often seen as a technical detail of which
 * the template author can't always keep track of. So we investigate the value of the number too,
 * then coerce it down without overflow to a type that will match the most overloaded methods. (This
 * is especially important as FTL often stores numbers in {@link BigDecimal}-s, which will hardly ever match any
 * method parameters.) We could simply return that number, like {@code Byte(0)} for an {@code Integer(0)},
 * however, then we would lose the information about what the original type was. The original type is sometimes
 * important, as in ambiguous situations the method where there's an exact type match should be selected (like,
 * when someone wants to select an overload explicitly with {@code m(x?int)}). Also, if an overload wins where
 * the parameter type at the position of the number is {@code Number} or {@code Object} (or {@code Comparable}
 * etc.), it's expected that we pass in the original value (an {@code Integer} in this example), especially if that
 * value is the return value of another Java method. That's why we use
 * {@link NumberWithFallbackType} numerical classes like {@link IntegerOrByte}, which represents both the original
 * type and the coerced type, all encoded into the class of the value, which is used as the overloaded method lookup
 * cache key.
 * 
 * See also: <tt>src\main\misc\overloadedNumberRules\prices.ods</tt>.
 * 
 * @param num the number to coerce
 * @param typeFlags the type flags of the target parameter position; see {@link TypeFlags}
 * 
 * @return The original number or a {@link NumberWithFallbackType}, depending on the actual value and the types
 * indicated in the {@code targetNumTypes} parameter.
 */

// For now we only support the backward-compatible mode that doesn't prevent roll overs and magnitude loss.

// However, we push the overloaded selection to the right direction, so we will at least indicate if the

// Either it was a non-integer, or it didn't mater what it was, as we don't have both integer and

// Note that we try to return the most specific type (i.e., the numerical type with the smallest range), but

// only among the types that are possible targets. Like if the only target is int and the value is 1, we

// will return Integer 1, not Byte 1, even though byte is automatically converted to int so it would

// work too. Why we avoid unnecessarily specific types is that they generate more overloaded method lookup

// cache entries, since the cache key is the array of the types of the argument values. So we want as few

// There's no hope to be 1-precise outside this region. (Although problems can occur even inside it...)

// We will try to ignore precision glitches (like 0.3 - 0.2 - 0.1 = -2.7E-17)

How to useOverloadedNumberUtil$DoubleOrLong in freemarker.ext.beans

Best Java code snippets using freemarker.ext.beans.OverloadedNumberUtil$DoubleOrLong (Showing top 3 results out of 315)

How to use
OverloadedNumberUtil$DoubleOrLong
in
freemarker.ext.beans