Public

<init>

ScheduledThreadPoolExecutor

Parsing JSON documents to java classes using gson

This class implements a simple HTTP server. A HttpServer is bound to an IP
address and port number a

com.sun.net.httpserver.HttpServer

A border layout lays out a container, arranging and resizing its components to
fit in five regions: 

java.awt.BorderLayout

This class implements the Set interface, backed by a hash table (actually a 
HashMap instance). It m

java.util.HashSet

A Map is a data structure consisting of a set of keys and values in which each
key is mapped to a si

java.util.Map

Defines the contract between a returned instance and the runtime when an
application needs to provid

javax.ws.rs.core.Response

org.hibernate.mapping.Table

getSystemService

findViewById

getContentResolver

/**
 * 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$FloatOrInteger in freemarker.ext.beans

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

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