Public

<init>

DateTime

Reading from database using SQL prepared statement

The Font class represents fonts, which are used to render text in a visible way.
A font provides the

java.awt.Font

This class is used to encode a string using the format required by
application/x-www-form-urlencoded

java.net.URLEncoder

Formats or parses dates and times.This class provides factories for obtaining
instances configured f

java.text.DateFormat

Thrown when trying to retrieve an element past the end of an Enumeration or
Iterator.

java.util.NoSuchElementException

XPath provides access to the XPath evaluation environment and expressions.

Evaluation of XPath Expr

javax.xml.xpath.XPath

org.hamcrest.core.IsNull

findViewById

onCreateOptionsMenu

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$LongOrByte in freemarker.ext.beans

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

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