Java SimpleNumberCoercerFactory.getCoercer方法代码示例

import com.espertech.esper.util.SimpleNumberCoercerFactory; //导入方法依赖的package包/类
private static SimpleNumberCoercer getCoercer(Class typeOne, Class typeTwo) throws ExprValidationException {
    // Get the common type such as Bool, String or Double and Long
    Class coercionType;
    boolean mustCoerce;
    try {
        coercionType = JavaClassHelper.getCompareToCoercionType(typeOne, typeTwo);
    } catch (CoercionException ex) {
        throw new ExprValidationException("Implicit conversion from datatype '" +
                typeTwo.getSimpleName() +
                "' to '" +
                typeOne.getSimpleName() +
                "' is not allowed");
    }

    // Check if we need to coerce
    mustCoerce = false;
    if ((coercionType != JavaClassHelper.getBoxedType(typeOne)) ||
            (coercionType != JavaClassHelper.getBoxedType(typeTwo))) {
        if (JavaClassHelper.isNumeric(coercionType)) {
            mustCoerce = true;
        }
    }
    return !mustCoerce ? null : SimpleNumberCoercerFactory.getCoercer(null, coercionType);
}
 

import com.espertech.esper.util.SimpleNumberCoercerFactory; //导入方法依赖的package包/类
/**
 * Ctor.
 * @param notIn false for =, true for !=
 * @param mustCoerce coercion required
 * @param coercionType type to coerce to
 * @param valueExpr LHS
 * @param selectClauseExpr select clause or null
 * @param filterExpr filter or null
 */
public SubselectEvalStrategyEqualsAny(boolean notIn, boolean mustCoerce, Class coercionType, ExprEvaluator valueExpr, ExprEvaluator selectClauseExpr, ExprEvaluator filterExpr)
{
    isNot = notIn;
    this.mustCoerce = mustCoerce;
    if (mustCoerce)
    {
        coercer = SimpleNumberCoercerFactory.getCoercer(null, coercionType);
    }
    else
    {
        coercer = null;
    }
    this.valueExpr = valueExpr;
    this.filterExpr = filterExpr;
    this.selectClauseExpr = selectClauseExpr;
}
 

import com.espertech.esper.util.SimpleNumberCoercerFactory; //导入方法依赖的package包/类
/**
 * Ctor.
 * @param notIn false for =, true for !=
 * @param mustCoerce coercion required
 * @param coercionType type to coerce to
 * @param valueExpr LHS
 * @param selectClauseExpr select clause or null
 * @param filterExpr filter or null
 */
public SubselectEvalStrategyEqualsIn(boolean notIn, boolean mustCoerce, Class coercionType, ExprEvaluator valueExpr, ExprEvaluator selectClauseExpr, ExprEvaluator filterExpr)
{
    isNotIn = notIn;
    this.mustCoerce = mustCoerce;
    if (mustCoerce)
    {
        coercer = SimpleNumberCoercerFactory.getCoercer(null, coercionType);
    }
    else
    {
        coercer = null;
    }
    this.valueExpr = valueExpr;
    this.filterExpr = filterExpr;
    this.selectClauseExpr = selectClauseExpr;
}
 

import com.espertech.esper.util.SimpleNumberCoercerFactory; //导入方法依赖的package包/类
/**
 * Ctor.
 * @param notIn false for =, true for !=
 * @param mustCoerce coercion required
 * @param coercionType type to coerce to
 * @param valueExpr LHS
 * @param selectClauseExpr select clause or null
 * @param filterExpr filter or null
 */
public SubselectEvalStrategyEqualsAll(boolean notIn, boolean mustCoerce, Class coercionType, ExprEvaluator valueExpr, ExprEvaluator selectClauseExpr, ExprEvaluator filterExpr)
{
    isNot = notIn;
    this.mustCoerce = mustCoerce;
    if (mustCoerce)
    {
        coercer = SimpleNumberCoercerFactory.getCoercer(null, coercionType);
    }
    else
    {
        coercer = null;
    }
    this.valueExpr = valueExpr;
    this.filterExpr = filterExpr;
    this.selectClauseExpr = selectClauseExpr;
}
 

import com.espertech.esper.util.SimpleNumberCoercerFactory; //导入方法依赖的package包/类
public ExprNodeScriptEvalBase(ExprNodeScript parent, String statementName, String[] names, ExprForge[] parameters, Class returnType, EventType eventTypeCollection) {
    this.parent = parent;
    this.statementName = statementName;
    this.names = names;
    this.parameters = parameters;
    this.returnType = returnType;
    this.eventTypeCollection = eventTypeCollection;

    if (JavaClassHelper.isNumeric(returnType)) {
        coercer = SimpleNumberCoercerFactory.getCoercer(Number.class, JavaClassHelper.getBoxedType(returnType));
    } else {
        coercer = null;
    }
}
 

import com.espertech.esper.util.SimpleNumberCoercerFactory; //导入方法依赖的package包/类
/**
 * Ctor.
 *
 * @param streamNum    is the stream number of the indexed stream
 * @param eventType    is the event type of the indexed stream
 * @param propertyName are the property names to get property values
 * @param coercionType are the classes to coerce indexed values to
 */
public PropertyIndexedEventTableSingleCoerceAddFactory(int streamNum, EventType eventType, String propertyName, Class coercionType) {
    super(streamNum, eventType, propertyName, false, null);
    this.coercionType = coercionType;
    if (JavaClassHelper.isNumeric(coercionType)) {
        coercer = SimpleNumberCoercerFactory.getCoercer(null, coercionType);
    } else {
        coercer = null;
    }
}
 

import com.espertech.esper.util.SimpleNumberCoercerFactory; //导入方法依赖的package包/类
/**
 * Ctor.
 *
 * @param streamNum     is the stream number of the indexed stream
 * @param eventType     is the event type of the indexed stream
 * @param propertyNames are the property names to get property values
 * @param coercionType  are the classes to coerce indexed values to
 */
public PropertyIndexedEventTableCoerceAddFactory(int streamNum, EventType eventType, String[] propertyNames, Class[] coercionType) {
    super(streamNum, eventType, propertyNames, false, null);
    this.coercionType = coercionType;
    coercers = new SimpleNumberCoercer[coercionType.length];
    for (int i = 0; i < coercionType.length; i++) {
        if (JavaClassHelper.isNumeric(coercionType[i])) {
            coercers[i] = SimpleNumberCoercerFactory.getCoercer(null, coercionType[i]);
        }
    }
}
 

import com.espertech.esper.util.SimpleNumberCoercerFactory; //导入方法依赖的package包/类
private static SimpleNumberCoercer getNumberCoercer(Class leftType, Class rightType, String expression) throws ExprValidationException {
    Class numericCoercionType = JavaClassHelper.getBoxedType(leftType);
    if (rightType != leftType) {
        if (JavaClassHelper.isNumeric(rightType)) {
            if (!JavaClassHelper.canCoerce(rightType, leftType)) {
                throwConversionError(rightType, leftType, expression);
            }
            return SimpleNumberCoercerFactory.getCoercer(rightType, numericCoercionType);
        }
    }
    return null;
}
 

import com.espertech.esper.util.SimpleNumberCoercerFactory; //导入方法依赖的package包/类
public void testGetValueSet() {
    List<FilterSpecParam> parameters = SupportFilterSpecBuilder.buildList(eventType, new Object[]
            {"intPrimitive", FilterOperator.EQUAL, 2});
    SimpleNumberCoercer numberCoercer = SimpleNumberCoercerFactory.getCoercer(int.class, Double.class);
    parameters.add(new FilterSpecParamEventProp(makeLookupable("doubleBoxed"), FilterOperator.EQUAL, "asName", "doublePrimitive", false, numberCoercer, Double.class, "Test"));
    FilterSpecCompiled filterSpec = new FilterSpecCompiled(eventType, "SupportBean", new List[]{parameters}, null);

    SupportBean eventBean = new SupportBean();
    eventBean.setDoublePrimitive(999.999);
    EventBean theEvent = SupportEventBeanFactory.createObject(eventBean);
    MatchedEventMap matchedEvents = new MatchedEventMapImpl(new MatchedEventMapMeta(new String[]{"asName"}, false));
    matchedEvents.add(0, theEvent);
    FilterValueSet valueSet = filterSpec.getValueSet(matchedEvents, null, null, null, null);

    // Assert the generated filter value container
    assertSame(eventType, valueSet.getEventType());
    assertEquals(2, valueSet.getParameters()[0].length);

    // Assert the first param
    FilterValueSetParam param = valueSet.getParameters()[0][0];
    assertEquals("intPrimitive", param.getLookupable().getExpression());
    assertEquals(FilterOperator.EQUAL, param.getFilterOperator());
    assertEquals(2, param.getFilterForValue());

    // Assert the second param
    param = (FilterValueSetParam) valueSet.getParameters()[0][1];
    assertEquals("doubleBoxed", param.getLookupable().getExpression());
    assertEquals(FilterOperator.EQUAL, param.getFilterOperator());
    assertEquals(999.999, param.getFilterForValue());
}
 

import com.espertech.esper.util.SimpleNumberCoercerFactory; //导入方法依赖的package包/类
public ExprNodeScriptEvalBase(String scriptName, String statementName, String[] names, ExprEvaluator[] parameters, Class returnType) {
    this.scriptName = scriptName;
    this.statementName = statementName;
    this.names = names;
    this.parameters = parameters;
    this.returnType = returnType;

    if (JavaClassHelper.isNumeric(returnType)) {
        coercer = SimpleNumberCoercerFactory.getCoercer(Number.class, JavaClassHelper.getBoxedType(returnType));
    }
    else {
        coercer = null;
    }
}
 

import com.espertech.esper.util.SimpleNumberCoercerFactory; //导入方法依赖的package包/类
/**
 * Ctor.
 * @param streamNum is the stream number of the indexed stream
 * @param eventType is the event type of the indexed stream
 * @param propertyName are the property names to get property values
 * @param coercionType are the classes to coerce indexed values to
 */
public PropertyIndexedEventTableSingleCoerceAddFactory(int streamNum, EventType eventType, String propertyName, Class coercionType)
{
    super(streamNum, eventType, propertyName, false, null);
    this.coercionType = coercionType;
    if (JavaClassHelper.isNumeric(coercionType)) {
        coercer = SimpleNumberCoercerFactory.getCoercer(null, coercionType);
    }
    else {
        coercer = null;
    }
}
 

import com.espertech.esper.util.SimpleNumberCoercerFactory; //导入方法依赖的package包/类
/**
 * Ctor.
 * @param streamNum is the stream number of the indexed stream
 * @param eventType is the event type of the indexed stream
 * @param propertyNames are the property names to get property values
 * @param coercionType are the classes to coerce indexed values to
 */
public PropertyIndexedEventTableCoerceAddFactory(int streamNum, EventType eventType, String[] propertyNames, Class[] coercionType)
{
    super(streamNum, eventType, propertyNames, false, null);
    this.coercionType = coercionType;
    coercers = new SimpleNumberCoercer[coercionType.length];
    for (int i = 0; i < coercionType.length; i++)
    {
        if (JavaClassHelper.isNumeric(coercionType[i])) {
            coercers[i] = SimpleNumberCoercerFactory.getCoercer(null, coercionType[i]);
        }
    }
}
 

import com.espertech.esper.util.SimpleNumberCoercerFactory; //导入方法依赖的package包/类
private void validateCaseTwo() throws ExprValidationException
{
    // validate we can compare result types
    List<Class> comparedTypes = new LinkedList<Class>();
    comparedTypes.add(optionalCompareExprNode.getType());
    for (UniformPair<ExprEvaluator> pair : whenThenNodeList)
    {
        comparedTypes.add(pair.getFirst().getType());
    }

    // Determine common denominator type
    try {
        Class coercionType = JavaClassHelper.getCommonCoercionType(comparedTypes.toArray(new Class[comparedTypes.size()]));

        // Determine if we need to coerce numbers when one type doesn't match any other type
        if (JavaClassHelper.isNumeric(coercionType))
        {
            mustCoerce = false;
            for (Class comparedType : comparedTypes)
            {
                if (comparedType != coercionType)
                {
                    mustCoerce = true;
                }
            }
            if (mustCoerce)
            {
                coercer = SimpleNumberCoercerFactory.getCoercer(null, coercionType);
            }
        }
    }
    catch (CoercionException ex)
    {
        throw new ExprValidationException("Implicit conversion not allowed: " + ex.getMessage());
    }
}
 

import com.espertech.esper.util.SimpleNumberCoercerFactory; //导入方法依赖的package包/类
private static SimpleNumberCoercer getNumberCoercer(Class leftType, Class rightType, String expression) throws ExprValidationException {
    Class numericCoercionType = JavaClassHelper.getBoxedType(leftType);
    if (rightType != leftType)
    {
        if (JavaClassHelper.isNumeric(rightType))
        {
            if (!JavaClassHelper.canCoerce(rightType, leftType))
            {
                throwConversionError(rightType, leftType, expression);
            }
            return SimpleNumberCoercerFactory.getCoercer(rightType, numericCoercionType);
        }
    }
    return null;
}
 

import com.espertech.esper.util.SimpleNumberCoercerFactory; //导入方法依赖的package包/类
public void testGetValueSet()
{
    List<FilterSpecParam> parameters = SupportFilterSpecBuilder.buildList(eventType, new Object[]
                                { "intPrimitive", FilterOperator.EQUAL, 2 });
    SimpleNumberCoercer numberCoercer = SimpleNumberCoercerFactory.getCoercer(int.class, Double.class);
    parameters.add(new FilterSpecParamEventProp(makeLookupable("doubleBoxed"), FilterOperator.EQUAL, "asName", "doublePrimitive", false, numberCoercer, Double.class, "Test"));
    FilterSpecCompiled filterSpec = new FilterSpecCompiled(eventType, "SupportBean", parameters, null);

    SupportBean eventBean = new SupportBean();
    eventBean.setDoublePrimitive(999.999);
    EventBean theEvent = SupportEventBeanFactory.createObject(eventBean);
    MatchedEventMap matchedEvents = new MatchedEventMapImpl(new MatchedEventMapMeta(new String[] {"asName"}, false));
    matchedEvents.add(0, theEvent);
    FilterValueSet valueSet = filterSpec.getValueSet(matchedEvents, null, null);

    // Assert the generated filter value container
    assertSame(eventType, valueSet.getEventType());
    assertEquals(2, valueSet.getParameters().size());

    // Assert the first param
    FilterValueSetParam param = valueSet.getParameters().getFirst();
    assertEquals("intPrimitive", param.getLookupable().getExpression());
    assertEquals(FilterOperator.EQUAL, param.getFilterOperator());
    assertEquals(2, param.getFilterForValue());

    // Assert the second param
    param = (FilterValueSetParam) valueSet.getParameters().toArray()[1];
    assertEquals("doubleBoxed", param.getLookupable().getExpression());
    assertEquals(FilterOperator.EQUAL, param.getFilterOperator());
    assertEquals(999.999, param.getFilterForValue());
}