Public

<init>

ScheduledThreadPoolExecutor

Updating database using SQL prepared statement

A Comparator is used to compare two objects to determine their ordering with
respect to each other. 

java.util.Comparator

An Executor that provides methods to manage termination and methods that can
produce a Future for tr

java.util.concurrent.ExecutorService

Factory and utility methods for Executor, ExecutorService,
ScheduledExecutorService, ThreadFactory, 

java.util.concurrent.Executors

A compiled representation of a regular expression. A regular expression,
specified as a string, must

java.util.regex.Pattern

Basic implementation of javax.sql.DataSource that is configured via JavaBeans
properties. This is no

org.apache.commons.dbcp.BasicDataSource

This is the central class in the log4j package. Most logging operations, except
configuration, are d

org.apache.log4j.Logger

getApplicationContext

Return the original filename in the client's filesystem.This may contain path
information depending 

getOriginalFilename

Sets the general request property. If a property with the key already exists,
overwrite its value wi

setRequestProperty

/**
 * 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 use freemarker.ext.beans.OverloadedNumberUtil$FloatOrIntegerconstructor

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

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